Foundry-Scrapping-API/internal/foundry/models/json/data.go

package json

import (
	"encoding/json"

	"gitea.local.lab/Lbenedar/foundry_helper_service/internal/foundry/models/db"
)

type FoundryState struct {
	IsAdmin   bool           `json:"isAdmin,omitempty"`
	IsSetup   bool           `json:"isSetup,omitempty"`
	Languages []Language     `json:"languages,omitempty"`
	Modules   []DataTemplate `json:"modules"`
	Release   Release        `json:"release"`
	Systems   []DataTemplate `json:"systems,omitempty"`
	Worlds    []DataTemplate `json:"worlds,omitempty"`
	World     *DataTemplate  `json:"world,omitempty"`
	Users     Users          `json:"users,omitempty"`
	Options   Options        `json:"options,omitempty"`

	//coreUpdate struct{}
	//featuredContent struct{}
	//files struct{}
	//news            struct{}

	//packageWarnings struct{} think about it
}

type Options struct {
	Language string `json:"language,omitempty"`
}

func (state FoundryState) GetRelease() Release {
	return state.Release
}

func (state FoundryState) GetFoundryStateDB(stateType db.StateType) *db.FoundryState {
	dbFoundryState := db.FoundryState{
		IsAdmin: state.IsAdmin,
		IsSetup: state.IsSetup,
		Type:    stateType,
		Options: db.Options{Language: state.Options.Language},
	}

	dbFoundryState.Modules = state.GetModules()
	dbFoundryState.Systems = state.GetSystems()
	dbFoundryState.Worlds = state.GetWorlds()
	dbFoundryState.Users = state.GetUsers()

	return &dbFoundryState
}

func (state *FoundryState) GetModules() db.Modules {
	modulesCopy := make([]db.Module, 0, 8)
	for i := range state.Modules {
		module := &(state.Modules[i])
		moduleCopy := db.Module{
			TextId:      module.Id,
			Title:       module.Title,
			Description: module.Description,
			Compatibility: db.Compatibility{
				Minimum: module.Compatibility.Minimum,
				Maximum: module.Compatibility.Maximum,
			},
			Url:     module.Url,
			Version: module.CoreVersion,

			Availability: module.Availability,
		}
		for j := range module.Languages {
			lang := db.Language{
				Lang: module.Languages[j].Lang,
				Name: module.Languages[j].Name,
				Path: module.Languages[j].Path,
			}
			moduleCopy.Languages = append(moduleCopy.Languages, lang)
		}
		modulesCopy = append(modulesCopy, moduleCopy)
	}
	return modulesCopy
}

func (state *FoundryState) GetSystems() db.Systems {
	systemsCopy := make([]db.System, 0, 8)
	for i := range state.Systems {
		system := &(state.Systems[i])
		systemCopy := db.System{
			TextId:      system.Id,
			Title:       system.Title,
			Description: system.Description,
			Url:         system.Url,
			Compatibility: db.Compatibility{
				Minimum: system.Compatibility.Minimum,
				Maximum: system.Compatibility.Maximum,
			},
			Download: system.Download,
		}
		systemsCopy = append(systemsCopy, systemCopy)
	}
	return systemsCopy
}

func (state *FoundryState) GetWorld() *db.World {
	return &db.World{
		TextId:      state.World.Id,
		Title:       state.World.Title,
		Description: state.World.Description,
		Compatibility: db.Compatibility{
			Minimum: state.World.Compatibility.Minimum,
			Maximum: state.World.Compatibility.Maximum,
		},
		System:        state.World.System,
		CoreVersion:   state.World.CoreVersion,
		SystemVersion: state.World.SystemVersion,
		LastPlayed:    state.World.LastPlayed,
		PlayTime:      state.World.PlayTime,
		NextSession:   state.World.NextSession,
	}
}

func (state *FoundryState) GetWorlds() db.Worlds {
	worldsCopy := make([]db.World, 0, 8)
	for i := range state.Worlds {
		world := &(state.Worlds[i])
		worldCopy := db.World{
			TextId:      world.Id,
			Title:       world.Title,
			Description: world.Description,
			Compatibility: db.Compatibility{
				Minimum: world.Compatibility.Minimum,
				Maximum: world.Compatibility.Maximum,
			},
			System:        world.System,
			CoreVersion:   world.CoreVersion,
			SystemVersion: world.SystemVersion,
			LastPlayed:    world.LastPlayed,
			PlayTime:      world.PlayTime,
			NextSession:   world.NextSession,
		}
		worldsCopy = append(worldsCopy, worldCopy)
	}

	if state.World != nil {
		worldsCopy = append(worldsCopy, *state.GetWorld())
	}
	return worldsCopy
}

func (state *FoundryState) GetUsers() db.Users {
	usersCopy := make(db.Users, 0, 8)
	for i := range state.Users {
		user := &(state.Users[i])
		userCopy := db.User{
			Name:      user.Name,
			Role:      user.Role,
			Character: user.Character,
			Color:     user.Color,
			Pronouns:  user.Pronouns,
			Hotbar:    user.Hotbar,
			Stats: db.UserStats{
				CoreVersion:    user.Stats.CoreVersion,
				SystemId:       user.Stats.SystemId,
				SystemVersion:  user.Stats.SystemVersion,
				CreatedTime:    user.Stats.CreatedTime,
				ModifiedTime:   user.Stats.ModifiedTime,
				LastModifiedBy: user.Stats.LastModifiedBy,
			},
		}
		usersCopy = append(usersCopy, userCopy)
	}
	return usersCopy
}

func ParseSetupModel(data []byte) (*FoundryState, error) {
	var modelSetup []FoundryState
	err := json.Unmarshal(data, &modelSetup)
	if err != nil {
		return nil, err
	}

	if len(modelSetup) > 1 {
		return nil, ErrorSetupMoreThanOne
	}
	return &modelSetup[0], nil
}