update get approval by letter

2025-10-15 17:26:06 +07:00
parent 58372ca195
commit da2246d45a
3 changed files with 179 additions and 127 deletions
@@ -1112,120 +1112,154 @@ func (s *LetterOutgoingServiceImpl) GetLetterApprovals(ctx context.Context, lett
 		return nil, err
 	}

-	// Get all approvals for this letter's current revision
-	approvals, err := s.processor.GetApprovalsByLetterAndRevision(ctx, letterID, letter.RevisionNumber)
+	// Get all approvals for this letter (all revisions)
+	approvals, err := s.processor.GetAllApprovalsByLetter(ctx, letterID)
 	if err != nil {
 		return nil, err
 	}

-	// Sort approvals by step order and parallel group
-	sort.Slice(approvals, func(i, j int) bool {
-		if approvals[i].StepOrder != approvals[j].StepOrder {
-			return approvals[i].StepOrder < approvals[j].StepOrder
-		}
-		return approvals[i].ParallelGroup < approvals[j].ParallelGroup
-	})
-
-	// Transform to response format
-	approvalResponses := make([]contract.EnhancedOutgoingLetterApprovalResponse, 0, len(approvals))
-	totalSteps := 0
-	currentStep := 0
-	stepOrdersSeen := make(map[int]bool)
-
+	// Group approvals by revision number from approval itself
+	revisionMap := make(map[int][]entities.LetterOutgoingApproval)
 	for _, approval := range approvals {
-		// Count unique step orders for total steps
-		if !stepOrdersSeen[approval.StepOrder] {
-			stepOrdersSeen[approval.StepOrder] = true
-			totalSteps++
-		}
-
-		// Determine current step (lowest step with pending/not_started status)
-		if approval.Status == entities.ApprovalStatusPending && (currentStep == 0 || approval.StepOrder < currentStep) {
-			currentStep = approval.StepOrder
-		}
-
-		approvalResp := contract.EnhancedOutgoingLetterApprovalResponse{
-			ID:            approval.ID,
-			LetterID:      approval.LetterID,
-			StepID:        approval.StepID,
-			StepOrder:     approval.StepOrder,
-			ParallelGroup: approval.ParallelGroup,
-			IsRequired:    approval.IsRequired,
-			ApproverID:    approval.ApproverID,
-			Status:        string(approval.Status),
-			Remarks:       approval.Remarks,
-			ActedAt:       approval.ActedAt,
-			CreatedAt:     approval.CreatedAt,
-		}
-
-		// Add step details if available
-		if approval.Step != nil {
-			approvalResp.Step = &contract.ApprovalFlowStepResponse{
-				ID:            approval.Step.ID,
-				StepOrder:     approval.Step.StepOrder,
-				ParallelGroup: approval.Step.ParallelGroup,
-				Required:      approval.Step.Required,
-				CreatedAt:     approval.Step.CreatedAt,
-				UpdatedAt:     approval.Step.UpdatedAt,
-			}
-
-			// Add approver role if available
-			if approval.Step.ApproverRole != nil {
-				approvalResp.Step.ApproverRole = &contract.RoleResponse{
-					ID:   approval.Step.ApproverRole.ID,
-					Name: approval.Step.ApproverRole.Name,
-					Code: approval.Step.ApproverRole.Code,
-				}
-			}
-
-			// Add approver user if available
-			if approval.Step.ApproverUser != nil {
-				approvalResp.Step.ApproverUser = &contract.UserResponse{
-					ID:    approval.Step.ApproverUser.ID,
-					Name:  approval.Step.ApproverUser.Name,
-					Email: approval.Step.ApproverUser.Email,
-				}
-			}
-		}
-
-		// Add approver details if available
-		if approval.Approver != nil {
-			approvalResp.Approver = &contract.UserResponse{
-				ID:    approval.Approver.ID,
-				Name:  approval.Approver.Name,
-				Email: approval.Approver.Email,
-			}
-		}
-
-		approvalResponses = append(approvalResponses, approvalResp)
+		revisionMap[approval.RevisionNumber] = append(revisionMap[approval.RevisionNumber], approval)
 	}

