bookmark_repository.go

// Copyright © 2021-2022 Jonas Muehlmann
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
// OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

// THIS CODE IS GENERATED BY GO GENERATE, IT'S TEMPLATE IS /templates/sql_repositories/sql_repository.go.tpl

package repository

import (
	 repoCommon "github.com/JonasMuehlmann/bntp.go/model/repository"
	"container/list"
	"fmt"
    "errors"
	"github.com/JonasMuehlmann/bntp.go/internal/helper"
	"github.com/JonasMuehlmann/bntp.go/model"
	"github.com/JonasMuehlmann/bntp.go/model/domain"
	"github.com/JonasMuehlmann/goaoi"
	"github.com/JonasMuehlmann/optional.go"
	"github.com/volatiletech/null/v8"
    "context"
    "database/sql"
    "github.com/volatiletech/sqlboiler/v4/boil"
    "github.com/volatiletech/sqlboiler/v4/queries"
    "github.com/volatiletech/sqlboiler/v4/queries/qm"
    "github.com/volatiletech/sqlboiler/v4/queries/qmhelper"
    log "github.com/sirupsen/logrus"
	"github.com/stoewer/go-strcase"
    "strings"
    
    
    "time"
    
)


//******************************************************************//
//                        Types and constants                       //
//******************************************************************//
type MssqlBookmarkRepository struct {
    db *sql.DB
    Logger *log.Logger
    
    tagRepository repoCommon.TagRepository
    
}

type BookmarkField string

var BookmarkFields = struct {
    CreatedAt  BookmarkField
    UpdatedAt  BookmarkField
    DeletedAt  BookmarkField
    URL  BookmarkField
    Title  BookmarkField
    BookmarkTypeID  BookmarkField
    IsCollection  BookmarkField
    ID  BookmarkField
    IsRead  BookmarkField
    
}{
    CreatedAt: "created_at",
    UpdatedAt: "updated_at",
    DeletedAt: "deleted_at",
    URL: "url",
    Title: "title",
    BookmarkTypeID: "bookmark_type_id",
    IsCollection: "is_collection",
    ID: "id",
    IsRead: "is_read",
    
}

var BookmarkFieldsList = []BookmarkField{
    BookmarkField("CreatedAt"),
    BookmarkField("UpdatedAt"),
    BookmarkField("DeletedAt"),
    BookmarkField("URL"),
    BookmarkField("Title"),
    BookmarkField("BookmarkTypeID"),
    BookmarkField("IsCollection"),
    BookmarkField("ID"),
    BookmarkField("IsRead"),
    
}

var BookmarkRelationsList = []string{
    "BookmarkType",
    "Tags",
    
}

type BookmarkFilter struct {
    CreatedAt optional.Optional[model.FilterOperation[time.Time]]
    UpdatedAt optional.Optional[model.FilterOperation[time.Time]]
    DeletedAt optional.Optional[model.FilterOperation[null.Time]]
    URL optional.Optional[model.FilterOperation[string]]
    Title optional.Optional[model.FilterOperation[null.String]]
    BookmarkTypeID optional.Optional[model.FilterOperation[null.Int64]]
    IsCollection optional.Optional[model.FilterOperation[int64]]
    ID optional.Optional[model.FilterOperation[int64]]
    IsRead optional.Optional[model.FilterOperation[int64]]
    
    
    Tags optional.Optional[model.FilterOperation[*Tag]]
}

type BookmarkUpdater struct {
    CreatedAt optional.Optional[model.UpdateOperation[time.Time]]
    UpdatedAt optional.Optional[model.UpdateOperation[time.Time]]
    DeletedAt optional.Optional[model.UpdateOperation[null.Time]]
    URL optional.Optional[model.UpdateOperation[string]]
    Title optional.Optional[model.UpdateOperation[null.String]]
    BookmarkTypeID optional.Optional[model.UpdateOperation[null.Int64]]
    IsCollection optional.Optional[model.UpdateOperation[int64]]
    ID optional.Optional[model.UpdateOperation[int64]]
    IsRead optional.Optional[model.UpdateOperation[int64]]
    
    
    Tags optional.Optional[model.UpdateOperation[TagSlice]]
}

type BookmarkUpdaterMapping[T any] struct {
    Field BookmarkField
    Updater model.UpdateOperation[T]
}

func (updater *BookmarkUpdater) GetSetUpdaters() *list.List {
    setUpdaters := list.New()

    if updater.CreatedAt.HasValue {
    setUpdaters.PushBack(BookmarkUpdaterMapping[time.Time]{Field: BookmarkFields.CreatedAt, Updater: updater.CreatedAt.Wrappee})
    }
    if updater.UpdatedAt.HasValue {
    setUpdaters.PushBack(BookmarkUpdaterMapping[time.Time]{Field: BookmarkFields.UpdatedAt, Updater: updater.UpdatedAt.Wrappee})
    }
    if updater.DeletedAt.HasValue {
    setUpdaters.PushBack(BookmarkUpdaterMapping[null.Time]{Field: BookmarkFields.DeletedAt, Updater: updater.DeletedAt.Wrappee})
    }
    if updater.URL.HasValue {
    setUpdaters.PushBack(BookmarkUpdaterMapping[string]{Field: BookmarkFields.URL, Updater: updater.URL.Wrappee})
    }
    if updater.Title.HasValue {
    setUpdaters.PushBack(BookmarkUpdaterMapping[null.String]{Field: BookmarkFields.Title, Updater: updater.Title.Wrappee})
    }
    if updater.BookmarkTypeID.HasValue {
    setUpdaters.PushBack(BookmarkUpdaterMapping[null.Int64]{Field: BookmarkFields.BookmarkTypeID, Updater: updater.BookmarkTypeID.Wrappee})
    }
    if updater.IsCollection.HasValue {
    setUpdaters.PushBack(BookmarkUpdaterMapping[int64]{Field: BookmarkFields.IsCollection, Updater: updater.IsCollection.Wrappee})
    }
    if updater.ID.HasValue {
    setUpdaters.PushBack(BookmarkUpdaterMapping[int64]{Field: BookmarkFields.ID, Updater: updater.ID.Wrappee})
    }
    if updater.IsRead.HasValue {
    setUpdaters.PushBack(BookmarkUpdaterMapping[int64]{Field: BookmarkFields.IsRead, Updater: updater.IsRead.Wrappee})
    }
    

    return setUpdaters
}

func (updater *BookmarkUpdater) ApplyToModel(bookmarkModel *Bookmark) {
    if updater.CreatedAt.HasValue {
        model.ApplyUpdater(&(*bookmarkModel).CreatedAt, updater.CreatedAt.Wrappee)
    }
    if updater.UpdatedAt.HasValue {
        model.ApplyUpdater(&(*bookmarkModel).UpdatedAt, updater.UpdatedAt.Wrappee)
    }
    if updater.DeletedAt.HasValue {
        model.ApplyUpdater(&(*bookmarkModel).DeletedAt, updater.DeletedAt.Wrappee)
    }
    if updater.URL.HasValue {
        model.ApplyUpdater(&(*bookmarkModel).URL, updater.URL.Wrappee)
    }
    if updater.Title.HasValue {
        model.ApplyUpdater(&(*bookmarkModel).Title, updater.Title.Wrappee)
    }
    if updater.BookmarkTypeID.HasValue {
        model.ApplyUpdater(&(*bookmarkModel).BookmarkTypeID, updater.BookmarkTypeID.Wrappee)
    }
    if updater.IsCollection.HasValue {
        model.ApplyUpdater(&(*bookmarkModel).IsCollection, updater.IsCollection.Wrappee)
    }
    if updater.ID.HasValue {
        model.ApplyUpdater(&(*bookmarkModel).ID, updater.ID.Wrappee)
    }
    if updater.IsRead.HasValue {
        model.ApplyUpdater(&(*bookmarkModel).IsRead, updater.IsRead.Wrappee)
    }
    
}

type queryModSliceBookmark []qm.QueryMod

func (s queryModSliceBookmark) Apply(q *queries.Query) {
    qm.Apply(q, s...)
}

func IsUnsetOptionalBookmark(o any) bool {
    switch t:= o.(type) {
        case null.JSON:
            return !t.Valid
        case null.Bytes:
            return !t.Valid
        case null.String:
            return !t.Valid
        case null.Byte:
            return !t.Valid
        case null.Float32:
            return !t.Valid
        case null.Float64:
            return !t.Valid
        case null.Int:
            return !t.Valid
        case null.Int8:
            return !t.Valid
        case null.Int16:
            return !t.Valid
        case null.Int32:
            return !t.Valid
        case null.Int64:
            return !t.Valid
        case null.Uint:
            return !t.Valid
        case null.Uint8:
            return !t.Valid
        case null.Uint16:
            return !t.Valid
        case null.Uint32:
            return !t.Valid
        case null.Uint64:
            return !t.Valid
    default:
        return false
    }
}

