mesa-fab-approval/Fab2ApprovalSystem/DMO/CorrectiveActionDMO.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.IO;
using System.Linq;
using System.Transactions;

using Dapper;

using Fab2ApprovalSystem.Misc;
using Fab2ApprovalSystem.Models;
using Fab2ApprovalSystem.ViewModels;

namespace Fab2ApprovalSystem.DMO;

public class CorrectiveActionDMO {

    private readonly AppSettings _AppSettings;
    private readonly WorkflowDMO wfDMO = new();
    private readonly IDbConnection db = new SqlConnection(GlobalVars.DB_CONNECTION_STRING);

    public CorrectiveActionDMO(AppSettings appSettings) =>
        _AppSettings = appSettings;

    public CorrectiveAction InsertCA(CorrectiveAction ca) {
        DynamicParameters parameters = new();

        parameters = new DynamicParameters();
        parameters.Add("@CANo", value: ca.CANo, dbType: DbType.Int32, direction: ParameterDirection.InputOutput);
        parameters.Add("@RequestorID", ca.RequestorID);

        db.Execute("_8DInsertCAItem", parameters, commandType: CommandType.StoredProcedure);
        ca.CANo = parameters.Get<int>("@CANo");

        return ca;
    }

    public void UpdateCorrectiveAction(CorrectiveAction model) {
        DynamicParameters parameters = new();

        using (TransactionScope transaction = new()) {
            try {
                parameters.Add("@CANo", model.CANo);
                parameters.Add("@CATitle", model.CATitle);
                parameters.Add("@RequestorID", model.RequestorID);
                parameters.Add("@IssueDate", model.IssueDate);
                parameters.Add("@D1AssigneeID", model.D1AssigneeID);
                parameters.Add("@CAType", model.CAType);
                parameters.Add("@CASourceID", model.CASourceID);
                parameters.Add("@ModuleID", model.ModuleID);
                parameters.Add("@QAID", model.QAID);
                parameters.Add("@D8DueDate", model.D8DueDate);
                parameters.Add("@Tool", model.Tools);
                parameters.Add("@ApprovedDate", model.ApprovedDate);
                parameters.Add("@RelatedMRB", model.RelatedMRB);
                parameters.Add("@RelatedAudit", model.RelatedAudit);
                parameters.Add("@D0Comments", model.D0Comments);
                parameters.Add("@D2ProblemDescription", model.D2ProblemDescription);
                parameters.Add("@D3RiskAssessmentNotes", model.D3RiskAssessmentNotes);
                parameters.Add("@D0Completed", model.D0Completed);
                parameters.Add("@D0Approved", model.D0Approved);
                parameters.Add("@D3Completed", model.D3Completed);
                parameters.Add("@D3Approved", model.D3Approved);
                parameters.Add("@D4RootCause1", model.D4RootCause1);
                parameters.Add("@D4RootCause2", model.D4RootCause2);
                parameters.Add("@D4RootCause3", model.D4RootCause3);
                parameters.Add("@D4RootCause4", model.D4RootCause4);
                parameters.Add("@D4Completed", model.D4Completed);
                parameters.Add("@D4Approved", model.D4Approved);
                parameters.Add("@D5Completed", model.D5Completed);
                parameters.Add("@D5Approved", model.D5Approved);
                parameters.Add("@D6Validated", model.D6Validated);
                parameters.Add("@D7Completed", model.D7Completed);
                parameters.Add("@D8Completed", model.D8Completed);
                parameters.Add("@D8Approved", model.D8Approved);
                parameters.Add("@D8TeamRecognition", model.D8TeamRecognition);
                parameters.Add("@D8LessonsLearned", model.D8LessonsLearned);
                parameters.Add("@TeamCaptainID", model.TeamCaptainID);
                parameters.Add("@CASponsorID", model.CASponsorID);
                parameters.Add("@CustomerName", model.CustomerName);
                parameters.Add("@CustomerPartNo", model.CustomerPartNo);
                parameters.Add("@IFXPartNo", model.IFXPartNo);
                parameters.Add("@PartQty", model.PartQty);
                parameters.Add("@InvoiceNo", model.InvoiceNo);
                parameters.Add("@PurchaseOrderNo", model.PurchaseOrderNo);
                parameters.Add("@SalesOrderNo", model.SalesOrderNo);
                parameters.Add("@DollarImpact", model.DollarImpact);
                parameters.Add("@BackgroundInfo", model.BackgroundInfo);
                parameters.Add("@Analysis", model.Analysis);
                parameters.Add("@VisualVerification", model.VisualVerification);
                parameters.Add("@InterimContainmentAction", model.InterimContainmentAction);
                parameters.Add("@ICAVerificationResults", model.ICAVerificationResults);
                parameters.Add("@ICAValidationActivities", model.ICAValidationActivities);
                parameters.Add("@RootCauseVerification", model.RootCauseVerification);
                parameters.Add("@EscapePoint", model.EscapePoint);
                parameters.Add("@FollowUpDate", model.FollowUpDate);
                parameters.Add("@CASubmitted", model.CASubmitted);

                db.Execute("_8DUpdateCorrectiveAction", parameters, commandType: CommandType.StoredProcedure);
                EventLogDMO.Add(new WinEventLog { UserID = "System", Comments = "Saved Corrective Action", DocumentType = "9", IssueID = model.CANo, OperationType = "Status", SysDocumentID = 1 });

                parameters = new DynamicParameters();
                parameters.Add("@CANo", model.CANo);
                db.Execute("_8DDeleteCAModuleID", parameters, commandType: CommandType.StoredProcedure);
                List<int> moduleIDs = model.ModuleIDs;
                if (moduleIDs != null) {
                    foreach (int moduleID in moduleIDs) {
                        parameters = new DynamicParameters();
                        parameters.Add("@CANo", model.CANo);
                        parameters.Add("@ModuleID", moduleID);
                        db.Execute("_8DInsertCAModuleID", parameters, commandType: CommandType.StoredProcedure);
                    }
                }

                parameters = new DynamicParameters();
                parameters.Add("@CANo", model.CANo);
                db.Execute("_8DDeleteRiskAssessmentAres", parameters, commandType: CommandType.StoredProcedure);
                List<int> riskAssessmentAreaIDs = model.RiskAssessmentAreaIDs;
                if (riskAssessmentAreaIDs != null) {
                    foreach (int riskAssessmentAreaID in riskAssessmentAreaIDs) {
                        parameters = new DynamicParameters();
                        parameters.Add("@CANo", model.CANo);
                        parameters.Add("@RiskAssessmentAreaID", riskAssessmentAreaID);
                        db.Execute("_8DInsertRiskAssessmentArea", parameters, commandType: CommandType.StoredProcedure);
                    }
                }

                parameters = new DynamicParameters();
                parameters.Add("@CANo", model.CANo);
                db.Execute("_8DDeleteTeamMembers", parameters, commandType: CommandType.StoredProcedure);
                List<int> teamMemberIDs = model.TeamMemberIDs;
                if (teamMemberIDs != null) {
                    foreach (int teamMemberID in teamMemberIDs) {
                        parameters = new DynamicParameters();
                        parameters.Add("@CANo", model.CANo);
                        parameters.Add("@TeamMemberID", teamMemberID);
                        db.Execute("_8DInsertTeamMemberID", parameters, commandType: CommandType.StoredProcedure);
                    }
                }

                transaction.Complete();
            } catch (Exception ex) {
                transaction.Dispose();
                throw new Exception(ex.Message + " " + ex.InnerException);
            }
        }

    }

