FormFieldDB.go

// generated by stacks/gong/go/models/orm_file_per_struct_back_repo.go
package orm

import (
	"database/sql"
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"path/filepath"
	"sort"
	"time"

	"gorm.io/gorm"

	"github.com/tealeg/xlsx/v3"

	"github.com/fullstack-lang/gongform/go/models"
)

// dummy variable to have the import declaration wihthout compile failure (even if no code needing this import is generated)
var dummy_FormField_sql sql.NullBool
var dummy_FormField_time time.Duration
var dummy_FormField_sort sort.Float64Slice

// FormFieldAPI is the input in POST API
//
// for POST, API, one needs the fields of the model as well as the fields
// from associations ("Has One" and "Has Many") that are generated to
// fullfill the ORM requirements for associations
//
// swagger:model formfieldAPI
type FormFieldAPI struct {
	gorm.Model

	models.FormField_WOP

	// encoding of pointers
	FormFieldPointersEncoding FormFieldPointersEncoding
}

// FormFieldPointersEncoding encodes pointers to Struct and
// reverse pointers of slice of poitners to Struct
type FormFieldPointersEncoding struct {
	// insertion for pointer fields encoding declaration

	// field FormFieldString is a pointer to another Struct (optional or 0..1)
	// This field is generated into another field to enable AS ONE association
	FormFieldStringID sql.NullInt64

	// field FormFieldFloat64 is a pointer to another Struct (optional or 0..1)
	// This field is generated into another field to enable AS ONE association
	FormFieldFloat64ID sql.NullInt64

	// field FormFieldInt is a pointer to another Struct (optional or 0..1)
	// This field is generated into another field to enable AS ONE association
	FormFieldIntID sql.NullInt64

	// field FormFieldDate is a pointer to another Struct (optional or 0..1)
	// This field is generated into another field to enable AS ONE association
	FormFieldDateID sql.NullInt64

	// field FormFieldTime is a pointer to another Struct (optional or 0..1)
	// This field is generated into another field to enable AS ONE association
	FormFieldTimeID sql.NullInt64

	// field FormFieldDateTime is a pointer to another Struct (optional or 0..1)
	// This field is generated into another field to enable AS ONE association
	FormFieldDateTimeID sql.NullInt64

	// field FormFieldSelect is a pointer to another Struct (optional or 0..1)
	// This field is generated into another field to enable AS ONE association
	FormFieldSelectID sql.NullInt64
}

// FormFieldDB describes a formfield in the database
//
// It incorporates the GORM ID, basic fields from the model (because they can be serialized),
// the encoded version of pointers
//
// swagger:model formfieldDB
type FormFieldDB struct {
	gorm.Model

	// insertion for basic fields declaration

	// Declation for basic field formfieldDB.Name
	Name_Data sql.NullString

	// Declation for basic field formfieldDB.InputTypeEnum
	InputTypeEnum_Data sql.NullString

	// Declation for basic field formfieldDB.Label
	Label_Data sql.NullString

	// Declation for basic field formfieldDB.Placeholder
	Placeholder_Data sql.NullString

	// Declation for basic field formfieldDB.HasBespokeWidth
	// provide the sql storage for the boolan
	HasBespokeWidth_Data sql.NullBool

	// Declation for basic field formfieldDB.BespokeWidthPx
	BespokeWidthPx_Data sql.NullInt64
	// encoding of pointers
	FormFieldPointersEncoding
}

// FormFieldDBs arrays formfieldDBs
// swagger:response formfieldDBsResponse
type FormFieldDBs []FormFieldDB

// FormFieldDBResponse provides response
// swagger:response formfieldDBResponse
type FormFieldDBResponse struct {
	FormFieldDB
}

// FormFieldWOP is a FormField without pointers (WOP is an acronym for "Without Pointers")
// it holds the same basic fields but pointers are encoded into uint
type FormFieldWOP struct {
	ID int `xlsx:"0"`

	// insertion for WOP basic fields

	Name string `xlsx:"1"`

	InputTypeEnum models.InputTypeEnum `xlsx:"2"`

	Label string `xlsx:"3"`

	Placeholder string `xlsx:"4"`

	HasBespokeWidth bool `xlsx:"5"`

	BespokeWidthPx int `xlsx:"6"`
	// insertion for WOP pointer fields
}

var FormField_Fields = []string{
	// insertion for WOP basic fields
	"ID",
	"Name",
	"InputTypeEnum",
	"Label",
	"Placeholder",
	"HasBespokeWidth",
	"BespokeWidthPx",
}

type BackRepoFormFieldStruct struct {
	// stores FormFieldDB according to their gorm ID
	Map_FormFieldDBID_FormFieldDB map[uint]*FormFieldDB

	// stores FormFieldDB ID according to FormField address
	Map_FormFieldPtr_FormFieldDBID map[*models.FormField]uint

	// stores FormField according to their gorm ID
	Map_FormFieldDBID_FormFieldPtr map[uint]*models.FormField

	db *gorm.DB

	stage *models.StageStruct
}

