RectLinkLinkDB.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/gongsvg/go/models"
)

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

// RectLinkLinkAPI 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 rectlinklinkAPI
type RectLinkLinkAPI struct {
	gorm.Model

	models.RectLinkLink_WOP

	// encoding of pointers
	// for API, it cannot be embedded
	RectLinkLinkPointersEncoding RectLinkLinkPointersEncoding
}

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

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

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

// RectLinkLinkDB describes a rectlinklink 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 rectlinklinkDB
type RectLinkLinkDB struct {
	gorm.Model

	// insertion for basic fields declaration

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

	// Declation for basic field rectlinklinkDB.TargetAnchorPosition
	TargetAnchorPosition_Data sql.NullFloat64

	// Declation for basic field rectlinklinkDB.Color
	Color_Data sql.NullString

	// Declation for basic field rectlinklinkDB.FillOpacity
	FillOpacity_Data sql.NullFloat64

	// Declation for basic field rectlinklinkDB.Stroke
	Stroke_Data sql.NullString

	// Declation for basic field rectlinklinkDB.StrokeWidth
	StrokeWidth_Data sql.NullFloat64

	// Declation for basic field rectlinklinkDB.StrokeDashArray
	StrokeDashArray_Data sql.NullString

	// Declation for basic field rectlinklinkDB.StrokeDashArrayWhenSelected
	StrokeDashArrayWhenSelected_Data sql.NullString

	// Declation for basic field rectlinklinkDB.Transform
	Transform_Data sql.NullString
	
	// encoding of pointers
	// for GORM serialization, it is necessary to embed to Pointer Encoding declaration
	RectLinkLinkPointersEncoding
}

// RectLinkLinkDBs arrays rectlinklinkDBs
// swagger:response rectlinklinkDBsResponse
type RectLinkLinkDBs []RectLinkLinkDB

// RectLinkLinkDBResponse provides response
// swagger:response rectlinklinkDBResponse
type RectLinkLinkDBResponse struct {
	RectLinkLinkDB
}

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

	// insertion for WOP basic fields

	Name string `xlsx:"1"`

	TargetAnchorPosition float64 `xlsx:"2"`

	Color string `xlsx:"3"`

	FillOpacity float64 `xlsx:"4"`

	Stroke string `xlsx:"5"`

	StrokeWidth float64 `xlsx:"6"`

	StrokeDashArray string `xlsx:"7"`

	StrokeDashArrayWhenSelected string `xlsx:"8"`

	Transform string `xlsx:"9"`
	// insertion for WOP pointer fields
}

var RectLinkLink_Fields = []string{
	// insertion for WOP basic fields
	"ID",
	"Name",
	"TargetAnchorPosition",
	"Color",
	"FillOpacity",
	"Stroke",
	"StrokeWidth",
	"StrokeDashArray",
	"StrokeDashArrayWhenSelected",
	"Transform",
}

type BackRepoRectLinkLinkStruct struct {
	// stores RectLinkLinkDB according to their gorm ID
	Map_RectLinkLinkDBID_RectLinkLinkDB map[uint]*RectLinkLinkDB

	// stores RectLinkLinkDB ID according to RectLinkLink address
	Map_RectLinkLinkPtr_RectLinkLinkDBID map[*models.RectLinkLink]uint

	// stores RectLinkLink according to their gorm ID
	Map_RectLinkLinkDBID_RectLinkLinkPtr map[uint]*models.RectLinkLink

	db *gorm.DB

	stage *models.StageStruct
}

func (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) GetStage() (stage *models.StageStruct) {
	stage = backRepoRectLinkLink.stage
	return
}

func (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) GetDB() *gorm.DB {
	return backRepoRectLinkLink.db
}

// GetRectLinkLinkDBFromRectLinkLinkPtr is a handy function to access the back repo instance from the stage instance
func (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) GetRectLinkLinkDBFromRectLinkLinkPtr(rectlinklink *models.RectLinkLink) (rectlinklinkDB *RectLinkLinkDB) {
	id := backRepoRectLinkLink.Map_RectLinkLinkPtr_RectLinkLinkDBID[rectlinklink]
	rectlinklinkDB = backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkDB[id]
	return
}