func TryUnwrapOptionalBookmark(o any) any {
    switch t:= o.(type) {
        case null.JSON:
            return t.JSON
        case null.Bytes:
            return t.Bytes
        case null.String:
            return t.String
        case null.Byte:
            return t.Byte
        case null.Float32:
            return t.Float32
        case null.Float64:
            return t.Float64
        case null.Int:
            return t.Int
        case null.Int8:
            return t.Int8
        case null.Int16:
            return t.Int16
        case null.Int32:
            return t.Int32
        case null.Int64:
            return t.Int64
        case null.Uint:
            return t.Uint
        case null.Uint8:
            return t.Uint8
        case null.Uint16:
            return t.Uint16
        case null.Uint32:
            return t.Uint32
        case null.Uint64:
            return t.Uint64
    default:
        return o
    }
}

func buildQueryModFilterBookmark[T any](filterField BookmarkField, filterOperation model.FilterOperation[T]) queryModSliceBookmark {
    var newQueryMod queryModSliceBookmark

    filterOperator := filterOperation.Operator

    switch filterOperator {
    case model.FilterEqual:
        filterOperand, ok := filterOperation.Operand.(model.ScalarOperand[T])
        if !ok {
            panic("expected a scalar operand for FilterEqual operator")
        }

        if IsUnsetOptionalBookmark(filterOperand.Operand) {
            newQueryMod = append(newQueryMod, qmhelper.WhereIsNull(strcase.SnakeCase(string(filterField))))
        } else {
            newQueryMod = append(newQueryMod, qm.Where(strcase.SnakeCase(string(filterField))+" = ?", TryUnwrapOptionalBookmark(filterOperand.Operand)))
        }
    case model.FilterNEqual:
        filterOperand, ok := filterOperation.Operand.(model.ScalarOperand[T])
        if !ok {
            panic("expected a scalar operand for FilterNEqual operator")
        }

        if IsUnsetOptionalBookmark(filterOperand.Operand) {
            newQueryMod = append(newQueryMod, qmhelper.WhereIsNotNull(strcase.SnakeCase(string(filterField))))
        } else {
            newQueryMod = append(newQueryMod, qm.Where(strcase.SnakeCase(string(filterField))+" != ?", TryUnwrapOptionalBookmark(filterOperand.Operand)))
        }
    case model.FilterGreaterThan:
        filterOperand, ok := filterOperation.Operand.(model.ScalarOperand[T])
        if !ok {
            panic("expected a scalar operand for FilterGreaterThan operator")
        }

        newQueryMod = append(newQueryMod, qm.Where(strcase.SnakeCase(string(filterField))+" > ?", TryUnwrapOptionalBookmark(filterOperand.Operand)))
    case model.FilterGreaterThanEqual:
        filterOperand, ok := filterOperation.Operand.(model.ScalarOperand[T])
        if !ok {
            panic("expected a scalar operand for FilterGreaterThanEqual operator")
        }

        newQueryMod = append(newQueryMod, qm.Where(strcase.SnakeCase(string(filterField))+" >= ?", TryUnwrapOptionalBookmark(filterOperand.Operand)))
    case model.FilterLessThan:
        filterOperand, ok := filterOperation.Operand.(model.ScalarOperand[T])
        if !ok {
            panic("expected a scalar operand for FilterLessThan operator")
        }

        newQueryMod = append(newQueryMod, qm.Where(strcase.SnakeCase(string(filterField))+" < ?", TryUnwrapOptionalBookmark(filterOperand.Operand)))
    case model.FilterLessThanEqual:
        filterOperand, ok := filterOperation.Operand.(model.ScalarOperand[T])
        if !ok {
            panic("expected a scalar operand for FilterLessThanEqual operator")
        }

        newQueryMod = append(newQueryMod, qm.Where(strcase.SnakeCase(string(filterField))+" <= ?", TryUnwrapOptionalBookmark(filterOperand.Operand)))
    case model.FilterIn:
        filterOperand, ok := filterOperation.Operand.(model.ListOperand[T])
        if !ok {
            panic("expected a list operand for FilterIn operator")
        }

		whereArgs, _ := goaoi.TransformCopySliceUnsafe(filterOperand.Operands, func(a T) any { return any(a) })

        newQueryMod = append(newQueryMod, qm.WhereIn(strcase.SnakeCase(string(filterField))+" IN ?", whereArgs...))
    case model.FilterNotIn:
        filterOperand, ok := filterOperation.Operand.(model.ListOperand[T])
        if !ok {
            panic("expected a list operand for FilterNotIn operator")
        }

		whereArgs, _ := goaoi.TransformCopySliceUnsafe(filterOperand.Operands, func(a T) any { return any(a) })

        newQueryMod = append(newQueryMod, qm.WhereNotIn(strcase.SnakeCase(string(filterField))+" IN ?", whereArgs...))
    case model.FilterBetween:
        filterOperand, ok := filterOperation.Operand.(model.RangeOperand[T])
        if !ok {
            panic("expected a scalar operand for FilterBetween operator")
        }

        newQueryMod = append(newQueryMod, qm.Where(strcase.SnakeCase(string(filterField))+" BETWEEN ? AND ?", filterOperand.Start, filterOperand.End))
    case model.FilterNotBetween:
        filterOperand, ok := filterOperation.Operand.(model.RangeOperand[T])
        if !ok {
            panic("expected a scalar operand for FilterNotBetween operator")
        }

        newQueryMod = append(newQueryMod, qm.Where(strcase.SnakeCase(string(filterField))+" NOT BETWEEN ? AND ?", filterOperand.Start, filterOperand.End))
    case model.FilterLike:
        filterOperand, ok := filterOperation.Operand.(model.ScalarOperand[T])
        if !ok {
            panic("expected a scalar operand for FilterLike operator")
        }

        newQueryMod = append(newQueryMod, qm.Where(strcase.SnakeCase(string(filterField))+" LIKE ?", filterOperand.Operand))
    case model.FilterNotLike:
        filterOperand, ok := filterOperation.Operand.(model.ScalarOperand[T])
        if !ok {
            panic("expected a scalar operand for FilterLike operator")
        }

        newQueryMod = append(newQueryMod, qm.Where(strcase.SnakeCase(string(filterField))+" NOT LIKE ?", filterOperand.Operand))
    case model.FilterOr:
        filterOperand, ok := filterOperation.Operand.(model.CompoundOperand[T])
        if !ok {
            panic("expected a scalar operand for FilterOr operator")
        }
        newQueryMod = append(newQueryMod, qm.Expr(buildQueryModFilterBookmark(filterField, filterOperand.LHS)))
        newQueryMod = append(newQueryMod, qm.Or2(qm.Expr(buildQueryModFilterBookmark(filterField, filterOperand.RHS))))
    case model.FilterAnd:
        filterOperand, ok := filterOperation.Operand.(model.CompoundOperand[T])
        if !ok {
            panic("expected a scalar operand for FilterAnd operator")
        }

        newQueryMod = append(newQueryMod, qm.Expr(buildQueryModFilterBookmark(filterField, filterOperand.LHS)))
        newQueryMod = append(newQueryMod, qm.Expr(buildQueryModFilterBookmark(filterField, filterOperand.RHS)))
    default:
        panic("Unhandled FilterOperator")
    }

    return newQueryMod
}

func buildQueryModListFromFilterBookmark(filter *BookmarkFilter) queryModSliceBookmark {
	queryModList := make(queryModSliceBookmark, 0, 9)

    if filter.CreatedAt.HasValue {
        newQueryMod := buildQueryModFilterBookmark("CreatedAt", filter.CreatedAt.Wrappee)
        queryModList = append(queryModList, newQueryMod...)
    }
    if filter.UpdatedAt.HasValue {
        newQueryMod := buildQueryModFilterBookmark("UpdatedAt", filter.UpdatedAt.Wrappee)
        queryModList = append(queryModList, newQueryMod...)
    }
    if filter.DeletedAt.HasValue {
        newQueryMod := buildQueryModFilterBookmark("DeletedAt", filter.DeletedAt.Wrappee)
        queryModList = append(queryModList, newQueryMod...)
    }
    if filter.URL.HasValue {
        newQueryMod := buildQueryModFilterBookmark("URL", filter.URL.Wrappee)
        queryModList = append(queryModList, newQueryMod...)
    }
    if filter.Title.HasValue {
        newQueryMod := buildQueryModFilterBookmark("Title", filter.Title.Wrappee)
        queryModList = append(queryModList, newQueryMod...)
    }
    if filter.BookmarkTypeID.HasValue {
        newQueryMod := buildQueryModFilterBookmark("BookmarkTypeID", filter.BookmarkTypeID.Wrappee)
        queryModList = append(queryModList, newQueryMod...)
    }
    if filter.IsCollection.HasValue {
        newQueryMod := buildQueryModFilterBookmark("IsCollection", filter.IsCollection.Wrappee)
        queryModList = append(queryModList, newQueryMod...)
    }
    if filter.ID.HasValue {
        newQueryMod := buildQueryModFilterBookmark("ID", filter.ID.Wrappee)
        queryModList = append(queryModList, newQueryMod...)
    }
    if filter.IsRead.HasValue {
        newQueryMod := buildQueryModFilterBookmark("IsRead", filter.IsRead.Wrappee)
        queryModList = append(queryModList, newQueryMod...)
    }
    

	return queryModList
}