func (backRepoFormField *BackRepoFormFieldStruct) GetStage() (stage *models.StageStruct) {
	stage = backRepoFormField.stage
	return
}

func (backRepoFormField *BackRepoFormFieldStruct) GetDB() *gorm.DB {
	return backRepoFormField.db
}

// GetFormFieldDBFromFormFieldPtr is a handy function to access the back repo instance from the stage instance
func (backRepoFormField *BackRepoFormFieldStruct) GetFormFieldDBFromFormFieldPtr(formfield *models.FormField) (formfieldDB *FormFieldDB) {
	id := backRepoFormField.Map_FormFieldPtr_FormFieldDBID[formfield]
	formfieldDB = backRepoFormField.Map_FormFieldDBID_FormFieldDB[id]
	return
}

// BackRepoFormField.CommitPhaseOne commits all staged instances of FormField to the BackRepo
// Phase One is the creation of instance in the database if it is not yet done to get the unique ID for each staged instance
func (backRepoFormField *BackRepoFormFieldStruct) CommitPhaseOne(stage *models.StageStruct) (Error error) {

	for formfield := range stage.FormFields {
		backRepoFormField.CommitPhaseOneInstance(formfield)
	}

	// parse all backRepo instance and checks wether some instance have been unstaged
	// in this case, remove them from the back repo
	for id, formfield := range backRepoFormField.Map_FormFieldDBID_FormFieldPtr {
		if _, ok := stage.FormFields[formfield]; !ok {
			backRepoFormField.CommitDeleteInstance(id)
		}
	}

	return
}

// BackRepoFormField.CommitDeleteInstance commits deletion of FormField to the BackRepo
func (backRepoFormField *BackRepoFormFieldStruct) CommitDeleteInstance(id uint) (Error error) {

	formfield := backRepoFormField.Map_FormFieldDBID_FormFieldPtr[id]

	// formfield is not staged anymore, remove formfieldDB
	formfieldDB := backRepoFormField.Map_FormFieldDBID_FormFieldDB[id]
	query := backRepoFormField.db.Unscoped().Delete(&formfieldDB)
	if query.Error != nil {
		log.Fatal(query.Error)
	}

	// update stores
	delete(backRepoFormField.Map_FormFieldPtr_FormFieldDBID, formfield)
	delete(backRepoFormField.Map_FormFieldDBID_FormFieldPtr, id)
	delete(backRepoFormField.Map_FormFieldDBID_FormFieldDB, id)

	return
}

// BackRepoFormField.CommitPhaseOneInstance commits formfield staged instances of FormField to the BackRepo
// Phase One is the creation of instance in the database if it is not yet done to get the unique ID for each staged instance
func (backRepoFormField *BackRepoFormFieldStruct) CommitPhaseOneInstance(formfield *models.FormField) (Error error) {

	// check if the formfield is not commited yet
	if _, ok := backRepoFormField.Map_FormFieldPtr_FormFieldDBID[formfield]; ok {
		return
	}

	// initiate formfield
	var formfieldDB FormFieldDB
	formfieldDB.CopyBasicFieldsFromFormField(formfield)

	query := backRepoFormField.db.Create(&formfieldDB)
	if query.Error != nil {
		log.Fatal(query.Error)
	}

	// update stores
	backRepoFormField.Map_FormFieldPtr_FormFieldDBID[formfield] = formfieldDB.ID
	backRepoFormField.Map_FormFieldDBID_FormFieldPtr[formfieldDB.ID] = formfield
	backRepoFormField.Map_FormFieldDBID_FormFieldDB[formfieldDB.ID] = &formfieldDB

	return
}

// BackRepoFormField.CommitPhaseTwo commits all staged instances of FormField to the BackRepo
// Phase Two is the update of instance with the field in the database
func (backRepoFormField *BackRepoFormFieldStruct) CommitPhaseTwo(backRepo *BackRepoStruct) (Error error) {

	for idx, formfield := range backRepoFormField.Map_FormFieldDBID_FormFieldPtr {
		backRepoFormField.CommitPhaseTwoInstance(backRepo, idx, formfield)
	}

	return
}