// BackRepoRectLinkLink.CommitPhaseOne commits all staged instances of RectLinkLink 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 (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) CommitPhaseOne(stage *models.StageStruct) (Error error) {

	for rectlinklink := range stage.RectLinkLinks {
		backRepoRectLinkLink.CommitPhaseOneInstance(rectlinklink)
	}

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

	return
}

// BackRepoRectLinkLink.CommitDeleteInstance commits deletion of RectLinkLink to the BackRepo
func (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) CommitDeleteInstance(id uint) (Error error) {

	rectlinklink := backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkPtr[id]

	// rectlinklink is not staged anymore, remove rectlinklinkDB
	rectlinklinkDB := backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkDB[id]
	query := backRepoRectLinkLink.db.Unscoped().Delete(&rectlinklinkDB)
	if query.Error != nil {
		log.Fatal(query.Error)
	}

	// update stores
	delete(backRepoRectLinkLink.Map_RectLinkLinkPtr_RectLinkLinkDBID, rectlinklink)
	delete(backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkPtr, id)
	delete(backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkDB, id)

	return
}

// BackRepoRectLinkLink.CommitPhaseOneInstance commits rectlinklink staged instances of RectLinkLink 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 (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) CommitPhaseOneInstance(rectlinklink *models.RectLinkLink) (Error error) {

	// check if the rectlinklink is not commited yet
	if _, ok := backRepoRectLinkLink.Map_RectLinkLinkPtr_RectLinkLinkDBID[rectlinklink]; ok {
		return
	}

	// initiate rectlinklink
	var rectlinklinkDB RectLinkLinkDB
	rectlinklinkDB.CopyBasicFieldsFromRectLinkLink(rectlinklink)

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

	// update stores
	backRepoRectLinkLink.Map_RectLinkLinkPtr_RectLinkLinkDBID[rectlinklink] = rectlinklinkDB.ID
	backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkPtr[rectlinklinkDB.ID] = rectlinklink
	backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkDB[rectlinklinkDB.ID] = &rectlinklinkDB

	return
}

// BackRepoRectLinkLink.CommitPhaseTwo commits all staged instances of RectLinkLink to the BackRepo
// Phase Two is the update of instance with the field in the database
func (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) CommitPhaseTwo(backRepo *BackRepoStruct) (Error error) {

	for idx, rectlinklink := range backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkPtr {
		backRepoRectLinkLink.CommitPhaseTwoInstance(backRepo, idx, rectlinklink)
	}

	return
}

