gitea-admin/lti-api
1
0
Fork 0
mirror of https://gitlab.com/mbugroup/lti-api.git synced 2026-05-23 14:55:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Feat[BE-261] : inisiate expense module

Browse Source
This commit is contained in:
aguhh18
2025-11-17 14:46:21 +07:00
parent d528096d56
commit 09d503f5be
15 changed files with 451 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/modules/expenses/controllers/expense.controller.go
+144
View File
@@ -0,0 +1,144 @@
package controller
import (
"math"
"strconv"
"gitlab.com/mbugroup/lti-api.git/internal/modules/expenses/dto"
service "gitlab.com/mbugroup/lti-api.git/internal/modules/expenses/services"
validation "gitlab.com/mbugroup/lti-api.git/internal/modules/expenses/validations"
"gitlab.com/mbugroup/lti-api.git/internal/response"
"github.com/gofiber/fiber/v2"
)
type ExpenseController struct {
ExpenseService service.ExpenseService
}
func NewExpenseController(expenseService service.ExpenseService) *ExpenseController {
return &ExpenseController{
ExpenseService: expenseService,
}
}
func (u *ExpenseController) GetAll(c *fiber.Ctx) error {
query := &validation.Query{
Page: c.QueryInt("page", 1),
Limit: c.QueryInt("limit", 10),
Search: c.Query("search", ""),
}
if query.Page < 1 || query.Limit < 1 {
return fiber.NewError(fiber.StatusBadRequest, "page and limit must be greater than 0")
}
result, totalResults, err := u.ExpenseService.GetAll(c, query)
if err != nil {
return err
}
return c.Status(fiber.StatusOK).
JSON(response.SuccessWithPaginate[dto.ExpenseListDTO]{
Code: fiber.StatusOK,
Status: "success",
Message: "Get all expenses successfully",
Meta: response.Meta{
Page: query.Page,
Limit: query.Limit,
TotalPages: int64(math.Ceil(float64(totalResults) / float64(query.Limit))),
TotalResults: totalResults,
},
Data: dto.ToExpenseListDTOs(result),
})
}
func (u *ExpenseController) GetOne(c *fiber.Ctx) error {
param := c.Params("id")
id, err := strconv.Atoi(param)
if err != nil {
return fiber.NewError(fiber.StatusBadRequest, "Invalid Id")
}
result, err := u.ExpenseService.GetOne(c, uint(id))
if err != nil {
return err
}
return c.Status(fiber.StatusOK).
JSON(response.Success{
Code: fiber.StatusOK,
Status: "success",
Message: "Get expense successfully",
Data: dto.ToExpenseListDTO(*result),
})
}
func (u *ExpenseController) CreateOne(c *fiber.Ctx) error {
req := new(validation.Create)
if err := c.BodyParser(req); err != nil {
return fiber.NewError(fiber.StatusBadRequest, "Invalid request body")
}
result, err := u.ExpenseService.CreateOne(c, req)
if err != nil {
return err
}
return c.Status(fiber.StatusCreated).
JSON(response.Success{
Code: fiber.StatusCreated,
Status: "success",
Message: "Create expense successfully",
Data: dto.ToExpenseListDTO(*result),
})
}
func (u *ExpenseController) UpdateOne(c *fiber.Ctx) error {
req := new(validation.Update)
param := c.Params("id")
id, err := strconv.Atoi(param)
if err != nil {
return fiber.NewError(fiber.StatusBadRequest, "Invalid Id")
}
if err := c.BodyParser(req); err != nil {
return fiber.NewError(fiber.StatusBadRequest, "Invalid request body")
}
result, err := u.ExpenseService.UpdateOne(c, req, uint(id))
if err != nil {
return err
}
return c.Status(fiber.StatusOK).
JSON(response.Success{
Code: fiber.StatusOK,
Status: "success",
Message: "Update expense successfully",
Data: dto.ToExpenseListDTO(*result),
})
}
func (u *ExpenseController) DeleteOne(c *fiber.Ctx) error {
param := c.Params("id")
id, err := strconv.Atoi(param)
if err != nil {
return fiber.NewError(fiber.StatusBadRequest, "Invalid Id")
}
if err := u.ExpenseService.DeleteOne(c, uint(id)); err != nil {
return err
}
return c.Status(fiber.StatusOK).
JSON(response.Common{
Code: fiber.StatusOK,
Status: "success",
Message: "Delete expense successfully",
})
}
internal/modules/expenses/dto/expense.dto.go
+66
View File
@@ -0,0 +1,66 @@
package dto
import (
"time"
entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
userDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/users/dto"
)
// === DTO Structs ===
type ExpenseBaseDTO struct {
Id uint `json:"id"`
Name string `json:"name"`
}
type ExpenseListDTO struct {
Id uint `json:"id"`
Name string `json:"name"`
CreatedUser *userDTO.UserBaseDTO `json:"created_user"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
}
type ExpenseDetailDTO struct {
ExpenseListDTO
}
// === Mapper Functions ===
func ToExpenseBaseDTO(e entity.Expense) ExpenseBaseDTO {
return ExpenseBaseDTO{
Id: e.Id,
Name: e.Name,
}
}
func ToExpenseListDTO(e entity.Expense) ExpenseListDTO {
var createdUser *userDTO.UserBaseDTO
if e.CreatedUser.Id != 0 {
mapped := userDTO.ToUserBaseDTO(e.CreatedUser)
createdUser = &mapped
}
return ExpenseListDTO{
Id: e.Id,
Name: e.Name,
CreatedAt: e.CreatedAt,
UpdatedAt: e.UpdatedAt,
CreatedUser: createdUser,
}
}
func ToExpenseListDTOs(e []entity.Expense) []ExpenseListDTO {
result := make([]ExpenseListDTO, len(e))
for i, r := range e {
result[i] = ToExpenseListDTO(r)
}
return result
}
func ToExpenseDetailDTO(e entity.Expense) ExpenseDetailDTO {
return ExpenseDetailDTO{
ExpenseListDTO: ToExpenseListDTO(e),
}
}
internal/modules/expenses/module.go
+26
View File
@@ -0,0 +1,26 @@
package expenses
import (
"github.com/go-playground/validator/v10"
"github.com/gofiber/fiber/v2"
"gorm.io/gorm"
rExpense "gitlab.com/mbugroup/lti-api.git/internal/modules/expenses/repositories"
sExpense "gitlab.com/mbugroup/lti-api.git/internal/modules/expenses/services"
rUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
sUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
)
type ExpenseModule struct{}
func (ExpenseModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *validator.Validate) {
expenseRepo := rExpense.NewExpenseRepository(db)
userRepo := rUser.NewUserRepository(db)
expenseService := sExpense.NewExpenseService(expenseRepo, validate)
userService := sUser.NewUserService(userRepo, validate)
ExpenseRoutes(router, userService, expenseService)
}
internal/modules/expenses/repositories/expense.repository.go
+21
View File
@@ -0,0 +1,21 @@
package repository
import (
entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
"gitlab.com/mbugroup/lti-api.git/internal/common/repository"
"gorm.io/gorm"
)
type ExpenseRepository interface {
repository.BaseRepository[entity.Expense]
}
type ExpenseRepositoryImpl struct {
*repository.BaseRepositoryImpl[entity.Expense]
}
func NewExpenseRepository(db *gorm.DB) ExpenseRepository {
return &ExpenseRepositoryImpl{
BaseRepositoryImpl: repository.NewBaseRepository[entity.Expense](db),
}
}
internal/modules/expenses/route.go
+28
View File
@@ -0,0 +1,28 @@
package expenses
import (
// m "gitlab.com/mbugroup/lti-api.git/internal/middleware"
controller "gitlab.com/mbugroup/lti-api.git/internal/modules/expenses/controllers"
expense "gitlab.com/mbugroup/lti-api.git/internal/modules/expenses/services"
user "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
"github.com/gofiber/fiber/v2"
)
func ExpenseRoutes(v1 fiber.Router, u user.UserService, s expense.ExpenseService) {
ctrl := controller.NewExpenseController(s)
route := v1.Group("/expenses")
// route.Get("/", m.Auth(u), ctrl.GetAll)
// route.Post("/", m.Auth(u), ctrl.CreateOne)
// route.Get("/:id", m.Auth(u), ctrl.GetOne)
// route.Patch("/:id", m.Auth(u), ctrl.UpdateOne)
// route.Delete("/:id", m.Auth(u), ctrl.DeleteOne)
route.Get("/", ctrl.GetAll)
route.Post("/", ctrl.CreateOne)
route.Get("/:id", ctrl.GetOne)
route.Patch("/:id", ctrl.UpdateOne)
route.Delete("/:id", ctrl.DeleteOne)
}
internal/modules/expenses/services/expense.service.go
+129
View File
@@ -0,0 +1,129 @@
package service
import (
"errors"
entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
repository "gitlab.com/mbugroup/lti-api.git/internal/modules/expenses/repositories"
validation "gitlab.com/mbugroup/lti-api.git/internal/modules/expenses/validations"
"gitlab.com/mbugroup/lti-api.git/internal/utils"
"github.com/go-playground/validator/v10"
"github.com/gofiber/fiber/v2"
"github.com/sirupsen/logrus"
"gorm.io/gorm"
)
type ExpenseService interface {
GetAll(ctx *fiber.Ctx, params *validation.Query) ([]entity.Expense, int64, error)
GetOne(ctx *fiber.Ctx, id uint) (*entity.Expense, error)
CreateOne(ctx *fiber.Ctx, req *validation.Create) (*entity.Expense, error)
UpdateOne(ctx *fiber.Ctx, req *validation.Update, id uint) (*entity.Expense, error)
DeleteOne(ctx *fiber.Ctx, id uint) error
}
type expenseService struct {
Log *logrus.Logger
Validate *validator.Validate
Repository repository.ExpenseRepository
}
func NewExpenseService(repo repository.ExpenseRepository, validate *validator.Validate) ExpenseService {
return &expenseService{
Log: utils.Log,
Validate: validate,
Repository: repo,
}
}
func (s expenseService) withRelations(db *gorm.DB) *gorm.DB {
return db.Preload("CreatedUser")
}
func (s expenseService) GetAll(c *fiber.Ctx, params *validation.Query) ([]entity.Expense, int64, error) {
if err := s.Validate.Struct(params); err != nil {
return nil, 0, err
}
offset := (params.Page - 1) * params.Limit
expenses, total, err := s.Repository.GetAll(c.Context(), offset, params.Limit, func(db *gorm.DB) *gorm.DB {
db = s.withRelations(db)
if params.Search != "" {
return db.Where("name LIKE ?", "%"+params.Search+"%")
}
return db.Order("created_at DESC").Order("updated_at DESC")
})
if err != nil {
s.Log.Errorf("Failed to get expenses: %+v", err)
return nil, 0, err
}
return expenses, total, nil
}
func (s expenseService) GetOne(c *fiber.Ctx, id uint) (*entity.Expense, error) {
expense, err := s.Repository.GetByID(c.Context(), id, s.withRelations)
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, fiber.NewError(fiber.StatusNotFound, "Expense not found")
}
if err != nil {
s.Log.Errorf("Failed get expense by id: %+v", err)
return nil, err
}
return expense, nil
}
func (s *expenseService) CreateOne(c *fiber.Ctx, req *validation.Create) (*entity.Expense, error) {
if err := s.Validate.Struct(req); err != nil {
return nil, err
}
createBody := &entity.Expense{
Name: req.Name,
}
if err := s.Repository.CreateOne(c.Context(), createBody, nil); err != nil {
s.Log.Errorf("Failed to create expense: %+v", err)
return nil, err
}
return s.GetOne(c, createBody.Id)
}
func (s expenseService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint) (*entity.Expense, error) {
if err := s.Validate.Struct(req); err != nil {
return nil, err
}
updateBody := make(map[string]any)
if req.Name != nil {
updateBody["name"] = *req.Name
}
if len(updateBody) == 0 {
return s.GetOne(c, id)
}
if err := s.Repository.PatchOne(c.Context(), id, updateBody, nil); err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, fiber.NewError(fiber.StatusNotFound, "Expense not found")
}
s.Log.Errorf("Failed to update expense: %+v", err)
return nil, err
}
return s.GetOne(c, id)
}
func (s expenseService) DeleteOne(c *fiber.Ctx, id uint) error {
if err := s.Repository.DeleteOne(c.Context(), id); err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return fiber.NewError(fiber.StatusNotFound, "Expense not found")
}
s.Log.Errorf("Failed to delete expense: %+v", err)
return err
}
return nil
}
internal/modules/expenses/validations/expense.validation.go
+15
View File
@@ -0,0 +1,15 @@
package validation
type Create struct {
Name string `json:"name" validate:"required_strict,min=3"`
}
type Update struct {
Name *string `json:"name,omitempty" validate:"omitempty"`
}
type Query struct {
Page int `query:"page" validate:"omitempty,number,min=1,gt=0"`
Limit int `query:"limit" validate:"omitempty,number,min=1,max=100,gt=0"`
Search string `query:"search" validate:"omitempty,max=50"`
}