type MssqlBookmarkRepositoryConstructorArgs struct {
    DB *sql.DB
    Logger *log.Logger
    
    TagRepository repoCommon.TagRepository
    
}

func (repo *MssqlBookmarkRepository) New(args any) (newRepo repoCommon.BookmarkRepository, err error) {
    constructorArgs, ok := args.(MssqlBookmarkRepositoryConstructorArgs)
    if !ok {
        err = fmt.Errorf("expected type %T but got %T", MssqlBookmarkRepositoryConstructorArgs{}, args)

repo.Logger.Error(err)

return
    }

    repo.db = constructorArgs.DB
    repo.Logger = constructorArgs.Logger
    
    repo.tagRepository = constructorArgs.TagRepository
    

    newRepo = repo

    return
}


//******************************************************************//
//                              Methods                             //
//******************************************************************//
func (repo *MssqlBookmarkRepository) Add(ctx context.Context, domainModels []*domain.Bookmark)  (err error){
    if len(domainModels) == 0 {
        repo.Logger.Debug(helper.LogMessageEmptyInput)

        err = helper.IneffectiveOperationError{Inner: helper.EmptyInputError{}}

repo.Logger.Error(err)

return
    }

	err = goaoi.AnyOfSlice(domainModels, func (e *domain.Bookmark) bool {return e == nil || e.IsDefault()})
	if err == nil{
		err = helper.NilInputError{}
		repo.Logger.Error(err)

		return
	}

    var tx *sql.Tx

    tx, err = repo.db.BeginTx(ctx, nil)
    if err != nil {
        repo.Logger.Error(err)

return err
    }


    err = repo.AddMinimal(ctx, domainModels, tx)
    if err != nil {
        repo.Logger.Error(err)

return err
    }

    err = repo.ReplaceTx(ctx, domainModels, tx)
    if err != nil {
        repo.Logger.Error(err)

        return err
    }

    tx.Commit()

    return
}

func (repo *MssqlBookmarkRepository) AddMinimal(ctx context.Context, domainModels []*domain.Bookmark, tx *sql.Tx)  (err error){
    if len(domainModels) == 0 {
        repo.Logger.Debug(helper.LogMessageEmptyInput)

        err = helper.IneffectiveOperationError{Inner: helper.EmptyInputError{}}

repo.Logger.Error(err)

return
    }

	err = goaoi.AnyOfSlice(domainModels, func (e *domain.Bookmark) bool {return e == nil || e.IsDefault()})
	if err == nil{
		err = helper.NilInputError{}
		repo.Logger.Error(err)

		return
	}

    var commitHere bool
    if tx == nil {
        tx, err = repo.db.BeginTx(ctx, nil)
        if err != nil {
repo.Logger.Error(err)

return
        }
        commitHere = true
    }

    var repositoryModels []any
    repositoryModels, err = goaoi.TransformCopySlice(domainModels, repo.GetBookmarkDomainToRepositoryModelMinimalTx(ctx, tx))
	if err != nil {
		return
	}

	for _, repositoryModel := range repositoryModels {
        repoModel, ok := repositoryModel.(*Bookmark)
        if !ok {
            err = fmt.Errorf("expected type *Bookmark but got %T", repoModel)

repo.Logger.Error(err)

return
        }

		err = repoModel.Insert(ctx, tx, boil.Infer())
		if err != nil {
            if strings.Contains(err.Error(), "UNIQUE") {
                err = helper.DuplicateInsertionError{Inner: err}
            }

			return
		}
	}

    if commitHere {
        tx.Commit()
    }

    return
}

func (repo *MssqlBookmarkRepository) ReplaceTx(ctx context.Context, domainModels []*domain.Bookmark, tx *sql.Tx)  (err error){
    
    if len(domainModels) == 0 {
        repo.Logger.Debug(helper.LogMessageEmptyInput)

        err = helper.IneffectiveOperationError{Inner: helper.EmptyInputError{}}

repo.Logger.Error(err)

return
    }

	err = goaoi.AnyOfSlice(domainModels, func (e *domain.Bookmark) bool {return e == nil || e.IsDefault()})
	if err == nil{
		err = helper.NilInputError{}
		repo.Logger.Error(err)

		return
	}

    var commitHere bool
    if tx == nil {
        tx, err = repo.db.BeginTx(ctx, nil)
        if err != nil {
repo.Logger.Error(err)

return
        }

        commitHere = true
    }

    var repositoryModels []any
    repositoryModels, err = goaoi.TransformCopySlice(domainModels, repo.GetBookmarkDomainToRepositoryModelTx(ctx, tx))
	if err != nil {
		return
	}

	for _, repositoryModel := range repositoryModels {
        repoModel, ok := repositoryModel.(*Bookmark)
        if !ok {
            err = fmt.Errorf("expected type *Bookmark but got %T", repoModel)

repo.Logger.Error(err)

return
        }

        var numAffectedRecords int64
		numAffectedRecords, err = repoModel.Update(ctx, tx, boil.Infer())
		if err != nil {
            if strings.Contains(err.Error(), "UNIQUE") {
                err = helper.DuplicateInsertionError{Inner: err}
            }

			return
		}

        if numAffectedRecords == 0 {
            var doesExist bool
            for _, repositoryBookmark := range repositoryModels {
                doesExist, err = Bookmarks(BookmarkWhere.ID.EQ(repositoryBookmark.(*Bookmark).ID)).Exists(ctx, tx)
                if err != nil {
                    return err
                }

                if !doesExist {
                    err = helper.IneffectiveOperationError{Inner: helper.NonExistentPrimaryDataError{}}

repo.Logger.Error(err)

return
                }
            }
        }

        err = repo.UpdateRelatedEntities(ctx,tx, repositoryModel.(*Bookmark))
        if err != nil {
            return err
        }

	}

    if commitHere {
    tx.Commit()
    }

    return
}

func (repo *MssqlBookmarkRepository) Replace(ctx context.Context, domainModels []*domain.Bookmark)  (err error){
    
    if len(domainModels) == 0 {
        repo.Logger.Debug(helper.LogMessageEmptyInput)

        err = helper.IneffectiveOperationError{Inner: helper.EmptyInputError{}}

repo.Logger.Error(err)

return
    }

	err = goaoi.AnyOfSlice(domainModels, func (e *domain.Bookmark) bool {return e == nil || e.IsDefault()})
	if err == nil{
		err = helper.NilInputError{}
		repo.Logger.Error(err)

		return
	}

    var repositoryModels []any
    repositoryModels, err = goaoi.TransformCopySlice(domainModels, repo.GetBookmarkDomainToRepositoryModel(ctx))
	if err != nil {
		return
	}

    var tx *sql.Tx

	tx, err = repo.db.BeginTx(ctx, nil)
	if err != nil {
		return
	}

	for _, repositoryModel := range repositoryModels {
        repoModel, ok := repositoryModel.(*Bookmark)
        if !ok {
            err = fmt.Errorf("expected type *Bookmark but got %T", repoModel)

repo.Logger.Error(err)

return
        }

        var numAffectedRecords int64
		numAffectedRecords, err = repoModel.Update(ctx, tx, boil.Infer())
		if err != nil {
            if strings.Contains(err.Error(), "UNIQUE") {
                err = helper.DuplicateInsertionError{Inner: err}
            }

			return
		}

        if numAffectedRecords == 0 {
            var doesExist bool
            for _, repositoryBookmark := range repositoryModels {
                doesExist, err = Bookmarks(BookmarkWhere.ID.EQ(repositoryBookmark.(*Bookmark).ID)).Exists(ctx, tx)
                if err != nil {
                    repo.Logger.Error(err)

return err
                }

                if !doesExist {
                    err = helper.IneffectiveOperationError{Inner: helper.NonExistentPrimaryDataError{}}

repo.Logger.Error(err)

return
                }
            }
        }

        err = repo.UpdateRelatedEntities(ctx,tx, repositoryModel.(*Bookmark))
        if err != nil {
            repo.Logger.Error(err)

return err
        }

	}

	tx.Commit()

    return
}

func (repo *MssqlBookmarkRepository) Upsert(ctx context.Context, domainModels []*domain.Bookmark)  (err error){
    if len(domainModels) == 0 {
        repo.Logger.Debug(helper.LogMessageEmptyInput)

        err = helper.IneffectiveOperationError{Inner: helper.EmptyInputError{}}

repo.Logger.Error(err)

return
    }

	err = goaoi.AnyOfSlice(domainModels, func (e *domain.Bookmark) bool {return e == nil || e.IsDefault()})
	if err == nil{
		err = helper.NilInputError{}
		repo.Logger.Error(err)

		return
	}

    var repositoryModels []any
    repositoryModels, err = goaoi.TransformCopySlice(domainModels, repo.GetBookmarkDomainToRepositoryModel(ctx))
	if err != nil {
		return
	}

    var tx *sql.Tx

	tx, err = repo.db.BeginTx(ctx, nil)
	if err != nil {
		return
	}

	for _, repositoryModel := range repositoryModels {
        repoModel, ok := repositoryModel.(*Bookmark)
        if !ok {
            err = fmt.Errorf("expected type *Bookmark but got %T", repoModel)

repo.Logger.Error(err)

return
        }

        
		err = repoModel.Upsert(ctx, tx, boil.Infer(), boil.Infer())
        
		if err != nil {
            if strings.Contains(err.Error(), "UNIQUE") {
                err = helper.DuplicateInsertionError{Inner: err}
            }

			return
		}

        err = repo.UpdateRelatedEntities(ctx,tx, repositoryModel.(*Bookmark))
        if err != nil {
            repo.Logger.Error(err)

return err
        }
	}

	tx.Commit()

    return
}

