github.com/angryronald/go-kit@v0.0.0-20240505173814-ff2bd9c79dbf/generic/repository/nosql/generic.repository.mutable.go

package nosql

import (
	"context"
	"fmt"
	"reflect"
	"strings"

	"github.com/gocql/gocql"
	"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       *gocql.Session
	keySpace string
}

// FindAll for IN params please pass the object directly without parsing to string
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) {
	tableName := repository.GetTableName(result)
	if !repository.IsValidOperations(conditionalOperations, relationalOperations, params) {
		return nil, repository.ErrBadParameters
	}

	where := ""
	i := 0
	args := []interface{}{}
	for k, v := range params {
		switch conditionalOperations[i] {
		case repository.IN:
			encapsulation := ""
			if !repository.AreAllNumbers(v.([]interface{})) && !repository.AreAllUUIDs(v.([]interface{})) {
				encapsulation = "'"
			}

			where = fmt.Sprintf(`%s %s %s (%s)`, where, k, conditionalOperations[i], repository.StringJoin(v.([]interface{}), encapsulation))

		case repository.ILIKE, repository.LIKE:
			return nil, repository.ErrNotImplement

		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++
	}

	query := fmt.Sprintf("SELECT * FROM %s.%s WHERE %s", r.keySpace, tableName, where)
	// due to unable to use pagination this part will be comment out for now
	// if page != 0 || limit != 0 {
	// 	query = fmt.Sprintf("%s LIMIT %d OFFSET %d", query, limit, (page-1)*limit)
	// }
	query = fmt.Sprintf("%s ALLOW FILTERING;", query)
	iter := r.db.Query(query, args...).Iter()

	resultRaw := make([]interface{}, 0)
	for {
		m := make(map[string]interface{})
		if !iter.MapScan(m) {
			break
		}
		resultRaw = append(resultRaw, m)
	}

	cast.TransformObject(resultRaw, &result)

	return result, nil
}

func (r *GenericRepository) FindOne(ctx context.Context, key string, value interface{}, result interface{}) (interface{}, error) {
	where := fmt.Sprintf(`%s %s ?`, key, repository.EQUAL_WITH)
	args := []interface{}{
		value,
	}
	tableName := repository.GetTableName(result)
	query := fmt.Sprintf("SELECT * FROM %s.%s WHERE %s ALLOW FILTERING;", r.keySpace, tableName, where)
	iter := r.db.Query(query, args...).Iter()

	m := make(map[string]interface{})
	if !iter.MapScan(m) {
		return nil, repository.ErrNotFound
	}

	cast.TransformObject(m, result)

	return result, nil
}

func (r *GenericRepository) FindByID(ctx context.Context, id uuid.UUID, result interface{}) (interface{}, error) {
	where := fmt.Sprintf(`ID %s ?`, repository.EQUAL_WITH)
	args := []interface{}{
		id.String(),
	}
	tableName := repository.GetTableName(result)
	query := fmt.Sprintf("SELECT * FROM %s.%s WHERE %s ALLOW FILTERING;", r.keySpace, tableName, where)
	iter := r.db.Query(query, args...).Iter()

	m := make(map[string]interface{})
	if !iter.MapScan(m) {
		return nil, repository.ErrNotFound
	}

	cast.TransformObject(m, result)

	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
	}

	tableName := repository.GetTableName(data)
	columns, values, err := GetPropertyNamesAndValues(data)
	if err != nil {
		return nil, err
	}
	paramString := ""
	for i := 0; i < len(values); i++ {
		paramString += "?,"
	}

	if len(paramString) > 0 {
		paramString = paramString[:len(paramString)-1]
	}

	query := fmt.Sprintf("INSERT INTO %s.%s (%s) VALUES (%s)", r.keySpace, tableName, strings.Join(columns, ","), paramString)
	if err = r.db.Query(query, values...).Exec(); err != nil {
		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
	}

	tableName := repository.GetTableName(data)
	columns, values, err := GetPropertyNamesAndValues(data)
	if err != nil {
		return nil, err
	}
	setQuery := []string{}
	newArgs := []interface{}{}
	var tempIDValue interface{}
	for i := 0; i < len(columns); i++ {
		if columns[i] == "ID" {
			tempIDValue = values[i]
			continue
		}
		setQuery = append(setQuery, fmt.Sprintf("%s=?", columns[i]))

		newArgs = append(newArgs, values[i])
	}
	newArgs = append(newArgs, tempIDValue)

	query := fmt.Sprintf("UPDATE %s.%s SET %s WHERE ID = ?;", r.keySpace, tableName, strings.Join(setQuery, ","))
	if err := r.db.Query(query, newArgs...).Exec(); err != nil {
		return nil, err
	}

	return data, nil
}