-	// If no current step found but there are approvals, check if all are completed
-	if currentStep == 0 && len(approvals) > 0 {
-		allCompleted := true
-		for _, approval := range approvals {
-			if approval.IsRequired && approval.Status != entities.ApprovalStatusApproved {
-				allCompleted = false
-				break
+	// Get sorted revision numbers
+	revisionNumbers := make([]int, 0, len(revisionMap))
+	for revNum := range revisionMap {
+		revisionNumbers = append(revisionNumbers, revNum)
+	}
+	sort.Sort(sort.Reverse(sort.IntSlice(revisionNumbers)))
+
+	// Process each revision
+	revisionResponses := make([]contract.OutgoingLetterApprovalRevisionNumberResponse, 0, len(revisionNumbers))
+
+	totalSteps := 0
+	currentStep := 0
+
+	for _, revNum := range revisionNumbers {
+		revisionApprovals := revisionMap[revNum]
+
+		// Sort approvals within this revision by step order and parallel group
+		sort.Slice(revisionApprovals, func(i, j int) bool {
+			if revisionApprovals[i].StepOrder != revisionApprovals[j].StepOrder {
+				return revisionApprovals[i].StepOrder < revisionApprovals[j].StepOrder
+			}
+			return revisionApprovals[i].ParallelGroup < revisionApprovals[j].ParallelGroup
+		})
+
+		// Transform to response format
+		approvalResponses := make([]contract.EnhancedOutgoingLetterApprovalResponse, 0, len(revisionApprovals))
+
+		// Only calculate totalSteps and currentStep for the current letter's revision
+		if revNum == letter.RevisionNumber {
+			stepOrdersSeen := make(map[int]bool)
+
+			for _, approval := range revisionApprovals {
+				// Count unique step orders for total steps
+				if !stepOrdersSeen[approval.StepOrder] {
+					stepOrdersSeen[approval.StepOrder] = true
+					totalSteps++
+				}
+
+				// Determine current step (lowest step with pending status)
+				if approval.Status == entities.ApprovalStatusPending && (currentStep == 0 || approval.StepOrder < currentStep) {
+					currentStep = approval.StepOrder
+				}
+			}
+
+			// If no current step found but there are approvals, check if all are completed
+			if currentStep == 0 && len(revisionApprovals) > 0 {
+				allCompleted := true
+				for _, approval := range revisionApprovals {
+					if approval.IsRequired && approval.Status != entities.ApprovalStatusApproved {
+						allCompleted = false
+						break
+					}
+				}
+				if allCompleted {
+					currentStep = totalSteps // All steps completed
+				}
 			}
 		}
-		if allCompleted {
-			currentStep = totalSteps // All steps completed
+
+		for _, approval := range revisionApprovals {
+			approvalResp := contract.EnhancedOutgoingLetterApprovalResponse{
+				ID:             approval.ID,
+				LetterID:       approval.LetterID,
+				StepID:         approval.StepID,
+				StepOrder:      approval.StepOrder,
+				ParallelGroup:  approval.ParallelGroup,
+				IsRequired:     approval.IsRequired,
+				ApproverID:     approval.ApproverID,
+				RevisionNumber: approval.RevisionNumber,
+				Status:         string(approval.Status),
+				Remarks:        approval.Remarks,
+				ActedAt:        approval.ActedAt,
+				CreatedAt:      approval.CreatedAt,
+			}
+
+			// Add step details if available
+			if approval.Step != nil {
+				approvalResp.Step = &contract.ApprovalFlowStepResponse{
+					ID:            approval.Step.ID,
+					StepOrder:     approval.Step.StepOrder,
+					ParallelGroup: approval.Step.ParallelGroup,
+					Required:      approval.Step.Required,
+					CreatedAt:     approval.Step.CreatedAt,
+					UpdatedAt:     approval.Step.UpdatedAt,
+				}
+
+				// Add approver role if available
+				if approval.Step.ApproverRole != nil {
+					approvalResp.Step.ApproverRole = &contract.RoleResponse{
+						ID:   approval.Step.ApproverRole.ID,
+						Name: approval.Step.ApproverRole.Name,
+						Code: approval.Step.ApproverRole.Code,
+					}
+				}
+
+				// Add approver user if available
+				if approval.Step.ApproverUser != nil {
+					approvalResp.Step.ApproverUser = &contract.UserResponse{
+						ID:    approval.Step.ApproverUser.ID,
+						Name:  approval.Step.ApproverUser.Name,
+						Email: approval.Step.ApproverUser.Email,
+					}
+				}
+			}
+
+			// Add approver details if available
+			if approval.Approver != nil {
+				approvalResp.Approver = &contract.UserResponse{
+					ID:    approval.Approver.ID,
+					Name:  approval.Approver.Name,
+					Email: approval.Approver.Email,
+				}
+			}
+
+			approvalResponses = append(approvalResponses, approvalResp)
 		}
+
+		// Add revision response
+		revisionResponses = append(revisionResponses, contract.OutgoingLetterApprovalRevisionNumberResponse{
+			RevisionNumber: revNum,
+			Approvals:      approvalResponses,
+		})
 	}

 	response := &contract.GetLetterApprovalsResponse{
-		LetterID:     letter.ID,
-		LetterNumber: letter.LetterNumber,
-		LetterStatus: string(letter.Status),
-		TotalSteps:   totalSteps,
-		CurrentStep:  currentStep,
-		Approvals:    approvalResponses,
+		LetterID:              letter.ID,
+		LetterNumber:          letter.LetterNumber,
+		LetterStatus:          string(letter.Status),
+		TotalSteps:            totalSteps,
+		CurrentStep:           currentStep,
+		CurrentRevisionNumber: letter.RevisionNumber,
+		Approvals:             revisionResponses,
 	}

 	return response, nil
 }
-
 func getUserIDFromContext(ctx context.Context) uuid.UUID {
 	appCtx := appcontext.FromGinContext(ctx)
 	if appCtx != nil {
@@ -1257,17 +1291,18 @@ func (s *LetterOutgoingServiceImpl) GetApprovalDiscussions(ctx context.Context,
 	approvals := make([]contract.EnhancedOutgoingLetterApprovalResponse, 0, len(letter.Approvals))
 	for _, approval := range letter.Approvals {
 		approvalResp := contract.EnhancedOutgoingLetterApprovalResponse{
-			ID:            approval.ID,
-			LetterID:      approval.LetterID,
-			StepID:        approval.StepID,
-			StepOrder:     approval.StepOrder,
-			ParallelGroup: approval.ParallelGroup,
-			IsRequired:    approval.IsRequired,
-			ApproverID:    approval.ApproverID,
-			Status:        string(approval.Status),
-			Remarks:       approval.Remarks,
-			ActedAt:       approval.ActedAt,
-			CreatedAt:     approval.CreatedAt,
+			ID:             approval.ID,
+			LetterID:       approval.LetterID,
+			StepID:         approval.StepID,
+			StepOrder:      approval.StepOrder,
+			ParallelGroup:  approval.ParallelGroup,
+			IsRequired:     approval.IsRequired,
+			ApproverID:     approval.ApproverID,
+			RevisionNumber: approval.RevisionNumber,
+			Status:         string(approval.Status),
+			Remarks:        approval.Remarks,
+			ActedAt:        approval.ActedAt,
+			CreatedAt:      approval.CreatedAt,
 		}

 		// Add step details if available