make sure to insert all tags in ParentPath and Subtags into db

Filter Converter //

******************************************************************//

Updater Converter //

******************************************************************//

bntp.go/model/repository/psql/tag_repository.go

Line 765 in a11b249

// TODO: make sure to insert all tags in ParentPath and Subtags into db

        return []*domain.Tag{}, err
    }

    domainModels := make([]*domain.Tag, 0, len(repositoryModels))

    for _, repoModel := range repositoryModels {
        domainModel, err := repo.TagRepositoryToDomainModel(ctx, repoModel)
        if err != nil {
            return domainModels, err
        }

        domainModels = append(domainModels, domainModel)
    }

    return domainModels, err
}




//******************************************************************//
//                            Converters                            //
//******************************************************************//
func (repo *PsqlTagRepository) GetTagDomainToRepositoryModel(ctx context.Context) func(domainModel *domain.Tag) (repositoryModel any, err error) {
    return func(domainModel *domain.Tag) (repositoryModel any, err error) {
        return repo.TagDomainToRepositoryModel(ctx, domainModel)
    }
}

func (repo *PsqlTagRepository) GetTagRepositoryToDomainModel(ctx context.Context) func(repositoryModel any) (domainModel *domain.Tag, err error) {
    return func(repositoryModel any) (domainModel *domain.Tag, err error) {

        return repo.TagRepositoryToDomainModel(ctx,repositoryModel)
    }
}


//******************************************************************//
//                          Model Converter                         //
//******************************************************************//



func (repo *PsqlTagRepository) TagDomainToRepositoryModel(ctx context.Context, domainModel *domain.Tag) (repositoryModel any, err error)  {

// TODO: make sure to insert all tags in ParentPath and Subtags into db
    repositoryModelConcrete := new(Tag)
    repositoryModelConcrete.R = repositoryModelConcrete.R.NewStruct()

    repositoryModelConcrete.ID = domainModel.ID
    repositoryModelConcrete.Tag = domainModel.Tag


//***********************    Set ParentTag    **********************//
    if len(domainModel.ParentPath) > 0 {
        repositoryModelConcrete.ParentTag = null.NewInt64(domainModel.ParentPath[len(domainModel.ParentPath) - 1].ID, true)
    }

//*************************    Set Path    *************************//
for _, tag := range domainModel.ParentPath {
    repositoryModelConcrete.Path += strconv.FormatInt(tag.ID, 10) + ";"
}

repositoryModelConcrete.Path += strconv.FormatInt(domainModel.ID, 10)

//************************    Set Children  ************************//
for _, tag := range domainModel.Subtags {
    repositoryModelConcrete.Children += strconv.FormatInt(tag.ID, 10) + ";"
}

    repositoryModel = repositoryModelConcrete

    return
}

// TODO: These functions should be context aware
func (repo *PsqlTagRepository) TagRepositoryToDomainModel(ctx context.Context, repositoryModel any) (domainModel *domain.Tag, err error) {
// TODO: make sure to insert all tags in ParentPath and Subtags into db
    domainModel = new(domain.Tag)

    repositoryModelConcrete := repositoryModel.(Tag)

    domainModel.ID = repositoryModelConcrete.ID
    domainModel.Tag = repositoryModelConcrete.Tag

//***********************    Set ParentPath    **********************//
var parentTagID int64
var parentTag *Tag
var domainParentTag *domain.Tag

for _, parentTagIDRaw := range strings.Split(repositoryModelConcrete.Path, ";")[:len(repositoryModelConcrete.Path)-2]{
    parentTagID, err = strconv.ParseInt(parentTagIDRaw, 10, 64)
    if err != nil {
        return
    }

    parentTag, err = Tags(TagWhere.ID.EQ(parentTagID)).One(ctx, repo.db)
    if err != nil {
        return
    }

    domainParentTag, err = repo.TagRepositoryToDomainModel(ctx, parentTag)
    if err != nil {
        return
    }

    domainModel.ParentPath = append(domainModel.ParentPath, domainParentTag)
}

//************************    Set Subtags ************************//
var childTagID int64
var childTag *Tag
var domainChildTag *domain.Tag

for _, childTagIDRaw := range strings.Split(repositoryModelConcrete.Children, ";")[:len(repositoryModelConcrete.Children)-2]{
    childTagID, err = strconv.ParseInt(childTagIDRaw, 10, 64)
    if err != nil {
        return
    }

    childTag, err = Tags(TagWhere.ID.EQ(childTagID)).One(ctx, repo.db)
    if err != nil {
        return
    }

    domainChildTag, err = repo.TagRepositoryToDomainModel(ctx, childTag)
    if err != nil {
        return
    }

    domainModel.Subtags = append(domainModel.Subtags, domainChildTag)
}

    repositoryModel = repositoryModelConcrete

    return
}

//******************************************************************//
//                         Filter Converter                         //
//******************************************************************//