func (repo *MssqlBookmarkRepository) Update(ctx context.Context, domainModels []*domain.Bookmark, domainColumnUpdater *domain.BookmarkUpdater)  (err error){
    if len(domainModels) == 0 {
        repo.Logger.Debug(helper.LogMessageEmptyInput)

        err = helper.IneffectiveOperationError{Inner: helper.EmptyInputError{}}

repo.Logger.Error(err)

return
    }

	err = goaoi.AnyOfSlice(domainModels, func (e *domain.Bookmark) bool {return e == nil || e.IsDefault()})
	if err == nil{
		err = helper.NilInputError{}
		repo.Logger.Error(err)

		return
	}

	if  domainColumnUpdater == nil {
		err = helper.NilInputError{}
		repo.Logger.Error(err)

		return
    }

	if  domainColumnUpdater.IsDefault() {
        err = helper.IneffectiveOperationError{Inner: helper.NopUpdaterError{}}
		repo.Logger.Error(err)

		return
    }

    var repositoryModels []any
    repositoryModels, err = goaoi.TransformCopySlice(domainModels, repo.GetBookmarkDomainToRepositoryModel(ctx))
	if err != nil {
		return
	}

    var repositoryUpdater any
    repositoryUpdater, err = repo.BookmarkDomainToRepositoryUpdater(ctx, domainColumnUpdater)
    if err != nil {
repo.Logger.Error(err)

return
    }

    var tx *sql.Tx

   	tx, err = repo.db.BeginTx(ctx, nil)
	if err != nil {
		return
	}

    var numAffectedRecords int64
    for _, repositoryModel := range   repositoryModels {
        repoModel, ok := repositoryModel.(*Bookmark)
        if !ok {
            err = fmt.Errorf("expected type *Bookmark but got %T", repoModel)

repo.Logger.Error(err)

return
        }

        repoUpdater, ok := repositoryUpdater.(*BookmarkUpdater)
        if !ok {
            err = fmt.Errorf("expected type *Bookmark but got %T", repoModel)

repo.Logger.Error(err)

return
        }

        repoUpdater.ApplyToModel(repoModel)
        numAffectedRecords, err = repoModel.Update(ctx, tx, boil.Infer())
        if err != nil {
            if strings.Contains(err.Error(), "UNIQUE") {
                err = helper.DuplicateInsertionError{Inner: err}
            }

repo.Logger.Error(err)

return
        }

        if numAffectedRecords == 0 {
            err = helper.IneffectiveOperationError{Inner: helper.NonExistentPrimaryDataError{}}

repo.Logger.Error(err)

return
        }

        err = repo.UpdateRelatedEntities(ctx,tx, repositoryModel.(*Bookmark))
        if err != nil {
            repo.Logger.Error(err)

return err
        }
    }

    err = tx.Commit()

    return
}

func (repo *MssqlBookmarkRepository) UpdateWhere(ctx context.Context, domainColumnFilter *domain.BookmarkFilter, domainColumnUpdater *domain.BookmarkUpdater) (numAffectedRecords int64, err error) {
	var modelsToUpdate BookmarkSlice

	if  domainColumnFilter == nil {
		err = helper.NilInputError{}
		repo.Logger.Error(err)

		return
    }

	if  domainColumnUpdater == nil {
		err = helper.NilInputError{}
		repo.Logger.Error(err)

		return
    }

	if  domainColumnUpdater.IsDefault() {
        err = helper.IneffectiveOperationError{Inner: helper.NopUpdaterError{}}
		repo.Logger.Error(err)

		return
    }

    var repositoryFilter any
    repositoryFilter, err = repo.BookmarkDomainToRepositoryFilter(ctx, domainColumnFilter)
    if err != nil {
repo.Logger.Error(err)

return
    }

    var repositoryUpdater any
    repositoryUpdater, err = repo.BookmarkDomainToRepositoryUpdater(ctx, domainColumnUpdater)
    if err != nil {
repo.Logger.Error(err)

return
    }

    repoUpdater, ok := repositoryUpdater.(*BookmarkUpdater)
    if !ok {
        err = fmt.Errorf("expected type *BookmarkUpdater but got %T", repoUpdater)

repo.Logger.Error(err)

return
    }


    repoFilter, ok := repositoryFilter.(*BookmarkFilter)
    if !ok {
        err = fmt.Errorf("expected type *BookmarkFilter but got %T", repoFilter)

repo.Logger.Error(err)

return
    }



	queryFilters := buildQueryModListFromFilterBookmark(repoFilter)

	modelsToUpdate, err = Bookmarks(queryFilters...).All(ctx, repo.db)
	if err != nil {
		return
	}

    if len(modelsToUpdate) == 0 {
        err = helper.IneffectiveOperationError{Inner: helper.NonExistentPrimaryDataError{}}

repo.Logger.Error(err)

return
    }

    var tx *sql.Tx

	tx, err = repo.db.BeginTx(ctx, nil)
	if err != nil {
		return
	}

    for _, repoModel := range modelsToUpdate {
        repoUpdater.ApplyToModel(repoModel)
        _, err = repoModel.Update(ctx, tx, boil.Infer())
        if err != nil {
            if strings.Contains(err.Error(), "UNIQUE") {
                err = helper.DuplicateInsertionError{Inner: err}
            }

repo.Logger.Error(err)

return
        }

        err = repo.UpdateRelatedEntities(ctx,tx, repoModel)
        if err != nil {
repo.Logger.Error(err)

return
        }

    }

    tx.Commit()

    numAffectedRecords = int64(len(modelsToUpdate))

    return
}

func (repo *MssqlBookmarkRepository) Delete(ctx context.Context, domainModels []*domain.Bookmark)  (err error){
    if len(domainModels) == 0 {
        repo.Logger.Debug(helper.LogMessageEmptyInput)

        err = helper.IneffectiveOperationError{Inner: helper.EmptyInputError{}}

repo.Logger.Error(err)

return
    }

	err = goaoi.AnyOfSlice(domainModels, func (e *domain.Bookmark) bool {return e == nil || e.IsDefault()})
	if err == nil{
		err = helper.NilInputError{}
		repo.Logger.Error(err)

		return
	}

    var repositoryModels []any
    repositoryModels, err = goaoi.TransformCopySlice(domainModels, repo.GetBookmarkDomainToRepositoryModel(ctx))
	if err != nil {
		return
	}

    var tx *sql.Tx

	tx, err = repo.db.BeginTx(ctx, nil)
	if err != nil {
		return
	}

    var numAffectedRecords int64

	for _, repositoryModel := range repositoryModels {
        repoModel, ok := repositoryModel.(*Bookmark)
        if !ok {
            err = fmt.Errorf("expected type *Bookmark but got %T", repoModel)

repo.Logger.Error(err)

return
        }

		numAffectedRecords, err = repoModel.Delete(ctx, tx)
		if err != nil {
			return
		}

        if numAffectedRecords == 0 {
            err = helper.IneffectiveOperationError{Inner: helper.NonExistentPrimaryDataError{}}

repo.Logger.Error(err)

return
        }

        err = repo.UpdateRelatedEntities(ctx,tx, repositoryModel.(*Bookmark))
        if err != nil {
            repo.Logger.Error(err)

return err
        }
	}

	tx.Commit()

    return
}

func (repo *MssqlBookmarkRepository) DeleteWhere(ctx context.Context, domainColumnFilter *domain.BookmarkFilter) (numAffectedRecords int64, err error) {
	if  domainColumnFilter == nil {
		err = helper.NilInputError{}
		repo.Logger.Error(err)

		return
    }

    var repositoryFilter any
    repositoryFilter, err = repo.BookmarkDomainToRepositoryFilter(ctx, domainColumnFilter)
    if err != nil {
repo.Logger.Error(err)

return
    }

    repoFilter, ok := repositoryFilter.(*BookmarkFilter)
    if !ok {
        err = fmt.Errorf("expected type *BookmarkFilter but got %T", repoFilter)

repo.Logger.Error(err)

return
    }



	queryFilters := buildQueryModListFromFilterBookmark(repoFilter)

    var tx *sql.Tx

	tx, err = repo.db.BeginTx(ctx, nil)
	if err != nil {
		return
	}

	numAffectedRecords, err = Bookmarks(queryFilters...).DeleteAll(ctx, tx)

    tx.Commit()

    return
}