    public CorrectiveAction GetCAItem(int caNo, int userID) {
        CorrectiveAction ca = new();

        //isITAR = 2;

        DynamicParameters parameters = new();
        parameters.Add("@CANo", value: caNo);
        parameters.Add("@UserID", userID);

        using (var multipleResultItems = db.QueryMultiple("_8DGetCAItem", parameters, commandType: CommandType.StoredProcedure)) {
            ca = multipleResultItems.Read<CorrectiveAction>().SingleOrDefault();

            List<int> moduleIDs = multipleResultItems.Read<int>().ToList();
            if (ca != null && moduleIDs != null) {
                if (moduleIDs.Count > 0)
                    ca.ModuleIDs.AddRange(moduleIDs);
            }

            List<int> teamMembers = multipleResultItems.Read<int>().ToList();
            if (ca != null && teamMembers != null) {
                if (teamMembers.Count > 0)
                    ca.TeamMemberIDs.AddRange(teamMembers);
            }

            List<int> riskAssessments = multipleResultItems.Read<int>().ToList();
            if (ca != null && riskAssessments != null) {
                if (riskAssessments.Count > 0)
                    ca.RiskAssessmentAreaIDs.AddRange(riskAssessments);
            }
        }

        return ca;
    }

    public CorrectiveAction GetCAItemReadOnly(int caNo, int userID) {
        CorrectiveAction ca = new();

        //isITAR = 2;

        DynamicParameters parameters = new();
        parameters.Add("@CANo", value: caNo);
        parameters.Add("@UserID", userID);

        using (var multipleResultItems = db.QueryMultiple("_8DGetCAItemReadOnly", parameters, commandType: CommandType.StoredProcedure)) {
            ca = multipleResultItems.Read<CorrectiveAction>().SingleOrDefault();

            List<int> moduleIDs = multipleResultItems.Read<int>().ToList();
            if (ca != null && moduleIDs != null) {
                if (moduleIDs.Count > 0)
                    ca.ModuleIDs.AddRange(moduleIDs);
            }

            List<int> teamMembers = multipleResultItems.Read<int>().ToList();
            if (ca != null && teamMembers != null) {
                if (teamMembers.Count > 0)
                    ca.TeamMemberIDs.AddRange(teamMembers);
            }

            List<int> riskAssessments = multipleResultItems.Read<int>().ToList();
            if (ca != null && riskAssessments != null) {
                if (riskAssessments.Count > 0)
                    ca.RiskAssessmentAreaIDs.AddRange(riskAssessments);
            }

        }

        return ca;
    }

