Merge branch 'feat/BE/Sprint-6' of https://gitlab.com/mbugroup/lti-api into dev/teguh

internal/modules/closings/controllers/closing.controller.go

@@ -0,0 +1,76 @@
+package controller
+
+import (
+	"math"
+	"strconv"
+
+	"gitlab.com/mbugroup/lti-api.git/internal/modules/closings/dto"
+	service "gitlab.com/mbugroup/lti-api.git/internal/modules/closings/services"
+	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/closings/validations"
+	"gitlab.com/mbugroup/lti-api.git/internal/response"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+type ClosingController struct {
+	ClosingService service.ClosingService
+}
+
+func NewClosingController(closingService service.ClosingService) *ClosingController {
+	return &ClosingController{
+		ClosingService: closingService,
+	}
+}
+
+func (u *ClosingController) 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.ClosingService.GetAll(c, query)
+	if err != nil {
+		return err
+	}
+
+	return c.Status(fiber.StatusOK).
+		JSON(response.SuccessWithPaginate[dto.ClosingListDTO]{
+			Code:    fiber.StatusOK,
+			Status:  "success",
+			Message: "Get all closings successfully",
+			Meta: response.Meta{
+				Page:         query.Page,
+				Limit:        query.Limit,
+				TotalPages:   int64(math.Ceil(float64(totalResults) / float64(query.Limit))),
+				TotalResults: totalResults,
+			},
+			Data: dto.ToClosingListDTOs(result),
+		})
+}
+
+func (u *ClosingController) 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.ClosingService.GetOne(c, uint(id))
+	if err != nil {
+		return err
+	}
+
+	return c.Status(fiber.StatusOK).
+		JSON(response.Success{
+			Code:    fiber.StatusOK,
+			Status:  "success",
+			Message: "Get closing successfully",
+			Data:    dto.ToClosingListDTO(*result),
+		})
+}

internal/modules/closings/dto/closing.dto.go

@@ -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 ClosingRelationDTO struct {
+	Id   uint   `json:"id"`
+	Name string `json:"name"`
+}
+
+type ClosingListDTO struct {
+	Id          uint                     `json:"id"`
+	Name        string                   `json:"name"`
+	CreatedUser *userDTO.UserRelationDTO `json:"created_user"`
+	CreatedAt   time.Time                `json:"created_at"`
+	UpdatedAt   time.Time                `json:"updated_at"`
+}
+
+type ClosingDetailDTO struct {
+	ClosingListDTO
+}
+
+// === Mapper Functions ===
+
+func ToClosingRelationDTO(e entity.ProjectFlock) ClosingRelationDTO {
+	return ClosingRelationDTO{
+		Id: e.Id,
+	}
+}
+
+func ToClosingListDTO(e entity.ProjectFlock) ClosingListDTO {
+	var createdUser *userDTO.UserRelationDTO
+	if e.CreatedUser.Id != 0 {
+		mapped := userDTO.ToUserRelationDTO(e.CreatedUser)
+		createdUser = &mapped
+	}
+
+	return ClosingListDTO{
+		Id:          e.Id,
+		CreatedAt:   e.CreatedAt,
+		UpdatedAt:   e.UpdatedAt,
+		CreatedUser: createdUser,
+	}
+}
+
+func ToClosingListDTOs(e []entity.ProjectFlock) []ClosingListDTO {
+	result := make([]ClosingListDTO, len(e))
+	for i, r := range e {
+		result[i] = ToClosingListDTO(r)
+	}
+	return result
+}
+
+func ToClosingDetailDTO(e entity.ProjectFlock) ClosingDetailDTO {
+	return ClosingDetailDTO{
+		ClosingListDTO: ToClosingListDTO(e),
+	}
+}

internal/modules/closings/module.go

@@ -0,0 +1,26 @@
+package closings
+
+import (
+	"github.com/go-playground/validator/v10"
+	"github.com/gofiber/fiber/v2"
+	"gorm.io/gorm"
+
+	rClosing "gitlab.com/mbugroup/lti-api.git/internal/modules/closings/repositories"
+	sClosing "gitlab.com/mbugroup/lti-api.git/internal/modules/closings/services"
+
+	rUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
+	sUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
+)
+
+type ClosingModule struct{}
+
+func (ClosingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *validator.Validate) {
+	closingRepo := rClosing.NewClosingRepository(db)
+	userRepo := rUser.NewUserRepository(db)
+
+	closingService := sClosing.NewClosingService(closingRepo, validate)
+	userService := sUser.NewUserService(userRepo, validate)
+
+	ClosingRoutes(router, userService, closingService)
+}
+

internal/modules/closings/repositories/closing.repository.go

@@ -0,0 +1,21 @@
+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 ClosingRepository interface {
+	repository.BaseRepository[entity.ProjectFlock]
+}
+
+type ClosingRepositoryImpl struct {
+	*repository.BaseRepositoryImpl[entity.ProjectFlock]
+}
+
+func NewClosingRepository(db *gorm.DB) ClosingRepository {
+	return &ClosingRepositoryImpl{
+		BaseRepositoryImpl: repository.NewBaseRepository[entity.ProjectFlock](db),
+	}
+}

internal/modules/closings/route.go

@@ -0,0 +1,25 @@
+package closings
+
+import (
+	// m "gitlab.com/mbugroup/lti-api.git/internal/middleware"
+	controller "gitlab.com/mbugroup/lti-api.git/internal/modules/closings/controllers"
+	closing "gitlab.com/mbugroup/lti-api.git/internal/modules/closings/services"
+	user "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+func ClosingRoutes(v1 fiber.Router, u user.UserService, s closing.ClosingService) {
+	ctrl := controller.NewClosingController(s)
+
+	route := v1.Group("/closings")
+
+	// 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.Get("/:id", ctrl.GetOne)
+}

internal/modules/closings/services/closing.service.go