func (repo *MssqlBookmarkRepository) CountWhere(ctx context.Context, domainColumnFilter *domain.BookmarkFilter) (numRecords int64, err error) {
	if  domainColumnFilter == nil {
		err = helper.NilInputError{}
		repo.Logger.Error(err)

		return
    }

    var repositoryFilter any
    repositoryFilter, err = repo.BookmarkDomainToRepositoryFilter(ctx, domainColumnFilter)
    if err != nil {
repo.Logger.Error(err)

return
    }

    repoFilter, ok := repositoryFilter.(*BookmarkFilter)
    if !ok {
        err = fmt.Errorf("expected type *BookmarkFilter but got %T", repoFilter)

repo.Logger.Error(err)

return
    }



	queryFilters := buildQueryModListFromFilterBookmark(repoFilter)

	return Bookmarks(queryFilters...).Count(ctx, repo.db)
}

func (repo *MssqlBookmarkRepository) CountAll(ctx context.Context) (numRecords int64, err error) {
	return Bookmarks().Count(ctx, repo.db)
}

func (repo *MssqlBookmarkRepository) DoesExist(ctx context.Context, domainModel *domain.Bookmark) (doesExist bool, err error) {
	if domainModel == nil {
        err = helper.NilInputError{}
		repo.Logger.Error(err)

		return
	}

    var repositoryModel any
    repositoryModel, err = repo.BookmarkDomainToRepositoryModel(ctx, domainModel)
    if err != nil {
repo.Logger.Error(err)

return
    }

    repoModel, ok := repositoryModel.(*Bookmark)
    if !ok {
        err = fmt.Errorf("expected type *Bookmark but got %T", repoModel)

repo.Logger.Error(err)

return
    }


	return BookmarkExists(ctx, repo.db, repoModel.ID)
}

func (repo *MssqlBookmarkRepository) DoesExistWhere(ctx context.Context, domainColumnFilter *domain.BookmarkFilter) (doesExist bool, err error) {
	if  domainColumnFilter == nil {
		err = helper.NilInputError{}
		repo.Logger.Error(err)

		return
    }

    var repositoryFilter any
    repositoryFilter, err = repo.BookmarkDomainToRepositoryFilter(ctx, domainColumnFilter)
    if err != nil {
repo.Logger.Error(err)

return
    }

    repoFilter, ok := repositoryFilter.(*BookmarkFilter)
    if !ok {
        err = fmt.Errorf("expected type *BookmarkFilter but got %T", repoFilter)

repo.Logger.Error(err)

return
    }



	queryFilters := buildQueryModListFromFilterBookmark(repoFilter)

	return Bookmarks(queryFilters...).Exists(ctx, repo.db)
}

func (repo *MssqlBookmarkRepository) GetWhere(ctx context.Context, domainColumnFilter *domain.BookmarkFilter) (records []*domain.Bookmark, err error) {
	if  domainColumnFilter == nil {
		err = helper.NilInputError{}
		repo.Logger.Error(err)

		return
    }

    var repositoryFilter any
    repositoryFilter, err = repo.BookmarkDomainToRepositoryFilter(ctx, domainColumnFilter)
    if err != nil {
repo.Logger.Error(err)

return
    }

    repoFilter, ok := repositoryFilter.(*BookmarkFilter)
    if !ok {
        err = fmt.Errorf("expected type *BookmarkFilter but got %T", repoFilter)

repo.Logger.Error(err)

return
    }




	queryFilters := buildQueryModListFromFilterBookmark(repoFilter)

    var repositoryModels BookmarkSlice
    repositoryModels, err = Bookmarks(queryFilters...).All(ctx, repo.db)
    if err != nil {
repo.Logger.Error(err)

return
    }

    if len(repositoryModels) == 0 {
    err = helper.IneffectiveOperationError{Inner: helper.NonExistentPrimaryDataError{}}

repo.Logger.Error(err)

return
    }


    tx, err := repo.db.BeginTx(ctx, nil)
    if err != nil {
repo.Logger.Error(err)

return
    }

    for _, repoModel := range repositoryModels {
        err = repo.LoadEntityRelations(ctx, tx, repoModel)
        if err != nil {
repo.Logger.Error(err)

return
        }
    }

    err = tx.Commit()
    if err != nil {
repo.Logger.Error(err)

return
    }

    records = make([]*domain.Bookmark, 0, len(repositoryModels))

    var domainModel *domain.Bookmark
    for _, repoModel := range repositoryModels {
        domainModel, err = repo.BookmarkRepositoryToDomainModel(ctx, repoModel)
        if err != nil {
repo.Logger.Error(err)

return
        }

        records = append(records, domainModel)
    }

    return
}

func (repo *MssqlBookmarkRepository) GetFirstWhere(ctx context.Context, domainColumnFilter *domain.BookmarkFilter) (record *domain.Bookmark, err error) {
	if  domainColumnFilter == nil {
		err = helper.NilInputError{}
		repo.Logger.Error(err)

		return
    }

    var repositoryFilter any
    repositoryFilter, err = repo.BookmarkDomainToRepositoryFilter(ctx, domainColumnFilter)
    if err != nil {
repo.Logger.Error(err)

return
    }

    repoFilter, ok := repositoryFilter.(*BookmarkFilter)
    if !ok {
        err =  fmt.Errorf("expected type *BookmarkFilter but got %T", repoFilter)

repo.Logger.Error(err)

return
    }



	queryFilters := buildQueryModListFromFilterBookmark(repoFilter)

    var repositoryModel *Bookmark
    repositoryModel, err = Bookmarks(queryFilters...).One(ctx, repo.db)
    if err != nil {
        if  errors.Is(err, sql.ErrNoRows){
            err = helper.IneffectiveOperationError{Inner: helper.NonExistentPrimaryDataError{}}
        }

repo.Logger.Error(err)

return
    }


    tx, err := repo.db.BeginTx(ctx, nil)
    if err != nil {
repo.Logger.Error(err)

return
    }

    err = repo.LoadEntityRelations(ctx, tx, repositoryModel)
    if err != nil {
repo.Logger.Error(err)

return
    }

    err = tx.Commit()
    if err != nil {
repo.Logger.Error(err)

return
    }

    record , err =repo.BookmarkRepositoryToDomainModel(ctx, repositoryModel)

    return
}

func (repo *MssqlBookmarkRepository) GetAll(ctx context.Context) (records []*domain.Bookmark, err error) {
    var repositoryModels BookmarkSlice
    repositoryModels, err = Bookmarks().All(ctx, repo.db)
    if err != nil {
repo.Logger.Error(err)

return
    }
    if len(repositoryModels) == 0 {
        err = helper.IneffectiveOperationError{Inner: helper.NonExistentPrimaryDataError{}}

repo.Logger.Error(err)

return
    }

    tx, err := repo.db.BeginTx(ctx, nil)
    if err != nil {
repo.Logger.Error(err)

return
    }

    for _, repoModel := range repositoryModels {
        err = repo.LoadEntityRelations(ctx, tx, repoModel)
        if err != nil {
repo.Logger.Error(err)

return
        }
    }

    err = tx.Commit()
    if err != nil {
repo.Logger.Error(err)

return
    }

    records = make([]*domain.Bookmark, 0, len(repositoryModels))

    var domainModel *domain.Bookmark
    for _, repoModel := range repositoryModels {
        domainModel, err = repo.BookmarkRepositoryToDomainModel(ctx, repoModel)
        if err != nil {
repo.Logger.Error(err)

return
        }

        records = append(records, domainModel)
    }

    return
}

func (repo *MssqlBookmarkRepository) GetFromIDs(ctx context.Context, IDs []int64) (records []*domain.Bookmark, err error) {
    filter := &domain.BookmarkFilter{ID: optional.Make(model.FilterOperation[int64]{Operand: model.ListOperand[int64]{IDs}, Operator: model.FilterIn})}

    var repositoryFilter any
    repositoryFilter, err = repo.BookmarkDomainToRepositoryFilter(ctx, filter)
    if err != nil {
repo.Logger.Error(err)

return
    }

    repoFilter, ok := repositoryFilter.(*BookmarkFilter)
    if !ok {
        err = fmt.Errorf("expected type *BookmarkFilter but got %T", repoFilter)

repo.Logger.Error(err)

return
    }




	queryFilters := buildQueryModListFromFilterBookmark(repoFilter)

    var repositoryModels BookmarkSlice
    repositoryModels, err = Bookmarks(queryFilters...).All(ctx, repo.db)
    if err != nil {
repo.Logger.Error(err)

return
    }

    if len(repositoryModels) == 0 {
    err = helper.IneffectiveOperationError{Inner: helper.NonExistentPrimaryDataError{}}

repo.Logger.Error(err)

return
    }

    tx, err := repo.db.BeginTx(ctx, nil)
    if err != nil {
repo.Logger.Error(err)

return
    }

    for _, repoModel := range repositoryModels {
        err = repo.LoadEntityRelations(ctx, tx, repoModel)
        if err != nil {
repo.Logger.Error(err)

return
        }
    }

    err = tx.Commit()
    if err != nil {
repo.Logger.Error(err)

return
    }

    records = make([]*domain.Bookmark, 0, len(repositoryModels))

    var domainModel *domain.Bookmark
    for _, repoModel := range repositoryModels {
        domainModel, err = repo.BookmarkRepositoryToDomainModel(ctx, repoModel)
        if err != nil {
repo.Logger.Error(err)

return
        }

        records = append(records, domainModel)
    }

    return
}