// BackRepoRectLinkLink.CommitPhaseTwoInstance commits {{structname }} of models.RectLinkLink to the BackRepo
// Phase Two is the update of instance with the field in the database
func (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) CommitPhaseTwoInstance(backRepo *BackRepoStruct, idx uint, rectlinklink *models.RectLinkLink) (Error error) {

	// fetch matching rectlinklinkDB
	if rectlinklinkDB, ok := backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkDB[idx]; ok {

		rectlinklinkDB.CopyBasicFieldsFromRectLinkLink(rectlinklink)

		// insertion point for translating pointers encodings into actual pointers
		// commit pointer value rectlinklink.Start translates to updating the rectlinklink.StartID
		rectlinklinkDB.StartID.Valid = true // allow for a 0 value (nil association)
		if rectlinklink.Start != nil {
			if StartId, ok := backRepo.BackRepoRect.Map_RectPtr_RectDBID[rectlinklink.Start]; ok {
				rectlinklinkDB.StartID.Int64 = int64(StartId)
				rectlinklinkDB.StartID.Valid = true
			}
		} else {
			rectlinklinkDB.StartID.Int64 = 0
			rectlinklinkDB.StartID.Valid = true
		}

		// commit pointer value rectlinklink.End translates to updating the rectlinklink.EndID
		rectlinklinkDB.EndID.Valid = true // allow for a 0 value (nil association)
		if rectlinklink.End != nil {
			if EndId, ok := backRepo.BackRepoLink.Map_LinkPtr_LinkDBID[rectlinklink.End]; ok {
				rectlinklinkDB.EndID.Int64 = int64(EndId)
				rectlinklinkDB.EndID.Valid = true
			}
		} else {
			rectlinklinkDB.EndID.Int64 = 0
			rectlinklinkDB.EndID.Valid = true
		}

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

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

	return
}

// BackRepoRectLinkLink.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 (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) CheckoutPhaseOne() (Error error) {

	rectlinklinkDBArray := make([]RectLinkLinkDB, 0)
	query := backRepoRectLinkLink.db.Find(&rectlinklinkDBArray)
	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
	rectlinklinkInstancesToBeRemovedFromTheStage := make(map[*models.RectLinkLink]any)
	for key, value := range backRepoRectLinkLink.stage.RectLinkLinks {
		rectlinklinkInstancesToBeRemovedFromTheStage[key] = value
	}

	// copy orm objects to the the map
	for _, rectlinklinkDB := range rectlinklinkDBArray {
		backRepoRectLinkLink.CheckoutPhaseOneInstance(&rectlinklinkDB)

		// do not remove this instance from the stage, therefore
		// remove instance from the list of instances to be be removed from the stage
		rectlinklink, ok := backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkPtr[rectlinklinkDB.ID]
		if ok {
			delete(rectlinklinkInstancesToBeRemovedFromTheStage, rectlinklink)
		}
	}

	// remove from stage and back repo's 3 maps all rectlinklinks that are not in the checkout
	for rectlinklink := range rectlinklinkInstancesToBeRemovedFromTheStage {
		rectlinklink.Unstage(backRepoRectLinkLink.GetStage())

		// remove instance from the back repo 3 maps
		rectlinklinkID := backRepoRectLinkLink.Map_RectLinkLinkPtr_RectLinkLinkDBID[rectlinklink]
		delete(backRepoRectLinkLink.Map_RectLinkLinkPtr_RectLinkLinkDBID, rectlinklink)
		delete(backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkDB, rectlinklinkID)
		delete(backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkPtr, rectlinklinkID)
	}

	return
}

// CheckoutPhaseOneInstance takes a rectlinklinkDB that has been found in the DB, updates the backRepo and stages the
// models version of the rectlinklinkDB
func (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) CheckoutPhaseOneInstance(rectlinklinkDB *RectLinkLinkDB) (Error error) {

	rectlinklink, ok := backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkPtr[rectlinklinkDB.ID]
	if !ok {
		rectlinklink = new(models.RectLinkLink)

		backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkPtr[rectlinklinkDB.ID] = rectlinklink
		backRepoRectLinkLink.Map_RectLinkLinkPtr_RectLinkLinkDBID[rectlinklink] = rectlinklinkDB.ID

		// append model store with the new element
		rectlinklink.Name = rectlinklinkDB.Name_Data.String
		rectlinklink.Stage(backRepoRectLinkLink.GetStage())
	}
	rectlinklinkDB.CopyBasicFieldsToRectLinkLink(rectlinklink)

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

	// preserve pointer to rectlinklinkDB. Otherwise, pointer will is recycled and the map of pointers
	// Map_RectLinkLinkDBID_RectLinkLinkDB)[rectlinklinkDB hold variable pointers
	rectlinklinkDB_Data := *rectlinklinkDB
	preservedPtrToRectLinkLink := &rectlinklinkDB_Data
	backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkDB[rectlinklinkDB.ID] = preservedPtrToRectLinkLink

	return
}