// BackRepoFormField.CommitPhaseTwoInstance commits {{structname }} of models.FormField to the BackRepo
// Phase Two is the update of instance with the field in the database
func (backRepoFormField *BackRepoFormFieldStruct) CommitPhaseTwoInstance(backRepo *BackRepoStruct, idx uint, formfield *models.FormField) (Error error) {

	// fetch matching formfieldDB
	if formfieldDB, ok := backRepoFormField.Map_FormFieldDBID_FormFieldDB[idx]; ok {

		formfieldDB.CopyBasicFieldsFromFormField(formfield)

		// insertion point for translating pointers encodings into actual pointers
		// commit pointer value formfield.FormFieldString translates to updating the formfield.FormFieldStringID
		formfieldDB.FormFieldStringID.Valid = true // allow for a 0 value (nil association)
		if formfield.FormFieldString != nil {
			if FormFieldStringId, ok := backRepo.BackRepoFormFieldString.Map_FormFieldStringPtr_FormFieldStringDBID[formfield.FormFieldString]; ok {
				formfieldDB.FormFieldStringID.Int64 = int64(FormFieldStringId)
				formfieldDB.FormFieldStringID.Valid = true
			}
		} else {
			formfieldDB.FormFieldStringID.Int64 = 0
			formfieldDB.FormFieldStringID.Valid = true
		}

		// commit pointer value formfield.FormFieldFloat64 translates to updating the formfield.FormFieldFloat64ID
		formfieldDB.FormFieldFloat64ID.Valid = true // allow for a 0 value (nil association)
		if formfield.FormFieldFloat64 != nil {
			if FormFieldFloat64Id, ok := backRepo.BackRepoFormFieldFloat64.Map_FormFieldFloat64Ptr_FormFieldFloat64DBID[formfield.FormFieldFloat64]; ok {
				formfieldDB.FormFieldFloat64ID.Int64 = int64(FormFieldFloat64Id)
				formfieldDB.FormFieldFloat64ID.Valid = true
			}
		} else {
			formfieldDB.FormFieldFloat64ID.Int64 = 0
			formfieldDB.FormFieldFloat64ID.Valid = true
		}

		// commit pointer value formfield.FormFieldInt translates to updating the formfield.FormFieldIntID
		formfieldDB.FormFieldIntID.Valid = true // allow for a 0 value (nil association)
		if formfield.FormFieldInt != nil {
			if FormFieldIntId, ok := backRepo.BackRepoFormFieldInt.Map_FormFieldIntPtr_FormFieldIntDBID[formfield.FormFieldInt]; ok {
				formfieldDB.FormFieldIntID.Int64 = int64(FormFieldIntId)
				formfieldDB.FormFieldIntID.Valid = true
			}
		} else {
			formfieldDB.FormFieldIntID.Int64 = 0
			formfieldDB.FormFieldIntID.Valid = true
		}

		// commit pointer value formfield.FormFieldDate translates to updating the formfield.FormFieldDateID
		formfieldDB.FormFieldDateID.Valid = true // allow for a 0 value (nil association)
		if formfield.FormFieldDate != nil {
			if FormFieldDateId, ok := backRepo.BackRepoFormFieldDate.Map_FormFieldDatePtr_FormFieldDateDBID[formfield.FormFieldDate]; ok {
				formfieldDB.FormFieldDateID.Int64 = int64(FormFieldDateId)
				formfieldDB.FormFieldDateID.Valid = true
			}
		} else {
			formfieldDB.FormFieldDateID.Int64 = 0
			formfieldDB.FormFieldDateID.Valid = true
		}

		// commit pointer value formfield.FormFieldTime translates to updating the formfield.FormFieldTimeID
		formfieldDB.FormFieldTimeID.Valid = true // allow for a 0 value (nil association)
		if formfield.FormFieldTime != nil {
			if FormFieldTimeId, ok := backRepo.BackRepoFormFieldTime.Map_FormFieldTimePtr_FormFieldTimeDBID[formfield.FormFieldTime]; ok {
				formfieldDB.FormFieldTimeID.Int64 = int64(FormFieldTimeId)
				formfieldDB.FormFieldTimeID.Valid = true
			}
		} else {
			formfieldDB.FormFieldTimeID.Int64 = 0
			formfieldDB.FormFieldTimeID.Valid = true
		}

		// commit pointer value formfield.FormFieldDateTime translates to updating the formfield.FormFieldDateTimeID
		formfieldDB.FormFieldDateTimeID.Valid = true // allow for a 0 value (nil association)
		if formfield.FormFieldDateTime != nil {
			if FormFieldDateTimeId, ok := backRepo.BackRepoFormFieldDateTime.Map_FormFieldDateTimePtr_FormFieldDateTimeDBID[formfield.FormFieldDateTime]; ok {
				formfieldDB.FormFieldDateTimeID.Int64 = int64(FormFieldDateTimeId)
				formfieldDB.FormFieldDateTimeID.Valid = true
			}
		} else {
			formfieldDB.FormFieldDateTimeID.Int64 = 0
			formfieldDB.FormFieldDateTimeID.Valid = true
		}

		// commit pointer value formfield.FormFieldSelect translates to updating the formfield.FormFieldSelectID
		formfieldDB.FormFieldSelectID.Valid = true // allow for a 0 value (nil association)
		if formfield.FormFieldSelect != nil {
			if FormFieldSelectId, ok := backRepo.BackRepoFormFieldSelect.Map_FormFieldSelectPtr_FormFieldSelectDBID[formfield.FormFieldSelect]; ok {
				formfieldDB.FormFieldSelectID.Int64 = int64(FormFieldSelectId)
				formfieldDB.FormFieldSelectID.Valid = true
			}
		} else {
			formfieldDB.FormFieldSelectID.Int64 = 0
			formfieldDB.FormFieldSelectID.Valid = true
		}

		query := backRepoFormField.db.Save(&formfieldDB)
		if query.Error != nil {
			log.Fatalln(query.Error)
		}

	} else {
		err := errors.New(
			fmt.Sprintf("Unkown FormField intance %s", formfield.Name))
		return err
	}

	return
}