func (repo *MssqlBookmarkRepository) AddType(ctx context.Context, types []string)  (err error){
    if len(types) == 0 {
        repo.Logger.Debug(helper.LogMessageEmptyInput)

        err = helper.IneffectiveOperationError{Inner: helper.EmptyInputError{}}

repo.Logger.Error(err)

return
    }

    for _, type_ := range types {
        repositoryModel := BookmarkType{BookmarkType: type_}

        err = repositoryModel.Insert(ctx, repo.db, boil.Infer())
        if err != nil {
            if strings.Contains(err.Error(), "UNIQUE") {
                err = helper.DuplicateInsertionError{Inner: err}
            }

repo.Logger.Error(err)

return
        }
    }

    return
}

func (repo *MssqlBookmarkRepository) DeleteType(ctx context.Context, types []string)  (err error){
    if len(types) == 0 {
        repo.Logger.Debug(helper.LogMessageEmptyInput)

        err = helper.IneffectiveOperationError{Inner: helper.EmptyInputError{}}

repo.Logger.Error(err)

return
    }

    var numAffectedRecords int64

    numAffectedRecords, err = BookmarkTypes(BookmarkTypeWhere.BookmarkType.IN(types)).DeleteAll(ctx, repo.db)
    if numAffectedRecords == 0 {
        err = helper.IneffectiveOperationError{Inner: helper.NonExistentPrimaryDataError{}}

repo.Logger.Error(err)

return
    }

	return
}

func (repo *MssqlBookmarkRepository) UpdateType(ctx context.Context, oldType string, newType string)  (err error){
    var repositoryModel *BookmarkType
    repositoryModel, err = BookmarkTypes(BookmarkTypeWhere.BookmarkType.EQ(oldType)).One(ctx, repo.db)
    if err != nil {
        if  errors.Is(err, sql.ErrNoRows){
            err = helper.IneffectiveOperationError{Inner: helper.NonExistentPrimaryDataError{}}
        }

repo.Logger.Error(err)

return
    }

    repositoryModel.BookmarkType = newType

    var numAffectedRecords int64
    numAffectedRecords, err = repositoryModel.Update(ctx, repo.db, boil.Infer())
    if err != nil {
        if strings.Contains(err.Error(), "UNIQUE") {
            err = helper.DuplicateInsertionError{Inner: err}

repo.Logger.Error(err)

return
        }
    }

    if numAffectedRecords == 0 {
        var doesExist bool
        doesExist, err = BookmarkTypes(BookmarkTypeWhere.BookmarkType.EQ(oldType)).Exists(ctx, repo.db)
        if err != nil {
            repo.Logger.Error(err)

return err
        }

        if !doesExist {
            err = helper.IneffectiveOperationError{Inner: helper.NonExistentPrimaryDataError{}}

repo.Logger.Error(err)

return
        }
    }

    return
}

func (repo *MssqlBookmarkRepository) GetAllTypes(ctx context.Context) (records []string, err error) {
    var repositoryModels []*BookmarkType
    repositoryModels, err = BookmarkTypes().All(ctx, repo.db)
    if err != nil {
repo.Logger.Error(err)

return
    }
    if len(repositoryModels) == 0 {
        err = helper.IneffectiveOperationError{Inner: helper.NonExistentPrimaryDataError{}}

repo.Logger.Error(err)

return
    }


    return goaoi.TransformCopySliceUnsafe(repositoryModels, func(m *BookmarkType) string {return m.BookmarkType})
}


func (repo *MssqlBookmarkRepository) GetTagRepository() repoCommon.TagRepository {
    return repo.tagRepository
}



//******************************************************************//
//                            Converters                            //
//******************************************************************//
func (repo *MssqlBookmarkRepository) GetBookmarkDomainToRepositoryModel(ctx context.Context) func(domainModel *domain.Bookmark) (repositoryModel any, err error) {
    return func(domainModel *domain.Bookmark) (repositoryModel any, err error) {
        return repo.BookmarkDomainToRepositoryModel(ctx, domainModel)
    }
}

func (repo *MssqlBookmarkRepository) GetBookmarkRepositoryToDomainModel(ctx context.Context) func(repositoryModel any) (domainModel *domain.Bookmark, err error) {
    return func(repositoryModel any) (domainModel *domain.Bookmark, err error) {

        return repo.BookmarkRepositoryToDomainModel(ctx,repositoryModel)
    }
}

func (repo *MssqlBookmarkRepository) GetBookmarkDomainToRepositoryModelMinimal(ctx context.Context) func(domainModel *domain.Bookmark) (repositoryModel any, err error) {
    return func(domainModel *domain.Bookmark) (repositoryModel any, err error) {
        return repo.BookmarkDomainToRepositoryModelMinimal(ctx, domainModel)
    }
}

func (repo *MssqlBookmarkRepository) GetBookmarkDomainToRepositoryModelTx(ctx context.Context, tx *sql.Tx) func(domainModel *domain.Bookmark) (repositoryModel any, err error) {
    return func(domainModel *domain.Bookmark) (repositoryModel any, err error) {
        return repo.BookmarkDomainToRepositoryModelTx(ctx, tx, domainModel)
    }
}

func (repo *MssqlBookmarkRepository) GetBookmarkRepositoryToDomainModelTx(ctx context.Context, tx *sql.Tx) func(repositoryModel any) (domainModel *domain.Bookmark, err error) {
    return func(repositoryModel any) (domainModel *domain.Bookmark, err error) {

        return repo.BookmarkRepositoryToDomainModelTx(ctx, tx,repositoryModel)
    }
}

func (repo *MssqlBookmarkRepository) GetBookmarkDomainToRepositoryModelMinimalTx(ctx context.Context, tx *sql.Tx) func(domainModel *domain.Bookmark) (repositoryModel any, err error) {
    return func(domainModel *domain.Bookmark) (repositoryModel any, err error) {
        return repo.BookmarkDomainToRepositoryModelMinimalTx(ctx, tx, domainModel)
    }
}

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

func (repo *MssqlBookmarkRepository) BookmarkDomainToRepositoryModel(ctx context.Context, domainModel *domain.Bookmark) ( repositoryModel any, err error)  {
    repositoryModelConcrete := new(Bookmark)
    repositoryModelConcrete.R = repositoryModelConcrete.R.NewStruct()

    repositoryModelConcrete.URL = domainModel.URL
    repositoryModelConcrete.ID = domainModel.ID


    //**********************    Set Timestamps    **********************//
    
    repositoryModelConcrete.CreatedAt = domainModel.CreatedAt
    repositoryModelConcrete.UpdatedAt = domainModel.UpdatedAt

    if domainModel.DeletedAt.HasValue {
        var convertedTime null.Time
        convertedTime, err = repoCommon.OptionalTimeToNullTime(domainModel.DeletedAt)
        if err != nil {
repo.Logger.Error(err)

return
        }

        repositoryModelConcrete.DeletedAt = convertedTime
    }
    


    //*************************    Set Title    ************************//
    if domainModel.Title.HasValue {
        repositoryModelConcrete.Title.Valid = true
        repositoryModelConcrete.Title.String = domainModel.Title.Wrappee
    }



    //******************    Set IsRead/IsCollection    *****************//
    if domainModel.IsRead {
        repositoryModelConcrete.IsRead = 1
    }

    if domainModel.IsCollection {
        repositoryModelConcrete.IsCollection = 1
    }

    //*************************    Set Tags    *************************//
    var repositoryTag *Tag

    if domainModel.TagIDs != nil {
        for _,  domainTagID := range domainModel.TagIDs {
            repositoryTag, err = Tags(TagWhere.ID.EQ(domainTagID)).One(ctx, repo.db)
            if err != nil {
                err = repoCommon.ReferenceToNonExistentDependencyError{Inner: err}

repo.Logger.Error(err)

return
            }

            repositoryModelConcrete.R.Tags = append(repositoryModelConcrete.R.Tags, &Tag{Tag: repositoryTag.Tag, ID: repositoryTag.ID})
        }
    }


    //*************************    Set Type    *************************//
	if domainModel.BookmarkType.HasValue {
        var repositoryBookmarkType *BookmarkType

        repositoryModelConcrete.R.BookmarkType = &BookmarkType{BookmarkType: domainModel.BookmarkType.Wrappee}
		repositoryBookmarkType, err = BookmarkTypes(BookmarkTypeWhere.BookmarkType.EQ(domainModel.BookmarkType.Wrappee)).One(ctx, repo.db)
		if err != nil {
            err = repoCommon.ReferenceToNonExistentDependencyError{Inner: err}

			return
		}

        if repositoryBookmarkType != nil {
            repositoryModelConcrete.BookmarkTypeID = null.NewInt64(repositoryBookmarkType.ID, true)
            repositoryModelConcrete.R.BookmarkType.ID = repositoryBookmarkType.ID
        } else {
            repositoryModelConcrete.R.BookmarkType = nil
        }
	}

    repositoryModel = repositoryModelConcrete

    return
}

