bebe/bamort
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added import and export of gsmaster data

Browse Source
This commit is contained in:
Frank
2025-01-02 15:57:35 +01:00
parent ff6f650b9e
commit 6c600fda15
5 changed files with 353 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/gsmaster/import_export.go
+167
View File
@@ -0,0 +1,167 @@
package gsmaster
import (
"bamort/database"
"encoding/json"
"fmt"
"os"
"gorm.io/gorm/clause"
)
// ExportData represents the combined data to be exported
type exportData struct {
Skills []Skill `json:"skills"`
WeaponSkills []WeaponSkill `json:"weapon_skills"`
Spells []Spell `json:"spells"`
Equipments []Equipment `json:"equipments"`
Weapons []Weapon `json:"weapons"`
Containers []Container `json:"containers"`
Transportations []Transportation `json:"transportations"`
Believes []Believe `json:"believes"`
}
func Export(filePath string) error {
var skills []Skill
var weaponSkills []WeaponSkill
var spells []Spell
var equipments []Equipment
var weapons []Weapon
var containers []Container
var transportations []Transportation
var believes []Believe
// Fetch all data from the respective tables
if err := database.DB.Find(&skills).Error; err != nil {
return fmt.Errorf("failed to retrieve equipment: %w", err)
}
if err := database.DB.Find(&weaponSkills).Error; err != nil {
return fmt.Errorf("failed to retrieve equipment: %w", err)
}
if err := database.DB.Find(&spells).Error; err != nil {
return fmt.Errorf("failed to retrieve equipment: %w", err)
}
if err := database.DB.Find(&equipments).Error; err != nil {
return fmt.Errorf("failed to retrieve equipment: %w", err)
}
if err := database.DB.Find(&weapons).Error; err != nil {
return fmt.Errorf("failed to retrieve equipment: %w", err)
}
if err := database.DB.Find(&containers).Error; err != nil {
return fmt.Errorf("failed to retrieve equipment: %w", err)
}
if err := database.DB.Find(&transportations).Error; err != nil {
return fmt.Errorf("failed to retrieve equipment: %w", err)
}
if err := database.DB.Find(&believes).Error; err != nil {
return fmt.Errorf("failed to retrieve equipment: %w", err)
}
// Combine the data into a single structure
exportData := exportData{
Skills: skills,
WeaponSkills: weaponSkills,
Spells: spells,
Equipments: equipments,
Weapons: weapons,
Containers: containers,
Transportations: transportations,
Believes: believes,
}
// Create the JSON file for writing
file, err := os.Create(filePath)
if err != nil {
return fmt.Errorf("failed to create JSON file: %w", err)
}
defer file.Close()
// Write the combined data as JSON
encoder := json.NewEncoder(file)
encoder.SetIndent("", " ") // Pretty-print the JSON
if err := encoder.Encode(exportData); err != nil {
return fmt.Errorf("failed to write JSON: %w", err)
}
fmt.Printf("Data exported to %s successfully\n", filePath)
return nil
}
// ReimportFromJSON reads a JSON file and reimports the data into the database
func Import(filePath string) error {
// Open the JSON file
file, err := os.Open(filePath)
if err != nil {
return fmt.Errorf("failed to open JSON file: %w", err)
}
defer file.Close()
// Decode the JSON file into the ExportData structure
var data exportData
decoder := json.NewDecoder(file)
if err := decoder.Decode(&data); err != nil {
return fmt.Errorf("failed to decode JSON file: %w", err)
}
// Save the data back to the database
if len(data.Skills) > 0 {
if err := database.DB.Clauses(clause.OnConflict{
UpdateAll: true, // Update all fields if there's a conflict
}).Create(&data.Skills).Error; err != nil {
return fmt.Errorf("failed to reimport skills: %w", err)
}
}
if len(data.WeaponSkills) > 0 {
if err := database.DB.Clauses(clause.OnConflict{
UpdateAll: true, // Update all fields if there's a conflict
}).Create(&data.WeaponSkills).Error; err != nil {
return fmt.Errorf("failed to reimport WeaponSkills: %w", err)
}
}
if len(data.Spells) > 0 {
if err := database.DB.Create(&data.Spells).Error; err != nil {
return fmt.Errorf("failed to reimport Spells: %w", err)
}
}
if len(data.Equipments) > 0 {
if err := database.DB.Clauses(clause.OnConflict{
UpdateAll: true, // Update all fields if there's a conflict
}).Create(&data.Equipments).Error; err != nil {
return fmt.Errorf("failed to reimport equipment: %w", err)
}
}
if len(data.Weapons) > 0 {
if err := database.DB.Clauses(clause.OnConflict{
UpdateAll: true, // Update all fields if there's a conflict
}).Create(&data.Weapons).Error; err != nil {
return fmt.Errorf("failed to reimport Weapons: %w", err)
}
}
if len(data.Containers) > 0 {
if err := database.DB.Clauses(clause.OnConflict{
UpdateAll: true, // Update all fields if there's a conflict
}).Create(&data.Containers).Error; err != nil {
return fmt.Errorf("failed to reimport Containers: %w", err)
}
}
if len(data.Transportations) > 0 {
if err := database.DB.Clauses(clause.OnConflict{
UpdateAll: true, // Update all fields if there's a conflict
}).Create(&data.Transportations).Error; err != nil {
return fmt.Errorf("failed to reimport Transportations: %w", err)
}
}
if len(data.Believes) > 0 {
if err := database.DB.Clauses(clause.OnConflict{
UpdateAll: true, // Update all fields if there's a conflict
}).Create(&data.Believes).Error; err != nil {
return fmt.Errorf("failed to reimport Believes: %w", err)
}
}
fmt.Printf("Data imported from %s successfully\n", filePath)
return nil
}
backend/gsmaster/model.go
+43
View File
@@ -404,3 +404,46 @@ func (object *Transportation) Save() error {
}
return nil
}
func (stamm *Believe) Create() error {
gameSystem := "midgard"
stamm.System = gameSystem
err := database.DB.Transaction(func(tx *gorm.DB) error {
// Save the main character record
if err := tx.Create(&stamm).Error; err != nil {
return fmt.Errorf("failed to save Lookup: %w", err)
}
return nil
})
return err
}
func (object *Believe) FirstId(value uint) error {
gameSystem := "midgard"
err := database.DB.First(&object, "system=? AND id = ?", gameSystem, value).Error
if err != nil {
// zauber found
return err
}
return nil
}
func (stamm *Believe) First(name string) error {
gameSystem := "midgard"
err := database.DB.First(&stamm, "system=? AND name = ?", gameSystem, name).Error
if err != nil {
// zauber found
return err
}
return nil
}
func (object *Believe) Save() error {
err := database.DB.Save(&object).Error
if err != nil {
// zauber found
return err
}
return nil
}
backend/importer/model.go
+27
View File
@@ -347,6 +347,26 @@ func TransformImportEquipment2GSDMaster(object *Ausruestung) (*gsmaster.Equipmen
return &gsmobj, nil
}
func TransformImportBelieve2GSDMaster(object string) (*gsmaster.Believe, error) {
gsmobj := gsmaster.Believe{}
err := gsmobj.First(object)
// if found check if we need to adjust masterdata
if err == nil {
return &gsmobj, nil
}
// if not found insert to masterdata
gsmobj.System = "midgard"
gsmobj.Name = object
gsmobj.Beschreibung = ""
//gsmobj.Quelle = object.Quelle
err = gsmobj.Create()
if err != nil {
return nil, fmt.Errorf("creating gsmaster record failed: %s", err)
}
return &gsmobj, nil
}
func CheckFertigkeiten2GSMaster(objects []Fertigkeit) error {
for i := range objects {
gsmobj, err := TransformImportFertigkeit2GSDMaster(&objects[i])
@@ -410,3 +430,10 @@ func CheckEquipments2GSMaster(objects []Ausruestung) error {
}
return nil
}
func CheckBelieve2GSMaster(objects *CharacterImport) error {
gsmobj, err := TransformImportBelieve2GSDMaster(objects.Glaube)
if err != nil {
return fmt.Errorf("creating gsmaster failed for 1 record: %s, %v", err, gsmobj)
}
return nil
}
backend/tests/importJSON2ImportStruct_test.go
+65 -14
View File
@@ -23,6 +23,7 @@ func initTestDB4Import() *gorm.DB {
&gsmaster.Container{},
&gsmaster.Transportation{},
&gsmaster.Equipment{},
&gsmaster.Believe{},
)
return db
}
@@ -228,8 +229,10 @@ func TestImportVTTStructure(t *testing.T) {
}
func TestImportSkill2GSMaster(t *testing.T) {
testDB := initTestDB4Import()
database.DB = testDB // Assign test DB to global DB
if database.DB == nil {
testDB := initTestDB4Import()
database.DB = testDB // Assign test DB to global DB
}
fileName := fmt.Sprintf("../testdata/%s", "VTT_Import1.json")
character, err := readImportChar(fileName)
assert.NoError(t, err, "Expected no error when Unmarshal filecontent")
@@ -270,8 +273,10 @@ func TestImportSkill2GSMaster(t *testing.T) {
}
func TestImportWeaponSkill2GSMaster(t *testing.T) {
testDB := initTestDB4Import()
database.DB = testDB // Assign test DB to global DB
if database.DB == nil {
testDB := initTestDB4Import()
database.DB = testDB // Assign test DB to global DB
}
fileName := fmt.Sprintf("../testdata/%s", "VTT_Import1.json")
character, err := readImportChar(fileName)
assert.NoError(t, err, "Expected no error when Unmarshal filecontent")
@@ -312,8 +317,10 @@ func TestImportWeaponSkill2GSMaster(t *testing.T) {
}
func TestImportSpell2GSMaster(t *testing.T) {
testDB := initTestDB4Import()
database.DB = testDB // Assign test DB to global DB
if database.DB == nil {
testDB := initTestDB4Import()
database.DB = testDB // Assign test DB to global DB
}
fileName := fmt.Sprintf("../testdata/%s", "VTT_Import1.json")
character, err := readImportChar(fileName)
assert.NoError(t, err, "Expected no error when Unmarshal filecontent")
@@ -356,8 +363,10 @@ func TestImportSpell2GSMaster(t *testing.T) {
}
func TestImportWeapon2GSMaster(t *testing.T) {
testDB := initTestDB4Import()
database.DB = testDB // Assign test DB to global DB
if database.DB == nil {
testDB := initTestDB4Import()
database.DB = testDB // Assign test DB to global DB
}
fileName := fmt.Sprintf("../testdata/%s", "VTT_Import1.json")
character, err := readImportChar(fileName)
assert.NoError(t, err, "Expected no error when Unmarshal filecontent")
@@ -400,8 +409,10 @@ func TestImportWeapon2GSMaster(t *testing.T) {
}
func TestImportContainer2GSMaster(t *testing.T) {
testDB := initTestDB4Import()
database.DB = testDB // Assign test DB to global DB
if database.DB == nil {
testDB := initTestDB4Import()
database.DB = testDB // Assign test DB to global DB
}
fileName := fmt.Sprintf("../testdata/%s", "VTT_Import1.json")
character, err := readImportChar(fileName)
assert.NoError(t, err, "Expected no error when Unmarshal filecontent")
@@ -444,8 +455,10 @@ func TestImportContainer2GSMaster(t *testing.T) {
}
func TestImportTransportation2GSMaster(t *testing.T) {
testDB := initTestDB4Import()
database.DB = testDB // Assign test DB to global DB
if database.DB == nil {
testDB := initTestDB4Import()
database.DB = testDB // Assign test DB to global DB
}
fileName := fmt.Sprintf("../testdata/%s", "VTT_Import1.json")
character, err := readImportChar(fileName)
assert.NoError(t, err, "Expected no error when Unmarshal filecontent")
@@ -488,8 +501,10 @@ func TestImportTransportation2GSMaster(t *testing.T) {
}
func TestImportEquipment2GSMaster(t *testing.T) {
testDB := initTestDB4Import()
database.DB = testDB // Assign test DB to global DB
if database.DB == nil {
testDB := initTestDB4Import()
database.DB = testDB // Assign test DB to global DB
}
fileName := fmt.Sprintf("../testdata/%s", "VTT_Import1.json")
character, err := readImportChar(fileName)
assert.NoError(t, err, "Expected no error when Unmarshal filecontent")
@@ -526,6 +541,42 @@ func TestImportEquipment2GSMaster(t *testing.T) {
err = importer.CheckEquipments2GSMaster(character.Ausruestung)
assert.NoError(t, err, "Expected no error when checkimg Transüportations against gsmaster")
}
func TestImportBelieve2GSMaster(t *testing.T) {
if database.DB == nil {
testDB := initTestDB4Import()
database.DB = testDB // Assign test DB to global DB
}
fileName := fmt.Sprintf("../testdata/%s", "VTT_Import1.json")
character, err := readImportChar(fileName)
assert.NoError(t, err, "Expected no error when Unmarshal filecontent")
//for i := range character.Fertigkeiten {
skill, erro := importer.TransformImportBelieve2GSDMaster(character.Glaube)
assert.NoError(t, erro, "Expected no error when Unmarshal filecontent")
assert.GreaterOrEqual(t, int(skill.ID), 1)
assert.Equal(t, "midgard", skill.System)
assert.Equal(t, "Torkin", skill.Name)
assert.Equal(t, "", skill.Beschreibung)
assert.Equal(t, "", skill.Quelle)
//}
skill2 := gsmaster.Believe{}
erro = skill2.First("Torkin")
assert.NoError(t, erro, "Expected no error when finding Record by name")
assert.Equal(t, 1, int(skill.ID))
skill3 := gsmaster.Believe{}
erro = skill3.FirstId(1)
assert.NoError(t, erro, "Expected no error when finding Record by ID")
assert.Equal(t, "Torkin", skill3.Name)
assert.Equal(t, skill2.ID, skill3.ID)
assert.Equal(t, skill2.System, skill3.System)
assert.Equal(t, skill2.Name, skill3.Name)
assert.Equal(t, skill2.Beschreibung, skill3.Beschreibung)
assert.Equal(t, skill2.Quelle, skill3.Quelle)
err = importer.CheckBelieve2GSMaster(character)
assert.NoError(t, err, "Expected no error when checkimg Transüportations against gsmaster")
}
/*
func TestImportFertigkeitenStammdatenSingle(t *testing.T) {
backend/tests/stammdaten_test.go
+51
View File
@@ -3,7 +3,9 @@ package tests
import (
"bamort/database"
"bamort/gsmaster"
"fmt"
"testing"
"time"
"github.com/stretchr/testify/assert"
"gorm.io/gorm"
@@ -18,10 +20,26 @@ func initTestDB4Lookup() *gorm.DB {
&gsmaster.Equipment{}, //needed for stammdaten.Check...
&gsmaster.Container{}, //needed for stammdaten.Check...
&gsmaster.Transportation{}, //needed for stammdaten.Check...
&gsmaster.Weapon{},
&gsmaster.Believe{},
)
return db
}
// GenerateFilename generates a filename based on the prefix and the current date/time
func generateFilename(prefix string, extension string) string {
// Get the current date and time
now := time.Now()
// Format the date and time as "YYYY-MM-DD_HH-MM-SS"
//timestamp = now.Format("2006-01-02_15-04-05")
timestamp := now.Format("20060102_150405")
// Combine the prefix and the timestamp to form the filename
return fmt.Sprintf("%s_%s.%s", prefix, timestamp, extension)
}
/*s
func TestCreateLookupSkill(t *testing.T) {
// Setup test database
testDB := initTestDB4Lookup()
@@ -218,3 +236,36 @@ func TestFindLookupTransportation(t *testing.T) {
assert.Equal(t, 0.6, stamm.Gewicht)
assert.Equal(t, 12.5, stamm.Volumen)
}
*/
func TestExportGSMasterdata(t *testing.T) {
// Setup test database
if database.DB == nil {
testDB := initTestDB4Import()
database.DB = testDB // Assign test DB to global DB
}
//testDB := initTestDB4Lookup()
//database.DB = testDB // Assign test DB to global DB
TestImportSkill2GSMaster(t)
TestImportWeaponSkill2GSMaster(t)
TestImportSpell2GSMaster(t)
TestImportWeapon2GSMaster(t)
TestImportContainer2GSMaster(t)
TestImportTransportation2GSMaster(t)
TestImportEquipment2GSMaster(t)
TestImportBelieve2GSMaster(t)
err := gsmaster.Export(generateFilename("../testdata/gsmaster_", "json"))
assert.NoError(t, err, "expexted no Error during Export if gsmaster data")
}
func TestImportGSMasterdata(t *testing.T) {
// Setup test database
if database.DB == nil {
testDB := initTestDB4Import()
database.DB = testDB // Assign test DB to global DB
}
//testDB := initTestDB4Lookup()
//database.DB = testDB // Assign test DB to global DB
err := gsmaster.Import(generateFilename("../testdata/gsmaster_", "json"))
assert.NoError(t, err, "expexted no Error during Export if gsmaster data")
}