// BackRepoFormField.CheckoutPhaseOne Checkouts all BackRepo instances to the Stage
//
// Phase One will result in having instances on the stage aligned with the back repo
// pointers are not initialized yet (this is for phase two)
func (backRepoFormField *BackRepoFormFieldStruct) CheckoutPhaseOne() (Error error) {

	formfieldDBArray := make([]FormFieldDB, 0)
	query := backRepoFormField.db.Find(&formfieldDBArray)
	if query.Error != nil {
		return query.Error
	}

	// list of instances to be removed
	// start from the initial map on the stage and remove instances that have been checked out
	formfieldInstancesToBeRemovedFromTheStage := make(map[*models.FormField]any)
	for key, value := range backRepoFormField.stage.FormFields {
		formfieldInstancesToBeRemovedFromTheStage[key] = value
	}

	// copy orm objects to the the map
	for _, formfieldDB := range formfieldDBArray {
		backRepoFormField.CheckoutPhaseOneInstance(&formfieldDB)

		// do not remove this instance from the stage, therefore
		// remove instance from the list of instances to be be removed from the stage
		formfield, ok := backRepoFormField.Map_FormFieldDBID_FormFieldPtr[formfieldDB.ID]
		if ok {
			delete(formfieldInstancesToBeRemovedFromTheStage, formfield)
		}
	}

	// remove from stage and back repo's 3 maps all formfields that are not in the checkout
	for formfield := range formfieldInstancesToBeRemovedFromTheStage {
		formfield.Unstage(backRepoFormField.GetStage())

		// remove instance from the back repo 3 maps
		formfieldID := backRepoFormField.Map_FormFieldPtr_FormFieldDBID[formfield]
		delete(backRepoFormField.Map_FormFieldPtr_FormFieldDBID, formfield)
		delete(backRepoFormField.Map_FormFieldDBID_FormFieldDB, formfieldID)
		delete(backRepoFormField.Map_FormFieldDBID_FormFieldPtr, formfieldID)
	}

	return
}

// CheckoutPhaseOneInstance takes a formfieldDB that has been found in the DB, updates the backRepo and stages the
// models version of the formfieldDB
func (backRepoFormField *BackRepoFormFieldStruct) CheckoutPhaseOneInstance(formfieldDB *FormFieldDB) (Error error) {

	formfield, ok := backRepoFormField.Map_FormFieldDBID_FormFieldPtr[formfieldDB.ID]
	if !ok {
		formfield = new(models.FormField)

		backRepoFormField.Map_FormFieldDBID_FormFieldPtr[formfieldDB.ID] = formfield
		backRepoFormField.Map_FormFieldPtr_FormFieldDBID[formfield] = formfieldDB.ID

		// append model store with the new element
		formfield.Name = formfieldDB.Name_Data.String
		formfield.Stage(backRepoFormField.GetStage())
	}
	formfieldDB.CopyBasicFieldsToFormField(formfield)

	// in some cases, the instance might have been unstaged. It is necessary to stage it again
	formfield.Stage(backRepoFormField.GetStage())

	// preserve pointer to formfieldDB. Otherwise, pointer will is recycled and the map of pointers
	// Map_FormFieldDBID_FormFieldDB)[formfieldDB hold variable pointers
	formfieldDB_Data := *formfieldDB
	preservedPtrToFormField := &formfieldDB_Data
	backRepoFormField.Map_FormFieldDBID_FormFieldDB[formfieldDB.ID] = preservedPtrToFormField

	return
}

// BackRepoFormField.CheckoutPhaseTwo Checkouts all staged instances of FormField to the BackRepo
// Phase Two is the update of instance with the field in the database
func (backRepoFormField *BackRepoFormFieldStruct) CheckoutPhaseTwo(backRepo *BackRepoStruct) (Error error) {

	// parse all DB instance and update all pointer fields of the translated models instance
	for _, formfieldDB := range backRepoFormField.Map_FormFieldDBID_FormFieldDB {
		backRepoFormField.CheckoutPhaseTwoInstance(backRepo, formfieldDB)
	}
	return
}

// BackRepoFormField.CheckoutPhaseTwoInstance Checkouts staged instances of FormField to the BackRepo
// Phase Two is the update of instance with the field in the database
func (backRepoFormField *BackRepoFormFieldStruct) CheckoutPhaseTwoInstance(backRepo *BackRepoStruct, formfieldDB *FormFieldDB) (Error error) {

	formfield := backRepoFormField.Map_FormFieldDBID_FormFieldPtr[formfieldDB.ID]

	formfieldDB.DecodePointers(backRepo, formfield)

	return
}