    public IEnumerable<CAUserList> GetUserList() {
        DynamicParameters parameters = new();
        List<CAUserList> userList = db.Query<CAUserList>("_8DGetUserList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return userList;
    }

    public IEnumerable<CAUserList> GetAllUserList() {
        DynamicParameters parameters = new();
        List<CAUserList> userList = db.Query<CAUserList>("_8DGetAllUserList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return userList;
    }

    public IEnumerable<CASource> GetCASourceList() {
        DynamicParameters parameters = new();
        List<CASource> caSourceList = db.Query<CASource>("_8DGetCASourceList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return caSourceList;
    }

    public IEnumerable<Module> GetModuleList() {
        DynamicParameters parameters = new();
        List<Module> moduleList = db.Query<Module>("_8DGetCAModuleList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return moduleList;
    }

    public void InsertCAAttachment(CA_Attachment attach) {
        DynamicParameters parameters = new();
        parameters.Add("@CANo", attach.CANo);
        parameters.Add("@D5D6CAID", attach.D5D6CAID);
        parameters.Add("@D7PAID", attach.D7PAID);
        parameters.Add("@CAFindingsID", attach.CAFindingsID);
        parameters.Add("@UploadedByID", attach.UploadedByID);
        parameters.Add("@FileName", attach.FileName);
        parameters.Add("@FileGUID", attach.FileGUID);
        parameters.Add("@Section", attach.Section);

        db.Execute("_8DInsertCAAttachment", parameters, commandType: CommandType.StoredProcedure);
    }

    public IEnumerable<CA_Attachment> GetCAAttachmentsList(int caNo, string section) {
        DynamicParameters parameters = new();
        parameters.Add("@CANo", caNo);
        parameters.Add("@Section", section);
        List<CA_Attachment> caAttachmentList = db.Query<CA_Attachment>("[_8DGetCAAttachmentList]", parameters, commandType: CommandType.StoredProcedure).ToList();
        return caAttachmentList;
    }

    public void DeleteCAAttachment(int attachmentID) {
        DynamicParameters parameters = new();
        parameters.Add("@AttachmentID", attachmentID);
        db.Execute("_8DDeleteCAAttachment", parameters, commandType: CommandType.StoredProcedure);
    }

    public string GetCAAttachmentFileName(string fileGUID) {
        DynamicParameters parameters = new();
        parameters.Add("@FileGUID", fileGUID);
        var fileName = db.Query<string>("_8DGetCAAttachmentFileName", parameters, commandType: CommandType.StoredProcedure).Single();
        return fileName;
    }

    public IEnumerable<D3ContainmentAction> GetD3ContainmentActions(int caNo) {
        DynamicParameters parameters = new();
        parameters.Add("@CANo", caNo);
        List<D3ContainmentAction> d3ContainmentActionList = db.Query<D3ContainmentAction>("_8DGetD3ContainmentActions", parameters, commandType: CommandType.StoredProcedure).ToList();
        return d3ContainmentActionList;
    }

    public void UpdateD3ContainmentAction(D3ContainmentAction model) {
        DynamicParameters parameters = new();
        parameters.Add("@ID", model.ID);
        parameters.Add("@ContainmentAction", model.ContainmentAction);
        parameters.Add("@Result", model.Result);
        parameters.Add("@ECNLinks", model.ECNLinks);
        parameters.Add("@ResponsibilityOwnerID", model.ResponsibilityOwnerID);
        parameters.Add("@ECD", model.ECD);
        parameters.Add("@ImplementedDate", model.ImplementedDate);

        db.Execute("_8DUpdateD3ContainmentAction", parameters, commandType: CommandType.StoredProcedure);
    }

    public void InsertD3ContainmentAction(D3ContainmentAction model) {
        DynamicParameters parameters = new();
        parameters.Add("@CANo", model.CANo);
        parameters.Add("@ContainmentAction", model.ContainmentAction);
        parameters.Add("@Result", model.Result);
        parameters.Add("@ECNLinks", model.ECNLinks);
        parameters.Add("@ResponsibilityOwnerID", model.ResponsibilityOwnerID);
        parameters.Add("@ECD", model.ECD);
        parameters.Add("@ImplementedDate", model.ImplementedDate);

        db.Execute("_8DInsertD3ContainmentAction", parameters, commandType: CommandType.StoredProcedure);
    }

    public void DeleteD3ContainmentActionItem(int d3ContainmentActionID) {
        DynamicParameters parameters = new();
        parameters.Add("@D3ContainmentActionID", d3ContainmentActionID);

        db.Execute("_8DDeleteD3ContainmentActionItem", parameters, commandType: CommandType.StoredProcedure);
    }

    public IEnumerable<RiskAssessmentArea> GetD3RiskAssessmentAreas() {
        DynamicParameters parameters = new();
        List<RiskAssessmentArea> dataList = db.Query<RiskAssessmentArea>("_8DGetD3RiskAssessmentAreas", parameters, commandType: CommandType.StoredProcedure).ToList();
        return dataList;
    }

    public IEnumerable<D5D6CorrectivetAction> GetD5D6CorrectivetActions(int caNo) {
        DynamicParameters parameters = new();
        parameters.Add("@CANo", caNo);
        List<D5D6CorrectivetAction> dataList = db.Query<D5D6CorrectivetAction>("_8DGetD5D6_CAList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return dataList;
    }

    public bool IsAIAssignee(int userId, int caId) {
        bool isAssignee = false;
        int aiIndex = 0;
        List<D5D6CorrectivetAction> actionItems = GetD5D6CorrectivetActions(caId).ToList();
        while (isAssignee == false && aiIndex < actionItems.Count) {
            D5D6CorrectivetAction actionItem = actionItems[aiIndex];
            if (actionItem.ResponsibilityOwnerID == userId && actionItem.ImplementedDate == null && actionItem.Approved) {
                isAssignee = true;
            }
            aiIndex++;
        }
        return isAssignee;
    }

    public IEnumerable<D5D6Improvement> GetD5D6Improvement() {
        DynamicParameters parameters = new();
        List<D5D6Improvement> dataList = db.Query<D5D6Improvement>("_8DGetD5D6Improvement", parameters, commandType: CommandType.StoredProcedure).ToList();
        return dataList;
    }

    public void InsertD5D6CorrectivetAction(D5D6CorrectivetAction model) {
        DynamicParameters parameters = new();
        parameters.Add("@CANo", model.CANo);
        parameters.Add("@CorrectiveAction", model.CorrectiveAction);
        parameters.Add("@Result", model.Result);
        parameters.Add("@ECNLinks", model.ECNLinks);
        parameters.Add("@ResponsibilityOwnerID", model.ResponsibilityOwnerID);
        parameters.Add("@ECD", model.ECD);
        parameters.Add("@ImprovementIDs", model.ImprovementID);
        parameters.Add("@ImplementedDate", model.ImplementedDate);
        parameters.Add("@CARequired", (model.CARequired));
        parameters.Add("@ActionType", (model.ActionType));

        db.Execute("_8DInsertD5D6CorrectiveAction", parameters, commandType: CommandType.StoredProcedure);
    }

    public void UpdateD5D6CorrectivetAction(D5D6CorrectivetAction model) {
        DynamicParameters parameters = new();
        parameters.Add("@D5D6CAID", model.ID);
        parameters.Add("@CorrectiveAction", model.CorrectiveAction);
        parameters.Add("@Result", model.Result);
        parameters.Add("@ECNLinks", model.ECNLinks);
        parameters.Add("@ResponsibilityOwnerID", model.ResponsibilityOwnerID);
        parameters.Add("@ECD", model.ECD);
        parameters.Add("@ImprovementIDs", model.ImprovementID);
        parameters.Add("@ImplementedDate", model.ImplementedDate);
        parameters.Add("@CARequired", (model.@CARequired));
        parameters.Add("@ActionType", (model.ActionType));

        db.Execute("_8DUpdateD5D6CorrectiveAction", parameters, commandType: CommandType.StoredProcedure);
    }

    public void DeleteD5D6CorrectivetAction(int d5d6CAID) {
        DynamicParameters parameters = new();
        parameters.Add("@D5D6CAID", d5d6CAID);

        db.Execute("_8DDeleteD5D6CorrectiveActionItem", parameters, commandType: CommandType.StoredProcedure);
    }

    public D5D6CorrectivetAction GetD5D5CAItem(int d5d6CAID) {
        D5D6CorrectivetAction model = new();
        DynamicParameters parameters = new();
        parameters.Add("@D5D6CAID", d5d6CAID);
        var data = db.Query<D5D6CorrectivetAction>("_8DGetD5D6CA", parameters, commandType: CommandType.StoredProcedure).Single();
        return data;
    }

    public IEnumerable<CA_Attachment> GetD5D6ItemAttachments(int d5d6CAID) {
        D5D6CorrectivetAction model = new();
        DynamicParameters parameters = new();
        parameters.Add("@D5D6CAID", d5d6CAID);
        List<CA_Attachment> data = db.Query<CA_Attachment>("_8DGetD5D6ItemAttachmentList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return data;
    }

    // D7=================================================================================================

    public IEnumerable<D7PreventiveAction> GetD7PreventiveActions(int caNo) {
        DynamicParameters parameters = new();
        parameters.Add("@CANo", caNo);
        List<D7PreventiveAction> dataList = db.Query<D7PreventiveAction>("_8DGetD7_PAList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return dataList;
    }

    public void InsertD7PreventiveAction(D7PreventiveAction model) {
        DynamicParameters parameters = new();
        parameters.Add("@CANo", model.CANo);
        parameters.Add("@PreventiveAction", model.PreventiveAction);
        parameters.Add("@Result", model.Result);
        parameters.Add("@ECNLinks", model.ECNLinks);
        parameters.Add("@ResponsibilityOwnerID", model.ResponsibilityOwnerID);
        parameters.Add("@ECD", model.ECD);
        parameters.Add("@ImplementedDate", model.ImplementedDate);

        db.Execute("_8DInsertD7PreventiveAction", parameters, commandType: CommandType.StoredProcedure);
    }

    public void UpdateD7PreventiveAction(D7PreventiveAction model) {
        DynamicParameters parameters = new();
        parameters.Add("@D7PAID", model.ID);
        parameters.Add("@PreventiveAction", model.PreventiveAction);
        parameters.Add("@Result", model.Result);
        parameters.Add("@ECNLinks", model.ECNLinks);
        parameters.Add("@ResponsibilityOwnerID", model.ResponsibilityOwnerID);
        parameters.Add("@ECD", model.ECD);
        parameters.Add("@ImplementedDate", model.ImplementedDate);

        db.Execute("_8DUpdateD7PreventiveAction", parameters, commandType: CommandType.StoredProcedure);
    }

    public D7PreventiveAction GetD7PAItem(int d7PAID) {
        D7PreventiveAction model = new();
        DynamicParameters parameters = new();
        parameters.Add("@D7PAID", d7PAID);
        var data = db.Query<D7PreventiveAction>("_8DGetD7PA", parameters, commandType: CommandType.StoredProcedure).Single();
        return data;
    }

    public void DeleteD7PreventiveActionItem(int D7PAID) {
        DynamicParameters parameters = new();
        parameters.Add("@D7PAID", D7PAID);

        db.Execute("_8DDeleteD7PreventiveActionItem", parameters, commandType: CommandType.StoredProcedure);
    }

    public IEnumerable<CA_Attachment> GetD7ItemAttachments(int d7PAID) {
        D7PreventiveAction model = new();
        DynamicParameters parameters = new();

        parameters.Add("@D7PAID", d7PAID);
        List<CA_Attachment> data = db.Query<CA_Attachment>("_8DGetD7ItemAttachmentList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return data;
    }

    public IEnumerable<CA_Attachment> GetCAFindingsItemAttachments(int caFindingsID) {
        D7PreventiveAction model = new();
        DynamicParameters parameters = new();
        parameters.Add("@CAFindingsID", caFindingsID);
        List<CA_Attachment> data = db.Query<CA_Attachment>("_8DGetCAFindingsItemAttachmentList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return data;
    }

    public void ReleaseLockOnDocument(int userID, int issueID) {
        DynamicParameters parameters = new();
        parameters.Add("@CANo", issueID);
        parameters.Add("@UserID", userID);
        db.Execute("_8DReleaseLockOnCADocuments", parameters, commandType: CommandType.StoredProcedure);
    }

    public List<string> GetRejectionAssigneeEmailList(int caNo) {
        DynamicParameters parameters = new();
        parameters.Add("@CANo", caNo);
        List<string> emailList = db.Query<string>("_8DGetRejectionAssigneeEmailList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return emailList;
    }

    public int StartApproval(int issueID, int userID, int worlflowNumber) {
        string subRoles = wfDMO.GetSubRoleItems(issueID, (int)GlobalVars.DocumentType.CorrectiveActionSection);

        // bubble the error 
        int appoverCount = 0;
        DynamicParameters parameters = new();
        parameters.Add("@CANo", issueID);
        parameters.Add("@UserID", userID);
        parameters.Add("@DocumentTypeID", (int)GlobalVars.DocumentType.CorrectiveAction);
        parameters.Add("@SubRoleCategoriesClause", subRoles);
        parameters.Add("@WorkFlowNumber", worlflowNumber);
        parameters.Add("@AppoverCount", appoverCount, dbType: DbType.Int32, direction: ParameterDirection.Output);

        db.Execute("_8DSubmitForApproval", parameters, commandType: CommandType.StoredProcedure);

        appoverCount = parameters.Get<int>("@AppoverCount");
        return appoverCount;
    }

    public List<int> Get8DQA() {
        List<int> users = new();
        DynamicParameters parameters = new();
        users = db.Query<int>("_8DGet8DQA", parameters, commandType: CommandType.StoredProcedure).ToList();
        return users;
    }

    public void StartSectionApproval(int issueID, int userID, string DSection) {
        //string subRoles = wfDMO.GetSubRoleItems(issueID, (int)GlobalVars.DocumentType.CorrectiveActionSection);

        // bubble the error 
        DynamicParameters parameters = new();
        parameters.Add("@CANo", issueID);
        parameters.Add("@8DQAUserID", userID);
        parameters.Add("@DSection", DSection);

        db.Execute("_8DSubmitForSectionApproval", parameters, commandType: CommandType.StoredProcedure);
    }

    public void ApproveSection(int issueID, int userID, string DSection) {
        //string subRoles = wfDMO.GetSubRoleItems(issueID, (int)GlobalVars.DocumentType.CorrectiveActionSection);

        // bubble the error 
        DynamicParameters parameters = new();
        parameters.Add("@UserID", userID);
        parameters.Add("@CANo", issueID);
        parameters.Add("@DSection", DSection);

        db.Execute("UpdateCASectionApproval", parameters, commandType: CommandType.StoredProcedure);
    }

    public bool IsLastSectionApprover(int caNo, string dSection) {
        bool islastApprover = false;

        DynamicParameters parameters = new();
        parameters.Add("@CaNo", caNo);
        parameters.Add("@DSection", dSection);
        parameters.Add("@IsLastApprover", islastApprover, dbType: DbType.Boolean, direction: ParameterDirection.Output);

        db.Execute("_8DIsLastSectionApprover", parameters, commandType: CommandType.StoredProcedure);
        islastApprover = parameters.Get<bool>("@IsLastApprover");

        return islastApprover;
    }

    public void RejectSection(int issueID, int userID, string DSection, string comments) {
        //string subRoles = wfDMO.GetSubRoleItems(issueID, (int)GlobalVars.DocumentType.CorrectiveActionSection);

        // bubble the error 
        DynamicParameters parameters = new();
        parameters.Add("@UserID", userID);
        parameters.Add("@CANo", issueID);
        parameters.Add("@DSection", DSection);
        parameters.Add("@Comments", comments);

        db.Execute("RejectCASectionApproval", parameters, commandType: CommandType.StoredProcedure);
    }

    public bool IsUserSectionApprover(int issueId, int userId) {
        bool isApprover = false;
        DynamicParameters parameters = new();
        parameters.Add("@issueId", issueId);
        parameters.Add("@userID", userId);
        parameters.Add("@isApprover", isApprover, dbType: DbType.Boolean, direction: ParameterDirection.Output);

        db.Execute("_8DIsUserApprover", parameters, commandType: CommandType.StoredProcedure);

        isApprover = parameters.Get<bool>("@isApprover");
        return isApprover;
    }

    public IEnumerable<CASectionApproval> GetCASectionApprovalLog(int caNo) {
        DynamicParameters parameters = new();
        parameters.Add("@CaNo", caNo);
        List<CASectionApproval> ApprovalLogList = db.Query<CASectionApproval>("_8DGetSectionApprovalLog", parameters, commandType: CommandType.StoredProcedure).ToList();
        return ApprovalLogList;
    }

    public DateTime SetCAComplete(int issueID) {
        DateTime followUpDate = new();
        DynamicParameters parameters = new();
        parameters.Add("@CaNo", issueID);
        parameters.Add("@followUpDate", followUpDate, dbType: DbType.DateTime, direction: ParameterDirection.Output);

        db.Execute("_8DSetAsComplete", parameters, commandType: CommandType.StoredProcedure);
        followUpDate = parameters.Get<DateTime>("@followUpDate");
        return followUpDate;
    }

    public DateTime SetCAD3DueDate(int issueID) {
        DateTime d3DueDate = new();
        DynamicParameters parameters = new();
        parameters.Add("@CaNo", issueID);
        parameters.Add("@D3DueDate", d3DueDate, dbType: DbType.DateTime, direction: ParameterDirection.Output);

        db.Execute("_8DSetD3DueDate", parameters, commandType: CommandType.StoredProcedure);
        d3DueDate = parameters.Get<DateTime>("@D3DueDate");
        return d3DueDate;
    }

    public DateTime SetCAD5D7DueDate(int issueID) {
        DateTime d5d7DueDate = new();
        DynamicParameters parameters = new();
        parameters.Add("@CaNo", issueID);
        parameters.Add("@D5D7DueDate", d5d7DueDate, dbType: DbType.DateTime, direction: ParameterDirection.Output);

        db.Execute("_8DSetD5D7DueDate", parameters, commandType: CommandType.StoredProcedure);
        d5d7DueDate = parameters.Get<DateTime>("@D5D7DueDate");
        return d5d7DueDate;
    }

    public IEnumerable<CAD3D5D7Due> GetCAD3D5D7Due() {
        DynamicParameters parameters = new();
        List<CAD3D5D7Due> dueList = db.Query<CAD3D5D7Due>("_8DGetDueD3D5D7", parameters, commandType: CommandType.StoredProcedure).ToList();
        return dueList;
    }

    public void SetD3D5D7NotificationDate(int caNo, string section) {
        DynamicParameters parameters = new();
        parameters.Add("@issueId", caNo);
        switch (section) {
            case "D3":
                db.Execute("_8DSetD3LastNotificationDate", parameters, commandType: CommandType.StoredProcedure);
                break;
            case "D5D7":
                db.Execute("_8DSetD5D7LastNotificationDate", parameters, commandType: CommandType.StoredProcedure);
                break;
            default:
                break;
        }

    }

    public IEnumerable<IssuesViewModel> GetECNList() {
        DynamicParameters parameters = new();
        List<IssuesViewModel> ecnList = db.Query<IssuesViewModel>("ECNGetECNList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return ecnList;
    }

    public void AttachSave(int caNo, int userId, string fullFileName, Stream stream) {
        // Some browsers send file names with full path.
        // We are only interested in the file name.

        var fileName = Path.GetFileName(fullFileName);
        var fileExtension = Path.GetExtension(fullFileName);
        //var physicalPath = Path.Combine(Server.MapPath("~/UserUploads"), fileName);       
        DirectoryInfo di;
        var ccPhysicalPath = _AppSettings.AttachmentFolder + @"CorrectiveAction\" + caNo;
        di = new DirectoryInfo(ccPhysicalPath);
        if (!di.Exists)
            di.Create();

        var guid = Guid.NewGuid().ToString();
        var physicalPath = Path.Combine(_AppSettings.AttachmentFolder + @"CorrectiveAction\" + caNo + @"\", guid + fileExtension);

        using (FileStream fileStream = new(physicalPath, FileMode.Create, FileAccess.Write)) {
            stream.CopyTo(fileStream);
        }
        CA_Attachment attach = new() {
            CANo = caNo,
            FileGUID = guid,
            FileName = fileName,
            UploadedByID = userId,
            Section = Functions.CASectionMapper(GlobalVars.CASection.Main)
        };

        // InsertCCAttachment(attach);
        InsertCAAttachment(attach);
    }

    public void D4FilesAttachSave(int caNo, int userId, string fullFileName, Stream stream) {
        // Some browsers send file names with full path.
        // We are only interested in the file name.

        var fileName = Path.GetFileName(fullFileName);
        var fileExtension = Path.GetExtension(fullFileName);
        //var physicalPath = Path.Combine(Server.MapPath("~/UserUploads"), fileName);       
        DirectoryInfo di;
        var ccPhysicalPath = _AppSettings.AttachmentFolder + @"CorrectiveAction\" + caNo;
        di = new DirectoryInfo(ccPhysicalPath);
        if (!di.Exists)
            di.Create();

        var guid = Guid.NewGuid().ToString();
        var physicalPath = Path.Combine(_AppSettings.AttachmentFolder + @"CorrectiveAction\" + caNo + @"\", guid + fileExtension);

        using (FileStream fileStream = new(physicalPath, FileMode.Create, FileAccess.Write)) {
            stream.CopyTo(fileStream);
        }
        CA_Attachment attach = new() {
            CANo = caNo,
            FileGUID = guid,
            FileName = fileName,
            UploadedByID = userId,
            Section = Functions.CASectionMapper(GlobalVars.CASection.D4)

        };

        //InsertCCAttachment(attach);
        InsertCAAttachment(attach);
    }

    public void SaveD7PA_Attachemnt(int d7PAID, int caNo, int userId, string fullFileName, Stream stream) {
        // Some browsers send file names with full path.
        // We are only interested in the file name.

        var fileName = Path.GetFileName(fullFileName);
        var fileExtension = Path.GetExtension(fullFileName);
        //var physicalPath = Path.Combine(Server.MapPath("~/UserUploads"), fileName);       
        DirectoryInfo di;
        var ccPhysicalPath = _AppSettings.AttachmentFolder + @"CorrectiveAction\" + caNo;
        di = new DirectoryInfo(ccPhysicalPath);
        if (!di.Exists)
            di.Create();

        var guid = Guid.NewGuid().ToString();
        var physicalPath = Path.Combine(_AppSettings.AttachmentFolder + @"CorrectiveAction\" + caNo + @"\", guid + fileExtension);

        using (FileStream fileStream = new(physicalPath, FileMode.Create, FileAccess.Write)) {
            stream.CopyTo(fileStream);
        }
        CA_Attachment attach = new() {
            D7PAID = d7PAID,
            CANo = caNo,
            FileGUID = guid,
            FileName = fileName,
            UploadedByID = userId,
            Section = Functions.CASectionMapper(GlobalVars.CASection.D7)

        };

        InsertCAAttachment(attach);
    }

    public void SaveD5D6CA_Attachemnt(int d5d6CAID, int caNo, int userId, string fullFileName, Stream stream) {
        // Some browsers send file names with full path.
        // We are only interested in the file name.

        var fileName = Path.GetFileName(fullFileName);
        var fileExtension = Path.GetExtension(fullFileName);
        //var physicalPath = Path.Combine(Server.MapPath("~/UserUploads"), fileName);       
        DirectoryInfo di;
        var ccPhysicalPath = _AppSettings.AttachmentFolder + @"CorrectiveAction\" + caNo;
        di = new DirectoryInfo(ccPhysicalPath);
        if (!di.Exists)
            di.Create();

        var guid = Guid.NewGuid().ToString();
        var physicalPath = Path.Combine(_AppSettings.AttachmentFolder + @"CorrectiveAction\" + caNo + @"\", guid + fileExtension);

        using (FileStream fileStream = new(physicalPath, FileMode.Create, FileAccess.Write)) {
            stream.CopyTo(fileStream);
        }
        CA_Attachment attach = new() {
            D5D6CAID = d5d6CAID,
            CANo = caNo,
            FileGUID = guid,
            FileName = fileName,
            UploadedByID = userId,
            Section = Functions.CASectionMapper(GlobalVars.CASection.D5)

        };

        InsertCAAttachment(attach);
    }

}