github.com/angryronald/go-kit@v0.0.0-20240505173814-ff2bd9c79dbf/generic/repository/sql/generic.repository.mutable.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 GenericRepository struct {
	db *gorm.DB
}

func (r *GenericRepository) 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 := fmt.Sprintf(`"deleted_at" %s %s`, repository.IS, "NULL")
	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 {
			if err == gorm.ErrRecordNotFound {
				return nil, repository.ErrNotFound
			}
			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 *GenericRepository) FindOne(ctx context.Context, key string, value interface{}, result interface{}) (interface{}, error) {
	where := fmt.Sprintf(`"deleted_at" %s NULL %s %s %s ?`, repository.IS, repository.AND, key, repository.EQUAL_WITH)
	args := []interface{}{
		value,
	}
	if err := r.db.Where(
		where,
		args,
	).First(&result).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, repository.ErrNotFound
		}
		return nil, err
	}

	return result, nil
}

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

	return result, nil
}

func (r *GenericRepository) 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 = repository.UpdatePropertyValue(data, "UpdatedBy", appcontext.UserID(ctx)); err != nil && err != repository.ErrPropertyNotFound {
		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 *GenericRepository) Update(ctx context.Context, data interface{}) (interface{}, error) {
	var err error

	newData, _ := repository.CopyObject(data)
	ID, _ := repository.GetStructPropertyAsString(newData, "ID")

	if _, err = r.FindByID(ctx, uuid.MustParse(ID), newData); err != nil {
		return nil, repository.ErrNotFound
	}

	if err = repository.UpdatePropertyValue(data, "UpdatedBy", appcontext.UserID(ctx)); err != nil && err != repository.ErrPropertyNotFound {
		return nil, err
	}

	if err = r.db.Save(data).Error; err != nil {
		return nil, err
	}
	return data, nil
}

func (r *GenericRepository) Delete(ctx context.Context, data interface{}) (interface{}, error) {
	userID := appcontext.UserID(ctx)
	if err := repository.UpdatePropertyValue(data, "DeletedBy", &userID); err != nil && err != repository.ErrPropertyNotFound {
		return nil, err
	}

	if err := r.db.Delete(data).Error; err != nil {
		return nil, err
	}
	return data, nil
}

func (r *GenericRepository) Upsert(ctx context.Context, data interface{}) (interface{}, error) {
	var currentID string
	var err error
	currentID, _ = repository.GetStructPropertyAsString(data, "ID")
	if currentID == "" {
		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 = repository.UpdatePropertyValue(data, "UpdatedBy", appcontext.UserID(ctx)); err != nil && err != repository.ErrPropertyNotFound {
		return nil, err
	}

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

func (r *GenericRepository) 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
		}
		if err = repository.UpdatePropertyValue(dataInArray[i], "UpdatedBy", 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 *GenericRepository) BulkUpsert(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++ {
		var currentID string
		var err error
		currentID, _ = repository.GetStructPropertyAsString(data, "ID")
		if currentID == "" {
			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
			}
		}
		if err = repository.UpdatePropertyValue(dataInArray[i], "UpdatedBy", appcontext.UserID(ctx)); err != nil {
			return nil, err
		}
	}

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

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

	return dataInArrayWithIdentity, tx.Commit().Error
}

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

	return result, nil
}

func NewRepository(db *gorm.DB) repository.GenericRepositoryInterface {
	return &GenericRepository{
		db: db,
	}
}

func NewMutableRepository(db *gorm.DB) repository.MutableGenericRepositoryInterface {
	return &GenericRepository{
		db: db,
	}
}