func (formfieldDB *FormFieldDB) DecodePointers(backRepo *BackRepoStruct, formfield *models.FormField) {

	// insertion point for checkout of pointer encoding
	// FormFieldString field
	formfield.FormFieldString = nil
	if formfieldDB.FormFieldStringID.Int64 != 0 {
		formfield.FormFieldString = backRepo.BackRepoFormFieldString.Map_FormFieldStringDBID_FormFieldStringPtr[uint(formfieldDB.FormFieldStringID.Int64)]
	}
	// FormFieldFloat64 field
	formfield.FormFieldFloat64 = nil
	if formfieldDB.FormFieldFloat64ID.Int64 != 0 {
		formfield.FormFieldFloat64 = backRepo.BackRepoFormFieldFloat64.Map_FormFieldFloat64DBID_FormFieldFloat64Ptr[uint(formfieldDB.FormFieldFloat64ID.Int64)]
	}
	// FormFieldInt field
	formfield.FormFieldInt = nil
	if formfieldDB.FormFieldIntID.Int64 != 0 {
		formfield.FormFieldInt = backRepo.BackRepoFormFieldInt.Map_FormFieldIntDBID_FormFieldIntPtr[uint(formfieldDB.FormFieldIntID.Int64)]
	}
	// FormFieldDate field
	formfield.FormFieldDate = nil
	if formfieldDB.FormFieldDateID.Int64 != 0 {
		formfield.FormFieldDate = backRepo.BackRepoFormFieldDate.Map_FormFieldDateDBID_FormFieldDatePtr[uint(formfieldDB.FormFieldDateID.Int64)]
	}
	// FormFieldTime field
	formfield.FormFieldTime = nil
	if formfieldDB.FormFieldTimeID.Int64 != 0 {
		formfield.FormFieldTime = backRepo.BackRepoFormFieldTime.Map_FormFieldTimeDBID_FormFieldTimePtr[uint(formfieldDB.FormFieldTimeID.Int64)]
	}
	// FormFieldDateTime field
	formfield.FormFieldDateTime = nil
	if formfieldDB.FormFieldDateTimeID.Int64 != 0 {
		formfield.FormFieldDateTime = backRepo.BackRepoFormFieldDateTime.Map_FormFieldDateTimeDBID_FormFieldDateTimePtr[uint(formfieldDB.FormFieldDateTimeID.Int64)]
	}
	// FormFieldSelect field
	formfield.FormFieldSelect = nil
	if formfieldDB.FormFieldSelectID.Int64 != 0 {
		formfield.FormFieldSelect = backRepo.BackRepoFormFieldSelect.Map_FormFieldSelectDBID_FormFieldSelectPtr[uint(formfieldDB.FormFieldSelectID.Int64)]
	}
	return
}

// CommitFormField allows commit of a single formfield (if already staged)
func (backRepo *BackRepoStruct) CommitFormField(formfield *models.FormField) {
	backRepo.BackRepoFormField.CommitPhaseOneInstance(formfield)
	if id, ok := backRepo.BackRepoFormField.Map_FormFieldPtr_FormFieldDBID[formfield]; ok {
		backRepo.BackRepoFormField.CommitPhaseTwoInstance(backRepo, id, formfield)
	}
	backRepo.CommitFromBackNb = backRepo.CommitFromBackNb + 1
}

// CommitFormField allows checkout of a single formfield (if already staged and with a BackRepo id)
func (backRepo *BackRepoStruct) CheckoutFormField(formfield *models.FormField) {
	// check if the formfield is staged
	if _, ok := backRepo.BackRepoFormField.Map_FormFieldPtr_FormFieldDBID[formfield]; ok {

		if id, ok := backRepo.BackRepoFormField.Map_FormFieldPtr_FormFieldDBID[formfield]; ok {
			var formfieldDB FormFieldDB
			formfieldDB.ID = id

			if err := backRepo.BackRepoFormField.db.First(&formfieldDB, id).Error; err != nil {
				log.Fatalln("CheckoutFormField : Problem with getting object with id:", id)
			}
			backRepo.BackRepoFormField.CheckoutPhaseOneInstance(&formfieldDB)
			backRepo.BackRepoFormField.CheckoutPhaseTwoInstance(backRepo, &formfieldDB)
		}
	}
}