@@ -0,0 +1,72 @@
+package service
+
+import (
+	"errors"
+
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	repository "gitlab.com/mbugroup/lti-api.git/internal/modules/closings/repositories"
+	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/closings/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 ClosingService interface {
+	GetAll(ctx *fiber.Ctx, params *validation.Query) ([]entity.ProjectFlock, int64, error)
+	GetOne(ctx *fiber.Ctx, id uint) (*entity.ProjectFlock, error)
+}
+
+type closingService struct {
+	Log        *logrus.Logger
+	Validate   *validator.Validate
+	Repository repository.ClosingRepository
+}
+
+func NewClosingService(repo repository.ClosingRepository, validate *validator.Validate) ClosingService {
+	return &closingService{
+		Log:        utils.Log,
+		Validate:   validate,
+		Repository: repo,
+	}
+}
+
+func (s closingService) withRelations(db *gorm.DB) *gorm.DB {
+	return db.Preload("CreatedUser")
+}
+
+func (s closingService) GetAll(c *fiber.Ctx, params *validation.Query) ([]entity.ProjectFlock, int64, error) {
+	if err := s.Validate.Struct(params); err != nil {
+		return nil, 0, err
+	}
+
+	offset := (params.Page - 1) * params.Limit
+
+	closings, 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 closings: %+v", err)
+		return nil, 0, err
+	}
+	return closings, total, nil
+}
+
+func (s closingService) GetOne(c *fiber.Ctx, id uint) (*entity.ProjectFlock, error) {
+	closing, err := s.Repository.GetByID(c.Context(), id, s.withRelations)
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, fiber.NewError(fiber.StatusNotFound, "Closing not found")
+	}
+	if err != nil {
+		s.Log.Errorf("Failed get closing by id: %+v", err)
+		return nil, err
+	}
+	return closing, nil
+}

internal/modules/closings/validations/closing.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"`
+}

internal/modules/inventory/adjustments/dto/adjustment.dto.go

