api-antrian-operasi/internal/domain/access/handler.go

package access

import (
	"antrian-operasi/internal/shared"

	"github.com/gin-gonic/gin"
)

type AccessHandler struct {
	repo IAccessRepository
}

func NewAccessHandler(repo IAccessRepository) AccessHandler {
	return AccessHandler{repo}
}

// SyncKeycloakRole godoc
// @Summary Sync Keycloak Role
// @Tags Access Role
// @Param body body SyncKeycloakRoleRequest true "Sync Keycloak Role"
// @Success 200 {object} shared.BaseResponse
// @Failure 500 {object} shared.BaseErrorResponse
// @Router /access/sync-keycloak-role [post]
func (h AccessHandler) SyncKeycloakRole(c *gin.Context) {
	var req SyncKeycloakRoleRequest

	//bind json body
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(400, shared.BaseErrorResponse{
			Success: false,
			Code:    400,
			Message: "error bind json",
			Errors:  shared.ValidationError(err),
		})
		return
	}

	//check user role exist
	users, err := h.repo.FindUserByKeycloakId(c, req.KeycloakId)
	if err != nil {
		errMessage := []string{err.Error()}
		c.JSON(500, shared.BaseErrorResponse{
			Success: false,
			Code:    500,
			Message: "error finding user by keycloak id",
			Errors:  errMessage,
		})
		return
	}

	//if not exist, create user & permission
	if len(users) == 0 {
		err = h.repo.CreateUserPermission(c, req)
	} else { //if exist, update role permission
		userId := users[0].ID
		err = h.repo.UpdateUserPermission(c, userId, req)
	}

	if err != nil {
		errMessage := []string{err.Error()}
		c.JSON(500, shared.BaseErrorResponse{
			Success: false,
			Code:    500,
			Message: "update / insert permission error",
			Errors:  errMessage,
		})
		return
	}

	c.JSON(200, shared.BaseResponse[SyncKeycloakRoleRequest]{
		Success: true,
		Code:    200,
		Message: "success sync role",
		Data:    req,
	})
}

// GetPageByKeycloakId godoc
// @Summary Get Pages By Keycloak Id
// @Tags Access Role
// @Param keycloak_id query string true "Keycloak ID"
// @Success 200 {object} shared.BaseResponse
// @Failure 500 {object} shared.BaseErrorResponse
// @Router /access/eligible-menu [get]
func (h AccessHandler) GetPageByKeycloakId(c *gin.Context) {
	keycloakId := c.Query("keycloak_id")

	pageResult, err := h.repo.GetAvailablePageByKeycloakId(c, keycloakId)
	if err != nil {
		errMessage := []string{err.Error()}
		c.JSON(500, shared.BaseErrorResponse{
			Success: false,
			Code:    500,
			Message: "error fetch page by keycloak id",
			Errors:  errMessage,
		})
		return
	}

	c.JSON(200, shared.BaseResponse[[]AvailableMenuResponse]{
		Success: true,
		Code:    200,
		Message: "success fetch eligible page",
		Data:    MapMenuModelToResponse(pageResult),
	})
}

// ListUserRole godoc
// @Summary Get List User And Role
// @Tags Access Role
// @Param search query string false "Search Keyword"
// @Param limit query string false "Limit" default(10)
// @Param offset query string false "Offset" default(0)
// @Success 200 {object} []UserRoleResponse
// @Failure 500 {object} shared.BaseErrorResponse
// @Router /access/list-user [get]
func (h AccessHandler) ListUserRole(c *gin.Context) {
	var query QueryListUserRole
	if err := c.ShouldBindQuery(&query); err != nil {
		c.JSON(400, gin.H{"error": err.Error()})
		return
	}

	res, err := h.repo.ListUserRole(c.Request.Context(), query)
	if err != nil {
		c.JSON(500, shared.BaseErrorResponse{
			Success: false,
			Code:    500,
			Message: err.Error(),
		})
		return
	}

	c.JSON(200,
		shared.ToBaseResponsePaginate(
			res.Data, res.Paging, true, 200, "success get list user role",
		))
}

// ListRolePageSettings godoc
// @Summary Get List Role Page Settings
// @Tags Access Role
// @Param search query string false "Search Keyword"
// @Param limit query string false "Limit" default(10)
// @Param offset query string false "Offset" default(0)
// @Success 200 {object} ListRolePermissionPaginateResponse
// @Failure 500 {object} shared.BaseErrorResponse
// @Router /access/role-permission [get]
func (h AccessHandler) ListRolePageSettings(c *gin.Context) {
	var query QueryListRolePermission
	if err := c.ShouldBindQuery(&query); err != nil {
		c.JSON(400, gin.H{"error": err.Error()})
		return
	}

	res, err := h.repo.ListRolePermission(c.Request.Context(), query)
	if err != nil {
		c.JSON(500, shared.BaseErrorResponse{
			Success: false,
			Code:    500,
			Message: err.Error(),
		})
		return
	}

	c.JSON(200,
		shared.ToBaseResponsePaginate(
			res.Data, res.Paging, true, 200, "success get list role permission",
		))
}

// DetailRolePageSettings godoc
// @Summary Detail Role Page Settings
// @Tags Access Role
// @Param id path string true "id role"
// @Success 200 {object} DetailRolePageResponse
// @Failure 500 {object} shared.BaseErrorResponse
// @Router /access/role-permission/{id} [get]
func (h AccessHandler) DetailRolePageSettings(c *gin.Context) {
	idPermission := c.Param("id")

	res, err := h.repo.DetailRolePermission(c, idPermission)
	if err != nil {
		c.JSON(500, shared.BaseErrorResponse{
			Success: false,
			Code:    500,
			Message: err.Error(),
		})
		return
	}

	c.JSON(200,
		shared.ToBaseResponse(
			res, true, 200, "success get detail role permission",
		))
}

func (h AccessHandler) UpdateRolePageSettings(c *gin.Context) {

}