// CopyBasicFieldsFromFormField
func (formfieldDB *FormFieldDB) CopyBasicFieldsFromFormField(formfield *models.FormField) {
	// insertion point for fields commit

	formfieldDB.Name_Data.String = formfield.Name
	formfieldDB.Name_Data.Valid = true

	formfieldDB.InputTypeEnum_Data.String = formfield.InputTypeEnum.ToString()
	formfieldDB.InputTypeEnum_Data.Valid = true

	formfieldDB.Label_Data.String = formfield.Label
	formfieldDB.Label_Data.Valid = true

	formfieldDB.Placeholder_Data.String = formfield.Placeholder
	formfieldDB.Placeholder_Data.Valid = true

	formfieldDB.HasBespokeWidth_Data.Bool = formfield.HasBespokeWidth
	formfieldDB.HasBespokeWidth_Data.Valid = true

	formfieldDB.BespokeWidthPx_Data.Int64 = int64(formfield.BespokeWidthPx)
	formfieldDB.BespokeWidthPx_Data.Valid = true
}

// CopyBasicFieldsFromFormField_WOP
func (formfieldDB *FormFieldDB) CopyBasicFieldsFromFormField_WOP(formfield *models.FormField_WOP) {
	// insertion point for fields commit

	formfieldDB.Name_Data.String = formfield.Name
	formfieldDB.Name_Data.Valid = true

	formfieldDB.InputTypeEnum_Data.String = formfield.InputTypeEnum.ToString()
	formfieldDB.InputTypeEnum_Data.Valid = true

	formfieldDB.Label_Data.String = formfield.Label
	formfieldDB.Label_Data.Valid = true

	formfieldDB.Placeholder_Data.String = formfield.Placeholder
	formfieldDB.Placeholder_Data.Valid = true

	formfieldDB.HasBespokeWidth_Data.Bool = formfield.HasBespokeWidth
	formfieldDB.HasBespokeWidth_Data.Valid = true

	formfieldDB.BespokeWidthPx_Data.Int64 = int64(formfield.BespokeWidthPx)
	formfieldDB.BespokeWidthPx_Data.Valid = true
}

// CopyBasicFieldsFromFormFieldWOP
func (formfieldDB *FormFieldDB) CopyBasicFieldsFromFormFieldWOP(formfield *FormFieldWOP) {
	// insertion point for fields commit

	formfieldDB.Name_Data.String = formfield.Name
	formfieldDB.Name_Data.Valid = true

	formfieldDB.InputTypeEnum_Data.String = formfield.InputTypeEnum.ToString()
	formfieldDB.InputTypeEnum_Data.Valid = true

	formfieldDB.Label_Data.String = formfield.Label
	formfieldDB.Label_Data.Valid = true

	formfieldDB.Placeholder_Data.String = formfield.Placeholder
	formfieldDB.Placeholder_Data.Valid = true

	formfieldDB.HasBespokeWidth_Data.Bool = formfield.HasBespokeWidth
	formfieldDB.HasBespokeWidth_Data.Valid = true

	formfieldDB.BespokeWidthPx_Data.Int64 = int64(formfield.BespokeWidthPx)
	formfieldDB.BespokeWidthPx_Data.Valid = true
}

// CopyBasicFieldsToFormField
func (formfieldDB *FormFieldDB) CopyBasicFieldsToFormField(formfield *models.FormField) {
	// insertion point for checkout of basic fields (back repo to stage)
	formfield.Name = formfieldDB.Name_Data.String
	formfield.InputTypeEnum.FromString(formfieldDB.InputTypeEnum_Data.String)
	formfield.Label = formfieldDB.Label_Data.String
	formfield.Placeholder = formfieldDB.Placeholder_Data.String
	formfield.HasBespokeWidth = formfieldDB.HasBespokeWidth_Data.Bool
	formfield.BespokeWidthPx = int(formfieldDB.BespokeWidthPx_Data.Int64)
}

// CopyBasicFieldsToFormField_WOP
func (formfieldDB *FormFieldDB) CopyBasicFieldsToFormField_WOP(formfield *models.FormField_WOP) {
	// insertion point for checkout of basic fields (back repo to stage)
	formfield.Name = formfieldDB.Name_Data.String
	formfield.InputTypeEnum.FromString(formfieldDB.InputTypeEnum_Data.String)
	formfield.Label = formfieldDB.Label_Data.String
	formfield.Placeholder = formfieldDB.Placeholder_Data.String
	formfield.HasBespokeWidth = formfieldDB.HasBespokeWidth_Data.Bool
	formfield.BespokeWidthPx = int(formfieldDB.BespokeWidthPx_Data.Int64)
}

// CopyBasicFieldsToFormFieldWOP
func (formfieldDB *FormFieldDB) CopyBasicFieldsToFormFieldWOP(formfield *FormFieldWOP) {
	formfield.ID = int(formfieldDB.ID)
	// insertion point for checkout of basic fields (back repo to stage)
	formfield.Name = formfieldDB.Name_Data.String
	formfield.InputTypeEnum.FromString(formfieldDB.InputTypeEnum_Data.String)
	formfield.Label = formfieldDB.Label_Data.String
	formfield.Placeholder = formfieldDB.Placeholder_Data.String
	formfield.HasBespokeWidth = formfieldDB.HasBespokeWidth_Data.Bool
	formfield.BespokeWidthPx = int(formfieldDB.BespokeWidthPx_Data.Int64)
}

