kontenhumas-be/app/module/menu_modules/repository/menu_modules.repository.go

package repository

import (
	"fmt"
	"netidhub-saas-be/app/database"
	"netidhub-saas-be/app/database/entity"
	"netidhub-saas-be/app/module/menu_modules/request"
	"netidhub-saas-be/utils/paginator"
)

type menuModulesRepository struct {
	DB *database.Database
}

// MenuModulesRepository define interface of IMenuModulesRepository
type MenuModulesRepository interface {
	GetAll(req request.MenuModulesQueryRequest) (menuModules []*entity.MenuModules, paging paginator.Pagination, err error)
	GetByMenuId(menuId uint) (menuModules []*entity.MenuModules, err error)
	GetByModuleId(moduleId uint) (menuModules []*entity.MenuModules, err error)
	FindOne(id uint) (menuModule *entity.MenuModules, err error)
	Create(menuModule *entity.MenuModules) (err error)
	CreateBatch(menuModules []*entity.MenuModules) (err error)
	Update(id uint, menuModule *entity.MenuModules) (err error)
	Delete(id uint) (err error)
	DeleteByMenuId(menuId uint) (err error)
	DeleteByModuleId(moduleId uint) (err error)
}

func NewMenuModulesRepository(db *database.Database) MenuModulesRepository {
	return &menuModulesRepository{
		DB: db,
	}
}

// implement interface of IMenuModulesRepository
func (_i *menuModulesRepository) GetAll(req request.MenuModulesQueryRequest) (menuModules []*entity.MenuModules, paging paginator.Pagination, err error) {
	var count int64

	query := _i.DB.DB.Model(&entity.MenuModules{})
	query = query.Where("is_active = ?", true)

	if req.MenuId != nil {
		query = query.Where("menu_id = ?", req.MenuId)
	}
	if req.ModuleId != nil {
		query = query.Where("module_id = ?", req.ModuleId)
	}
	if req.ClientId != nil {
		query = query.Where("client_id = ?", req.ClientId)
	}

	// Preload relations
	query = query.Preload("Menu").Preload("Module")

	query.Count(&count)

	// Apply sorting
	if req.Pagination.SortBy != "" {
		direction := "ASC"
		if req.Pagination.Sort == "desc" {
			direction = "DESC"
		}
		query.Order(fmt.Sprintf("%s %s", req.Pagination.SortBy, direction))
	} else {
		query.Order("position ASC")
	}

	// Apply pagination (manual calculation like articles)
	page := req.Pagination.Page
	limit := req.Pagination.Limit
	if page <= 0 {
		page = 1
	}
	if limit <= 0 {
		limit = 10
	}

	offset := (page - 1) * limit
	err = query.Offset(offset).Limit(limit).Find(&menuModules).Error
	if err != nil {
		return
	}

	// Create pagination response
	paging = paginator.Pagination{
		Page:      page,
		Limit:     limit,
		Count:     count,
		TotalPage: int((count + int64(limit) - 1) / int64(limit)),
	}

	return
}

func (_i *menuModulesRepository) GetByMenuId(menuId uint) (menuModules []*entity.MenuModules, err error) {
	query := _i.DB.DB.Model(&entity.MenuModules{})
	query = query.Where("menu_id = ? AND is_active = ?", menuId, true)
	query = query.Preload("Module")
	query = query.Order("position ASC")
	err = query.Find(&menuModules).Error
	return
}

func (_i *menuModulesRepository) GetByModuleId(moduleId uint) (menuModules []*entity.MenuModules, err error) {
	query := _i.DB.DB.Model(&entity.MenuModules{})
	query = query.Where("module_id = ? AND is_active = ?", moduleId, true)
	query = query.Preload("Menu")
	err = query.Find(&menuModules).Error
	return
}

func (_i *menuModulesRepository) FindOne(id uint) (menuModule *entity.MenuModules, err error) {
	query := _i.DB.DB.Preload("Menu").Preload("Module")
	if err := query.First(&menuModule, id).Error; err != nil {
		return nil, err
	}
	return menuModule, nil
}

func (_i *menuModulesRepository) Create(menuModule *entity.MenuModules) (err error) {
	return _i.DB.DB.Create(menuModule).Error
}

func (_i *menuModulesRepository) CreateBatch(menuModules []*entity.MenuModules) (err error) {
	return _i.DB.DB.Create(&menuModules).Error
}

func (_i *menuModulesRepository) Update(id uint, menuModule *entity.MenuModules) (err error) {
	return _i.DB.DB.Model(&entity.MenuModules{}).
		Where(&entity.MenuModules{ID: id}).
		Updates(menuModule).Error
}

func (_i *menuModulesRepository) Delete(id uint) error {
	return _i.DB.DB.Delete(&entity.MenuModules{}, id).Error
}

func (_i *menuModulesRepository) DeleteByMenuId(menuId uint) (err error) {
	return _i.DB.DB.Where("menu_id = ?", menuId).Delete(&entity.MenuModules{}).Error
}

func (_i *menuModulesRepository) DeleteByModuleId(moduleId uint) (err error) {
	return _i.DB.DB.Where("module_id = ?", moduleId).Delete(&entity.MenuModules{}).Error
}