feat(BE): fix fifo system recording and uniformity dto

internal/common/repository/common.base.repository.go

@@ -187,10 +187,11 @@ func (r *BaseRepositoryImpl[T]) PatchOne(
 	updates map[string]any,
 	modifier func(*gorm.DB) *gorm.DB,
 ) error {
-	q := r.db.WithContext(ctx).Model(new(T)).Where("id = ?", id)
+	q := r.db.WithContext(ctx)
 	if modifier != nil {
 		q = modifier(q)
 	}
+	q = q.Model(new(T)).Where("id = ?", id)
 
 	result := q.Updates(updates)
 	if result.Error != nil {

internal/common/service/common.fifo.service.go

@@ -715,7 +715,7 @@ func (s *fifoService) releaseUsagePortion(
 			}
 		} else {
 			if err := s.allocations.PatchOne(ctx, allocation.Id, map[string]any{
-				"quantity": allocation.Qty - releaseAmt,
+				"qty": allocation.Qty - releaseAmt,
 			}, func(db *gorm.DB) *gorm.DB {
 				return s.txOrDB(tx, db)
 			}); err != nil {

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

@@ -229,7 +229,13 @@ func (s *recordingService) CreateOne(c *fiber.Ctx, req *validation.Create) (*ent
 			CreatedBy:             actorID,
 		}
 
-		if err := s.Repository.CreateOne(ctx, &createdRecording, func(*gorm.DB) *gorm.DB { return tx }); err != nil {
+		createTx := tx.WithContext(ctx).Select(
+			"ProjectFlockKandangId",
+			"RecordDatetime",
+			"Day",
+			"CreatedBy",
+		)
+		if err := createTx.Create(&createdRecording).Error; err != nil {
 			if errors.Is(err, gorm.ErrDuplicatedKey) {
 				return fiber.NewError(
 					fiber.StatusBadRequest,
@@ -299,9 +305,11 @@ func (s recordingService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uin
 	ctx := c.Context()
 
 	var recordingEntity *entity.Recording
+	var updatedRecording *entity.Recording
 	transactionErr := s.Repository.DB().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		recording, err := s.Repository.GetByID(ctx, id, func(db *gorm.DB) *gorm.DB {
-			return s.Repository.WithRelations(tx)
+		repoTx := s.Repository.WithTx(tx)
+		recording, err := repoTx.GetByID(ctx, id, func(db *gorm.DB) *gorm.DB {
+			return s.Repository.WithRelations(db)
 		})
 		if err != nil {
 			if errors.Is(err, gorm.ErrRecordNotFound) {
@@ -470,13 +478,31 @@ func (s recordingService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uin
 			}
 		}
 
+		updated, err := repoTx.GetByID(ctx, recordingEntity.Id, func(db *gorm.DB) *gorm.DB {
+			return s.Repository.WithRelations(db)
+		})
+		if err != nil {
+			s.Log.Errorf("Failed to reload recording %d after update: %+v", recordingEntity.Id, err)
+			return err
+		}
+		updatedRecording = updated
+
 		return nil
 	})
 	if transactionErr != nil {
 		return nil, transactionErr
 	}
 
-	return s.GetOne(c, id)
+	if updatedRecording == nil {
+		return s.GetOne(c, id)
+	}
+	if err := s.attachLatestApproval(ctx, updatedRecording); err != nil {
+		return nil, err
+	}
+	if err := s.attachProductionStandard(ctx, updatedRecording); err != nil {
+		return nil, err
+	}
+	return updatedRecording, nil
 }
 
 func (s recordingService) Approval(c *fiber.Ctx, req *validation.Approve) ([]entity.Recording, error) {

internal/modules/production/uniformities/controllers/uniformity.controller.go

@@ -93,6 +93,10 @@ func (u *UniformityController) GetOne(c *fiber.Ctx) error {
 			Uniformity:       result.Uniformity,
 			Cv:               result.Cv,
 		}
+		document, documentURL, err = u.UniformityService.GetDocumentInfo(c, id)
+		if err != nil {
+			return err
+		}
 	}
 
 	standard, err := u.UniformityService.GetStandard(c, result)

internal/modules/production/uniformities/services/uniformity.service.go

@@ -39,6 +39,7 @@ type UniformityService interface {
 	Approval(ctx *fiber.Ctx, req *validation.Approve) ([]entity.ProjectFlockKandangUniformity, error)
 	ParseBodyWeightExcel(ctx *fiber.Ctx, file *multipart.FileHeader) ([]BodyWeightExcelRow, error)
 	ComputeUniformity(rows []BodyWeightExcelRow) (UniformityCalculation, error)
+	GetDocumentInfo(ctx *fiber.Ctx, uniformityID uint) (*entity.Document, string, error)
 	CalculateUniformityFromDocument(ctx *fiber.Ctx, uniformityID uint) (UniformityCalculation, *entity.Document, string, error)
 }
 
@@ -592,28 +593,19 @@ func (s uniformityService) ComputeUniformity(rows []BodyWeightExcelRow) (Uniform
 	return computeUniformity(rows)
 }
 
+func (s uniformityService) GetDocumentInfo(c *fiber.Ctx, uniformityID uint) (*entity.Document, string, error) {
+	return s.fetchUniformityDocument(c.Context(), uniformityID, true)
+}
+
 func (s uniformityService) CalculateUniformityFromDocument(c *fiber.Ctx, uniformityID uint) (UniformityCalculation, *entity.Document, string, error) {
-	if s.DocumentSvc == nil {
-		return UniformityCalculation{}, nil, "", fiber.NewError(fiber.StatusInternalServerError, "Document service not available")
-	}
-
-	documents, err := s.DocumentSvc.ListByTarget(c.Context(), "UNIFORMITY", uint64(uniformityID))
+	document, url, err := s.fetchUniformityDocument(c.Context(), uniformityID, false)
 	if err != nil {
 		return UniformityCalculation{}, nil, "", err
 	}
-	if len(documents) == 0 {
+	if document == nil || url == "" {
 		return UniformityCalculation{}, nil, "", fiber.NewError(fiber.StatusNotFound, "Uniformity document not found")
 	}
 
-	document := documents[0]
-	url, err := s.DocumentSvc.PresignURL(c.Context(), document, 15*time.Minute)
-	if err != nil {
-		return UniformityCalculation{}, nil, "", err
-	}
-	if url == "" {
-		return UniformityCalculation{}, nil, "", fiber.NewError(fiber.StatusBadRequest, "Uniformity document URL not available")
-	}
-
 	req, err := http.NewRequestWithContext(c.Context(), http.MethodGet, url, nil)
 	if err != nil {
 		return UniformityCalculation{}, nil, "", err
@@ -638,7 +630,35 @@ func (s uniformityService) CalculateUniformityFromDocument(c *fiber.Ctx, uniform
 		return UniformityCalculation{}, nil, "", err
 	}
 
-	return calculation, &document, url, nil
+	return calculation, document, url, nil
+}
+
+func (s uniformityService) fetchUniformityDocument(ctx context.Context, uniformityID uint, allowMissing bool) (*entity.Document, string, error) {
+	if s.DocumentSvc == nil {
+		return nil, "", fiber.NewError(fiber.StatusInternalServerError, "Document service not available")
+	}
+
+	documents, err := s.DocumentSvc.ListByTarget(ctx, "UNIFORMITY", uint64(uniformityID))
+	if err != nil {
+		return nil, "", err
+	}
+	if len(documents) == 0 {
+		if allowMissing {
+			return nil, "", nil
+		}
+		return nil, "", fiber.NewError(fiber.StatusNotFound, "Uniformity document not found")
+	}
+
+	document := documents[0]
+	url, err := s.DocumentSvc.PresignURL(ctx, document, 15*time.Minute)
+	if err != nil {
+		return nil, "", err
+	}
+	if url == "" {
+		return nil, "", fiber.NewError(fiber.StatusBadRequest, "Uniformity document URL not available")
+	}
+
+	return &document, url, nil
 }
 
 func (s *uniformityService) createUniformityApproval(