// Backup generates a json file from a slice of all FormFieldDB instances in the backrepo
func (backRepoFormField *BackRepoFormFieldStruct) Backup(dirPath string) {

	filename := filepath.Join(dirPath, "FormFieldDB.json")

	// organize the map into an array with increasing IDs, in order to have repoductible
	// backup file
	forBackup := make([]*FormFieldDB, 0)
	for _, formfieldDB := range backRepoFormField.Map_FormFieldDBID_FormFieldDB {
		forBackup = append(forBackup, formfieldDB)
	}

	sort.Slice(forBackup[:], func(i, j int) bool {
		return forBackup[i].ID < forBackup[j].ID
	})

	file, err := json.MarshalIndent(forBackup, "", " ")

	if err != nil {
		log.Fatal("Cannot json FormField ", filename, " ", err.Error())
	}

	err = ioutil.WriteFile(filename, file, 0644)
	if err != nil {
		log.Fatal("Cannot write the json FormField file", err.Error())
	}
}

// Backup generates a json file from a slice of all FormFieldDB instances in the backrepo
func (backRepoFormField *BackRepoFormFieldStruct) BackupXL(file *xlsx.File) {

	// organize the map into an array with increasing IDs, in order to have repoductible
	// backup file
	forBackup := make([]*FormFieldDB, 0)
	for _, formfieldDB := range backRepoFormField.Map_FormFieldDBID_FormFieldDB {
		forBackup = append(forBackup, formfieldDB)
	}

	sort.Slice(forBackup[:], func(i, j int) bool {
		return forBackup[i].ID < forBackup[j].ID
	})

	sh, err := file.AddSheet("FormField")
	if err != nil {
		log.Fatal("Cannot add XL file", err.Error())
	}
	_ = sh

	row := sh.AddRow()
	row.WriteSlice(&FormField_Fields, -1)
	for _, formfieldDB := range forBackup {

		var formfieldWOP FormFieldWOP
		formfieldDB.CopyBasicFieldsToFormFieldWOP(&formfieldWOP)

		row := sh.AddRow()
		row.WriteStruct(&formfieldWOP, -1)
	}
}

// RestoreXL from the "FormField" sheet all FormFieldDB instances
func (backRepoFormField *BackRepoFormFieldStruct) RestoreXLPhaseOne(file *xlsx.File) {

	// resets the map
	BackRepoFormFieldid_atBckpTime_newID = make(map[uint]uint)

	sh, ok := file.Sheet["FormField"]
	_ = sh
	if !ok {
		log.Fatal(errors.New("sheet not found"))
	}

	// log.Println("Max row is", sh.MaxRow)
	err := sh.ForEachRow(backRepoFormField.rowVisitorFormField)
	if err != nil {
		log.Fatal("Err=", err)
	}
}

func (backRepoFormField *BackRepoFormFieldStruct) rowVisitorFormField(row *xlsx.Row) error {

	log.Printf("row line %d\n", row.GetCoordinate())
	log.Println(row)

	// skip first line
	if row.GetCoordinate() > 0 {
		var formfieldWOP FormFieldWOP
		row.ReadStruct(&formfieldWOP)

		// add the unmarshalled struct to the stage
		formfieldDB := new(FormFieldDB)
		formfieldDB.CopyBasicFieldsFromFormFieldWOP(&formfieldWOP)

		formfieldDB_ID_atBackupTime := formfieldDB.ID
		formfieldDB.ID = 0
		query := backRepoFormField.db.Create(formfieldDB)
		if query.Error != nil {
			log.Fatal(query.Error)
		}
		backRepoFormField.Map_FormFieldDBID_FormFieldDB[formfieldDB.ID] = formfieldDB
		BackRepoFormFieldid_atBckpTime_newID[formfieldDB_ID_atBackupTime] = formfieldDB.ID
	}
	return nil
}

// RestorePhaseOne read the file "FormFieldDB.json" in dirPath that stores an array
// of FormFieldDB and stores it in the database
// the map BackRepoFormFieldid_atBckpTime_newID is updated accordingly
func (backRepoFormField *BackRepoFormFieldStruct) RestorePhaseOne(dirPath string) {

	// resets the map
	BackRepoFormFieldid_atBckpTime_newID = make(map[uint]uint)

	filename := filepath.Join(dirPath, "FormFieldDB.json")
	jsonFile, err := os.Open(filename)
	// if we os.Open returns an error then handle it
	if err != nil {
		log.Fatal("Cannot restore/open the json FormField file", filename, " ", err.Error())
	}

	// read our opened jsonFile as a byte array.
	byteValue, _ := ioutil.ReadAll(jsonFile)

	var forRestore []*FormFieldDB

	err = json.Unmarshal(byteValue, &forRestore)

	// fill up Map_FormFieldDBID_FormFieldDB
	for _, formfieldDB := range forRestore {

		formfieldDB_ID_atBackupTime := formfieldDB.ID
		formfieldDB.ID = 0
		query := backRepoFormField.db.Create(formfieldDB)
		if query.Error != nil {
			log.Fatal(query.Error)
		}
		backRepoFormField.Map_FormFieldDBID_FormFieldDB[formfieldDB.ID] = formfieldDB
		BackRepoFormFieldid_atBckpTime_newID[formfieldDB_ID_atBackupTime] = formfieldDB.ID
	}

	if err != nil {
		log.Fatal("Cannot restore/unmarshall json FormField file", err.Error())
	}
}