// BackRepoRectLinkLink.CheckoutPhaseTwo Checkouts all staged instances of RectLinkLink to the BackRepo
// Phase Two is the update of instance with the field in the database
func (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) CheckoutPhaseTwo(backRepo *BackRepoStruct) (Error error) {

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

// BackRepoRectLinkLink.CheckoutPhaseTwoInstance Checkouts staged instances of RectLinkLink to the BackRepo
// Phase Two is the update of instance with the field in the database
func (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) CheckoutPhaseTwoInstance(backRepo *BackRepoStruct, rectlinklinkDB *RectLinkLinkDB) (Error error) {

	rectlinklink := backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkPtr[rectlinklinkDB.ID]

	rectlinklinkDB.DecodePointers(backRepo, rectlinklink)

	return
}

func (rectlinklinkDB *RectLinkLinkDB) DecodePointers(backRepo *BackRepoStruct, rectlinklink *models.RectLinkLink) {

	// insertion point for checkout of pointer encoding
	// Start field
	rectlinklink.Start = nil
	if rectlinklinkDB.StartID.Int64 != 0 {
		rectlinklink.Start = backRepo.BackRepoRect.Map_RectDBID_RectPtr[uint(rectlinklinkDB.StartID.Int64)]
	}
	// End field
	rectlinklink.End = nil
	if rectlinklinkDB.EndID.Int64 != 0 {
		rectlinklink.End = backRepo.BackRepoLink.Map_LinkDBID_LinkPtr[uint(rectlinklinkDB.EndID.Int64)]
	}
	return
}

// CommitRectLinkLink allows commit of a single rectlinklink (if already staged)
func (backRepo *BackRepoStruct) CommitRectLinkLink(rectlinklink *models.RectLinkLink) {
	backRepo.BackRepoRectLinkLink.CommitPhaseOneInstance(rectlinklink)
	if id, ok := backRepo.BackRepoRectLinkLink.Map_RectLinkLinkPtr_RectLinkLinkDBID[rectlinklink]; ok {
		backRepo.BackRepoRectLinkLink.CommitPhaseTwoInstance(backRepo, id, rectlinklink)
	}
	backRepo.CommitFromBackNb = backRepo.CommitFromBackNb + 1
}

// CommitRectLinkLink allows checkout of a single rectlinklink (if already staged and with a BackRepo id)
func (backRepo *BackRepoStruct) CheckoutRectLinkLink(rectlinklink *models.RectLinkLink) {
	// check if the rectlinklink is staged
	if _, ok := backRepo.BackRepoRectLinkLink.Map_RectLinkLinkPtr_RectLinkLinkDBID[rectlinklink]; ok {

		if id, ok := backRepo.BackRepoRectLinkLink.Map_RectLinkLinkPtr_RectLinkLinkDBID[rectlinklink]; ok {
			var rectlinklinkDB RectLinkLinkDB
			rectlinklinkDB.ID = id

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

// CopyBasicFieldsFromRectLinkLink
func (rectlinklinkDB *RectLinkLinkDB) CopyBasicFieldsFromRectLinkLink(rectlinklink *models.RectLinkLink) {
	// insertion point for fields commit

	rectlinklinkDB.Name_Data.String = rectlinklink.Name
	rectlinklinkDB.Name_Data.Valid = true

	rectlinklinkDB.TargetAnchorPosition_Data.Float64 = rectlinklink.TargetAnchorPosition
	rectlinklinkDB.TargetAnchorPosition_Data.Valid = true

	rectlinklinkDB.Color_Data.String = rectlinklink.Color
	rectlinklinkDB.Color_Data.Valid = true

	rectlinklinkDB.FillOpacity_Data.Float64 = rectlinklink.FillOpacity
	rectlinklinkDB.FillOpacity_Data.Valid = true

	rectlinklinkDB.Stroke_Data.String = rectlinklink.Stroke
	rectlinklinkDB.Stroke_Data.Valid = true

	rectlinklinkDB.StrokeWidth_Data.Float64 = rectlinklink.StrokeWidth
	rectlinklinkDB.StrokeWidth_Data.Valid = true

	rectlinklinkDB.StrokeDashArray_Data.String = rectlinklink.StrokeDashArray
	rectlinklinkDB.StrokeDashArray_Data.Valid = true

	rectlinklinkDB.StrokeDashArrayWhenSelected_Data.String = rectlinklink.StrokeDashArrayWhenSelected
	rectlinklinkDB.StrokeDashArrayWhenSelected_Data.Valid = true

	rectlinklinkDB.Transform_Data.String = rectlinklink.Transform
	rectlinklinkDB.Transform_Data.Valid = true
}

// CopyBasicFieldsFromRectLinkLink_WOP
func (rectlinklinkDB *RectLinkLinkDB) CopyBasicFieldsFromRectLinkLink_WOP(rectlinklink *models.RectLinkLink_WOP) {
	// insertion point for fields commit

	rectlinklinkDB.Name_Data.String = rectlinklink.Name
	rectlinklinkDB.Name_Data.Valid = true

	rectlinklinkDB.TargetAnchorPosition_Data.Float64 = rectlinklink.TargetAnchorPosition
	rectlinklinkDB.TargetAnchorPosition_Data.Valid = true

	rectlinklinkDB.Color_Data.String = rectlinklink.Color
	rectlinklinkDB.Color_Data.Valid = true

	rectlinklinkDB.FillOpacity_Data.Float64 = rectlinklink.FillOpacity
	rectlinklinkDB.FillOpacity_Data.Valid = true

	rectlinklinkDB.Stroke_Data.String = rectlinklink.Stroke
	rectlinklinkDB.Stroke_Data.Valid = true

	rectlinklinkDB.StrokeWidth_Data.Float64 = rectlinklink.StrokeWidth
	rectlinklinkDB.StrokeWidth_Data.Valid = true

	rectlinklinkDB.StrokeDashArray_Data.String = rectlinklink.StrokeDashArray
	rectlinklinkDB.StrokeDashArray_Data.Valid = true

	rectlinklinkDB.StrokeDashArrayWhenSelected_Data.String = rectlinklink.StrokeDashArrayWhenSelected
	rectlinklinkDB.StrokeDashArrayWhenSelected_Data.Valid = true

	rectlinklinkDB.Transform_Data.String = rectlinklink.Transform
	rectlinklinkDB.Transform_Data.Valid = true
}

// CopyBasicFieldsFromRectLinkLinkWOP
func (rectlinklinkDB *RectLinkLinkDB) CopyBasicFieldsFromRectLinkLinkWOP(rectlinklink *RectLinkLinkWOP) {
	// insertion point for fields commit

	rectlinklinkDB.Name_Data.String = rectlinklink.Name
	rectlinklinkDB.Name_Data.Valid = true

	rectlinklinkDB.TargetAnchorPosition_Data.Float64 = rectlinklink.TargetAnchorPosition
	rectlinklinkDB.TargetAnchorPosition_Data.Valid = true

	rectlinklinkDB.Color_Data.String = rectlinklink.Color
	rectlinklinkDB.Color_Data.Valid = true

	rectlinklinkDB.FillOpacity_Data.Float64 = rectlinklink.FillOpacity
	rectlinklinkDB.FillOpacity_Data.Valid = true

	rectlinklinkDB.Stroke_Data.String = rectlinklink.Stroke
	rectlinklinkDB.Stroke_Data.Valid = true

	rectlinklinkDB.StrokeWidth_Data.Float64 = rectlinklink.StrokeWidth
	rectlinklinkDB.StrokeWidth_Data.Valid = true

	rectlinklinkDB.StrokeDashArray_Data.String = rectlinklink.StrokeDashArray
	rectlinklinkDB.StrokeDashArray_Data.Valid = true

	rectlinklinkDB.StrokeDashArrayWhenSelected_Data.String = rectlinklink.StrokeDashArrayWhenSelected
	rectlinklinkDB.StrokeDashArrayWhenSelected_Data.Valid = true

	rectlinklinkDB.Transform_Data.String = rectlinklink.Transform
	rectlinklinkDB.Transform_Data.Valid = true
}

// CopyBasicFieldsToRectLinkLink
func (rectlinklinkDB *RectLinkLinkDB) CopyBasicFieldsToRectLinkLink(rectlinklink *models.RectLinkLink) {
	// insertion point for checkout of basic fields (back repo to stage)
	rectlinklink.Name = rectlinklinkDB.Name_Data.String
	rectlinklink.TargetAnchorPosition = rectlinklinkDB.TargetAnchorPosition_Data.Float64
	rectlinklink.Color = rectlinklinkDB.Color_Data.String
	rectlinklink.FillOpacity = rectlinklinkDB.FillOpacity_Data.Float64
	rectlinklink.Stroke = rectlinklinkDB.Stroke_Data.String
	rectlinklink.StrokeWidth = rectlinklinkDB.StrokeWidth_Data.Float64
	rectlinklink.StrokeDashArray = rectlinklinkDB.StrokeDashArray_Data.String
	rectlinklink.StrokeDashArrayWhenSelected = rectlinklinkDB.StrokeDashArrayWhenSelected_Data.String
	rectlinklink.Transform = rectlinklinkDB.Transform_Data.String
}

// CopyBasicFieldsToRectLinkLink_WOP
func (rectlinklinkDB *RectLinkLinkDB) CopyBasicFieldsToRectLinkLink_WOP(rectlinklink *models.RectLinkLink_WOP) {
	// insertion point for checkout of basic fields (back repo to stage)
	rectlinklink.Name = rectlinklinkDB.Name_Data.String
	rectlinklink.TargetAnchorPosition = rectlinklinkDB.TargetAnchorPosition_Data.Float64
	rectlinklink.Color = rectlinklinkDB.Color_Data.String
	rectlinklink.FillOpacity = rectlinklinkDB.FillOpacity_Data.Float64
	rectlinklink.Stroke = rectlinklinkDB.Stroke_Data.String
	rectlinklink.StrokeWidth = rectlinklinkDB.StrokeWidth_Data.Float64
	rectlinklink.StrokeDashArray = rectlinklinkDB.StrokeDashArray_Data.String
	rectlinklink.StrokeDashArrayWhenSelected = rectlinklinkDB.StrokeDashArrayWhenSelected_Data.String
	rectlinklink.Transform = rectlinklinkDB.Transform_Data.String
}

// CopyBasicFieldsToRectLinkLinkWOP
func (rectlinklinkDB *RectLinkLinkDB) CopyBasicFieldsToRectLinkLinkWOP(rectlinklink *RectLinkLinkWOP) {
	rectlinklink.ID = int(rectlinklinkDB.ID)
	// insertion point for checkout of basic fields (back repo to stage)
	rectlinklink.Name = rectlinklinkDB.Name_Data.String
	rectlinklink.TargetAnchorPosition = rectlinklinkDB.TargetAnchorPosition_Data.Float64
	rectlinklink.Color = rectlinklinkDB.Color_Data.String
	rectlinklink.FillOpacity = rectlinklinkDB.FillOpacity_Data.Float64
	rectlinklink.Stroke = rectlinklinkDB.Stroke_Data.String
	rectlinklink.StrokeWidth = rectlinklinkDB.StrokeWidth_Data.Float64
	rectlinklink.StrokeDashArray = rectlinklinkDB.StrokeDashArray_Data.String
	rectlinklink.StrokeDashArrayWhenSelected = rectlinklinkDB.StrokeDashArrayWhenSelected_Data.String
	rectlinklink.Transform = rectlinklinkDB.Transform_Data.String
}

// Backup generates a json file from a slice of all RectLinkLinkDB instances in the backrepo
func (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) Backup(dirPath string) {

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

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

	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 RectLinkLink ", filename, " ", err.Error())
	}

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

// Backup generates a json file from a slice of all RectLinkLinkDB instances in the backrepo
func (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) BackupXL(file *xlsx.File) {

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

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

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

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

		var rectlinklinkWOP RectLinkLinkWOP
		rectlinklinkDB.CopyBasicFieldsToRectLinkLinkWOP(&rectlinklinkWOP)

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

// RestoreXL from the "RectLinkLink" sheet all RectLinkLinkDB instances
func (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) RestoreXLPhaseOne(file *xlsx.File) {

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

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

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

func (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) rowVisitorRectLinkLink(row *xlsx.Row) error {

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

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

		// add the unmarshalled struct to the stage
		rectlinklinkDB := new(RectLinkLinkDB)
		rectlinklinkDB.CopyBasicFieldsFromRectLinkLinkWOP(&rectlinklinkWOP)

		rectlinklinkDB_ID_atBackupTime := rectlinklinkDB.ID
		rectlinklinkDB.ID = 0
		query := backRepoRectLinkLink.db.Create(rectlinklinkDB)
		if query.Error != nil {
			log.Fatal(query.Error)
		}
		backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkDB[rectlinklinkDB.ID] = rectlinklinkDB
		BackRepoRectLinkLinkid_atBckpTime_newID[rectlinklinkDB_ID_atBackupTime] = rectlinklinkDB.ID
	}
	return nil
}

// RestorePhaseOne read the file "RectLinkLinkDB.json" in dirPath that stores an array
// of RectLinkLinkDB and stores it in the database
// the map BackRepoRectLinkLinkid_atBckpTime_newID is updated accordingly
func (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) RestorePhaseOne(dirPath string) {

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

	filename := filepath.Join(dirPath, "RectLinkLinkDB.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 RectLinkLink file", filename, " ", err.Error())
	}

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

	var forRestore []*RectLinkLinkDB

	err = json.Unmarshal(byteValue, &forRestore)

	// fill up Map_RectLinkLinkDBID_RectLinkLinkDB
	for _, rectlinklinkDB := range forRestore {

		rectlinklinkDB_ID_atBackupTime := rectlinklinkDB.ID
		rectlinklinkDB.ID = 0
		query := backRepoRectLinkLink.db.Create(rectlinklinkDB)
		if query.Error != nil {
			log.Fatal(query.Error)
		}
		backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkDB[rectlinklinkDB.ID] = rectlinklinkDB
		BackRepoRectLinkLinkid_atBckpTime_newID[rectlinklinkDB_ID_atBackupTime] = rectlinklinkDB.ID
	}

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

// RestorePhaseTwo uses all map BackRepo<RectLinkLink>id_atBckpTime_newID
// to compute new index
func (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) RestorePhaseTwo() {

	for _, rectlinklinkDB := range backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkDB {

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

		// insertion point for reindexing pointers encoding
		// reindexing Start field
		if rectlinklinkDB.StartID.Int64 != 0 {
			rectlinklinkDB.StartID.Int64 = int64(BackRepoRectid_atBckpTime_newID[uint(rectlinklinkDB.StartID.Int64)])
			rectlinklinkDB.StartID.Valid = true
		}

		// reindexing End field
		if rectlinklinkDB.EndID.Int64 != 0 {
			rectlinklinkDB.EndID.Int64 = int64(BackRepoLinkid_atBckpTime_newID[uint(rectlinklinkDB.EndID.Int64)])
			rectlinklinkDB.EndID.Valid = true
		}

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

}

// BackRepoRectLinkLink.ResetReversePointers commits all staged instances of RectLinkLink to the BackRepo
// Phase Two is the update of instance with the field in the database
func (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) ResetReversePointers(backRepo *BackRepoStruct) (Error error) {

	for idx, rectlinklink := range backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkPtr {
		backRepoRectLinkLink.ResetReversePointersInstance(backRepo, idx, rectlinklink)
	}

	return
}

func (backRepoRectLinkLink *BackRepoRectLinkLinkStruct) ResetReversePointersInstance(backRepo *BackRepoStruct, idx uint, rectlinklink *models.RectLinkLink) (Error error) {

	// fetch matching rectlinklinkDB
	if rectlinklinkDB, ok := backRepoRectLinkLink.Map_RectLinkLinkDBID_RectLinkLinkDB[idx]; ok {
		_ = rectlinklinkDB // 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 BackRepoRectLinkLinkid_atBckpTime_newID map[uint]uint