game.go

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"encoding/json"
	"fmt"
	"strings"
	"time"

	"entgo.io/ent/dialect/sql"
	"github.com/stark-sim/avalon_backend/pkg/ent/game"
	"github.com/stark-sim/avalon_backend/pkg/ent/room"
)

// Game is the model entity for the Game schema.
type Game struct {
	config `json:"-"`
	// ID of the ent.
	ID int64 `json:"id,omitempty"`
	// CreatedBy holds the value of the "created_by" field.
	CreatedBy int64 `json:"created_by"`
	// UpdatedBy holds the value of the "updated_by" field.
	UpdatedBy int64 `json:"updated_by"`
	// CreatedAt holds the value of the "created_at" field.
	CreatedAt time.Time `json:"created_at"`
	// UpdatedAt holds the value of the "updated_at" field.
	UpdatedAt time.Time `json:"updated_at"`
	// DeletedAt holds the value of the "deleted_at" field.
	DeletedAt time.Time `json:"deleted_at"`
	// 所属房间 ID
	RoomID int64 `json:"room_id"`
	// 游戏结果
	Result game.Result `json:"result"`
	// 游戏人数
	Capacity uint8 `json:"capacity"`
	// 被刺杀者[们] ID
	TheAssassinatedIds []string `json:"the_assassinated_ids"`
	// 刺杀机会，默认为 1 次
	AssassinChance uint8 `json:"assassin_chance"`
	// 游戏是否关闭，需要有结果且所有人都退出才会关闭或者强制关闭
	Closed bool `json:"closed"`
	// Edges holds the relations/edges for other nodes in the graph.
	// The values are being populated by the GameQuery when eager-loading is set.
	Edges GameEdges `json:"edges"`
}

// GameEdges holds the relations/edges for other nodes in the graph.
type GameEdges struct {
	// GameUsers holds the value of the game_users edge.
	GameUsers []*GameUser `json:"game_users,omitempty"`
	// Missions holds the value of the missions edge.
	Missions []*Mission `json:"missions,omitempty"`
	// Room holds the value of the room edge.
	Room *Room `json:"room,omitempty"`
	// loadedTypes holds the information for reporting if a
	// type was loaded (or requested) in eager-loading or not.
	loadedTypes [3]bool
	// totalCount holds the count of the edges above.
	totalCount [3]map[string]int

	namedGameUsers map[string][]*GameUser
	namedMissions  map[string][]*Mission
}

// GameUsersOrErr returns the GameUsers value or an error if the edge
// was not loaded in eager-loading.
func (e GameEdges) GameUsersOrErr() ([]*GameUser, error) {
	if e.loadedTypes[0] {
		return e.GameUsers, nil
	}
	return nil, &NotLoadedError{edge: "game_users"}
}

// MissionsOrErr returns the Missions value or an error if the edge
// was not loaded in eager-loading.
func (e GameEdges) MissionsOrErr() ([]*Mission, error) {
	if e.loadedTypes[1] {
		return e.Missions, nil
	}
	return nil, &NotLoadedError{edge: "missions"}
}

// RoomOrErr returns the Room value or an error if the edge
// was not loaded in eager-loading, or loaded but was not found.
func (e GameEdges) RoomOrErr() (*Room, error) {
	if e.loadedTypes[2] {
		if e.Room == nil {
			// Edge was loaded but was not found.
			return nil, &NotFoundError{label: room.Label}
		}
		return e.Room, nil
	}
	return nil, &NotLoadedError{edge: "room"}
}

// scanValues returns the types for scanning values from sql.Rows.
func (*Game) scanValues(columns []string) ([]any, error) {
	values := make([]any, len(columns))
	for i := range columns {
		switch columns[i] {
		case game.FieldTheAssassinatedIds:
			values[i] = new([]byte)
		case game.FieldClosed:
			values[i] = new(sql.NullBool)
		case game.FieldID, game.FieldCreatedBy, game.FieldUpdatedBy, game.FieldRoomID, game.FieldCapacity, game.FieldAssassinChance:
			values[i] = new(sql.NullInt64)
		case game.FieldResult:
			values[i] = new(sql.NullString)
		case game.FieldCreatedAt, game.FieldUpdatedAt, game.FieldDeletedAt:
			values[i] = new(sql.NullTime)
		default:
			return nil, fmt.Errorf("unexpected column %q for type Game", columns[i])
		}
	}
	return values, nil
}

