github.com/angryronald/go-kit@v0.0.0-20240505173814-ff2bd9c79dbf/generic/repository/sql/generic.repository.immutable.go

package sql

import (
	"context"
	"fmt"

	"gorm.io/gorm"

	"github.com/google/uuid"

	"github.com/angryronald/go-kit/appcontext"
	"github.com/angryronald/go-kit/cast"
	"github.com/angryronald/go-kit/generic/repository"
)

type ImmutableGenericRepository struct {
	db *gorm.DB
}

func (r *ImmutableGenericRepository) FindAll(ctx context.Context, params map[string]interface{}, conditionalOperations []repository.ConditionalOperation, relationalOperations []repository.RelationalOperation, page int, limit int, result interface{}) (interface{}, error) {
	if !repository.IsValidOperations(conditionalOperations, relationalOperations, params) {
		return nil, repository.ErrBadParameters
	}

	where := "true"
	i := 0
	args := []interface{}{}
	if len(params) > 0 {
		where = fmt.Sprintf(`%s %s`, where, repository.AND)
	}
	for k, v := range params {
		switch conditionalOperations[i] {
		case repository.IN:
			encapsulation := ""
			if !repository.AreAllNumbers(v.([]interface{})) {
				encapsulation = "'"
			}
			where = fmt.Sprintf(`%s %s %s (%s)`, where, k, conditionalOperations[i], repository.StringJoin(v.([]interface{}), encapsulation))

			break

		case repository.ILIKE, repository.LIKE:
			where = fmt.Sprintf(`%s %s %s ?`, where, k, conditionalOperations[i])
			args = append(args, fmt.Sprintf("%%%s%%", v))
			break

		default:
			where = fmt.Sprintf(`%s %s %s ?`, where, k, conditionalOperations[i])
			args = append(args, v)
		}

		if i < len(relationalOperations) {
			where = fmt.Sprintf(`%s %s`, where, relationalOperations[i])
		}
		i++
	}

	order := fmt.Sprintf(`"created_at" %s`, repository.DESC)

	if page == 0 && limit == 0 {
		if err := r.db.Where(
			where,
			args...,
		).Order(order).Find(&result).Error; err != nil {
			return nil, err
		}

		return result, nil
	}

	if err := r.db.Where(
		where,
		args...,
	).Order(order).
		Offset((page - 1) * limit).
		Limit(limit).
		Find(&result).Error; err != nil {
		return nil, err
	}

	return result, nil
}

func (r *ImmutableGenericRepository) FindOne(ctx context.Context, key string, value interface{}, result interface{}) (interface{}, error) {
	where := fmt.Sprintf(`%s %s ?`, key, repository.EQUAL_WITH)
	args := []interface{}{
		value,
	}
	if err := r.db.Where(
		where,
		args,
	).First(&result).Error; err != nil {
		return nil, err
	}

	return result, nil
}

func (r *ImmutableGenericRepository) FindByID(ctx context.Context, id uuid.UUID, result interface{}) (interface{}, error) {
	where := fmt.Sprintf(`"id" %s ?`, repository.EQUAL_WITH)
	args := []interface{}{
		id,
	}
	if err := r.db.Where(
		where,
		args,
	).First(&result).Error; err != nil {
		return nil, err
	}

	return result, nil
}

func (r *ImmutableGenericRepository) Insert(ctx context.Context, data interface{}) (interface{}, error) {
	newID, err := uuid.NewRandom()
	if err != nil {
		return nil, err
	}
	if err = repository.UpdatePropertyValue(data, "ID", newID); err != nil {
		return nil, err
	}
	if err = repository.UpdatePropertyValue(data, "CreatedBy", appcontext.UserID(ctx)); err != nil {
		return nil, err
	}

	if err := r.db.Create(data).Error; err != nil {
		if err == gorm.ErrDuplicatedKey {
			return nil, repository.ErrConflict
		}
		return nil, err
	}
	return data, nil
}

func (r *ImmutableGenericRepository) BulkInsert(ctx context.Context, data interface{}) (interface{}, error) {
	tx := r.db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	copyOfData, err := repository.CopySliceOfPointers(data)
	if err != nil {
		return nil, err
	}

	dataInArray := cast.StructPointerArrayToInterfacePointerArray(copyOfData)
	for i := 0; i < len(dataInArray); i++ {
		newID, err := uuid.NewRandom()
		if err != nil {
			return nil, err
		}

		if err = repository.UpdatePropertyValue(dataInArray[i], "ID", newID); err != nil {
			return nil, err
		}
		if err = repository.UpdatePropertyValue(dataInArray[i], "CreatedBy", appcontext.UserID(ctx)); err != nil {
			return nil, err
		}
	}

	dataInArrayWithIdentity, err := repository.CopySliceOfPointersWithIdentitySeparated(copyOfData, dataInArray)
	if err != nil {
		return nil, err
	}

	if err := r.db.Create(dataInArrayWithIdentity).Error; err != nil {
		tx.Rollback()
		if err == gorm.ErrDuplicatedKey {
			return nil, repository.ErrConflict
		}
		return nil, err
	}
	return dataInArrayWithIdentity, tx.Commit().Error
}

func (r *ImmutableGenericRepository) Query(ctx context.Context, query string, params []interface{}, result interface{}) (interface{}, error) {
	if err := r.db.Raw(query, params...).Find(&result).Error; err != nil {
		return nil, err
	}

	return result, nil
}

func NewImmutableRepository(db *gorm.DB) repository.ImmutableGenericRepositoryInterface {
	return &ImmutableGenericRepository{
		db: db,
	}
}