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

package repository

import (
	"errors"
	"fmt"
	"reflect"
	"strings"
	"unicode"

	"github.com/google/uuid"
)

func IsValidOperations(conditionalOperations []ConditionalOperation, relationalOperations []RelationalOperation, params map[string]interface{}) bool {
	if (len(params) == len(conditionalOperations) && len(conditionalOperations)-len(relationalOperations) == 1) || (len(conditionalOperations) == 0 && len(relationalOperations) == 0 && len(params) == 0) {
		return true
	}

	return false
}

//	func ToSnakeCase(s string) string {
//		var result []string
//		for i, r := range s {
//			if i > 0 && unicode.IsUpper(r) {
//				result = append(result, "_")
//			}
//			result = append(result, strings.ToLower(string(r)))
//		}
//		return strings.Join(result, "")
//	}
func ToSnakeCase(s string) string {
	var result strings.Builder

	for i, r := range s {
		if i > 0 && unicode.IsUpper(r) {
			nextIsLower := i < len(s)-1 && unicode.IsLower(rune(s[i+1]))
			if nextIsLower {
				result.WriteByte('_')
			}
		}
		result.WriteRune(unicode.ToLower(r))
	}
	return result.String()
}

func GetTableName(model interface{}) string {
	// typeName := reflect.TypeOf(model).Elem().Name()
	t := reflect.TypeOf(model)
	for t.Kind() == reflect.Ptr || t.Kind() == reflect.Slice || t.Kind() == reflect.Array {
		t = t.Elem()
	}
	typeName := t.Name()
	return ToSnakeCase(typeName) + "s"
}

func IsMapStringInterface(obj interface{}) bool {
	// Use reflection to check the type of the object.
	objType := reflect.TypeOf(obj)
	return objType.Kind() == reflect.Map && objType.Key().Kind() == reflect.String && objType.Elem().Kind() == reflect.Interface
}

// GetStructPropertyAsString retrieves the value of a specific property from a struct
// and converts it to a string. If the property is of type uuid.UUID, it's converted to a string.
func GetStructPropertyAsString(inputStruct interface{}, propertyName string) (string, error) {
	if IsMapStringInterface(inputStruct) {
		result, ok := inputStruct.(map[string]interface{})
		if !ok {
			return "", fmt.Errorf("input is not a map[string]interface{}")
		}
		return fmt.Sprint(result[propertyName]), nil
	}
	valueOfData := reflect.ValueOf(inputStruct)

	// Ensure obj is a pointer to a struct
	if valueOfData.Kind() != reflect.Ptr || valueOfData.Elem().Kind() != reflect.Struct {
		return "", errors.New("object must be a pointer to a struct")
	}

	valueOfData = valueOfData.Elem()

	t := valueOfData.Type()

	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		fieldValue := valueOfData.Field(i)

		if strings.ToUpper(field.Name) == propertyName {
			// break
			if fieldValue.Type() == reflect.TypeOf(uuid.UUID{}) {
				uuidValue, ok := fieldValue.Interface().(uuid.UUID)
				if !ok {
					return "", fmt.Errorf("failed to convert field '%s' to UUID", propertyName)
				}
				return uuidValue.String(), nil
			} else {
				return fmt.Sprintf("%v", fieldValue.Interface()), nil
			}
		}
	}

	return "", fmt.Errorf("field '%s' does not exist in the struct", propertyName)
}

// CopyObject creates a new object with the same field values as the source object.
func CopyObject(src interface{}) (interface{}, error) {
	// Ensure src is a pointer to a struct.
	srcValue := reflect.ValueOf(src)

	if srcValue.Kind() != reflect.Ptr {
		return nil, fmt.Errorf("src must be a pointer")
	}

	srcElem := srcValue.Elem()

	if srcElem.Kind() != reflect.Struct {
		return nil, fmt.Errorf("src must point to a struct")
	}

	// Create a new object of the same type as src.
	dest := reflect.New(srcElem.Type()).Interface()

	// Get the value of the destination object.
	destValue := reflect.ValueOf(dest).Elem()

	// Copy the fields from src to dest.
	for i := 0; i < srcElem.NumField(); i++ {
		srcField := srcElem.Field(i)
		destField := destValue.Field(i)

		// Check if the field is exported (starts with an uppercase letter).
		if srcField.CanInterface() {
			// Set the value of the destination field to the value of the source field.
			destField.Set(srcField)
		}
	}

	return dest, nil
}