// assignValues assigns the values that were returned from sql.Rows (after scanning)
// to the Game fields.
func (ga *Game) assignValues(columns []string, values []any) error {
	if m, n := len(values), len(columns); m < n {
		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
	}
	for i := range columns {
		switch columns[i] {
		case game.FieldID:
			value, ok := values[i].(*sql.NullInt64)
			if !ok {
				return fmt.Errorf("unexpected type %T for field id", value)
			}
			ga.ID = int64(value.Int64)
		case game.FieldCreatedBy:
			if value, ok := values[i].(*sql.NullInt64); !ok {
				return fmt.Errorf("unexpected type %T for field created_by", values[i])
			} else if value.Valid {
				ga.CreatedBy = value.Int64
			}
		case game.FieldUpdatedBy:
			if value, ok := values[i].(*sql.NullInt64); !ok {
				return fmt.Errorf("unexpected type %T for field updated_by", values[i])
			} else if value.Valid {
				ga.UpdatedBy = value.Int64
			}
		case game.FieldCreatedAt:
			if value, ok := values[i].(*sql.NullTime); !ok {
				return fmt.Errorf("unexpected type %T for field created_at", values[i])
			} else if value.Valid {
				ga.CreatedAt = value.Time
			}
		case game.FieldUpdatedAt:
			if value, ok := values[i].(*sql.NullTime); !ok {
				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
			} else if value.Valid {
				ga.UpdatedAt = value.Time
			}
		case game.FieldDeletedAt:
			if value, ok := values[i].(*sql.NullTime); !ok {
				return fmt.Errorf("unexpected type %T for field deleted_at", values[i])
			} else if value.Valid {
				ga.DeletedAt = value.Time
			}
		case game.FieldRoomID:
			if value, ok := values[i].(*sql.NullInt64); !ok {
				return fmt.Errorf("unexpected type %T for field room_id", values[i])
			} else if value.Valid {
				ga.RoomID = value.Int64
			}
		case game.FieldResult:
			if value, ok := values[i].(*sql.NullString); !ok {
				return fmt.Errorf("unexpected type %T for field result", values[i])
			} else if value.Valid {
				ga.Result = game.Result(value.String)
			}
		case game.FieldCapacity:
			if value, ok := values[i].(*sql.NullInt64); !ok {
				return fmt.Errorf("unexpected type %T for field capacity", values[i])
			} else if value.Valid {
				ga.Capacity = uint8(value.Int64)
			}
		case game.FieldTheAssassinatedIds:
			if value, ok := values[i].(*[]byte); !ok {
				return fmt.Errorf("unexpected type %T for field the_assassinated_ids", values[i])
			} else if value != nil && len(*value) > 0 {
				if err := json.Unmarshal(*value, &ga.TheAssassinatedIds); err != nil {
					return fmt.Errorf("unmarshal field the_assassinated_ids: %w", err)
				}
			}
		case game.FieldAssassinChance:
			if value, ok := values[i].(*sql.NullInt64); !ok {
				return fmt.Errorf("unexpected type %T for field assassin_chance", values[i])
			} else if value.Valid {
				ga.AssassinChance = uint8(value.Int64)
			}
		case game.FieldClosed:
			if value, ok := values[i].(*sql.NullBool); !ok {
				return fmt.Errorf("unexpected type %T for field closed", values[i])
			} else if value.Valid {
				ga.Closed = value.Bool
			}
		}
	}
	return nil
}

// QueryGameUsers queries the "game_users" edge of the Game entity.
func (ga *Game) QueryGameUsers() *GameUserQuery {
	return (&GameClient{config: ga.config}).QueryGameUsers(ga)
}

// QueryMissions queries the "missions" edge of the Game entity.
func (ga *Game) QueryMissions() *MissionQuery {
	return (&GameClient{config: ga.config}).QueryMissions(ga)
}

// QueryRoom queries the "room" edge of the Game entity.
func (ga *Game) QueryRoom() *RoomQuery {
	return (&GameClient{config: ga.config}).QueryRoom(ga)
}

// Update returns a builder for updating this Game.
// Note that you need to call Game.Unwrap() before calling this method if this Game
// was returned from a transaction, and the transaction was committed or rolled back.
func (ga *Game) Update() *GameUpdateOne {
	return (&GameClient{config: ga.config}).UpdateOne(ga)
}

