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-127]: create available qty API and inisiate sales order and delivery order

Browse Source
This commit is contained in:
aguhh18
2025-11-07 13:24:48 +07:00
parent ba12320d12
commit 6e69e97d26
24 changed files with 695 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/modules/marketing/module.go
+13
View File
@@ -0,0 +1,13 @@
package marketing
import (
"github.com/go-playground/validator/v10"
"github.com/gofiber/fiber/v2"
"gorm.io/gorm"
)
type MarketingModule struct{}
func (MarketingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *validator.Validate) {
RegisterRoutes(router, db, validate)
}
internal/modules/marketing/route.go
+25
View File
@@ -0,0 +1,25 @@
package marketing
import (
"gitlab.com/mbugroup/lti-api.git/internal/modules"
"github.com/go-playground/validator/v10"
"github.com/gofiber/fiber/v2"
"gorm.io/gorm"
salesOrderss "gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/sales-orders"
// MODULE IMPORTS
)
func RegisterRoutes(router fiber.Router, db *gorm.DB, validate *validator.Validate) {
group := router.Group("/marketing")
allModules := []modules.Module{
salesOrderss.SalesOrdersModule{},
// MODULE REGISTRY
}
for _, m := range allModules {
m.RegisterRoutes(group, db, validate)
}
}
internal/modules/marketing/sales-orders/controllers/sales-orders.controller.go
+144
View File
@@ -0,0 +1,144 @@
package controller
import (
"math"
"strconv"
"gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/sales-orders/dto"
service "gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/sales-orders/services"
validation "gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/sales-orders/validations"
"gitlab.com/mbugroup/lti-api.git/internal/response"
"github.com/gofiber/fiber/v2"
)
type SalesOrdersController struct {
SalesOrdersService service.SalesOrdersService
}
func NewSalesOrdersController(salesOrdersService service.SalesOrdersService) *SalesOrdersController {
return &SalesOrdersController{
SalesOrdersService: salesOrdersService,
}
}
func (u *SalesOrdersController) 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.SalesOrdersService.GetAll(c, query)
if err != nil {
return err
}
return c.Status(fiber.StatusOK).
JSON(response.SuccessWithPaginate[dto.SalesOrdersListDTO]{
Code: fiber.StatusOK,
Status: "success",
Message: "Get all salesOrderss successfully",
Meta: response.Meta{
Page: query.Page,
Limit: query.Limit,
TotalPages: int64(math.Ceil(float64(totalResults) / float64(query.Limit))),
TotalResults: totalResults,
},
Data: dto.ToSalesOrdersListDTOs(result),
})
}
func (u *SalesOrdersController) 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.SalesOrdersService.GetOne(c, uint(id))
if err != nil {
return err
}
return c.Status(fiber.StatusOK).
JSON(response.Success{
Code: fiber.StatusOK,
Status: "success",
Message: "Get salesOrders successfully",
Data: dto.ToSalesOrdersListDTO(*result),
})
}
func (u *SalesOrdersController) 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.SalesOrdersService.CreateOne(c, req)
// if err != nil {
// return err
// }
return c.Status(fiber.StatusCreated).
JSON(response.Success{
Code: fiber.StatusCreated,
Status: "success",
Message: "Create salesOrders successfully",
Data: req,
})
}
func (u *SalesOrdersController) 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.SalesOrdersService.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 salesOrders successfully",
Data: dto.ToSalesOrdersListDTO(*result),
})
}
func (u *SalesOrdersController) 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.SalesOrdersService.DeleteOne(c, uint(id)); err != nil {
return err
}
return c.Status(fiber.StatusOK).
JSON(response.Common{
Code: fiber.StatusOK,
Status: "success",
Message: "Delete salesOrders successfully",
})
}
internal/modules/marketing/sales-orders/dto/sales-orders.dto.go
+64
View File
@@ -0,0 +1,64 @@
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 SalesOrdersBaseDTO struct {
Id uint `json:"id"`
Name string `json:"name"`
}
type SalesOrdersListDTO struct {
SalesOrdersBaseDTO
CreatedUser *userDTO.UserBaseDTO `json:"created_user"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
}
type SalesOrdersDetailDTO struct {
SalesOrdersListDTO
}
// === Mapper Functions ===
func ToSalesOrdersBaseDTO(e entity.SalesOrders) SalesOrdersBaseDTO {
return SalesOrdersBaseDTO{
Id: e.Id,
Name: e.Name,
}
}
func ToSalesOrdersListDTO(e entity.SalesOrders) SalesOrdersListDTO {
var createdUser *userDTO.UserBaseDTO
if e.CreatedUser.Id != 0 {
mapped := userDTO.ToUserBaseDTO(e.CreatedUser)
createdUser = &mapped
}
return SalesOrdersListDTO{
SalesOrdersBaseDTO: ToSalesOrdersBaseDTO(e),
CreatedAt: e.CreatedAt,
UpdatedAt: e.UpdatedAt,
CreatedUser: createdUser,
}
}
func ToSalesOrdersListDTOs(e []entity.SalesOrders) []SalesOrdersListDTO {
result := make([]SalesOrdersListDTO, len(e))
for i, r := range e {
result[i] = ToSalesOrdersListDTO(r)
}
return result
}
func ToSalesOrdersDetailDTO(e entity.SalesOrders) SalesOrdersDetailDTO {
return SalesOrdersDetailDTO{
SalesOrdersListDTO: ToSalesOrdersListDTO(e),
}
}
internal/modules/marketing/sales-orders/module.go
+26
View File
@@ -0,0 +1,26 @@
package sales_orders
import (
"github.com/go-playground/validator/v10"
"github.com/gofiber/fiber/v2"
"gorm.io/gorm"
rSalesOrders "gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/sales-orders/repositories"
sSalesOrders "gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/sales-orders/services"
rUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
sUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
)
type SalesOrdersModule struct{}
func (SalesOrdersModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *validator.Validate) {
salesOrdersRepo := rSalesOrders.NewSalesOrdersRepository(db)
userRepo := rUser.NewUserRepository(db)
salesOrdersService := sSalesOrders.NewSalesOrdersService(salesOrdersRepo, validate)
userService := sUser.NewUserService(userRepo, validate)
SalesOrdersRoutes(router, userService, salesOrdersService)
}
internal/modules/marketing/sales-orders/repositories/sales-orders.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 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/route.go
+28
View File
@@ -0,0 +1,28 @@
package sales_orders
import (
// m "gitlab.com/mbugroup/lti-api.git/internal/middleware"
controller "gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/sales-orders/controllers"
salesOrders "gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/sales-orders/services"
user "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
"github.com/gofiber/fiber/v2"
)
func SalesOrdersRoutes(v1 fiber.Router, u user.UserService, s salesOrders.SalesOrdersService) {
ctrl := controller.NewSalesOrdersController(s)
route := v1.Group("/sales-orders")
// 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/marketing/sales-orders/services/sales-orders.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/marketing/sales-orders/repositories"
validation "gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/sales-orders/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 SalesOrdersService interface {
GetAll(ctx *fiber.Ctx, params *validation.Query) ([]entity.SalesOrders, int64, error)
GetOne(ctx *fiber.Ctx, id uint) (*entity.SalesOrders, error)
CreateOne(ctx *fiber.Ctx, req *validation.Create) (*entity.SalesOrders, error)
UpdateOne(ctx *fiber.Ctx, req *validation.Update, id uint) (*entity.SalesOrders, error)
DeleteOne(ctx *fiber.Ctx, id uint) error
}
type salesOrdersService struct {
Log *logrus.Logger
Validate *validator.Validate
Repository repository.SalesOrdersRepository
}
func NewSalesOrdersService(repo repository.SalesOrdersRepository, validate *validator.Validate) SalesOrdersService {
return &salesOrdersService{
Log: utils.Log,
Validate: validate,
Repository: repo,
}
}
func (s salesOrdersService) withRelations(db *gorm.DB) *gorm.DB {
return db.Preload("CreatedUser")
}
func (s salesOrdersService) GetAll(c *fiber.Ctx, params *validation.Query) ([]entity.SalesOrders, int64, error) {
if err := s.Validate.Struct(params); err != nil {
return nil, 0, err
}
offset := (params.Page - 1) * params.Limit
salesOrderss, 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 salesOrderss: %+v", err)
return nil, 0, err
}
return salesOrderss, total, nil
}
func (s salesOrdersService) GetOne(c *fiber.Ctx, id uint) (*entity.SalesOrders, error) {
salesOrders, err := s.Repository.GetByID(c.Context(), id, s.withRelations)
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, fiber.NewError(fiber.StatusNotFound, "SalesOrders not found")
}
if err != nil {
s.Log.Errorf("Failed get salesOrders by id: %+v", err)
return nil, err
}
return salesOrders, nil
}
func (s *salesOrdersService) CreateOne(c *fiber.Ctx, req *validation.Create) (*entity.SalesOrders, error) {
if err := s.Validate.Struct(req); err != nil {
return nil, err
}
createBody := &entity.SalesOrders{
Name: req.Name,
}
if err := s.Repository.CreateOne(c.Context(), createBody, nil); err != nil {
s.Log.Errorf("Failed to create salesOrders: %+v", err)
return nil, err
}
return s.GetOne(c, createBody.Id)
}
func (s salesOrdersService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint) (*entity.SalesOrders, 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, "SalesOrders not found")
}
s.Log.Errorf("Failed to update salesOrders: %+v", err)
return nil, err
}
return s.GetOne(c, id)
}
func (s salesOrdersService) 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, "SalesOrders not found")
}
s.Log.Errorf("Failed to delete salesOrders: %+v", err)
return err
}
return nil
}
internal/modules/marketing/sales-orders/validations/sales-orders.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"`
}