func (r *GenericRepository) Delete(ctx context.Context, data interface{}) (interface{}, error) {
	ID, _ := repository.GetStructPropertyAsString(data, "ID")

	tableName := repository.GetTableName(data)
	query := fmt.Sprintf("DELETE FROM %s.%s WHERE ID = ?;", r.keySpace, tableName)
	if err := r.db.Query(query, ID).Exec(); err != nil {
		return nil, err
	}

	return data, nil
}

func (r *GenericRepository) Upsert(ctx context.Context, data interface{}) (interface{}, error) {
	return nil, repository.ErrNotImplement
}

func (r *GenericRepository) BulkInsert(ctx context.Context, data interface{}) (interface{}, error) {
	return nil, repository.ErrNotImplement
}

func (r *GenericRepository) BulkUpsert(ctx context.Context, data interface{}) (interface{}, error) {
	return nil, repository.ErrNotImplement
}

func (r *GenericRepository) Query(ctx context.Context, query string, params []interface{}, result interface{}) (interface{}, error) {
	iter := r.db.Query(query, params...).Iter()

	resultRaw := make([]interface{}, 0)
	for {
		m := make(map[string]interface{})
		if !iter.MapScan(m) {
			break
		}
		resultRaw = append(resultRaw, m)
	}

	cast.TransformObject(resultRaw, &result)

	return result, nil
}

// DO NOT USE Pointer for nosql (Cassandra) object due to migration issue, please use cast library to casting object do not rely on result due type mismatch, deleted process need to be adjusted later, for now it would be hard delete
func NewRepository(db *gocql.Session, keySpace string) repository.GenericRepositoryInterface {
	return &GenericRepository{
		db:       db,
		keySpace: keySpace,
	}
}

// DO NOT USE Pointer for nosql (Cassandra) object due to migration issue, please use cast library to casting object do not rely on result due type mismatch, deleted process need to be adjusted later, for now it would be hard delete
func NewMutableRepository(db *gocql.Session, keySpace string) repository.MutableGenericRepositoryInterface {
	return &GenericRepository{
		db:       db,
		keySpace: keySpace,
	}
}

func MigrateTable(session *gocql.Session, keySpace string, entity interface{}) error {
	tableName := repository.GetTableName(entity)
	entityType := reflect.TypeOf(entity).Elem()

	createQuery := fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s.%s (", keySpace, tableName)
	for i := 0; i < entityType.NumField(); i++ {
		field := entityType.Field(i)
		fieldName := field.Name
		fieldType := field.Type

		// If the field type is a pointer, dereference it
		if field.Type.Kind() == reflect.Ptr {
			fieldType = field.Type.Elem()
		} else {
			fieldType = field.Type
		}

		// Skip unexported fields
		if field.PkgPath != "" {
			continue
		}

		createQuery += fmt.Sprintf("%s %s,", fieldName, GoTypeMapToCQLType[fieldType.Name()])
		if fieldName == "ID" {
			createQuery = fmt.Sprintf("%s PRIMARY KEY,", createQuery[:len(createQuery)-1])
		}
	}
	createQuery = createQuery[:len(createQuery)-1] + ") WITH CLUSTERING ORDER BY (CreatedAt DESC);"

	if err := session.Query(createQuery).Exec(); err != nil {
		return err
	}

	return nil
}