@@ -104,12 +104,12 @@ func ToProductWarehouseDTO(e *entity.ProductWarehouse) *ProductWarehouseDTO {
 
 func ToAdjustmentRelationDTO(e *entity.StockLog) AdjustmentRelationDTO {
 	return AdjustmentRelationDTO{
-		Id:                 e.Id,
-		TransactionType:    e.TransactionType,
-		Quantity:           e.Quantity,
-		BeforeQuantity:     e.BeforeQuantity,
-		AfterQuantity:      e.AfterQuantity,
-		Note:               e.Note,
+		Id: e.Id,
+		// TransactionType: e.LoggableType,
+		// Quantity:           e.Q,
+		// BeforeQuantity:     e.BeforeQuantity,
+		// AfterQuantity:      e.AfterQuantity,
+		Note:               e.Notes,
 		ProductWarehouseId: e.ProductWarehouseId,
 		ProductWarehouse:   ToProductWarehouseDTO(e.ProductWarehouse),
 	}
@@ -136,6 +136,6 @@ func ToAdjustmentListDTO(e *entity.StockLog) AdjustmentListDTO {
 func ToAdjustmentDetailDTO(e *entity.StockLog) AdjustmentDetailDTO {
 	return AdjustmentDetailDTO{
 		AdjustmentListDTO: ToAdjustmentListDTO(e),
-		UpdatedAt:         e.UpdatedAt,
+		// UpdatedAt:         e.UpdatedAt,
 	}
 }

internal/modules/inventory/adjustments/services/adjustment.service.go

@@ -66,7 +66,7 @@ func (s *adjustmentService) GetOne(c *fiber.Ctx, id uint) (*entity.StockLog, err
 		return nil, err
 	}
 
-	if stockLog.LogType != entity.LogTypeAdjustment {
+	if stockLog.LoggableType != entity.LogTypeAdjustment {
 		return nil, fiber.NewError(fiber.StatusNotFound, "Adjustment not found")
 	}
 
@@ -110,7 +110,7 @@ func (s *adjustmentService) Adjustment(c *fiber.Ctx, req *validation.Create) (*e
 			ProductId:   uint(req.ProductID),
 			WarehouseId: uint(req.WarehouseID),
 			Quantity:    0,
-			CreatedBy:   actorID, 
+			// CreatedBy:   1, // TODO: should Get from auth middleware
 		}
 
 		if err := s.ProductWarehouseRepo.CreateOne(ctx, newPW, nil); err != nil {
@@ -128,25 +128,23 @@ func (s *adjustmentService) Adjustment(c *fiber.Ctx, req *validation.Create) (*e
 		}
 
 		afterQuantity := productWarehouse.Quantity
+		newLog := &entity.StockLog{
+			// TransactionType:    transactionType,
+			LoggableType:       entity.LogTypeAdjustment,
+			LoggableId:         0,
+			Notes:              req.Note,
+			ProductWarehouseId: productWarehouse.Id,
+			CreatedBy:          actorID, // TODO: should Get from auth middleware
+		}
 		if transactionType == entity.TransactionTypeIncrease {
 			afterQuantity += req.Quantity
+			newLog.Increase = afterQuantity
 		} else {
 			if productWarehouse.Quantity < req.Quantity {
 				return fiber.NewError(fiber.StatusBadRequest, "Insufficient stock for adjustment")
 			}
 			afterQuantity -= req.Quantity
-		}
-
-		newLog := &entity.StockLog{
-			TransactionType:    transactionType,
-			Quantity:           req.Quantity,
-			BeforeQuantity:     productWarehouse.Quantity,
-			AfterQuantity:      afterQuantity,
-			LogType:            entity.LogTypeAdjustment,
-			LogId:              0,
-			Note:               req.Note,
-			ProductWarehouseId: productWarehouse.Id,
-			CreatedBy:          actorID,
+			newLog.Decrease = afterQuantity
 		}
 
 		if err := s.StockLogsRepository.WithTx(tx).CreateOne(ctx, newLog, nil); err != nil {

internal/modules/inventory/product-stocks/controllers/product-stock.controller.go

@@ -0,0 +1,77 @@
+package controller
+
+import (
+	"math"
+	"strconv"
+
+	"gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-stocks/dto"
+	service "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-stocks/services"
+	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-stocks/validations"
+	"gitlab.com/mbugroup/lti-api.git/internal/response"
+
+	"github.com/gofiber/fiber/v2"
+	// entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+)
+
+type ProductStockController struct {
+	ProductStockService service.ProductStockService
+}
+
+func NewProductStockController(productStockService service.ProductStockService) *ProductStockController {
+	return &ProductStockController{
+		ProductStockService: productStockService,
+	}
+}
+
+func (u *ProductStockController) 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.ProductStockService.GetAll(c, query)
+	if err != nil {
+		return err
+	}
+
+	return c.Status(fiber.StatusOK).
+		JSON(response.SuccessWithPaginate[dto.ProductStockListDTO]{
+			Code:    fiber.StatusOK,
+			Status:  "success",
+			Message: "Get all productStocks successfully",
+			Meta: response.Meta{
+				Page:         query.Page,
+				Limit:        query.Limit,
+				TotalPages:   int64(math.Ceil(float64(totalResults) / float64(query.Limit))),
+				TotalResults: totalResults,
+			},
+			Data: dto.ToProductStockListDTOs(result),
+		})
+}
+
+func (u *ProductStockController) GetOne(c *fiber.Ctx) error {
+	param := c.Params("id")
+
+	id, err := strconv.Atoi(param)
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "Invalid Id")
+	}
+
+	res, err := u.ProductStockService.GetOne(c, uint(id))
+	if err != nil {
+		return err
+	}
+
+	return c.Status(fiber.StatusOK).
+		JSON(response.Success{
+			Code:    fiber.StatusOK,
+			Status:  "success",
+			Message: "Retrieved product successfully",
+			Data:    dto.ToProductStockDetailDTO(*res),
+		})
+}

internal/modules/inventory/product-stocks/dto/product-stock.dto.go

@@ -0,0 +1,224 @@
+package dto
+
+import (
+	"time"
+
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	locationDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/locations/dto"
+	productCategoryDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/product-categories/dto"
+	uomDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/uoms/dto"
+	userDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/users/dto"
+)
+
+// === DTO Structs ===
+
+type ProductStockRelationDTO struct {
+	Id   uint   `json:"id"`
+	Name string `json:"name"`
+}
+
+type ProductStockListDTO struct {
+	Id                uint                                           `json:"id"`
+	Name              string                                         `json:"name"`
+	Brand             string                                         `json:"brand"`
+	Sku               *string                                        `json:"sku,omitempty"`
+	ProductPrice      float64                                        `json:"product_price"`
+	SellingPrice      *float64                                       `json:"selling_price,omitempty"`
+	Tax               *float64                                       `json:"tax,omitempty"`
+	ExpiryPeriod      *int                                           `json:"expiry_period,omitempty"`
+	Flags             []string                                       `json:"flags"`
+	Uom               *uomDTO.UomRelationDTO                         `json:"uom,omitempty"`
+	ProductCategory   *productCategoryDTO.ProductCategoryRelationDTO `json:"product_category,omitempty"`
+	CreatedUser       *userDTO.UserRelationDTO                       `json:"created_user"`
+	CreatedAt         time.Time                                      `json:"created_at"`
+	UpdatedAt         time.Time                                      `json:"updated_at"`
+	Suppliers         []SupplierDTO                                  `json:"suppliers,omitempty"`
+	ProductWarehouses []ProductWarehouseDTO                          `json:"product_warehouses,omitempty"`
+	TotalStock        float64                                        `json:"total_stock"`
+}
+
+type ProductStockDetailDTO struct {
+	ProductStockListDTO
+}
+
+type SupplierDTO struct {
+	Id       uint   `json:"id"`
+	Name     string `json:"name"`
+	Alias    string `json:"alias"`
+	Category string `json:"category"`
+}
+
+type ProductWarehouseDTO struct {
+	Id            uint                             `json:"id"`
+	ProductId     uint                             `json:"product_id"`
+	WarehouseId   uint                             `json:"warehouse_id"`
+	WarehouseName string                           `json:"warehouse_name"`
+	Location      *locationDTO.LocationRelationDTO `json:"location"`
+	CurrentStock  float64                          `json:"current_stock"`
+	StockLogs     []StockLogDetailDTO              `json:"stock_logs"`
+}
+
+type StockLogDetailDTO struct {
+	Id                 uint                     `json:"id"`
+	Increase           float64                  `json:"increase"`
+	Decrease           float64                  `json:"decrease"`
+	LoggableType       string                   `json:"loggable_type"`
+	LoggableId         uint                     `json:"loggable_id"`
+	Notes              *string                  `json:"notes"`
+	ProductWarehouseId uint                     `json:"product_warehouse_id"`
+	CreatedBy          uint                     `json:"created_by"`
+	CreatedUser        *userDTO.UserRelationDTO `json:"created_user,omitempty"`
+	CreatedAt          time.Time                `json:"created_at"`
+}
+
+// === Mapper Functions ===
+func ToProductStockListDTO(e entity.Product) ProductStockListDTO {
+	var createdUser *userDTO.UserRelationDTO
+	if e.CreatedUser.Id != 0 {
+		mapped := userDTO.ToUserRelationDTO(e.CreatedUser)
+		createdUser = &mapped
+	}
+
+	var categoryRef *productCategoryDTO.ProductCategoryRelationDTO
+	if e.ProductCategory.Id != 0 {
+		mapped := productCategoryDTO.ToProductCategoryRelationDTO(e.ProductCategory)
+		categoryRef = &mapped
+	}
+
+	flags := make([]string, len(e.Flags))
+	for i, f := range e.Flags {
+		flags[i] = f.Name
+	}
+
+	var uomRef *uomDTO.UomRelationDTO
+	if e.Uom.Id != 0 {
+		mapped := uomDTO.ToUomRelationDTO(e.Uom)
+		uomRef = &mapped
+	}
+
+	return ProductStockListDTO{
+		Id:              e.Id,
+		Name:            e.Name,
+		Flags:           flags,
+		Uom:             uomRef,
+		Brand:           e.Brand,
+		Sku:             e.Sku,
+		ProductPrice:    e.ProductPrice,
+		SellingPrice:    e.SellingPrice,
+		Tax:             e.Tax,
+		ExpiryPeriod:    e.ExpiryPeriod,
+		CreatedAt:       e.CreatedAt,
+		UpdatedAt:       e.UpdatedAt,
+		CreatedUser:     createdUser,
+		ProductCategory: categoryRef,
+		Suppliers:       mapSupplierDTOs(e.ProductSuppliers),
+		TotalStock:      calculateTotalStock(e.ProductWarehouses),
+	}
+}
+
+func ToProductStockListDTOs(e []entity.Product) []ProductStockListDTO {
+	result := make([]ProductStockListDTO, len(e))
+	for i, r := range e {
+		result[i] = ToProductStockListDTO(r)
+	}
+	return result
+}
+
+func ToProductStockDetailDTO(e entity.Product) ProductStockDetailDTO {
+	base := ToProductStockListDTO(e)
+	base.ProductWarehouses = mapProductWarehouseDTOs(e.ProductWarehouses)
+
+	return ProductStockDetailDTO{
+		ProductStockListDTO: base,
+	}
+}
+
+// --- helpers ---
+
+func mapSupplierDTOs(src []entity.ProductSupplier) []SupplierDTO {
+	if len(src) == 0 {
+		return nil
+	}
+	result := make([]SupplierDTO, 0, len(src))
+	for _, ps := range src {
+		if ps.Supplier.Id == 0 {
+			continue
+		}
+		result = append(result, SupplierDTO{
+			Id:       ps.Supplier.Id,
+			Name:     ps.Supplier.Name,
+			Alias:    ps.Supplier.Alias,
+			Category: ps.Supplier.Category,
+		})
+	}
+	return result
+}
+
+func mapProductWarehouseDTOs(src []entity.ProductWarehouse) []ProductWarehouseDTO {
+	if len(src) == 0 {
+		return []ProductWarehouseDTO{}
+	}
+	result := make([]ProductWarehouseDTO, 0, len(src))
+	for _, pw := range src {
+		dto := ProductWarehouseDTO{
+			Id:           pw.Id,
+			ProductId:    pw.ProductId,
+			WarehouseId:  pw.WarehouseId,
+			CurrentStock: pw.Quantity,
+			StockLogs:    mapStockLogs(pw.StockLogs),
+		}
+		if pw.Warehouse.Id != 0 {
+			dto.WarehouseName = pw.Warehouse.Name
+			if pw.Warehouse.Location != nil {
+				mapped := locationDTO.ToLocationRelationDTO(*pw.Warehouse.Location)
+				dto.Location = &mapped
+			}
+		}
+		result = append(result, dto)
+	}
+	return result
+}
+
+func mapStockLogs(src []entity.StockLog) []StockLogDetailDTO {
+	if len(src) == 0 {
+		return []StockLogDetailDTO{}
+	}
+	result := make([]StockLogDetailDTO, 0, len(src))
+	for _, log := range src {
+		var notes *string
+		if log.Notes != "" {
+			n := log.Notes
+			notes = &n
+		}
+
+		result = append(result, StockLogDetailDTO{
+			Id:                 log.Id,
+			Increase:           log.Increase,
+			Decrease:           log.Decrease,
+			LoggableType:       log.LoggableType,
+			LoggableId:         log.LoggableId,
+			Notes:              notes,
+			ProductWarehouseId: log.ProductWarehouseId,
+			CreatedBy:          log.CreatedBy,
+			CreatedUser:        mapCreatedUser(log.CreatedUser),
+			CreatedAt:          log.CreatedAt,
+		})
+	}
+	return result
+}
+
+func mapCreatedUser(user *entity.User) *userDTO.UserRelationDTO {
+	if user == nil || user.Id == 0 {
+		return nil
+	}
+	mapped := userDTO.ToUserRelationDTO(*user)
+	return &mapped
+}
+
+func calculateTotalStock(productWarehouses []entity.ProductWarehouse) float64 {
+	var total float64
+	for _, pw := range productWarehouses {
+		total += pw.Quantity
+	}
+	return total
+}

internal/modules/inventory/product-stocks/module.go

@@ -0,0 +1,25 @@
+package productStocks
+
+import (
+	"github.com/go-playground/validator/v10"
+	"github.com/gofiber/fiber/v2"
+	"gorm.io/gorm"
+
+	sProductStock "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-stocks/services"
+
+	rProduct "gitlab.com/mbugroup/lti-api.git/internal/modules/master/products/repositories"
+	rUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
+	sUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
+)
+
+type ProductStockModule struct{}
+
+func (ProductStockModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *validator.Validate) {
+	productRepo := rProduct.NewProductRepository(db)
+	userRepo := rUser.NewUserRepository(db)
+
+	productStockService := sProductStock.NewProductStockService(productRepo, validate)
+	userService := sUser.NewUserService(userRepo, validate)
+
+	ProductStockRoutes(router, userService, productStockService)
+}

internal/modules/inventory/product-stocks/repositories/product-stock.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 ProductStockRepository interface {
+// 	repository.BaseRepository[entity.ProductStock]
+// }
+
+// type ProductStockRepositoryImpl struct {
+// 	*repository.BaseRepositoryImpl[entity.ProductStock]
+// }
+
+// func NewProductStockRepository(db *gorm.DB) ProductStockRepository {
+// 	return &ProductStockRepositoryImpl{
+// 		BaseRepositoryImpl: repository.NewBaseRepository[entity.ProductStock](db),
+// 	}
+// }

internal/modules/inventory/product-stocks/route.go

@@ -0,0 +1,25 @@
+package productStocks
+
+import (
+	// m "gitlab.com/mbugroup/lti-api.git/internal/middleware"
+	controller "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-stocks/controllers"
+	productStock "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-stocks/services"
+	user "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+func ProductStockRoutes(v1 fiber.Router, u user.UserService, s productStock.ProductStockService) {
+	ctrl := controller.NewProductStockController(s)
+
+	route := v1.Group("/product-stocks")
+
+	// 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.Get("/:id", ctrl.GetOne)
+}

internal/modules/inventory/product-stocks/services/product-stock.service.go

@@ -0,0 +1,91 @@
+package service
+
+import (
+	"errors"
+
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-stocks/validations"
+	productRepository "gitlab.com/mbugroup/lti-api.git/internal/modules/master/products/repositories"
+	"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 ProductStockService interface {
+	GetAll(ctx *fiber.Ctx, params *validation.Query) ([]entity.Product, int64, error)
+	GetOne(ctx *fiber.Ctx, id uint) (*entity.Product, error)
+}
+
+type productStockService struct {
+	Log               *logrus.Logger
+	Validate          *validator.Validate
+	ProductRepository productRepository.ProductRepository
+}
+
+func NewProductStockService(
+	productRepo productRepository.ProductRepository,
+	validate *validator.Validate,
+) ProductStockService {
+	return &productStockService{
+		Log:               utils.Log,
+		Validate:          validate,
+		ProductRepository: productRepo,
+	}
+}
+
+func (s productStockService) withRelations(db *gorm.DB) *gorm.DB {
+	return db.
+		Preload("CreatedUser").
+		Preload("Uom").
+		Preload("ProductCategory").
+		Preload("Flags").
+		Preload("ProductWarehouses").
+		Preload("ProductWarehouses.Warehouse").
+		Preload("ProductWarehouses.Warehouse.Location").
+		Preload("ProductWarehouses.Warehouse.Location.Area").
+		Preload("ProductWarehouses.StockLogs", func(db *gorm.DB) *gorm.DB {
+			return db.Order("created_at ASC")
+		}).
+		Preload("ProductWarehouses.StockLogs.CreatedUser").
+		Preload("ProductSuppliers").
+		Preload("ProductSuppliers.Supplier", func(db *gorm.DB) *gorm.DB {
+			return db.Order("suppliers.name ASC")
+		})
+}
+
+func (s productStockService) GetAll(c *fiber.Ctx, params *validation.Query) ([]entity.Product, int64, error) {
+	if err := s.Validate.Struct(params); err != nil {
+		return nil, 0, err
+	}
+
+	offset := (params.Page - 1) * params.Limit
+
+	productStocks, total, err := s.ProductRepository.GetAll(c.Context(), offset, params.Limit, func(db *gorm.DB) *gorm.DB {
+		db = s.withRelations(db)
+		if params.Search != "" {
+			return db.Where("name ILIKE ?", "%"+params.Search+"%")
+		}
+		return db.Order("created_at DESC").Order("updated_at DESC")
+	})
+
+	if err != nil {
+		s.Log.Errorf("Failed to get productStocks: %+v", err)
+		return nil, 0, err
+	}
+	return productStocks, total, nil
+}
+
+func (s productStockService) GetOne(c *fiber.Ctx, id uint) (*entity.Product, error) {
+	product, err := s.ProductRepository.GetByID(c.Context(), id, s.withRelations)
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, fiber.NewError(fiber.StatusNotFound, "Product not found")
+	}
+	if err != nil {
+		s.Log.Errorf("Failed get product by id: %+v", err)
+		return nil, err
+	}
+	return product, nil
+}

internal/modules/inventory/product-stocks/validations/product-stock.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"`
+}

internal/modules/inventory/product-warehouses/dto/product_warehouse.dto.go

@@ -98,8 +98,8 @@ func ToProductWarehouseNestedDTO(e entity.ProductWarehouse) ProductWarehousNeste
 func ToProductWarehouseListDTO(e entity.ProductWarehouse) ProductWarehouseListDTO {
 	dto := ProductWarehouseListDTO{
 		ProductWarehouseRelationDTO: ToProductWarehouseRelationDTO(e),
-		CreatedAt:                   e.CreatedAt,
-		UpdatedAt:                   e.UpdatedAt,
+		// CreatedAt:                   e.CreatedAt,
+		// UpdatedAt:                   e.UpdatedAt,
 	}
 
 	// Map Product relation jika ada
@@ -140,13 +140,13 @@ func ToProductWarehouseListDTO(e entity.ProductWarehouse) ProductWarehouseListDT
 	}
 
 	// Map CreatedUser relation jika ada
-	if e.CreatedUser.Id != 0 {
-		user := UserRelationDTO{
-			Id:       e.CreatedUser.Id,
-			Username: e.CreatedUser.Name,
-		}
-		dto.CreatedUser = &user
-	}
+	// if e.CreatedUser.Id != 0 {
+	// 	user := UserRelationDTO{
+	// 		Id:       e.CreatedUser.Id,
+	// 		Username: e.CreatedUser.Name,
+	// 	}
+	// 	dto.CreatedUser = &user
+	// }
 
 	return dto
 }

internal/modules/inventory/product-warehouses/repositories/product_warehouse.repository.go

@@ -213,11 +213,11 @@ func (r *ProductWarehouseRepositoryImpl) EnsureProductWarehouse(
 		ProductId:   productID,
 		WarehouseId: warehouseID,
 		Quantity:    0,
-		CreatedBy:   uint(createdBy),
-	}
-	if entity.CreatedBy == 0 {
-		entity.CreatedBy = 1
+		// CreatedBy:   uint(createdBy),
 	}
+	// if entity.CreatedBy == 0 {
+	// 	entity.CreatedBy = 1
+	// }
 
 	if err := r.CreateOne(ctx, entity, nil); err != nil {
 		return 0, err

internal/modules/inventory/route.go

@@ -8,6 +8,7 @@ import (
 	"gorm.io/gorm"
 
 	adjustments "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/adjustments"
+	productStocks "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-stocks"
 	productWarehouses "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses"
 	transfers "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/transfers"
 	// MODULE IMPORTS
@@ -21,6 +22,7 @@ func RegisterRoutes(router fiber.Router, db *gorm.DB, validate *validator.Valida
 
 		adjustments.AdjustmentModule{},
 		transfers.TransferModule{},
+		productStocks.ProductStockModule{},
 		// MODULE REGISTRY
 	}
 

internal/modules/inventory/transfers/services/transfer.service.go

@@ -271,15 +271,18 @@ func (s *transferService) CreateOne(c *fiber.Ctx, req *validation.TransferReques
 			s.Log.Infof("Source product warehouse updated: %+v", sourcePW.Id)
 
 			// create stock log for decrease (source)
-			beforeQty := sourcePW.Quantity + product.ProductQty // sourcePW already decreased
+			// beforeQty := sourcePW.Quantity + product.ProductQty // sourcePW already decreased
 			decreaseLog := &entity.StockLog{
-				TransactionType:    entity.TransactionTypeDecrease,
-				Quantity:           product.ProductQty,
-				BeforeQuantity:     beforeQty,
-				AfterQuantity:      sourcePW.Quantity,
-				LogType:            entity.LogTypeTransfer,
-				LogId:              uint(entityTransfer.Id),
-				Note:               "",
+				// TransactionType:    entity.TransactionTypeDecrease,
+				// Quantity:           product.ProductQty,
+				// BeforeQuantity:     beforeQty,
+				// AfterQuantity:      sourcePW.Qty,
+				// LogType:            entity.LogTypeTransfer,
+				// LogId:              uint(entityTransfer.Id),
+				Decrease:           product.ProductQty,
+				Notes:              "",
+				LoggableType:       entity.LogTypeTransfer,
+				LoggableId:         uint(entityTransfer.Id),
 				ProductWarehouseId: sourcePW.Id,
 				CreatedBy:          actorID,
 			}
@@ -302,7 +305,7 @@ func (s *transferService) CreateOne(c *fiber.Ctx, req *validation.TransferReques
 					ProductId:   uint(product.ProductID),
 					WarehouseId: uint(req.DestinationWarehouseID),
 					Quantity:    0,
-					CreatedBy:   actorID,
+					// CreatedBy:   1, // TODO: should Get from auth middleware
 				}
 				if err := s.ProductWarehouseRepo.WithTx(tx).CreateOne(c.Context(), destPW, nil); err != nil {
 					s.Log.Errorf("Failed to create destination product warehouse: %+v", err)
@@ -319,15 +322,16 @@ func (s *transferService) CreateOne(c *fiber.Ctx, req *validation.TransferReques
 			s.Log.Infof("Destination product warehouse updated: %+v", destPW.Id)
 
 			// create stock log for increase (destination)
-			beforeDestQty := destPW.Quantity - product.ProductQty
+			// beforeDestQty := destPW.Quantity - product.ProductQty
 			increaseLog := &entity.StockLog{
-				TransactionType:    entity.TransactionTypeIncrease,
-				Quantity:           product.ProductQty,
-				BeforeQuantity:     beforeDestQty,
-				AfterQuantity:      destPW.Quantity,
-				LogType:            entity.LogTypeTransfer,
-				LogId:              uint(entityTransfer.Id),
-				Note:               "",
+				// TransactionType:    entity.TransactionTypeIncrease,
+				// Quantity:           product.ProductQty,
+				// BeforeQuantity:     beforeDestQty,
+				// AfterQuantity:      destPW.Qty,
+				Increase:           product.ProductQty,
+				LoggableType:       entity.LogTypeTransfer,
+				LoggableId:         uint(entityTransfer.Id),
+				Notes:              "",
 				ProductWarehouseId: destPW.Id,
 				CreatedBy:          actorID,
 			}

internal/modules/marketing/sales-orders/services/sales-orders.service.go

@@ -344,7 +344,6 @@ func (s salesOrdersService) UpdateOne(c *fiber.Ctx, req *validation.Update, id u
 					return fiber.NewError(fiber.StatusInternalServerError, "Failed to create update approval")
 				}
 			}
-
 		}
 
 		return nil

internal/modules/production/chickins/services/chickin.service.go

@@ -557,7 +557,7 @@ func (s *chickinService) getOrCreateProductWarehouse(ctx *fiber.Ctx, warehouseId
 		ProductId:   product.Id,
 		WarehouseId: warehouseId,
 		Quantity:    0,
-		CreatedBy:   actorID,
+		// CreatedBy:   actorID,
 	}
 
 	if err := s.ProductWarehouseRepo.WithTx(dbTransaction).CreateOne(ctx.Context(), newPW, nil); err != nil {

internal/modules/production/recordings/module.go

@@ -2,6 +2,7 @@ package recordings
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/go-playground/validator/v10"
 	"github.com/gofiber/fiber/v2"
@@ -14,6 +15,7 @@ import (
 	rRecording "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/repositories"
 	sRecording "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/services"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
 
 	rUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
 	sUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
@@ -26,6 +28,25 @@ func (RecordingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 	projectFlockKandangRepo := rProjectFlock.NewProjectFlockKandangRepository(db)
 	projectFlockPopulationRepo := rProjectFlock.NewProjectFlockPopulationRepository(db)
 	productWarehouseRepo := rProductWarehouse.NewProductWarehouseRepository(db)
+	stockAllocationRepo := commonRepo.NewStockAllocationRepository(db)
+
+	fifoService := commonSvc.NewFifoService(db, stockAllocationRepo, productWarehouseRepo, utils.Log)
+	if err := fifoService.RegisterUsable(fifo.UsableConfig{
+		Key:   fifo.UsableKeyRecordingStock,
+		Table: "recording_stocks",
+		Columns: fifo.UsableColumns{
+			ID:                 "id",
+			ProductWarehouseID: "product_warehouse_id",
+			UsageQuantity:      "usage_qty",
+			PendingQuantity:    "pending_qty",
+			CreatedAt:          "created_at",
+		},
+	}); err != nil {
+		if !strings.Contains(strings.ToLower(err.Error()), "already registered") {
+			panic(fmt.Sprintf("failed to register recording usable workflow: %v", err))
+		}
+	}
+
 	approvalRepo := commonRepo.NewApprovalRepository(db)
 	approvalService := commonSvc.NewApprovalService(approvalRepo)
 	if err := approvalService.RegisterWorkflowSteps(utils.ApprovalWorkflowRecording, utils.RecordingApprovalSteps); err != nil {
@@ -41,6 +62,7 @@ func (RecordingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		projectFlockPopulationRepo,
 		approvalRepo,
 		approvalService,
+		fifoService,
 		validate,
 	)
 	userService := sUser.NewUserService(userRepo, validate)

internal/modules/production/recordings/repositories/recording.repository.go

@@ -25,6 +25,7 @@ type RecordingRepository interface {
 	CreateStocks(tx *gorm.DB, stocks []entity.RecordingStock) error
 	DeleteStocks(tx *gorm.DB, recordingID uint) error
 	ListStocks(tx *gorm.DB, recordingID uint) ([]entity.RecordingStock, error)
+	UpdateStockUsage(tx *gorm.DB, stockID uint, usageQty, pendingQty float64) error
 
 	CreateDepletions(tx *gorm.DB, depletions []entity.RecordingDepletion) error
 	DeleteDepletions(tx *gorm.DB, recordingID uint) error
@@ -120,6 +121,15 @@ func (r *RecordingRepositoryImpl) ListStocks(tx *gorm.DB, recordingID uint) ([]e
 	return items, nil
 }
 
+func (r *RecordingRepositoryImpl) UpdateStockUsage(tx *gorm.DB, stockID uint, usageQty, pendingQty float64) error {
+	return tx.Model(&entity.RecordingStock{}).
+		Where("id = ?", stockID).
+		Updates(map[string]any{
+			"usage_qty":   usageQty,
+			"pending_qty": pendingQty,
+		}).Error
+}
+
 func (r *RecordingRepositoryImpl) CreateDepletions(tx *gorm.DB, depletions []entity.RecordingDepletion) error {
 	if len(depletions) == 0 {
 		return nil

internal/modules/production/recordings/services/recording.service.go

@@ -14,6 +14,7 @@ import (
 	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/validations"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
 	approvalutils "gitlab.com/mbugroup/lti-api.git/internal/utils/approvals"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
 	recordingutil "gitlab.com/mbugroup/lti-api.git/internal/utils/recording"
 	"math"
 	"strings"
@@ -36,6 +37,13 @@ type RecordingService interface {
 	Approval(ctx *fiber.Ctx, req *validation.Approve) ([]entity.Recording, error)
 }
 
+type RecordingFIFOIntegrationService interface {
+	ConsumeRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock) error
+	ReleaseRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock) error
+}
+
+var recordingStockUsableKey = fifo.UsableKeyRecordingStock
+
 type recordingService struct {
 	Log                        *logrus.Logger
 	Validate                   *validator.Validate
@@ -45,6 +53,7 @@ type recordingService struct {
 	ProjectFlockPopulationRepo rProjectFlock.ProjectFlockPopulationRepository
 	ApprovalRepo               commonRepo.ApprovalRepository
 	ApprovalSvc                commonSvc.ApprovalService
+	FifoSvc                    commonSvc.FifoService
 }
 
 func NewRecordingService(
@@ -54,6 +63,7 @@ func NewRecordingService(
 	projectFlockPopulationRepo rProjectFlock.ProjectFlockPopulationRepository,
 	approvalRepo commonRepo.ApprovalRepository,
 	approvalSvc commonSvc.ApprovalService,
+	fifoSvc commonSvc.FifoService,
 	validate *validator.Validate,
 ) RecordingService {
 	return &recordingService{
@@ -65,6 +75,20 @@ func NewRecordingService(
 		ProjectFlockPopulationRepo: projectFlockPopulationRepo,
 		ApprovalRepo:               approvalRepo,
 		ApprovalSvc:                approvalSvc,
+		FifoSvc:                    fifoSvc,
+	}
+}
+
+func NewRecordingFIFOIntegrationService(
+	repo repository.RecordingRepository,
+	productWarehouseRepo rProductWarehouse.ProductWarehouseRepository,
+	fifoSvc commonSvc.FifoService,
+) RecordingFIFOIntegrationService {
+	return &recordingService{
+		Log:                  utils.Log,
+		Repository:           repo,
+		ProductWarehouseRepo: productWarehouseRepo,
+		FifoSvc:              fifoSvc,
 	}
 }
 
@@ -222,6 +246,10 @@ func (s *recordingService) CreateOne(c *fiber.Ctx, req *validation.Create) (*ent
 			return err
 		}
 
+		if err := s.consumeRecordingStocks(ctx, tx, mappedStocks); err != nil {
+			return err
+		}
+
 		mappedDepletions := recordingutil.MapDepletions(createdRecording.Id, req.Depletions)
 		if err := s.Repository.CreateDepletions(tx, mappedDepletions); err != nil {
 			s.Log.Errorf("Failed to persist depletions: %+v", err)
@@ -234,7 +262,7 @@ func (s *recordingService) CreateOne(c *fiber.Ctx, req *validation.Create) (*ent
 			return err
 		}
 
-		if err := s.adjustProductWarehouseQuantities(ctx, tx, buildWarehouseDeltas(nil, mappedDepletions, nil, mappedStocks, nil, mappedEggs)); err != nil {
+		if err := s.adjustProductWarehouseQuantities(ctx, tx, buildWarehouseDeltas(nil, mappedDepletions, nil, nil, nil, mappedEggs)); err != nil {
 			s.Log.Errorf("Failed to adjust product warehouses: %+v", err)
 			return err
 		}
@@ -347,6 +375,10 @@ func (s recordingService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uin
 				return err
 			}
 
+			if err := s.releaseRecordingStocks(ctx, tx, existingStocks); err != nil {
+				return err
+			}
+
 			if err := s.Repository.DeleteStocks(tx, recordingEntity.Id); err != nil {
 				s.Log.Errorf("Failed to clear stocks: %+v", err)
 				return err
@@ -358,8 +390,7 @@ func (s recordingService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uin
 				return err
 			}
 
-			if err := s.adjustProductWarehouseQuantities(ctx, tx, buildWarehouseDeltas(nil, nil, existingStocks, mappedStocks, nil, nil)); err != nil {
-				s.Log.Errorf("Failed to adjust product warehouses for stocks: %+v", err)
+			if err := s.consumeRecordingStocks(ctx, tx, mappedStocks); err != nil {
 				return err
 			}
 		}
@@ -691,7 +722,11 @@ func (s recordingService) DeleteOne(c *fiber.Ctx, id uint) error {
 			return err
 		}
 
-		if err := s.adjustProductWarehouseQuantities(ctx, tx, buildWarehouseDeltas(oldDepletions, nil, oldStocks, nil, oldEggs, nil)); err != nil {
+		if err := s.releaseRecordingStocks(ctx, tx, oldStocks); err != nil {
+			return err
+		}
+
+		if err := s.adjustProductWarehouseQuantities(ctx, tx, buildWarehouseDeltas(oldDepletions, nil, nil, nil, oldEggs, nil)); err != nil {
 			return err
 		}
 
@@ -746,6 +781,77 @@ func (s *recordingService) ensureProductWarehousesExist(c *fiber.Ctx, stocks []v
 	return nil
 }
 
+func (s *recordingService) consumeRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock) error {
+	if len(stocks) == 0 || s.FifoSvc == nil {
+		return nil
+	}
+
+	for _, stock := range stocks {
+		if stock.Id == 0 {
+			continue
+		}
+
+		var desired float64
+		if stock.UsageQty != nil {
+			desired = *stock.UsageQty
+		}
+
+		result, err := s.FifoSvc.Consume(ctx, commonSvc.StockConsumeRequest{
+			UsableKey:          recordingStockUsableKey,
+			UsableID:           stock.Id,
+			ProductWarehouseID: stock.ProductWarehouseId,
+			Quantity:           desired,
+			AllowPending:       true,
+			Tx:                 tx,
+		})
+		if err != nil {
+			s.Log.Errorf("Failed to consume FIFO stock for recording stock %d: %+v", stock.Id, err)
+			return err
+		}
+
+		if err := s.Repository.UpdateStockUsage(tx, stock.Id, result.UsageQuantity, result.PendingQuantity); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (s *recordingService) ConsumeRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock) error {
+	return s.consumeRecordingStocks(ctx, tx, stocks)
+}
+
+func (s *recordingService) releaseRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock) error {
+	if len(stocks) == 0 || s.FifoSvc == nil {
+		return nil
+	}
+
+	for _, stock := range stocks {
+		if stock.Id == 0 {
+			continue
+		}
+
+		if err := s.FifoSvc.ReleaseUsage(ctx, commonSvc.StockReleaseRequest{
+			UsableKey: recordingStockUsableKey,
+			UsableID:  stock.Id,
+			Tx:        tx,
+		}); err != nil {
+			s.Log.Errorf("Failed to release FIFO stock for recording stock %d: %+v", stock.Id, err)
+			return err
+		}
+
+		if err := s.Repository.UpdateStockUsage(tx, stock.Id, 0, 0); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (s *recordingService) ReleaseRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock) error {
+	return s.releaseRecordingStocks(ctx, tx, stocks)
+}
+
 func buildWarehouseDeltas(
 	oldDepletions, newDepletions []entity.RecordingDepletion,
 	oldStocks, newStocks []entity.RecordingStock,
@@ -758,12 +864,6 @@ func buildWarehouseDeltas(
 	for _, item := range newDepletions {
 		accumulateWarehouseDelta(deltas, item.ProductWarehouseId, item.Qty)
 	}
-	for _, item := range oldStocks {
-		accumulateWarehouseDelta(deltas, item.ProductWarehouseId, usageQtyValue(item.UsageQty))
-	}
-	for _, item := range newStocks {
-		accumulateWarehouseDelta(deltas, item.ProductWarehouseId, -usageQtyValue(item.UsageQty))
-	}
 	for _, item := range oldEggs {
 		accumulateWarehouseDelta(deltas, item.ProductWarehouseId, -float64(item.Qty))
 	}
@@ -773,13 +873,6 @@ func buildWarehouseDeltas(
 	return deltas
 }
 
-func usageQtyValue(val *float64) float64 {
-	if val == nil {
-		return 0
-	}
-	return *val
-}
-
 func accumulateWarehouseDelta(deltas map[uint]float64, id uint, value float64) {
 	if id == 0 || value == 0 {
 		return

internal/modules/production/transfer_layings/services/transfer_laying.service.go

@@ -778,7 +778,7 @@ func (s *transferLayingService) getOrCreateProductWarehouse(ctx context.Context,
 		ProductId:   productID,
 		WarehouseId: warehouseID,
 		Quantity:    quantity,
-		CreatedBy:   actorID,
+		// CreatedBy:   actorID,
 	}
 
 	if err := productWarehouseRepoTx.CreateOne(ctx, newWarehouse, nil); err != nil {