func CopySliceOfPointers(slice interface{}) (interface{}, error) {
	// Ensure that the input is a slice.
	sliceValue := reflect.ValueOf(slice)
	if sliceValue.Kind() != reflect.Slice {
		return nil, fmt.Errorf("input must be a slice")
	}

	// Create a new slice of the same type.
	newSlice := reflect.MakeSlice(sliceValue.Type(), sliceValue.Len(), sliceValue.Cap())

	// Copy each element from the source slice to the new slice.
	for i := 0; i < sliceValue.Len(); i++ {
		srcElement := sliceValue.Index(i)
		if srcElement.Kind() != reflect.Ptr || srcElement.Elem().Kind() != reflect.Struct {
			return nil, fmt.Errorf("element at index %d is not a struct pointer", i)
		}

		// Create a new instance of the struct type and copy the field values.
		destElement := reflect.New(srcElement.Elem().Type()).Elem()
		destElement.Set(srcElement.Elem())

		newSlice.Index(i).Set(destElement.Addr())
	}

	return newSlice.Interface(), nil
}

func CopySliceOfPointersWithIdentitySeparated(sourceSlice interface{}, slice []interface{}) (interface{}, error) {
	// Ensure that the input is a slice.
	sliceValue := reflect.ValueOf(sourceSlice)
	if sliceValue.Kind() != reflect.Slice {
		return nil, fmt.Errorf("input must be a slice")
	}

	// Create a new slice of the same type.
	newSlice := reflect.MakeSlice(sliceValue.Type(), 0, 0)

	for _, s := range slice {
		sWithIdentity := reflect.ValueOf(s)
		newSlice = reflect.Append(newSlice, sWithIdentity)
	}

	return newSlice.Interface(), nil
}

func AreAllNumbers(arr []interface{}) bool {
	for _, elem := range arr {
		switch elem.(type) {
		case int, int8, int16, int32, int64,
			uint, uint8, uint16, uint32, uint64,
			float32, float64:
			// Do nothing, element is a number
			break
		default:
			return false // Element is not a number
		}
	}
	return true // All elements are numbers
}

func StringJoin(arr []interface{}, encapsulation string) string {
	result := ""
	for _, elem := range arr {
		result = fmt.Sprintf(`%s%s%v%s,`, result, encapsulation, elem, encapsulation)
	}
	return result[:len(result)-1]
}

func UpdatePropertyValue(obj interface{}, propertyName string, newValue interface{}) error {
	// Make sure the input is a pointer to a struct.
	val := reflect.ValueOf(obj)
	if val.Kind() != reflect.Ptr || val.Elem().Kind() != reflect.Struct {
		return fmt.Errorf("input must be a pointer to a struct")
	}

	// Get the value of the ID field.
	idField := val.Elem().FieldByName(propertyName)
	if !idField.IsValid() {
		return ErrPropertyNotFound
	}

	// Check if the newID has the same type as the ID field.
	if idField.Type() != reflect.TypeOf(newValue) {
		return ErrPropertyTypeNotMatch
	}

	// Update the ID field with the new value.
	idField.Set(reflect.ValueOf(newValue))

	return nil
}

func AreAllUUIDs(arr []interface{}) bool {
	for _, elem := range arr {
		switch elem.(type) {
		case uuid.UUID:
			// Do nothing, element is a number
			break
		default:
			return false // Element is not a number
		}
	}
	return true
}