add db models, refactor json models, add references in migrations

internal/foundry/models/db/errors.go

@@ -0,0 +1,8 @@
+package db
+
+import "errors"
+
+var (
+	ErrorSetupMoreThanOne = errors.New("Passed more than one setupData")
+	ErrorSetupNotFound    = errors.New("Not found setup data from your request")
+)

internal/foundry/models/db/foundry_state.go

@@ -0,0 +1,113 @@
+package db
+
+import (
+	"context"
+	"database/sql"
+	"time"
+)
+
+type StateType int
+
+const (
+	AuthState    = StateType(0)
+	SetupState   = StateType(1)
+	JoinState    = StateType(2)
+	PlayersState = StateType(3)
+	UpdateState  = StateType(4)
+	LicenseState = StateType(5)
+)
+
+type FoundryState struct {
+	Id        int
+	IsAdmin   bool
+	IsSetup   bool
+	Type      StateType
+	CreatedAt time.Time
+	Options   Options
+	Modules   Modules
+	Systems   Systems
+	Worlds    Worlds
+	Users     Users
+}
+
+type Compatibility struct {
+	Id       int
+	Minimum  string
+	Verified string
+	Maximum  string
+}
+
+type Options struct {
+	Id       int
+	Language string
+}
+
+type FoundryStateModel struct {
+	DB *sql.DB
+}
+
+func (m FoundryStateModel) Insert(state *FoundryState) error {
+	query := `
+		INSERT INTO foundry_state (is_admin, is_setup, state_type)
+		VALUES ($1, $2, $3)
+		RETURNING id, created_at`
+
+	args := []any{state.IsAdmin, state.IsSetup, state.Type}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	err := m.DB.QueryRowContext(ctx, query, args...).Scan(&state.Id, &state.CreatedAt)
+	if err != nil {
+		return err
+	}
+
+	err = m.InsertOptions(&state.Options, state.Id)
+	if err != nil {
+		return err
+	}
+
+	for i := range state.Modules {
+		err = m.InsertModule(&state.Modules[i], state.Id)
+		if err != nil {
+			return err
+		}
+	}
+
+	for i := range state.Systems {
+		err = m.InsertSystem(&state.Systems[i], state.Id)
+		if err != nil {
+			return err
+		}
+	}
+
+	for i := range state.Worlds {
+		err = m.InsertWorld(&state.Worlds[i], state.Id)
+		if err != nil {
+			return err
+		}
+	}
+
+	for i := range state.Users {
+		err = m.InsertUser(&state.Users[i], state.Id)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (m FoundryStateModel) InsertOptions(options *Options, stateId int) error {
+	query := `
+		INSERT INTO options (state_id, lang)
+		VALUES ($1, $2)
+		RETURNING id`
+
+	args := []any{stateId, options.Language}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	return m.DB.QueryRowContext(ctx, query, args...).Scan(&options.Id)
+}

internal/foundry/models/db/models.go

@@ -0,0 +1,35 @@
+package db
+
+import "database/sql"
+
+// var (
+// 	ErrRecordNotFound = errors.New("record not found")
+// 	ErrEditConflict   = errors.New("edit conflict")
+// )
+
+type Models struct {
+	FoundryState FoundryStateModel
+}
+
+// type Models struct {
+// 	Movies interface {
+// 		Insert(movie *Movie) error
+// 		Get(id int64) (*Movie, error)
+// 		Update(movie *Movie) error
+// 		Delete(id int64) error
+// 		GetAll(title string, genres []string, filter Filters) ([]*Movie, Metadata, error)
+// 	}
+// }
+
+func NewModels(db *sql.DB) Models {
+	return Models{
+		FoundryState: FoundryStateModel{DB: db},
+	}
+}
+
+// func NewMockModels() Models {
+// 	return Models{
+// 		Movies: MockMovieModel{},
+// 		Users:  MockMovieModel{},
+// 	}
+// }

internal/foundry/models/db/module.go

@@ -0,0 +1,84 @@
+package db
+
+import (
+	"context"
+	"time"
+)
+
+type Module struct {
+	Id            int
+	TextId        string
+	Title         string
+	Description   string
+	Url           string
+	Version       string
+	Availability  int
+	CreatedAt     time.Time
+	Languages     []Language
+	Compatibility Compatibility
+}
+
+type Language struct {
+	Id   string
+	Lang string
+	Name string
+	Path string
+}
+
+type Modules []Module
+
+func (modules Modules) GetById(id int) *Module {
+	return &modules[id]
+}
+
+func (m FoundryStateModel) InsertModule(module *Module, stateId int) error {
+	query := `
+		INSERT INTO modules (state_id, text_id, title, description, url, version, availability)
+		VALUES ($1, $2, $3, $4, $5, $6, $7)
+		RETURNING id, created_at`
+
+	args := []any{stateId, module.TextId, module.Title, module.Description, module.Url, module.Version, module.Availability}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	err := m.DB.QueryRowContext(ctx, query, args...).Scan(&module.Id, &module.CreatedAt)
+	if err != nil {
+		return err
+	}
+	for i := range module.Languages {
+		err = m.InsertModuleLanguages(&module.Languages[i], module.Id)
+		if err != nil {
+			return err
+		}
+	}
+	return m.InsertModuleCompatibility(&module.Compatibility, module.Id)
+}
+
+func (m FoundryStateModel) InsertModuleCompatibility(compatibility *Compatibility, moduleId int) error {
+	query := `
+		INSERT INTO modules_compatibility (model_id, minumum, verified, maximum)
+		VALUES ($1, $2, $3, $4)
+		RETURNING id`
+
+	args := []any{moduleId, compatibility.Minimum, compatibility.Verified, compatibility.Maximum}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	return m.DB.QueryRowContext(ctx, query, args...).Scan(&compatibility.Id)
+}
+
+func (m FoundryStateModel) InsertModuleLanguages(lang *Language, moduleId int) error {
+	query := `
+		INSERT INTO modules_compatibility (model_id, language, name, path)
+		VALUES ($1, $2, $3, $4)
+		RETURNING id`
+
+	args := []any{moduleId, lang.Lang, lang.Name, lang.Path}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	return m.DB.QueryRowContext(ctx, query, args...).Scan(&lang.Id)
+}

internal/foundry/models/db/system.go

@@ -0,0 +1,53 @@
+package db
+
+import (
+	"context"
+	"time"
+)
+
+type System struct {
+	Id            int
+	TextId        string
+	Title         string
+	Description   string
+	Url           string
+	Download      string
+	CreatedAt     time.Time
+	Compatibility Compatibility
+}
+
+type Systems []System
+
+func (systems Systems) GetById(id int) *System {
+	return &systems[id]
+}
+
+func (m FoundryStateModel) InsertSystem(system *System, stateId int) error {
+	query := `
+		INSERT INTO systems (state_id, text_id, title, description, url, download)
+		VALUES ($1, $2, $3, $4, $5, $6)`
+
+	args := []any{stateId, system.TextId, system.Title, system.Description, system.Url, system.Download}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	err := m.DB.QueryRowContext(ctx, query, args...).Scan(&system.Id)
+	if err != nil {
+		return err
+	}
+	return m.InsertModuleCompatibility(&system.Compatibility, system.Id)
+}
+
+func (m FoundryStateModel) InsertSystenCompatibility(compatibility *Compatibility, systemId int) error {
+	query := `
+		INSERT INTO systems_compatibility (system_id, minumum, verified, maximum)
+		VALUES ($1, $2, $3, $4)`
+
+	args := []any{systemId, compatibility.Minimum, compatibility.Verified, compatibility.Maximum}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	return m.DB.QueryRowContext(ctx, query, args...).Scan(&compatibility.Id)
+}

internal/foundry/models/db/user.go

@@ -0,0 +1,91 @@
+package db
+
+import (
+	"context"
+	"time"
+)
+
+type User struct {
+	Id        int
+	Name      string
+	Role      int
+	Character string
+	Color     string
+	Pronouns  string
+	CreatedAt time.Time
+	Hotbar    map[string]string
+	Stats     UserStats
+}
+
+type UserStats struct {
+	Id             int
+	CoreVersion    string
+	SystemId       string
+	SystemVersion  string
+	CreatedTime    int64
+	ModifiedTime   int64
+	LastModifiedBy string
+}
+
+type Users []User
+
+func (users Users) GetById(id int) *User {
+	return &users[id]
+}
+
+func (m FoundryStateModel) InsertUser(user *User, stateId int) error {
+	query := `
+		INSERT INTO users (state_id, name, role, character, color, pronouns)
+		VALUES ($1, $2, $3, $4, $5, $6)
+		RETURNING id, created_at`
+
+	args := []any{stateId, user.Name, user.Role, user.Character, user.Color, user.Pronouns}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	err := m.DB.QueryRowContext(ctx, query, args...).Scan(&user.Id, &user.CreatedAt)
+	if err != nil {
+		return err
+	}
+
+	for k, v := range user.Hotbar {
+		err = m.InsertUserHotbar(k, v, user.Id)
+		if err != nil {
+			return err
+		}
+	}
+
+	return m.InsertUserStats(&user.Stats, user.Id)
+}
+
+func (m FoundryStateModel) InsertUserHotbar(key string, value string, userId int) error {
+	query := `
+		INSERT INTO users_hotbar (user_id, key, value)
+		VALUES ($1, $2, $3)`
+
+	args := []any{userId, key, value}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	_, err := m.DB.ExecContext(ctx, query, args...)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (m FoundryStateModel) InsertUserStats(stats *UserStats, userId int) error {
+	query := `
+		INSERT INTO users_stats (user_id, core_version, system_id, system_version, created_time, modified_time, last_modified_by)
+		VALUES ($1, $2, $3, $4, $5, $6, $7)
+		RETURNING id`
+
+	args := []any{userId, stats.CoreVersion, stats.SystemId, stats.SystemVersion, stats.CreatedTime, stats.ModifiedTime, stats.LastModifiedBy}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	return m.DB.QueryRowContext(ctx, query, args...).Scan(&stats.Id)
+}

internal/foundry/models/db/world.go

@@ -0,0 +1,81 @@
+package db
+
+import (
+	"context"
+	"time"
+)
+
+type World struct {
+	Id            int
+	TextId        string
+	Title         string
+	Description   string
+	System        string
+	CoreVersion   string
+	SystemVersion string
+	LastPlayed    string
+	PlayTime      int64
+	NextSession   time.Time
+	CreatedAt     time.Time
+	Compatibility Compatibility
+}
+
+type Worlds []World
+
+func (worlds Worlds) GetById(id int) *World {
+	return &worlds[id]
+}
+
+func (m FoundryStateModel) InsertWorld(world *World, stateId int) error {
+	query := `
+		INSERT INTO worlds (state_id, text_id, title, description, system, core_version, system_version, playtime, next_session)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+		RETURNING id, created_at`
+
+	args := []any{stateId, world.TextId, world.Title, world.Description, world.System, world.System, world.CoreVersion, world.SystemVersion, world.PlayTime, world.NextSession}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	err := m.DB.QueryRowContext(ctx, query, args...).Scan(&world.Id, &world.CreatedAt)
+	if err != nil {
+		return err
+	}
+	return m.InsertWorldCompatibility(&world.Compatibility, world.Id)
+}
+
+func (m FoundryStateModel) InsertWorldCompatibility(compatibility *Compatibility, worldId int) error {
+	query := `
+		INSERT INTO worlds_compatibility (world_id, minumum, verified, maximum)
+		VALUES ($1, $2, $3, $4)
+		RETURNING id`
+
+	args := []any{worldId, compatibility.Minimum, compatibility.Verified, compatibility.Maximum}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	return m.DB.QueryRowContext(ctx, query, args...).Scan(&compatibility.Id)
+}
+
+// func (worlds Worlds) GetSessionTime(worldName string) (*time.Time, error) {
+// 	if worldName == "" && len(worlds) != 1 {
+// 		return nil, ErrorSetupNotFound
+// 	}
+
+// 	if worldName == "" {
+// 		return &worlds.GetById(0).NextSession, nil
+// 	} else {
+// 		for i := range worlds {
+// 			if worlds[i].Id == worldName {
+// 				return &worlds.GetById(0).NextSession, nil
+// 			}
+// 		}
+// 	}
+
+// 	return nil, ErrorSetupNotFound
+// }
+
+// func (world World) GetSessionTime() *time.Time {
+// 	return &world.NextSession
+// }