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-115,116,117): implement chickin CRUD, approve logic, and stock availabilit

Browse Source
This commit is contained in:
aguhh18
2025-10-20 06:01:16 +07:00
parent 68a670a2bd
commit 83c3e61113
34 changed files with 558 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/modules/production/chickins/controllers/chickin.controller.go
+22 -1
View File
@@ -88,7 +88,7 @@ func (u *ChickinController) CreateOne(c *fiber.Ctx) error {
Code: fiber.StatusCreated,
Status: "success",
Message: "Create chickin successfully",
Data: dto.ToChickinListDTO(*result),
Data: result,
})
}
@@ -138,3 +138,24 @@ func (u *ChickinController) DeleteOne(c *fiber.Ctx) error {
Message: "Delete chickin successfully",
})
}
func (u *ChickinController) Approve(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.ChickinService.Approve(c, uint(id)); err != nil {
return err
}
return c.Status(fiber.StatusOK).
JSON(response.Success{
Code: fiber.StatusOK,
Status: "success",
Message: "Approve chickin successfully",
Data: nil,
})
}
internal/modules/production/chickins/dto/chickin.dto.go
+96 -45
View File
@@ -1,84 +1,135 @@
package dto
import (
"time"
"time"
entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
userDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/users/dto"
entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
)
// === DTO Structs ===
type ChickinBaseDTO struct {
Id uint `json:"id"`
Name string `json:"name"`
Id uint `json:"id"`
ProjectFlocId uint `json:"project_floc_id"`
ChickInDate time.Time `json:"chick_in_date"`
Quantity float64 `json:"quantity"`
Note string `json:"note"`
}
type ChickinSimpleDTO struct {
Id uint `json:"id"`
Name string `json:"name"`
Id uint `json:"id"`
ProjectFlocId uint `json:"project_floc_id"`
ChickInDate time.Time `json:"chick_in_date"`
Quantity float64 `json:"quantity"`
Note string `json:"note"`
CreatedBy uint `json:"created_by"`
}
type UserBaseDTO struct {
Id uint `json:"id"`
Name string `json:"name"`
}
type ChickinListDTO struct {
ChickinBaseDTO
CreatedUser *userDTO.UserBaseDTO `json:"created_user"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
ChickinBaseDTO
ProjectFlock *ProjectFlockDTO `json:"project_flock"`
CreatedUser *UserBaseDTO `json:"created_user"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
}
type ProjectFlockDTO struct {
Id uint `json:"id"`
Period int `json:"period"`
FlockId uint `json:"flock_id"`
FlockName string `json:"flock_name"`
}
// === Mapper Functions ===
func ToProjectFlockDTO(e entity.ProjectFlock) ProjectFlockDTO {
return ProjectFlockDTO{
Id: e.Id,
Period: e.Period,
FlockId: e.FlockId,
FlockName: e.Flock.Name,
}
}
type ChickinDetailDTO struct {
ChickinListDTO
ChickinListDTO
}
// === Mapper Functions ===
func ToChickinBaseDTO(e entity.ProjectChickin) ChickinBaseDTO {
return ChickinBaseDTO{
Id: e.Id,
}
return ChickinBaseDTO{
Id: e.Id,
ProjectFlocId: e.ProjectFlocId,
ChickInDate: e.ChickInDate,
Quantity: e.Quantity,
Note: e.Note,
}
}
func ToChickinSimpleDTO(e entity.ProjectChickin) ChickinSimpleDTO {
return ChickinSimpleDTO{
Id: e.Id,
}
return ChickinSimpleDTO{
Id: e.Id,
ProjectFlocId: e.ProjectFlocId,
ChickInDate: e.ChickInDate,
Quantity: e.Quantity,
Note: e.Note,
CreatedBy: e.CreatedBy,
}
}
func ToChickinListDTO(e entity.ProjectChickin) ChickinListDTO {
var createdUser *userDTO.UserBaseDTO
if e.CreatedUser.Id != 0 {
mapped := userDTO.ToUserBaseDTO(e.CreatedUser)
createdUser = &mapped
}
var createdUser *UserBaseDTO
if e.CreatedUser.Id != 0 {
mapped := ToUserBaseDTO(e.CreatedUser)
createdUser = &mapped
}
return ChickinListDTO{
ChickinBaseDTO: ToChickinBaseDTO(e),
CreatedAt: e.CreatedAt,
UpdatedAt: e.UpdatedAt,
CreatedUser: createdUser,
}
var projectFlock *ProjectFlockDTO
if e.ProjectFlock.Id != 0 {
mapped := ToProjectFlockDTO(e.ProjectFlock)
projectFlock = &mapped
}
return ChickinListDTO{
ChickinBaseDTO: ToChickinBaseDTO(e),
ProjectFlock: projectFlock,
CreatedAt: e.CreatedAt,
UpdatedAt: e.UpdatedAt,
CreatedUser: createdUser,
}
}
func ToChickinListDTOs(e []entity.ProjectChickin) []ChickinListDTO {
result := make([]ChickinListDTO, len(e))
for i, r := range e {
result[i] = ToChickinListDTO(r)
}
return result
result := make([]ChickinListDTO, len(e))
for i, r := range e {
result[i] = ToChickinListDTO(r)
}
return result
}
func ToChickinSimpleDTOs(e []entity.ProjectChickin) []ChickinSimpleDTO {
result := make([]ChickinSimpleDTO, len(e))
for i, r := range e {
result[i] = ToChickinSimpleDTO(r)
}
return result
result := make([]ChickinSimpleDTO, len(e))
for i, r := range e {
result[i] = ToChickinSimpleDTO(r)
}
return result
}
func ToChickinDetailDTO(e entity.ProjectChickin) ChickinDetailDTO {
return ChickinDetailDTO{
ChickinListDTO: ToChickinListDTO(e),
}
}
return ChickinDetailDTO{
ChickinListDTO: ToChickinListDTO(e),
}
}
func ToUserBaseDTO(e entity.User) UserBaseDTO {
return UserBaseDTO{
Id: e.Id,
Name: e.Name,
}
}
internal/modules/production/chickins/module.go
+13 -2
View File
@@ -5,8 +5,14 @@ import (
"github.com/gofiber/fiber/v2"
"gorm.io/gorm"
rProductWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
rKandang "gitlab.com/mbugroup/lti-api.git/internal/modules/master/kandangs/repositories"
rWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/master/warehouses/repositories"
rChickin "gitlab.com/mbugroup/lti-api.git/internal/modules/production/chickins/repositories"
sChickin "gitlab.com/mbugroup/lti-api.git/internal/modules/production/chickins/services"
rAuditLog "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
rProjectFlock "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/repositories"
rUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
sUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
@@ -16,11 +22,16 @@ type ChickinModule struct{}
func (ChickinModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *validator.Validate) {
chickinRepo := rChickin.NewChickinRepository(db)
kandangRepo := rKandang.NewKandangRepository(db)
auditlogrepo := rAuditLog.NewAuditLogRepository(db)
warehouseRepo := rWarehouse.NewWarehouseRepository(db)
projectFlockRepo := rProjectFlock.NewProjectflockRepository(db)
productWarehouseRepo := rProductWarehouse.NewProductWarehouseRepository(db)
userRepo := rUser.NewUserRepository(db)
chickinService := sChickin.NewChickinService(chickinRepo, validate)
chickinService := sChickin.NewChickinService(chickinRepo, kandangRepo, warehouseRepo, productWarehouseRepo, projectFlockRepo, auditlogrepo, validate)
userService := sUser.NewUserService(userRepo, validate)
ChickinRoutes(router, userService, chickinService)
}
internal/modules/production/chickins/repositories/chickin.repository.go
-21
View File
@@ -1,21 +0,0 @@
package repository
import (
"gitlab.com/mbugroup/lti-api.git/internal/common/repository"
entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
"gorm.io/gorm"
)
type ChickinRepository interface {
repository.BaseRepository[entity.ProjectChickin]
}
type ChickinRepositoryImpl struct {
*repository.BaseRepositoryImpl[entity.ProjectChickin]
}
func NewChickinRepository(db *gorm.DB) ChickinRepository {
return &ChickinRepositoryImpl{
BaseRepositoryImpl: repository.NewBaseRepository[entity.ProjectChickin](db),
}
}
internal/modules/production/chickins/repositories/project_chickin.repository.go
+36
View File
@@ -0,0 +1,36 @@
package repository
import (
"context"
"gitlab.com/mbugroup/lti-api.git/internal/common/repository"
entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
"gorm.io/gorm"
)
type ProjectChickinRepository interface {
repository.BaseRepository[entity.ProjectChickin]
GetFirstByProjectFlockID(ctx context.Context, projectFlockID uint) (*entity.ProjectChickin, error)
}
type ChickinRepositoryImpl struct {
*repository.BaseRepositoryImpl[entity.ProjectChickin]
}
func NewChickinRepository(db *gorm.DB) ProjectChickinRepository {
return &ChickinRepositoryImpl{
BaseRepositoryImpl: repository.NewBaseRepository[entity.ProjectChickin](db),
}
}
func (r *ChickinRepositoryImpl) GetFirstByProjectFlockID(ctx context.Context, projectFlockID uint) (*entity.ProjectChickin, error) {
var chickin entity.ProjectChickin
err := r.DB().WithContext(ctx).
Where("project_floc_id = ?", projectFlockID).
Where("deleted_at IS NULL").
First(&chickin).Error
if err != nil {
return nil, err
}
return &chickin, nil
}
internal/modules/production/chickins/route.go
+1
View File
@@ -25,4 +25,5 @@ func ChickinRoutes(v1 fiber.Router, u user.UserService, s chickin.ChickinService
route.Get("/:id", ctrl.GetOne)
route.Patch("/:id", ctrl.UpdateOne)
route.Delete("/:id", ctrl.DeleteOne)
route.Post("/:id/approve", ctrl.Approve)
}
internal/modules/production/chickins/services/chickin.service.go
+180 -15
View File
@@ -4,8 +4,14 @@ import (
"errors"
entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
rProductWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
KandangRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/master/kandangs/repositories"
rWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/master/warehouses/repositories"
repository "gitlab.com/mbugroup/lti-api.git/internal/modules/production/chickins/repositories"
validation "gitlab.com/mbugroup/lti-api.git/internal/modules/production/chickins/validations"
rProjectFlock "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/repositories"
AuditLogRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
"gitlab.com/mbugroup/lti-api.git/internal/utils"
"github.com/go-playground/validator/v10"
@@ -20,24 +26,39 @@ type ChickinService interface {
CreateOne(ctx *fiber.Ctx, req *validation.Create) (*entity.ProjectChickin, error)
UpdateOne(ctx *fiber.Ctx, req *validation.Update, id uint) (*entity.ProjectChickin, error)
DeleteOne(ctx *fiber.Ctx, id uint) error
Approve(ctx *fiber.Ctx, id uint) error
}
type chickinService struct {
Log *logrus.Logger
Validate *validator.Validate
Repository repository.ChickinRepository
Log *logrus.Logger
Validate *validator.Validate
Repository repository.ProjectChickinRepository
KandangRepo KandangRepo.KandangRepository
WarehouseRepo rWarehouse.WarehouseRepository
ProductWarehouseRepo rProductWarehouse.ProductWarehouseRepository
ProjectFlockRepo rProjectFlock.ProjectflockRepository
AuditLogRepo AuditLogRepo.AuditLogRepository
}
func NewChickinService(repo repository.ChickinRepository, validate *validator.Validate) ChickinService {
func NewChickinService(repo repository.ProjectChickinRepository, kandangRepo KandangRepo.KandangRepository, warehouseRepo rWarehouse.WarehouseRepository, productWarehouseRepo rProductWarehouse.ProductWarehouseRepository, projectFlockRepo rProjectFlock.ProjectflockRepository, auditLogRepo AuditLogRepo.AuditLogRepository, validate *validator.Validate) ChickinService {
return &chickinService{
Log: utils.Log,
Validate: validate,
Repository: repo,
Log: utils.Log,
Validate: validate,
Repository: repo,
KandangRepo: kandangRepo,
WarehouseRepo: warehouseRepo,
ProductWarehouseRepo: productWarehouseRepo,
ProjectFlockRepo: projectFlockRepo,
AuditLogRepo: auditLogRepo,
}
}
func (s chickinService) withRelations(db *gorm.DB) *gorm.DB {
return db.Preload("CreatedUser")
return db.
Preload("CreatedUser").
Preload("ProjectFlock").
Preload("ProjectFlock.ProductCategory")
}
func (s chickinService) GetAll(c *fiber.Ctx, params *validation.Query) ([]entity.ProjectChickin, int64, error) {
@@ -79,16 +100,125 @@ func (s *chickinService) CreateOne(c *fiber.Ctx, req *validation.Create) (*entit
return nil, err
}
createBody := &entity.ProjectChickin{
ProjectFlocId: 1,
// ambil salah satu kandang dari project_floc_id dari kandang repository
kandang, err := s.KandangRepo.GetFirstByProjectFlockID(c.Context(), 1)
if err != nil {
s.Log.Errorf("Failed to get kandang: %+v", err)
return nil, err
}
// ambil warehouse dari kandangid
warehouse, err := s.WarehouseRepo.GetByKandangID(c.Context(), kandang.Id)
if err != nil {
s.Log.Errorf("Failed to get warehouse: %+v", err)
return nil, err
}
// getprojectflock id with relation
projectFlock, err := s.ProjectFlockRepo.GetByID(
c.Context(),
req.ProjectFlockId,
func(db *gorm.DB) *gorm.DB {
return db.Preload("ProductCategory")
},
)
if err != nil {
s.Log.Errorf("Failed to get project flock: %+v", err)
return nil, fiber.NewError(fiber.StatusNotFound, "Project Flock not found")
}
// ambil quantity
var productWarehouse entity.ProductWarehouse
err = s.ProductWarehouseRepo.DB().WithContext(c.Context()).
Joins("JOIN products ON products.id = product_warehouses.product_id").
Joins("JOIN product_categories ON product_categories.id = products.product_category_id").
Where("product_categories.code = ? AND product_warehouses.warehouse_id = ?", projectFlock.ProductCategory.Code, warehouse.Id).
Order("created_at DESC").
First(&productWarehouse).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, fiber.NewError(fiber.StatusNotFound, "Product Warehouse not found for the given Project Flock and Warehouse")
}
s.Log.Errorf("Failed to get product warehouse: %+v", err)
return nil, err
}
if err := s.Repository.CreateOne(c.Context(), createBody, nil); err != nil {
if productWarehouse.Quantity < 1 {
return nil, fiber.NewError(fiber.StatusBadRequest, "Insufficient product quantity in warehouse")
}
// masukan ke chic in
chickinDate, err := utils.ParseDateString(req.ChickInDate)
if err != nil {
s.Log.Errorf("Failed to parse chickin date: %+v", err)
return nil, fiber.NewError(fiber.StatusBadRequest, "Invalid ChickInDate format")
}
newChickin := &entity.ProjectChickin{
ProjectFlocId: req.ProjectFlockId,
ChickInDate: chickinDate,
Quantity: productWarehouse.Quantity,
Note: "",
CreatedBy: 1, //todo: ganti dengan
}
err = s.Repository.CreateOne(c.Context(), newChickin, nil)
if err != nil {
s.Log.Errorf("Failed to create chickin: %+v", err)
return nil, err
}
return s.GetOne(c, createBody.Id)
// Kurangi quantity di product warehouse
updatedQuantity := productWarehouse.Quantity - newChickin.Quantity
if updatedQuantity < 0 {
updatedQuantity = 0
}
err = s.ProductWarehouseRepo.PatchOne(c.Context(), productWarehouse.Id, map[string]any{
"quantity": updatedQuantity,
}, nil)
if err != nil {
s.Log.Errorf("Failed to update product warehouse quantity: %+v", err)
return nil, err
}
// masukan check apakah stock availability ada, jika ada update, jika tidak buat baru
stockAvailability := &entity.StockAvailability{
EntityType: entity.EntityTypeProjectFlockKandang,
ReservedQuantity: productWarehouse.Quantity,
EntityId: req.ProjectFlockId, //todo: nanti pakek projct flock kandang id
ProductId: productWarehouse.ProductId,
}
var existingStockAvailability entity.StockAvailability
err = s.ProductWarehouseRepo.DB().WithContext(c.Context()).
Where("entity_type = ? AND entity_id = ? AND product_id = ?", stockAvailability.EntityType, stockAvailability.EntityId, stockAvailability.ProductId).
First(&existingStockAvailability).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
// buat baru
stockAvailability.ReservedQuantity = newChickin.Quantity
stockAvailability.Quantity = 0
err = s.ProductWarehouseRepo.DB().WithContext(c.Context()).Create(stockAvailability).Error
if err != nil {
s.Log.Errorf("Failed to create stock availability: %+v", err)
return nil, err
}
} else {
s.Log.Errorf("Failed to get stock availability: %+v", err)
return nil, err
}
} else {
// update existing
newQuantity := existingStockAvailability.ReservedQuantity + newChickin.Quantity
err = s.ProductWarehouseRepo.DB().WithContext(c.Context()).
Model(&existingStockAvailability).
Update("reserved_quantity", newQuantity).Error
if err != nil {
s.Log.Errorf("Failed to update stock availability: %+v", err)
return nil, err
}
}
return nil, nil
}
func (s chickinService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint) (*entity.ProjectChickin, error) {
@@ -98,10 +228,9 @@ func (s chickinService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint)
updateBody := make(map[string]any)
if req.Name != nil {
updateBody["name"] = *req.Name
if req.ChickInDate != "" {
updateBody["chick_in_date"] = req.ChickInDate
}
if len(updateBody) == 0 {
return s.GetOne(c, id)
}
@@ -125,5 +254,41 @@ func (s chickinService) DeleteOne(c *fiber.Ctx, id uint) error {
s.Log.Errorf("Failed to delete chickin: %+v", err)
return err
}
return nil
}
func (s *chickinService) Approve(c *fiber.Ctx, id uint) error {
chickin, err := s.Repository.GetByID(
c.Context(),
id,
nil,
)
if errors.Is(err, gorm.ErrRecordNotFound) {
return fiber.NewError(fiber.StatusNotFound, "Chickin not found")
}
if err != nil {
s.Log.Errorf("Failed get chickin by id: %+v", err)
return err
}
//pindahkan stock dari reserved ke actual stock
// get stock avaibility untuk di update
var stockAvailability entity.StockAvailability
err = s.ProductWarehouseRepo.DB().WithContext(c.Context()).
Where("entity_type = ? AND entity_id = ? ", entity.EntityTypeProjectFlockKandang, chickin.ProjectFlocId).
First(&stockAvailability).Error
if err != nil {
s.Log.Errorf("Failed to get stock availability: %+v", err)
return err
}
newReservedQuantity := stockAvailability.ReservedQuantity - chickin.Quantity
if newReservedQuantity < 0 {
newReservedQuantity = 0
}
return nil
}
internal/modules/production/chickins/validations/chickin.validation.go
+3 -2
View File
@@ -1,11 +1,12 @@
package validation
type Create struct {
Name string `json:"name" validate:"required_strict,min=3"`
ProjectFlockId uint `json:"project_flock_id" validate:"required,number,min=1"`
ChickInDate string `json:"chick_in_date" validate:"required,datetime=2006-01-02"`
}
type Update struct {
Name *string `json:"name,omitempty" validate:"omitempty"`
ChickInDate string `json:"chick_in_date" validate:"required,datetime=2006-01-02"`
}
type Query struct {
internal/modules/production/route.go
+1 -1
View File
@@ -7,9 +7,9 @@ import (
"github.com/gofiber/fiber/v2"
"gorm.io/gorm"
chickins "gitlab.com/mbugroup/lti-api.git/internal/modules/production/chickins"
projectflocks "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks"
recordings "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings"
chickins "gitlab.com/mbugroup/lti-api.git/internal/modules/production/chickins"
// MODULE IMPORTS
)