// Unwrap unwraps the Game entity that was returned from a transaction after it was closed,
// so that all future queries will be executed through the driver which created the transaction.
func (ga *Game) Unwrap() *Game {
	_tx, ok := ga.config.driver.(*txDriver)
	if !ok {
		panic("ent: Game is not a transactional entity")
	}
	ga.config.driver = _tx.drv
	return ga
}

// String implements the fmt.Stringer.
func (ga *Game) String() string {
	var builder strings.Builder
	builder.WriteString("Game(")
	builder.WriteString(fmt.Sprintf("id=%v, ", ga.ID))
	builder.WriteString("created_by=")
	builder.WriteString(fmt.Sprintf("%v", ga.CreatedBy))
	builder.WriteString(", ")
	builder.WriteString("updated_by=")
	builder.WriteString(fmt.Sprintf("%v", ga.UpdatedBy))
	builder.WriteString(", ")
	builder.WriteString("created_at=")
	builder.WriteString(ga.CreatedAt.Format(time.ANSIC))
	builder.WriteString(", ")
	builder.WriteString("updated_at=")
	builder.WriteString(ga.UpdatedAt.Format(time.ANSIC))
	builder.WriteString(", ")
	builder.WriteString("deleted_at=")
	builder.WriteString(ga.DeletedAt.Format(time.ANSIC))
	builder.WriteString(", ")
	builder.WriteString("room_id=")
	builder.WriteString(fmt.Sprintf("%v", ga.RoomID))
	builder.WriteString(", ")
	builder.WriteString("result=")
	builder.WriteString(fmt.Sprintf("%v", ga.Result))
	builder.WriteString(", ")
	builder.WriteString("capacity=")
	builder.WriteString(fmt.Sprintf("%v", ga.Capacity))
	builder.WriteString(", ")
	builder.WriteString("the_assassinated_ids=")
	builder.WriteString(fmt.Sprintf("%v", ga.TheAssassinatedIds))
	builder.WriteString(", ")
	builder.WriteString("assassin_chance=")
	builder.WriteString(fmt.Sprintf("%v", ga.AssassinChance))
	builder.WriteString(", ")
	builder.WriteString("closed=")
	builder.WriteString(fmt.Sprintf("%v", ga.Closed))
	builder.WriteByte(')')
	return builder.String()
}

// IsEntity implement fedruntime.Entity
func (ga Game) IsEntity() {}

// NamedGameUsers returns the GameUsers named value or an error if the edge was not
// loaded in eager-loading with this name.
func (ga *Game) NamedGameUsers(name string) ([]*GameUser, error) {
	if ga.Edges.namedGameUsers == nil {
		return nil, &NotLoadedError{edge: name}
	}
	nodes, ok := ga.Edges.namedGameUsers[name]
	if !ok {
		return nil, &NotLoadedError{edge: name}
	}
	return nodes, nil
}

func (ga *Game) appendNamedGameUsers(name string, edges ...*GameUser) {
	if ga.Edges.namedGameUsers == nil {
		ga.Edges.namedGameUsers = make(map[string][]*GameUser)
	}
	if len(edges) == 0 {
		ga.Edges.namedGameUsers[name] = []*GameUser{}
	} else {
		ga.Edges.namedGameUsers[name] = append(ga.Edges.namedGameUsers[name], edges...)
	}
}

// NamedMissions returns the Missions named value or an error if the edge was not
// loaded in eager-loading with this name.
func (ga *Game) NamedMissions(name string) ([]*Mission, error) {
	if ga.Edges.namedMissions == nil {
		return nil, &NotLoadedError{edge: name}
	}
	nodes, ok := ga.Edges.namedMissions[name]
	if !ok {
		return nil, &NotLoadedError{edge: name}
	}
	return nodes, nil
}

func (ga *Game) appendNamedMissions(name string, edges ...*Mission) {
	if ga.Edges.namedMissions == nil {
		ga.Edges.namedMissions = make(map[string][]*Mission)
	}
	if len(edges) == 0 {
		ga.Edges.namedMissions[name] = []*Mission{}
	} else {
		ga.Edges.namedMissions[name] = append(ga.Edges.namedMissions[name], edges...)
	}
}

// Games is a parsable slice of Game.
type Games []*Game

func (ga Games) config(cfg config) {
	for _i := range ga {
		ga[_i].config = cfg
	}
}