From 09d503f5bee656288dd4ab5e31949296da8c8d67 Mon Sep 17 00:00:00 2001 From: aguhh18 Date: Mon, 17 Nov 2025 14:46:21 +0700 Subject: [PATCH] Feat[BE-261] : inisiate expense module --- internal/entities/delivery-orders.go | 23 --- .../entities/{sales-orders.go => expense.go} | 5 +- .../controllers/expense.controller.go | 144 ++++++++++++++++++ internal/modules/expenses/dto/expense.dto.go | 66 ++++++++ internal/modules/expenses/module.go | 26 ++++ .../repositories/expense.repository.go | 21 +++ internal/modules/expenses/route.go | 28 ++++ .../expenses/services/expense.service.go | 129 ++++++++++++++++ .../validations/expense.validation.go | 15 ++ .../dto/product_warehouse.dto.go | 2 +- .../sales-orders/dto/sales-orders.dto.go | 14 +- .../modules/marketing/sales-orders/module.go | 5 +- .../repositories/sales-orders.repository.go | 21 --- .../services/sales-orders.service.go | 14 +- internal/route/route.go | 2 + 15 files changed, 451 insertions(+), 64 deletions(-) delete mode 100644 internal/entities/delivery-orders.go rename internal/entities/{sales-orders.go => expense.go} (70%) create mode 100644 internal/modules/expenses/controllers/expense.controller.go create mode 100644 internal/modules/expenses/dto/expense.dto.go create mode 100644 internal/modules/expenses/module.go create mode 100644 internal/modules/expenses/repositories/expense.repository.go create mode 100644 internal/modules/expenses/route.go create mode 100644 internal/modules/expenses/services/expense.service.go create mode 100644 internal/modules/expenses/validations/expense.validation.go delete mode 100644 internal/modules/marketing/sales-orders/repositories/sales-orders.repository.go diff --git a/internal/entities/delivery-orders.go b/internal/entities/delivery-orders.go deleted file mode 100644 index 291ba20c..00000000 --- a/internal/entities/delivery-orders.go +++ /dev/null @@ -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"` -} diff --git a/internal/entities/sales-orders.go b/internal/entities/expense.go similarity index 70% rename from internal/entities/sales-orders.go rename to internal/entities/expense.go index faa6d901..a427582d 100644 --- a/internal/entities/sales-orders.go +++ b/internal/entities/expense.go @@ -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"` } diff --git a/internal/modules/expenses/controllers/expense.controller.go b/internal/modules/expenses/controllers/expense.controller.go new file mode 100644 index 00000000..074f2f0a --- /dev/null +++ b/internal/modules/expenses/controllers/expense.controller.go @@ -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", + }) +} diff --git a/internal/modules/expenses/dto/expense.dto.go b/internal/modules/expenses/dto/expense.dto.go new file mode 100644 index 00000000..b7bd1b5f --- /dev/null +++ b/internal/modules/expenses/dto/expense.dto.go @@ -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), + } +} diff --git a/internal/modules/expenses/module.go b/internal/modules/expenses/module.go new file mode 100644 index 00000000..c9b2ab66 --- /dev/null +++ b/internal/modules/expenses/module.go @@ -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) +} + diff --git a/internal/modules/expenses/repositories/expense.repository.go b/internal/modules/expenses/repositories/expense.repository.go new file mode 100644 index 00000000..94712cd5 --- /dev/null +++ b/internal/modules/expenses/repositories/expense.repository.go @@ -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), + } +} diff --git a/internal/modules/expenses/route.go b/internal/modules/expenses/route.go new file mode 100644 index 00000000..49a4e7c5 --- /dev/null +++ b/internal/modules/expenses/route.go @@ -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) +} diff --git a/internal/modules/expenses/services/expense.service.go b/internal/modules/expenses/services/expense.service.go new file mode 100644 index 00000000..1b57263e --- /dev/null +++ b/internal/modules/expenses/services/expense.service.go @@ -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 +} diff --git a/internal/modules/expenses/validations/expense.validation.go b/internal/modules/expenses/validations/expense.validation.go new file mode 100644 index 00000000..7d16d3ee --- /dev/null +++ b/internal/modules/expenses/validations/expense.validation.go @@ -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"` +} diff --git a/internal/modules/inventory/product-warehouses/dto/product_warehouse.dto.go b/internal/modules/inventory/product-warehouses/dto/product_warehouse.dto.go index c6ac5931..f88a6ca3 100644 --- a/internal/modules/inventory/product-warehouses/dto/product_warehouse.dto.go +++ b/internal/modules/inventory/product-warehouses/dto/product_warehouse.dto.go @@ -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, diff --git a/internal/modules/marketing/sales-orders/dto/sales-orders.dto.go b/internal/modules/marketing/sales-orders/dto/sales-orders.dto.go index 03a0d59a..86bd5f84 100644 --- a/internal/modules/marketing/sales-orders/dto/sales-orders.dto.go +++ b/internal/modules/marketing/sales-orders/dto/sales-orders.dto.go @@ -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, } } diff --git a/internal/modules/marketing/sales-orders/module.go b/internal/modules/marketing/sales-orders/module.go index 6d1963af..0d9583d0 100644 --- a/internal/modules/marketing/sales-orders/module.go +++ b/internal/modules/marketing/sales-orders/module.go @@ -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) diff --git a/internal/modules/marketing/sales-orders/repositories/sales-orders.repository.go b/internal/modules/marketing/sales-orders/repositories/sales-orders.repository.go deleted file mode 100644 index 5f8cfe79..00000000 --- a/internal/modules/marketing/sales-orders/repositories/sales-orders.repository.go +++ /dev/null @@ -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), - } -} diff --git a/internal/modules/marketing/sales-orders/services/sales-orders.service.go b/internal/modules/marketing/sales-orders/services/sales-orders.service.go index 0dc47a2c..62f694f3 100644 --- a/internal/modules/marketing/sales-orders/services/sales-orders.service.go +++ b/internal/modules/marketing/sales-orders/services/sales-orders.service.go @@ -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) diff --git a/internal/route/route.go b/internal/route/route.go index 04adf6e2..7b7059b5 100644 --- a/internal/route/route.go +++ b/internal/route/route.go @@ -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 }