func (repo *MssqlBookmarkRepository) BookmarkDomainToRepositoryModelMinimal(ctx context.Context, domainModel *domain.Bookmark) ( repositoryModel any, err error)  {
    repositoryModelConcrete := new(Bookmark)
    repositoryModelConcrete.R = repositoryModelConcrete.R.NewStruct()

    repositoryModelConcrete.URL = domainModel.URL
    repositoryModelConcrete.ID = domainModel.ID


    //**********************    Set Timestamps    **********************//
    
    repositoryModelConcrete.CreatedAt = domainModel.CreatedAt
    repositoryModelConcrete.UpdatedAt = domainModel.UpdatedAt

    if domainModel.DeletedAt.HasValue {
        var convertedTime null.Time
        convertedTime, err = repoCommon.OptionalTimeToNullTime(domainModel.DeletedAt)
        if err != nil {
repo.Logger.Error(err)

return
        }

        repositoryModelConcrete.DeletedAt = convertedTime
    }
    


    //*************************    Set Title    ************************//
    if domainModel.Title.HasValue {
        repositoryModelConcrete.Title.Valid = true
        repositoryModelConcrete.Title.String = domainModel.Title.Wrappee
    }



    //******************    Set IsRead/IsCollection    *****************//
    if domainModel.IsRead {
        repositoryModelConcrete.IsRead = 1
    }

    if domainModel.IsCollection {
        repositoryModelConcrete.IsCollection = 1
    }

    repositoryModel = repositoryModelConcrete

    return
}

func (repo *MssqlBookmarkRepository) BookmarkRepositoryToDomainModel(ctx context.Context, repositoryModel any) (domainModel *domain.Bookmark, err error) {
    domainModel = new(domain.Bookmark)

    repositoryModelConcrete := repositoryModel.(*Bookmark)

    domainModel.URL = repositoryModelConcrete.URL
    domainModel.ID = repositoryModelConcrete.ID
    

    if repositoryModelConcrete.R == nil {
        repositoryModelConcrete.R = repositoryModelConcrete.R.NewStruct()
    }

    if repositoryModelConcrete.R.BookmarkType != nil {
        domainModel.BookmarkType = optional.Make(repositoryModelConcrete.R.BookmarkType.BookmarkType)
    }

    //**********************    Set Timestamps    **********************//
    
    domainModel.CreatedAt = repositoryModelConcrete.CreatedAt
    domainModel.UpdatedAt = repositoryModelConcrete.UpdatedAt

    if repositoryModelConcrete.DeletedAt.Valid {
        domainModel.DeletedAt.Set(repositoryModelConcrete.DeletedAt.Time)
    }
    

    //*************************    Set Title    ************************//
    if repositoryModelConcrete.Title.Valid {
        domainModel.Title.Set(repositoryModelConcrete.Title.String)
    }

    //******************    Set IsRead/IsCollection    *****************//
    domainModel.IsRead = repositoryModelConcrete.IsRead > 0
    domainModel.IsCollection = repositoryModelConcrete.IsCollection > 0

    //*************************    Set Tags    *************************//
    domainModel.TagIDs, _ = goaoi.TransformCopySliceUnsafe(repositoryModelConcrete.R.Tags, func (t *Tag) int64 {return t.ID;})

    return
}





func (repo *MssqlBookmarkRepository) BookmarkDomainToRepositoryModelTx(ctx context.Context, tx *sql.Tx, domainModel *domain.Bookmark) ( repositoryModel any, err error)  {
    repositoryModelConcrete := new(Bookmark)
    repositoryModelConcrete.R = repositoryModelConcrete.R.NewStruct()

    repositoryModelConcrete.URL = domainModel.URL
    repositoryModelConcrete.ID = domainModel.ID


    //**********************    Set Timestamps    **********************//
    
    repositoryModelConcrete.CreatedAt = domainModel.CreatedAt
    repositoryModelConcrete.UpdatedAt = domainModel.UpdatedAt

    if domainModel.DeletedAt.HasValue {
        var convertedTime null.Time
        convertedTime, err = repoCommon.OptionalTimeToNullTime(domainModel.DeletedAt)
        if err != nil {
repo.Logger.Error(err)

return
        }

        repositoryModelConcrete.DeletedAt = convertedTime
    }
    


    //*************************    Set Title    ************************//
    if domainModel.Title.HasValue {
        repositoryModelConcrete.Title.Valid = true
        repositoryModelConcrete.Title.String = domainModel.Title.Wrappee
    }



    //******************    Set IsRead/IsCollection    *****************//
    if domainModel.IsRead {
        repositoryModelConcrete.IsRead = 1
    }

    if domainModel.IsCollection {
        repositoryModelConcrete.IsCollection = 1
    }

    //*************************    Set Tags    *************************//
    var repositoryTag *Tag

    if domainModel.TagIDs != nil {
        for _,  domainTagID := range domainModel.TagIDs {
            repositoryTag, err = Tags(TagWhere.ID.EQ(domainTagID)).One(ctx, tx)
            if err != nil {
                err = repoCommon.ReferenceToNonExistentDependencyError{Inner: err}

repo.Logger.Error(err)

return
            }

            repositoryModelConcrete.R.Tags = append(repositoryModelConcrete.R.Tags, &Tag{Tag: repositoryTag.Tag, ID: repositoryTag.ID})
        }
    }


    //*************************    Set Type    *************************//
	if domainModel.BookmarkType.HasValue {
        var repositoryBookmarkType *BookmarkType

        repositoryModelConcrete.R.BookmarkType = &BookmarkType{BookmarkType: domainModel.BookmarkType.Wrappee}
		repositoryBookmarkType, err = BookmarkTypes(BookmarkTypeWhere.BookmarkType.EQ(domainModel.BookmarkType.Wrappee)).One(ctx, tx)
		if err != nil {
            err = repoCommon.ReferenceToNonExistentDependencyError{Inner: err}

			return
		}

        if repositoryBookmarkType != nil {
            repositoryModelConcrete.BookmarkTypeID = null.NewInt64(repositoryBookmarkType.ID, true)
            repositoryModelConcrete.R.BookmarkType.ID = repositoryBookmarkType.ID
        } else {
            repositoryModelConcrete.R.BookmarkType = nil
        }
	}

    repositoryModel = repositoryModelConcrete

    return
}

func (repo *MssqlBookmarkRepository) BookmarkDomainToRepositoryModelMinimalTx(ctx context.Context, tx *sql.Tx, domainModel *domain.Bookmark) ( repositoryModel any, err error)  {
    repositoryModelConcrete := new(Bookmark)
    repositoryModelConcrete.R = repositoryModelConcrete.R.NewStruct()

    repositoryModelConcrete.URL = domainModel.URL
    repositoryModelConcrete.ID = domainModel.ID


    //**********************    Set Timestamps    **********************//
    
    repositoryModelConcrete.CreatedAt = domainModel.CreatedAt
    repositoryModelConcrete.UpdatedAt = domainModel.UpdatedAt

    if domainModel.DeletedAt.HasValue {
        var convertedTime null.Time
        convertedTime, err = repoCommon.OptionalTimeToNullTime(domainModel.DeletedAt)
        if err != nil {
repo.Logger.Error(err)

return
        }

        repositoryModelConcrete.DeletedAt = convertedTime
    }
    


    //*************************    Set Title    ************************//
    if domainModel.Title.HasValue {
        repositoryModelConcrete.Title.Valid = true
        repositoryModelConcrete.Title.String = domainModel.Title.Wrappee
    }



    //******************    Set IsRead/IsCollection    *****************//
    if domainModel.IsRead {
        repositoryModelConcrete.IsRead = 1
    }

    if domainModel.IsCollection {
        repositoryModelConcrete.IsCollection = 1
    }

    repositoryModel = repositoryModelConcrete

    return
}

func (repo *MssqlBookmarkRepository) BookmarkRepositoryToDomainModelTx(ctx context.Context, tx *sql.Tx, repositoryModel any) (domainModel *domain.Bookmark, err error) {
    domainModel = new(domain.Bookmark)

    repositoryModelConcrete := repositoryModel.(*Bookmark)

    domainModel.URL = repositoryModelConcrete.URL
    domainModel.ID = repositoryModelConcrete.ID
    

    if repositoryModelConcrete.R == nil {
        repositoryModelConcrete.R = repositoryModelConcrete.R.NewStruct()
    }

    if repositoryModelConcrete.R.BookmarkType != nil {
        domainModel.BookmarkType = optional.Make(repositoryModelConcrete.R.BookmarkType.BookmarkType)
    }

    //**********************    Set Timestamps    **********************//
    
    domainModel.CreatedAt = repositoryModelConcrete.CreatedAt
    domainModel.UpdatedAt = repositoryModelConcrete.UpdatedAt

    if repositoryModelConcrete.DeletedAt.Valid {
        domainModel.DeletedAt.Set(repositoryModelConcrete.DeletedAt.Time)
    }
    

    //*************************    Set Title    ************************//
    if repositoryModelConcrete.Title.Valid {
        domainModel.Title.Set(repositoryModelConcrete.Title.String)
    }

    //******************    Set IsRead/IsCollection    *****************//
    domainModel.IsRead = repositoryModelConcrete.IsRead > 0
    domainModel.IsCollection = repositoryModelConcrete.IsCollection > 0

    //*************************    Set Tags    *************************//
    domainModel.TagIDs, _ = goaoi.TransformCopySliceUnsafe(repositoryModelConcrete.R.Tags, func (t *Tag) int64 {return t.ID;})

    return
}




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

