gitea-admin/lti-api
1
0
Fork 0
mirror of https://gitlab.com/mbugroup/lti-api.git synced 2026-05-20 13:31:56 +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/entities/delivery-orders.go
-23
View File
@@ -1,23 +0,0 @@
package entities
import (
"time"
"gorm.io/gorm"
)
type DeliveryOrders struct {
Id uint `gorm:"primaryKey" json:"id"`
DeliveryNumber string `gorm:"type:varchar(255);not null;uniqueIndex" json:"delivery_number"`
DeliveryDate time.Time `gorm:"not null" json:"delivery_date"`
MarketingId uint `gorm:"not null" json:"marketing_id"`
Notes string `gorm:"type:text" json:"notes"`
CreatedBy uint `gorm:"not null" json:"created_by"`
CreatedAt time.Time `gorm:"autoCreateTime" json:"created_at"`
UpdatedAt time.Time `gorm:"autoUpdateTime" json:"updated_at"`
DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
Marketing *Marketing `gorm:"foreignKey:MarketingId;references:Id" json:"marketing,omitempty"`
DeliveryProducts []MarketingDeliveryProduct `gorm:"-" json:"delivery_products,omitempty"`
CreatedUser *User `gorm:"foreignKey:CreatedBy;references:Id" json:"created_user,omitempty"`
}
internal/entities/sales-orders.go → internal/entities/expense.go
+2 -3
View File
@@ -6,7 +6,7 @@ import (
"gorm.io/gorm"
)
type SalesOrders struct {
type Expense struct {
Id uint `gorm:"primaryKey"`
Name string `gorm:"not null;uniqueIndex:idx_name,where:deleted_at IS NULL"`
CreatedBy uint `gorm:"not null"`
@@ -14,6 +14,5 @@ type SalesOrders struct {
UpdatedAt time.Time `gorm:"autoUpdateTime"`
DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
CreatedUser User `gorm:"foreignKey:CreatedBy;references:Id"`
LatestApproval *Approval `gorm:"-" json:"latest_approval,omitempty"`
CreatedUser User `gorm:"foreignKey:CreatedBy;references:Id"`
}
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"`
}
internal/modules/inventory/product-warehouses/dto/product_warehouse.dto.go
+1 -1
View File
@@ -129,7 +129,7 @@ func ToProductWarehouseListDTO(e entity.ProductWarehouse) ProductWarehouseListDT
}
}
if &e.Warehouse.Area != nil && e.Warehouse.Area.Id != 0 {
if e.Warehouse.Area.Id != 0 {
warehouse.Area = &AreaBaseDTO{
Id: e.Warehouse.Area.Id,
Name: e.Warehouse.Area.Name,
internal/modules/marketing/sales-orders/dto/sales-orders.dto.go
+9 -5
View File
@@ -48,14 +48,18 @@ func ToMarketingProductDTO(e entity.MarketingProduct) MarketingProductDTO {
}
}
func ToSalesOrdersListDTO(e entity.SalesOrders) SalesOrdersListDTO {
func ToSalesOrdersListDTO(e entity.Marketing) SalesOrdersListDTO {
products := make([]MarketingProductDTO, len(e.Products))
for i, p := range e.Products {
products[i] = ToMarketingProductDTO(p)
}
return SalesOrdersListDTO{
Id: e.Id,
SoNumber: e.Name,
SoDate: time.Time{},
Notes: "",
SalesOrder: []MarketingProductDTO{},
SoNumber: e.SoNumber,
SoDate: e.SoDate,
Notes: e.Notes,
SalesOrder: products,
}
}
internal/modules/marketing/sales-orders/module.go
+2 -3
View File
@@ -21,11 +21,10 @@ import (
type SalesOrdersModule struct{}
func (SalesOrdersModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *validator.Validate) {
salesOrdersRepo := rSalesOrders.NewSalesOrdersRepository(db)
marketingRepo := rSalesOrders.NewMarketingRepository(db)
userRepo := rUser.NewUserRepository(db)
customerRepo := rCustomer.NewCustomerRepository(db)
productWarehouseRepo := rProductWarehouse.NewProductWarehouseRepository(db)
marketingRepo := rSalesOrders.NewMarketingRepository(db)
approvalSvc := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(db))
@@ -33,7 +32,7 @@ func (SalesOrdersModule) RegisterRoutes(router fiber.Router, db *gorm.DB, valida
panic(fmt.Sprintf("failed to register marketing approval workflow: %v", err))
}
salesOrdersService := sSalesOrders.NewSalesOrdersService(salesOrdersRepo, customerRepo, productWarehouseRepo, marketingRepo, userRepo, approvalSvc, validate)
salesOrdersService := sSalesOrders.NewSalesOrdersService(marketingRepo, customerRepo, productWarehouseRepo, userRepo, approvalSvc, validate)
userService := sUser.NewUserService(userRepo, validate)
SalesOrdersRoutes(router, userService, salesOrdersService)
internal/modules/marketing/sales-orders/repositories/sales-orders.repository.go
-21
View File
@@ -1,21 +0,0 @@
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 SalesOrdersRepository interface {
repository.BaseRepository[entity.SalesOrders]
}
type SalesOrdersRepositoryImpl struct {
*repository.BaseRepositoryImpl[entity.SalesOrders]
}
func NewSalesOrdersRepository(db *gorm.DB) SalesOrdersRepository {
return &SalesOrdersRepositoryImpl{
BaseRepositoryImpl: repository.NewBaseRepository[entity.SalesOrders](db),
}
}
internal/modules/marketing/sales-orders/services/sales-orders.service.go
+6 -8
View File
@@ -34,22 +34,20 @@ type SalesOrdersService interface {
type salesOrdersService struct {
Log *logrus.Logger
Validate *validator.Validate
Repository repository.SalesOrdersRepository
MarketingRepo repository.MarketingRepository
CustomerRepo customerRepo.CustomerRepository
ProductWarehouseRepo productWarehouseRepo.ProductWarehouseRepository
MarketingRepo repository.MarketingRepository
UserRepo userRepo.UserRepository
ApprovalSvc commonSvc.ApprovalService
}
func NewSalesOrdersService(repo repository.SalesOrdersRepository, customerRepo customerRepo.CustomerRepository, productWarehouseRepo productWarehouseRepo.ProductWarehouseRepository, marketingRepo repository.MarketingRepository, userRepo userRepo.UserRepository, approvalSvc commonSvc.ApprovalService, validate *validator.Validate) SalesOrdersService {
func NewSalesOrdersService(marketingRepo repository.MarketingRepository, customerRepo customerRepo.CustomerRepository, productWarehouseRepo productWarehouseRepo.ProductWarehouseRepository, userRepo userRepo.UserRepository, approvalSvc commonSvc.ApprovalService, validate *validator.Validate) SalesOrdersService {
return &salesOrdersService{
Log: utils.Log,
Validate: validate,
Repository: repo,
MarketingRepo: marketingRepo,
CustomerRepo: customerRepo,
ProductWarehouseRepo: productWarehouseRepo,
MarketingRepo: marketingRepo,
UserRepo: userRepo,
ApprovalSvc: approvalSvc,
}
@@ -118,7 +116,7 @@ func (s *salesOrdersService) CreateOne(c *fiber.Ctx, req *validation.Create) (*e
soNumber := fmt.Sprintf("SO-%05d", nextSeq)
var marketing *entity.Marketing
err = s.Repository.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
err = s.MarketingRepo.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
marketingRepoTx := repository.NewMarketingRepository(dbTransaction)
marketingProductRepoTx := repository.NewMarketingProductRepository(dbTransaction)
@@ -208,7 +206,7 @@ func (s salesOrdersService) UpdateOne(c *fiber.Ctx, req *validation.Update, id u
}
}
err = s.Repository.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
err = s.MarketingRepo.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
marketingRepoTx := repository.NewMarketingRepository(dbTransaction)
marketingProductRepoTx := repository.NewMarketingProductRepository(dbTransaction)
@@ -366,7 +364,7 @@ func (s salesOrdersService) DeleteOne(c *fiber.Ctx, id uint) error {
return fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch sales order")
}
err = s.Repository.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
err = s.MarketingRepo.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
marketingProductRepoTx := repository.NewMarketingProductRepository(dbTransaction)
marketingDeliveryProductRepoTx := repository.NewMarketingDeliveryProductRepository(dbTransaction)
internal/route/route.go
+2
View File
@@ -17,6 +17,7 @@ import (
purchases "gitlab.com/mbugroup/lti-api.git/internal/modules/purchases"
ssoModule "gitlab.com/mbugroup/lti-api.git/internal/modules/sso"
users "gitlab.com/mbugroup/lti-api.git/internal/modules/users"
expenses "gitlab.com/mbugroup/lti-api.git/internal/modules/expenses"
// MODULE IMPORTS
)
@@ -36,6 +37,7 @@ func Routes(app *fiber.App, db *gorm.DB) {
purchases.PurchaseModule{},
marketing.MarketingModule{},
ssoModule.Module{},
expenses.ExpenseModule{},
// MODULE REGISTRY
}