init bootstrap

2025-07-06 15:02:09 +02:00
commit 016728532c
47 changed files with 8894 additions and 0 deletions
--- a/local/repository/base.go
+++ b/local/repository/base.go
@@ -0,0 +1,121 @@
+package repository
+
+import (
+	"context"
+	"fmt"
+
+	"gorm.io/gorm"
+)
+
+// BaseRepository provides generic CRUD operations for any model
+type BaseRepository[T any, F any] struct {
+	db        *gorm.DB
+	modelType T
+}
+
+// NewBaseRepository creates a new base repository for the given model type
+func NewBaseRepository[T any, F any](db *gorm.DB, model T) *BaseRepository[T, F] {
+	return &BaseRepository[T, F]{
+		db:        db,
+		modelType: model,
+	}
+}
+
+// GetAll retrieves all records based on the filter
+func (r *BaseRepository[T, F]) GetAll(ctx context.Context, filter *F) (*[]T, error) {
+	result := new([]T)
+	query := r.db.WithContext(ctx).Model(&r.modelType)
+
+	// Apply filter conditions if filter implements Filterable
+	if filterable, ok := any(filter).(Filterable); ok {
+		query = filterable.ApplyFilter(query)
+	}
+
+	// Apply pagination if filter implements Pageable
+	if pageable, ok := any(filter).(Pageable); ok {
+		offset, limit := pageable.Pagination()
+		query = query.Offset(offset).Limit(limit)
+	}
+
+	// Apply sorting if filter implements Sortable
+	if sortable, ok := any(filter).(Sortable); ok {
+		field, desc := sortable.GetSorting()
+		if desc {
+			query = query.Order(field + " DESC")
+		} else {
+			query = query.Order(field)
+		}
+	}
+
+	if err := query.Find(result).Error; err != nil {
+		return nil, fmt.Errorf("error getting records: %w", err)
+	}
+
+	return result, nil
+}
+
+// GetByID retrieves a single record by ID
+func (r *BaseRepository[T, F]) GetByID(ctx context.Context, id interface{}) (*T, error) {
+	result := new(T)
+	if err := r.db.WithContext(ctx).Where("id = ?", id).First(result).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("error getting record by ID: %w", err)
+	}
+	return result, nil
+}
+
+// Insert creates a new record
+func (r *BaseRepository[T, F]) Insert(ctx context.Context, model *T) error {
+	if err := r.db.WithContext(ctx).Create(model).Error; err != nil {
+		return fmt.Errorf("error creating record: %w", err)
+	}
+	return nil
+}
+
+// Update modifies an existing record
+func (r *BaseRepository[T, F]) Update(ctx context.Context, model *T) error {
+	if err := r.db.WithContext(ctx).Save(model).Error; err != nil {
+		return fmt.Errorf("error updating record: %w", err)
+	}
+	return nil
+}
+
+// Delete removes a record by ID
+func (r *BaseRepository[T, F]) Delete(ctx context.Context, id interface{}) error {
+	if err := r.db.WithContext(ctx).Delete(new(T), id).Error; err != nil {
+		return fmt.Errorf("error deleting record: %w", err)
+	}
+	return nil
+}
+
+// Count returns the total number of records matching the filter
+func (r *BaseRepository[T, F]) Count(ctx context.Context, filter *F) (int64, error) {
+	var count int64
+	query := r.db.WithContext(ctx).Model(&r.modelType)
+
+	if filterable, ok := any(filter).(Filterable); ok {
+		query = filterable.ApplyFilter(query)
+	}
+
+	if err := query.Count(&count).Error; err != nil {
+		return 0, fmt.Errorf("error counting records: %w", err)
+	}
+
+	return count, nil
+}
+
+// Interfaces for filter capabilities
+
+type Filterable interface {
+	ApplyFilter(*gorm.DB) *gorm.DB
+}
+
+type Pageable interface {
+	Pagination() (offset, limit int)
+}
+
+type Sortable interface {
+	GetSorting() (field string, desc bool)
+}
--- a/local/repository/membership.go
+++ b/local/repository/membership.go
@@ -0,0 +1,171 @@
+package repository
+
+import (
+	"context"
+	"omega-server/local/model"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+// MembershipRepository handles database operations for users, roles, and permissions.
+type MembershipRepository struct {
+	*BaseRepository[model.User, model.MembershipFilter]
+	db *gorm.DB
+}
+
+// NewMembershipRepository creates a new MembershipRepository.
+func NewMembershipRepository(db *gorm.DB) *MembershipRepository {
+	return &MembershipRepository{
+		BaseRepository: NewBaseRepository[model.User, model.MembershipFilter](db, model.User{}),
+		db:             db,
+	}
+}
+
+// FindUserByUsername finds a user by their username.
+// It preloads the user's role and the role's permissions.
+func (r *MembershipRepository) FindUserByUsername(ctx context.Context, username string) (*model.User, error) {
+	var user model.User
+	db := r.db.WithContext(ctx)
+	err := db.Preload("Roles.Permissions").Where("username = ?", username).First(&user).Error
+	if err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+// FindUserByIDWithPermissions finds a user by their ID and preloads Role and Permissions.
+func (r *MembershipRepository) FindUserByIDWithPermissions(ctx context.Context, userID string) (*model.User, error) {
+	var user model.User
+	db := r.db.WithContext(ctx)
+	err := db.Preload("Roles.Permissions").First(&user, "id = ?", userID).Error
+	if err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+// CreateUser creates a new user.
+func (r *MembershipRepository) CreateUser(ctx context.Context, user *model.User) error {
+	db := r.db.WithContext(ctx)
+	return db.Create(user).Error
+}
+
+// FindRoleByName finds a role by its name.
+func (r *MembershipRepository) FindRoleByName(ctx context.Context, name string) (*model.Role, error) {
+	var role model.Role
+	db := r.db.WithContext(ctx)
+	err := db.Where("name = ?", name).First(&role).Error
+	if err != nil {
+		return nil, err
+	}
+	return &role, nil
+}
+
+// CreateRole creates a new role.
+func (r *MembershipRepository) CreateRole(ctx context.Context, role *model.Role) error {
+	db := r.db.WithContext(ctx)
+	return db.Create(role).Error
+}
+
+// FindPermissionByName finds a permission by its name.
+func (r *MembershipRepository) FindPermissionByName(ctx context.Context, name string) (*model.Permission, error) {
+	var permission model.Permission
+	db := r.db.WithContext(ctx)
+	err := db.Where("name = ?", name).First(&permission).Error
+	if err != nil {
+		return nil, err
+	}
+	return &permission, nil
+}
+
+// CreatePermission creates a new permission.
+func (r *MembershipRepository) CreatePermission(ctx context.Context, permission *model.Permission) error {
+	db := r.db.WithContext(ctx)
+	return db.Create(permission).Error
+}
+
+// AssignPermissionsToRole assigns a set of permissions to a role.
+func (r *MembershipRepository) AssignPermissionsToRole(ctx context.Context, role *model.Role, permissions []model.Permission) error {
+	db := r.db.WithContext(ctx)
+	return db.Model(role).Association("Permissions").Replace(permissions)
+}
+
+// GetUserPermissions retrieves all permissions for a given user ID.
+func (r *MembershipRepository) GetUserPermissions(ctx context.Context, userID uuid.UUID) ([]string, error) {
+	var user model.User
+	db := r.db.WithContext(ctx)
+
+	if err := db.Preload("Roles.Permissions").First(&user, "id = ?", userID).Error; err != nil {
+		return nil, err
+	}
+
+	permissionSet := make(map[string]bool)
+	for _, role := range user.Roles {
+		for _, permission := range role.Permissions {
+			permissionSet[permission.Name] = true
+		}
+	}
+
+	permissions := make([]string, 0, len(permissionSet))
+	for permission := range permissionSet {
+		permissions = append(permissions, permission)
+	}
+
+	return permissions, nil
+}
+
+// ListUsers retrieves all users.
+func (r *MembershipRepository) ListUsers(ctx context.Context) ([]*model.User, error) {
+	var users []*model.User
+	db := r.db.WithContext(ctx)
+	err := db.Preload("Roles").Find(&users).Error
+	return users, err
+}
+
+// DeleteUser deletes a user.
+func (r *MembershipRepository) DeleteUser(ctx context.Context, userID uuid.UUID) error {
+	db := r.db.WithContext(ctx)
+	return db.Delete(&model.User{}, "id = ?", userID).Error
+}
+
+// FindUserByID finds a user by their ID.
+func (r *MembershipRepository) FindUserByID(ctx context.Context, userID uuid.UUID) (*model.User, error) {
+	var user model.User
+	db := r.db.WithContext(ctx)
+	err := db.Preload("Roles").First(&user, "id = ?", userID).Error
+	if err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+// UpdateUser updates a user's details in the database.
+func (r *MembershipRepository) UpdateUser(ctx context.Context, user *model.User) error {
+	db := r.db.WithContext(ctx)
+	return db.Save(user).Error
+}
+
+// FindRoleByID finds a role by its ID.
+func (r *MembershipRepository) FindRoleByID(ctx context.Context, roleID uuid.UUID) (*model.Role, error) {
+	var role model.Role
+	db := r.db.WithContext(ctx)
+	err := db.First(&role, "id = ?", roleID).Error
+	if err != nil {
+		return nil, err
+	}
+	return &role, nil
+}
+
+// ListUsersWithFilter retrieves users based on the membership filter.
+func (r *MembershipRepository) ListUsersWithFilter(ctx context.Context, filter *model.MembershipFilter) (*[]model.User, error) {
+	return r.BaseRepository.GetAll(ctx, filter)
+}
+
+// ListRoles retrieves all roles.
+func (r *MembershipRepository) ListRoles(ctx context.Context) ([]*model.Role, error) {
+	var roles []*model.Role
+	db := r.db.WithContext(ctx)
+	err := db.Find(&roles).Error
+	return roles, err
+}
--- a/local/repository/repository.go
+++ b/local/repository/repository.go
@@ -0,0 +1,14 @@
+package repository
+
+import (
+	"go.uber.org/dig"
+)
+
+// InitializeRepositories
+// Initializes Dependency Injection modules for repositories
+//
+//	Args:
+//		*dig.Container: Dig Container
+func InitializeRepositories(c *dig.Container) {
+	c.Provide(NewMembershipRepository)
+}