func (repo *MssqlBookmarkRepository) BookmarkDomainToRepositoryFilter(ctx context.Context, domainFilter *domain.BookmarkFilter) (repositoryFilter any, err error)  {
    repositoryFilterConcrete := new(BookmarkFilter)

    repositoryFilterConcrete.URL = domainFilter.URL
    repositoryFilterConcrete.ID = domainFilter.ID

    //**********************    Set Timestamps    **********************//
    
    repositoryFilterConcrete.CreatedAt = domainFilter.CreatedAt
    repositoryFilterConcrete.UpdatedAt = domainFilter.UpdatedAt

    if domainFilter.DeletedAt.HasValue {
        var convertedFilter model.FilterOperation[null.Time]

        convertedFilter, err = model.ConvertFilter[null.Time, optional.Optional[time.Time]](domainFilter.DeletedAt.Wrappee, repoCommon.OptionalTimeToNullTime)
        if err != nil {
repo.Logger.Error(err)

return
        }

        repositoryFilterConcrete.DeletedAt.Set(convertedFilter)
    }
    


    //*************************    Set Title    ************************//
    if domainFilter.Title.HasValue {
        var convertedFilter model.FilterOperation[null.String]

        convertedFilter, err = model.ConvertFilter[null.String, optional.Optional[string]](domainFilter.Title.Wrappee, repoCommon.OptionalStringToNullString)
        if err != nil {
repo.Logger.Error(err)

return
        }

        repositoryFilterConcrete.Title.Set(convertedFilter)
    }



    //******************    Set IsRead/IsCollection    *****************//
    if domainFilter.IsRead.HasValue {
        var convertedFilter model.FilterOperation[int64]

        convertedFilter, err = model.ConvertFilter[int64, bool](domainFilter.IsRead.Wrappee, repoCommon.BoolToInt)
        if err != nil {
repo.Logger.Error(err)

return
        }

        repositoryFilterConcrete.IsRead.Set(convertedFilter)
    }

    if domainFilter.IsCollection.HasValue {
        var convertedFilter model.FilterOperation[int64]

        convertedFilter, err = model.ConvertFilter[int64, bool](domainFilter.IsCollection.Wrappee, repoCommon.BoolToInt)
        if err != nil {
repo.Logger.Error(err)

return
        }

        repositoryFilterConcrete.IsCollection.Set(convertedFilter)
    }


    //*************************    Set Tags    *************************//

    if domainFilter.TagIDs.HasValue {
        var convertedFilter model.FilterOperation[*Tag]

        converter := func (tagID int64) (*Tag, error) {return Tags(TagWhere.ID.EQ(tagID)).One(ctx, repo.db)}
        convertedFilter, err = model.ConvertFilter[*Tag, int64](domainFilter.TagIDs.Wrappee, converter)
        if err != nil {
repo.Logger.Error(err)

return
        }

        repositoryFilterConcrete.Tags.Set(convertedFilter)
    }

    //*************************    Set Type    *************************//

    var convertedTypeIDFilter model.FilterOperation[null.Int64]
    if domainFilter.BookmarkType.HasValue {
        convertedTypeIDFilter, err = model.ConvertFilter[null.Int64,optional.Optional[string]](domainFilter.BookmarkType.Wrappee, func(type_ optional.Optional[string]) (null.Int64, error) {
            if !type_.HasValue {
                return  null.NewInt64(-1, false), nil
            }


            bookmarkType, err := BookmarkTypes(BookmarkTypeWhere.BookmarkType.EQ(type_.Wrappee)).One(ctx, repo.db)

            return null.NewInt64(bookmarkType.ID, true), err
        })
        if err != nil {
repo.Logger.Error(err)

return
        }


        repositoryFilterConcrete.BookmarkTypeID.Set(convertedTypeIDFilter)
    }

    repositoryFilter = repositoryFilterConcrete

    return
}



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

func (repo *MssqlBookmarkRepository) BookmarkDomainToRepositoryUpdater(ctx context.Context, domainUpdater *domain.BookmarkUpdater) (repositoryUpdater any, err error)  {
    repositoryUpdaterConcrete := new(BookmarkUpdater)

	if domainUpdater.CreatedAt.HasValue {
        
        repositoryUpdaterConcrete.CreatedAt.Set(model.UpdateOperation[time.Time]{Operator: domainUpdater.CreatedAt.Wrappee.Operator, Operand: domainUpdater.CreatedAt.Wrappee.Operand})
        
    }

	if domainUpdater.UpdatedAt.HasValue {
        
        repositoryUpdaterConcrete.UpdatedAt.Set(model.UpdateOperation[time.Time]{Operator: domainUpdater.UpdatedAt.Wrappee.Operator, Operand: domainUpdater.UpdatedAt.Wrappee.Operand})
        
    }

	if domainUpdater.DeletedAt.HasValue {
        
        var convertedTime null.Time
        convertedTime, err = repoCommon.OptionalTimeToNullTime(domainUpdater.DeletedAt.Wrappee.Operand)
        if err != nil {
repo.Logger.Error(err)

return
        }

        repositoryUpdaterConcrete.DeletedAt.Set(model.UpdateOperation[null.Time]{Operator: domainUpdater.UpdatedAt.Wrappee.Operator, Operand: convertedTime})
        
    }

	if domainUpdater.URL.HasValue {
        repositoryUpdaterConcrete.URL.Set(model.UpdateOperation[string]{Operator: domainUpdater.URL.Wrappee.Operator, Operand: domainUpdater.URL.Wrappee.Operand})
    }

	if domainUpdater.Title.HasValue {
        var convertedUpdater null.String
        convertedUpdater, err = repoCommon.OptionalStringToNullString(domainUpdater.Title.Wrappee.Operand)
        if err != nil {
repo.Logger.Error(err)

return
        }

        repositoryUpdaterConcrete.Title.Set(model.UpdateOperation[null.String]{Operator: domainUpdater.Title.Wrappee.Operator, Operand: convertedUpdater})
    }

	if domainUpdater.TagIDs.HasValue {
        var rawTag *Tag
        convertedUpdater := make(TagSlice, 0, len(domainUpdater.TagIDs.Wrappee.Operand))

        for _, tag := range domainUpdater.TagIDs.Wrappee.Operand {
            rawTag, err =  Tags(TagWhere.ID.EQ(tag)).One(ctx, repo.db)
            if err != nil {
repo.Logger.Error(err)

return
            }

            convertedUpdater = append(convertedUpdater, rawTag)
        }

        repositoryUpdaterConcrete.Tags.Set(model.UpdateOperation[TagSlice]{Operator: domainUpdater.TagIDs.Wrappee.Operator, Operand: convertedUpdater})
    }

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

	if domainUpdater.IsCollection.HasValue {
        var convertedUpdater int64
        convertedUpdater, err = repoCommon.BoolToInt(domainUpdater.IsCollection.Wrappee.Operand)
        if err != nil {
repo.Logger.Error(err)

return
        }

        repositoryUpdaterConcrete.IsCollection.Set(model.UpdateOperation[int64]{Operator: domainUpdater.IsCollection.Wrappee.Operator, Operand: convertedUpdater})
    }

	if domainUpdater.IsRead.HasValue {
        var convertedUpdater int64
        convertedUpdater, err = repoCommon.BoolToInt(domainUpdater.IsRead.Wrappee.Operand)
        if err != nil {
repo.Logger.Error(err)

return
        }

        repositoryUpdaterConcrete.IsRead.Set(model.UpdateOperation[int64]{Operator: domainUpdater.IsRead.Wrappee.Operator, Operand: convertedUpdater})
    }

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

    repositoryUpdater = repositoryUpdaterConcrete

    return

}





func (repo *MssqlBookmarkRepository) UpdateRelatedEntities(ctx context.Context, tx *sql.Tx, repositoryModel *Bookmark) error  {
	var err error

	if repositoryModel.R == nil {
		return nil
	}


	err = repositoryModel.SetTags(ctx, tx, false, repositoryModel.R.Tags...)
	if err != nil {
		repo.Logger.Error(err)

return err
	}
    if repositoryModel.R.BookmarkType != nil {
        err = repositoryModel.SetBookmarkType(ctx, tx, false, repositoryModel.R.BookmarkType)
        if err != nil {
            repo.Logger.Error(err)

return err
        }
    }

	return nil

}

// PERF: This can probably be sped up by not using singular mode
func (repo *MssqlBookmarkRepository) LoadEntityRelations(ctx context.Context, tx *sql.Tx, repoModel *Bookmark) (err error) {
    if repoModel.R == nil {
        repoModel.R = repoModel.R.NewStruct()
    }


    err = repoModel.L.LoadTags(ctx, repo.db, true, repoModel, nil)
    if err != nil {
repo.Logger.Error(err)

return
    }

    err = repoModel.L.LoadBookmarkType(ctx, repo.db, true, repoModel, nil)

    return

}