func (repo *PsqlTagRepository) TagDomainToRepositoryFilter(ctx context.Context, domainFilter *domain.TagFilter) (repositoryFilter any, err error)  {
    repositoryFilterConcrete := new(TagFilter)

	repositoryFilterConcrete.ID = domainFilter.ID
	repositoryFilterConcrete.Tag = domainFilter.Tag

	if domainFilter.ParentPath.HasValue {

		//*********************    Set ParentPath    *********************//
		var convertedParentTagTagFilter model.FilterOperation[*Tag]

		convertedParentTagTagFilter, err = model.ConvertFilter[*Tag, *domain.Tag](domainFilter.ParentPath.Wrappee, repoCommon.MakeDomainToRepositoryEntityConverterGeneric[domain.Tag, Tag](ctx, repo.TagDomainToRepositoryModel))
		if err != nil {
			return
		}

		repositoryFilterConcrete.ParentTagTag.Push(convertedParentTagTagFilter)
		//*************************    Set Path    *************************//
		var convertedPathFilter model.FilterOperation[string]

		convertedPathFilter, err = model.ConvertFilter[string, *domain.Tag](domainFilter.ParentPath.Wrappee, func(tag *domain.Tag) (string, error) { return strconv.FormatInt(tag.ID, 10), nil })
		if err != nil {
			return
		}

		repositoryFilterConcrete.Path.Push(convertedPathFilter)
		//**********************    Set ParentTag    ***********************//
		var convertedParentTagFilter model.FilterOperation[null.Int64]

		convertedParentTagFilter, err = model.ConvertFilter[null.Int64, *domain.Tag](domainFilter.ParentPath.Wrappee, func(tag *domain.Tag) (null.Int64, error) { return null.NewInt64(tag.ID, true), nil })
		if err != nil {
			return
		}

		repositoryFilterConcrete.ParentTag.Push(convertedParentTagFilter)
	}

	//**********************    Set child tags *********************//
	if domainFilter.Subtags.HasValue {
		var convertedFilter model.FilterOperation[string]

		convertedFilter, err = model.ConvertFilter[string, *domain.Tag](domainFilter.Subtags.Wrappee, func(tag *domain.Tag) (string, error) { return strconv.FormatInt(tag.ID, 10), nil })
		if err != nil {
			return
		}

		repositoryFilterConcrete.Children.Push(convertedFilter)
	}

    repositoryFilter = repositoryFilterConcrete

	return
}

//******************************************************************//
//                         Updater Converter                        //
//******************************************************************//



func (repo *PsqlTagRepository) TagDomainToRepositoryUpdater(ctx context.Context, domainUpdater *domain.TagUpdater) (repositoryUpdater any, err error)  {
    repositoryUpdaterConcrete := new(TagUpdater)

	//**************************    Set tag    *************************//
	if domainUpdater.Tag.HasValue {
		repositoryUpdaterConcrete.Tag.Push(model.UpdateOperation[string]{Operator: domainUpdater.Tag.Wrappee.Operator, Operand: repositoryUpdaterConcrete.Tag.Wrappee.Operand})
	}

	//***********    Set ParentPath    ***********//
	if domainUpdater.ParentPath.HasValue {
		var convertedTagRaw any
		tag := domainUpdater.ParentPath.Wrappee.Operand[len(domainUpdater.ParentPath.Wrappee.Operand)-1]
		convertedTagRaw, err =  repo.TagDomainToRepositoryModel(ctx, tag)
		if err != nil {
			return
		}

		repositoryUpdaterConcrete.ParentTagTag.Push(model.UpdateOperation[*Tag]{Operator: domainUpdater.ParentPath.Wrappee.Operator, Operand: convertedTagRaw.(*Tag)})
		repositoryUpdaterConcrete.ParentTag.Push(model.UpdateOperation[null.Int64]{Operator: domainUpdater.ParentPath.Wrappee.Operator, Operand: null.NewInt64(convertedTagRaw.(*Tag).ID, true)})

		pathIDs := make([]string, 0, len(domainUpdater.ParentPath.Wrappee.Operand)+1)
		for _, tag := range domainUpdater.ParentPath.Wrappee.Operand {
			pathIDs = append(pathIDs, strconv.FormatInt(tag.ID, 10))
		}

		pathIDs = append(pathIDs, strconv.FormatInt(tag.ID, 10))

		repositoryUpdaterConcrete.Path.Push(model.UpdateOperation[string]{Operator: domainUpdater.ParentPath.Wrappee.Operator, Operand: strings.Join(pathIDs, ";")})
	}

	//***********************    Set Children    ***********************//
	if domainUpdater.Subtags.HasValue {
		pathIDs := make([]string, 0, len(domainUpdater.Subtags.Wrappee.Operand)+1)
		for _, tag := range domainUpdater.Subtags.Wrappee.Operand {
			pathIDs = append(pathIDs, strconv.FormatInt(tag.ID, 10))
		}

		repositoryUpdaterConcrete.Children.Push(model.UpdateOperation[string]{Operator: domainUpdater.Subtags.Wrappee.Operator, Operand: strings.Join(pathIDs, ";")})
	}

	//**************************    Set ID    **************************//
	if domainUpdater.ID.HasValue {
		repositoryUpdaterConcrete.ID.Push(model.UpdateOperation[int64]{Operator: domainUpdater.ID.Wrappee.Operator, Operand: repositoryUpdaterConcrete.ID.Wrappee.Operand})
	}

    repositoryUpdater = repositoryUpdaterConcrete

	return
}

825433b928a2ab0c6a8e207410f5e34f233945f3