// RestorePhaseTwo uses all map BackRepo<FormField>id_atBckpTime_newID
// to compute new index
func (backRepoFormField *BackRepoFormFieldStruct) RestorePhaseTwo() {

	for _, formfieldDB := range backRepoFormField.Map_FormFieldDBID_FormFieldDB {

		// next line of code is to avert unused variable compilation error
		_ = formfieldDB

		// insertion point for reindexing pointers encoding
		// reindexing FormFieldString field
		if formfieldDB.FormFieldStringID.Int64 != 0 {
			formfieldDB.FormFieldStringID.Int64 = int64(BackRepoFormFieldStringid_atBckpTime_newID[uint(formfieldDB.FormFieldStringID.Int64)])
			formfieldDB.FormFieldStringID.Valid = true
		}

		// reindexing FormFieldFloat64 field
		if formfieldDB.FormFieldFloat64ID.Int64 != 0 {
			formfieldDB.FormFieldFloat64ID.Int64 = int64(BackRepoFormFieldFloat64id_atBckpTime_newID[uint(formfieldDB.FormFieldFloat64ID.Int64)])
			formfieldDB.FormFieldFloat64ID.Valid = true
		}

		// reindexing FormFieldInt field
		if formfieldDB.FormFieldIntID.Int64 != 0 {
			formfieldDB.FormFieldIntID.Int64 = int64(BackRepoFormFieldIntid_atBckpTime_newID[uint(formfieldDB.FormFieldIntID.Int64)])
			formfieldDB.FormFieldIntID.Valid = true
		}

		// reindexing FormFieldDate field
		if formfieldDB.FormFieldDateID.Int64 != 0 {
			formfieldDB.FormFieldDateID.Int64 = int64(BackRepoFormFieldDateid_atBckpTime_newID[uint(formfieldDB.FormFieldDateID.Int64)])
			formfieldDB.FormFieldDateID.Valid = true
		}

		// reindexing FormFieldTime field
		if formfieldDB.FormFieldTimeID.Int64 != 0 {
			formfieldDB.FormFieldTimeID.Int64 = int64(BackRepoFormFieldTimeid_atBckpTime_newID[uint(formfieldDB.FormFieldTimeID.Int64)])
			formfieldDB.FormFieldTimeID.Valid = true
		}

		// reindexing FormFieldDateTime field
		if formfieldDB.FormFieldDateTimeID.Int64 != 0 {
			formfieldDB.FormFieldDateTimeID.Int64 = int64(BackRepoFormFieldDateTimeid_atBckpTime_newID[uint(formfieldDB.FormFieldDateTimeID.Int64)])
			formfieldDB.FormFieldDateTimeID.Valid = true
		}

		// reindexing FormFieldSelect field
		if formfieldDB.FormFieldSelectID.Int64 != 0 {
			formfieldDB.FormFieldSelectID.Int64 = int64(BackRepoFormFieldSelectid_atBckpTime_newID[uint(formfieldDB.FormFieldSelectID.Int64)])
			formfieldDB.FormFieldSelectID.Valid = true
		}

		// update databse with new index encoding
		query := backRepoFormField.db.Model(formfieldDB).Updates(*formfieldDB)
		if query.Error != nil {
			log.Fatal(query.Error)
		}
	}

}

// BackRepoFormField.ResetReversePointers commits all staged instances of FormField to the BackRepo
// Phase Two is the update of instance with the field in the database
func (backRepoFormField *BackRepoFormFieldStruct) ResetReversePointers(backRepo *BackRepoStruct) (Error error) {

	for idx, formfield := range backRepoFormField.Map_FormFieldDBID_FormFieldPtr {
		backRepoFormField.ResetReversePointersInstance(backRepo, idx, formfield)
	}

	return
}

func (backRepoFormField *BackRepoFormFieldStruct) ResetReversePointersInstance(backRepo *BackRepoStruct, idx uint, formfield *models.FormField) (Error error) {

	// fetch matching formfieldDB
	if formfieldDB, ok := backRepoFormField.Map_FormFieldDBID_FormFieldDB[idx]; ok {
		_ = formfieldDB // to avoid unused variable error if there are no reverse to reset

		// insertion point for reverse pointers reset
		// end of insertion point for reverse pointers reset
	}

	return
}

// this field is used during the restauration process.
// it stores the ID at the backup time and is used for renumbering
var BackRepoFormFieldid_atBckpTime_newID map[uint]uint