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

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

using Dapper;

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

namespace Fab2ApprovalSystem.DMO;

public class ECN_DMO {

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

    internal ECN InsertECN(ECN ecn) {
        DynamicParameters parameters = new();
        parameters.Add("@ECNNumber", value: ecn.ECNNumber, dbType: DbType.Int32, direction: ParameterDirection.InputOutput);
        parameters.Add("@OriginatorID", ecn.OriginatorID);

        db.Execute("ECNInsertItem", parameters, commandType: CommandType.StoredProcedure);
        ecn.ECNNumber = parameters.Get<int>("@ECNNumber");

        return ecn;
    }

    internal void UpdateECN(ECN ecn) {
        DynamicParameters parameters = new();
        using (TransactionScope transanction = new()) {
            parameters = new DynamicParameters();
            parameters.Add("@ECNNumber", ecn.ECNNumber);
            parameters.Add("@Title", ecn.Title);
            parameters.Add("@IsECN", ecn.IsECN);
            parameters.Add("@IsTECN", ecn.IsTECN);
            parameters.Add("@IsEmergencyTECN", ecn.IsEmergencyTECN);
            parameters.Add("@ExpirationDate", ecn.ExpirationDate);
            parameters.Add("@ExtensionDate", ecn.ExtensionDate);
            parameters.Add("@CancellationDate", ecn.CancellationDate);
            parameters.Add("@AcknowledgementRequired", ecn.AcknowledgementRequired);
            parameters.Add("@TrainingRequired", ecn.TrainingRequired);
            parameters.Add("@AreaID", ecn.AreaID);
            parameters.Add("@TechnologyID", ecn.TechnologyID);
            parameters.Add("@PCRBRequired", ecn.PCRBRequired);
            parameters.Add("@PCRBNumber", ecn.PCRBNumber);
            parameters.Add("@TestProgramChangeRequired", ecn.TestProgramChangeRequired);
            parameters.Add("@MetrologyChangeRequired", ecn.MetrologyChangeRequired);
            parameters.Add("@SPCChangeRequired", ecn.SPCChangeRequired);
            parameters.Add("@NewPartFlowRequired", ecn.NewPartFlowRequired);
            parameters.Add("@SPNChangeRequired", ecn.SPNChangeRequired);
            parameters.Add("@ImplementationDetails", ecn.ImplementationDetails);
            parameters.Add("@ImpactOnEnvironment", ecn.ImpactOnEnvironment);
            parameters.Add("@ImpactOnEnvironmentDescription", ecn.ImpactOnEnvironmentDescription);
            parameters.Add("@ImpactOnCapacity", ecn.ImpactOnCapacity);
            parameters.Add("@ImpactOnCapacityDescription", ecn.ImpactOnCapacityDescription);
            parameters.Add("@IsMA", ecn.IsMA);
            parameters.Add("@IsRH", ecn.IsRH);
            parameters.Add("@IsAU", ecn.IsAU);
            parameters.Add("@IsIndustrial", ecn.IsIndustrial);
            parameters.Add("@MaterialConsumptionChangeRequired", ecn.MaterialConsumptionChangeRequired);
            parameters.Add("@MaterialConsumptionChangeDescription", ecn.MaterialConsumptionChangeDescription);
            parameters.Add("@ReasonForChange", ecn.ReasonForChange);
            parameters.Add("@DescriptionOfChange", ecn.DescriptionOfChange);
            parameters.Add("@NotAFlowChange", ecn.NotAFlowChange);
            parameters.Add("@AttachECN_TECNToLots", ecn.AttachECN_TECNToLots);
            parameters.Add("@SPNFlowChangeAtSingleStep", ecn.SPNFlowChangeAtSingleStep);
            parameters.Add("@SPNFlowChangeAtMultipleSteps", ecn.SPNFlowChangeAtMultipleSteps);
            parameters.Add("@CategoryID", ecn.CategoryID);
            parameters.Add("@FIChangeRequired", ecn.FIChangeRequired);
            parameters.Add("@NumberOfLotsAffected", ecn.NumberOfLotsAffected);
            parameters.Add("@RecipeChange", ecn.RecipeChange);
            // RJK ITAR/EC
            parameters.Add("@IsDocEC", ecn.IsDocEC);
            db.Execute("ECNUpdate", parameters, commandType: CommandType.StoredProcedure);

            parameters = new DynamicParameters();
            parameters.Add("@ECNNumber", ecn.ECNNumber);
            db.Execute("ECNDeleteAffectedDepartments", parameters, commandType: CommandType.StoredProcedure);
            List<int> ecnDepIDs = ecn.DepartmentIDs;
            if (ecnDepIDs != null) {
                foreach (int depId in ecnDepIDs) {
                    parameters = new DynamicParameters();
                    parameters.Add("@ECNNumber", ecn.ECNNumber);
                    parameters.Add("@DepartmentID", depId);
                    db.Execute("ECNInsertAffectedDepartments", parameters, commandType: CommandType.StoredProcedure);
                }
            }

            parameters = new DynamicParameters();
            parameters.Add("@ECNNumber", ecn.ECNNumber);
            db.Execute("ECNDeleteAffectedModules", parameters, commandType: CommandType.StoredProcedure);

            List<int> ecnModuleIDs = ecn.ModuleIDs;
            if (ecnModuleIDs != null) {
                foreach (int moduleID in ecnModuleIDs) {
                    parameters = new DynamicParameters();
                    parameters.Add("@ECNNumber", ecn.ECNNumber);
                    parameters.Add("@ModuleID", moduleID);
                    db.Execute("ECNInsertAffectedModules", parameters, commandType: CommandType.StoredProcedure);
                }
            }

            List<int> ecnAreaIDs = ecn.AreaIDs;
            parameters = new DynamicParameters();
            parameters.Add("@ECNNumber", ecn.ECNNumber);
            db.Execute("ECNDeleteAffectedAreas", parameters, commandType: CommandType.StoredProcedure);

            if (ecnAreaIDs != null) {
                foreach (int ecnAreaID in ecnAreaIDs) {
                    parameters = new DynamicParameters();
                    parameters.Add("@ECNNumber", ecn.ECNNumber);
                    parameters.Add("@AreaID", ecnAreaID);
                    db.Execute("ECNInsertAffectedAreas", parameters, commandType: CommandType.StoredProcedure);
                }
            }

            List<int> ecnTechnologyIDs = ecn.TechnologyIDs;
            parameters = new DynamicParameters();
            parameters.Add("@ECNNumber", ecn.ECNNumber);
            db.Execute("ECNDeleteAffectedTechnologies", parameters, commandType: CommandType.StoredProcedure);

            if (ecnTechnologyIDs != null) {
                foreach (int ecnTechnologyID in ecnTechnologyIDs) {
                    parameters = new DynamicParameters();
                    parameters.Add("@ECNNumber", ecn.ECNNumber);

                    parameters.Add("@TechnologyID", ecnTechnologyID);
                    db.Execute("ECNInsertAffectedTechnologies", parameters, commandType: CommandType.StoredProcedure);
                }
            }

            List<int> ecnAcknowledgementByIDs = ecn.AcknowledgementByIDs;
            parameters = new DynamicParameters();
            parameters.Add("@ECNNumber", ecn.ECNNumber);
            db.Execute("ECNDeleteAcknowledgementBy", parameters, commandType: CommandType.StoredProcedure);

            if (ecnAcknowledgementByIDs != null) {
                foreach (int ecnAcknowledgementByID in ecnAcknowledgementByIDs) {
                    parameters = new DynamicParameters();
                    parameters.Add("@ECNNumber", ecn.ECNNumber);

                    parameters.Add("@AcknowledgementByID", ecnAcknowledgementByID);
                    db.Execute("ECNInsertAcknowledgementBy", parameters, commandType: CommandType.StoredProcedure);
                }
            }

            List<int> ecnTrainingByIDs = ecn.TrainingByIDs;
            parameters = new DynamicParameters();
            parameters.Add("@ECNNumber", ecn.ECNNumber);
            db.Execute("ECNDeleteTrainingBy", parameters, commandType: CommandType.StoredProcedure);

            if (ecnTrainingByIDs != null) {
                foreach (int ecnTrainingByID in ecnTrainingByIDs) {
                    parameters = new DynamicParameters();
                    parameters.Add("@ECNNumber", ecn.ECNNumber);

                    parameters.Add("@TrainingByID", ecnTrainingByID);
                    db.Execute("ECNInsertTrainingBy", parameters, commandType: CommandType.StoredProcedure);
                }
            }

            List<int> ecnProductFamilyIDs = ecn.ProductFamilyIDs;
            parameters = new DynamicParameters();
            parameters.Add("@ECNNumber", ecn.ECNNumber);
            db.Execute("ECNDeleteAffectedProductFamilies", parameters, commandType: CommandType.StoredProcedure);

            if (ecnProductFamilyIDs != null) {
                foreach (int ecnProductFamilyID in ecnProductFamilyIDs) {
                    parameters = new DynamicParameters();
                    parameters.Add("@ECNNumber", ecn.ECNNumber);

                    parameters.Add("@ProductFamilyID", ecnProductFamilyID);
                    db.Execute("ECNInsertAffectedProductFamilies", parameters, commandType: CommandType.StoredProcedure);
                }
            }

            transanction.Complete();
        }
    }

    internal ECN GetECN(int ecnNumber, out int isITAR, int userID) {
        /* IsITAR 
            0 = false
            1 = true
            2 = not required
       */
        isITAR = 2;

        ECN ecnItem = new();
        DynamicParameters parameters = new();
        parameters.Add("@ECNNumber", value: ecnNumber);
        parameters.Add("@UserID", userID);
        parameters.Add("@IsITAR", value: isITAR, dbType: DbType.Int32, direction: ParameterDirection.InputOutput);

        using (var multipleResultItems = db.QueryMultiple("ECNGetItem", parameters, commandType: CommandType.StoredProcedure)) {
            ecnItem = multipleResultItems.Read<ECN>().SingleOrDefault();

            List<int> departments = multipleResultItems.Read<int>().ToList();
            if (ecnItem != null && departments != null) {
                if (departments.Count > 0)
                    ecnItem.DepartmentIDs.AddRange(departments);
            }

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

            List<int> areas = multipleResultItems.Read<int>().ToList();
            if (ecnItem != null && areas != null) {
                if (areas.Count > 0)
                    ecnItem.AreaIDs.AddRange(areas);
            }

            List<int> technologies = multipleResultItems.Read<int>().ToList();
            if (ecnItem != null && technologies != null) {
                if (technologies.Count > 0)
                    ecnItem.TechnologyIDs.AddRange(technologies);
            }

            List<int> acknowledgmentby = multipleResultItems.Read<int>().ToList();
            if (ecnItem != null && acknowledgmentby != null) {
                if (acknowledgmentby.Count > 0)
                    ecnItem.AcknowledgementByIDs.AddRange(acknowledgmentby);
            }

            List<int> trainingby = multipleResultItems.Read<int>().ToList();
            if (ecnItem != null && trainingby != null) {
                if (trainingby.Count > 0)
                    ecnItem.TrainingByIDs.AddRange(trainingby);
            }

            List<int> productfamilies = multipleResultItems.Read<int>().ToList();
            if (ecnItem != null && productfamilies != null) {
                if (productfamilies.Count > 0)
                    ecnItem.ProductFamilyIDs.AddRange(productfamilies);
            }

        }

        isITAR = parameters.Get<int>("@IsITAR");

        return ecnItem;
    }

    public int PCRBExists(int pcrb) {
        int result = 0;
        ECN ecnItem = new();
        DynamicParameters parameters = new();
        parameters.Add("@PCRB", value: pcrb);
        parameters.Add("@Result", value: result, dbType: DbType.Int32, direction: ParameterDirection.InputOutput);

        db.Execute("ECNPCRBExists", parameters, commandType: CommandType.StoredProcedure);
        result = parameters.Get<int>("@Result");

        return result;
    }

    internal ECN GetECNForRead(int ecnNumber, out int isITAR, int userID) {
        /* IsITAR 
            0 = false
            1 = true
            2 = not required
       */
        isITAR = 2;

        ECN ecnItem = new();
        DynamicParameters parameters = new();
        parameters.Add("@ECNNumber", value: ecnNumber);
        parameters.Add("@UserID", userID);
        parameters.Add("@IsITAR", value: isITAR, dbType: DbType.Int32, direction: ParameterDirection.InputOutput);

        using (var multipleResultItems = db.QueryMultiple("ECNGetItemForRead", parameters, commandType: CommandType.StoredProcedure)) {
            ecnItem = multipleResultItems.Read<ECN>().SingleOrDefault();

            List<int> departments = multipleResultItems.Read<int>().ToList();
            if (ecnItem != null && departments != null) {
                if (departments.Count > 0)
                    ecnItem.DepartmentIDs.AddRange(departments);
            }

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

            List<int> areas = multipleResultItems.Read<int>().ToList();
            if (ecnItem != null && areas != null) {
                if (areas.Count > 0)
                    ecnItem.AreaIDs.AddRange(areas);
            }

            List<int> technologies = multipleResultItems.Read<int>().ToList();
            if (ecnItem != null && technologies != null) {
                if (technologies.Count > 0)
                    ecnItem.TechnologyIDs.AddRange(technologies);
            }

            List<int> acknowledgmentby = multipleResultItems.Read<int>().ToList();
            if (ecnItem != null && acknowledgmentby != null) {
                if (acknowledgmentby.Count > 0)
                    ecnItem.AcknowledgementByIDs.AddRange(acknowledgmentby);
            }

            List<int> trainingby = multipleResultItems.Read<int>().ToList();
            if (ecnItem != null && trainingby != null) {
                if (trainingby.Count > 0)
                    ecnItem.TrainingByIDs.AddRange(trainingby);
            }

            List<int> productfamilies = multipleResultItems.Read<int>().ToList();
            if (ecnItem != null && productfamilies != null) {
                if (productfamilies.Count > 0)
                    ecnItem.ProductFamilyIDs.AddRange(productfamilies);
            }

        }

        isITAR = parameters.Get<int>("@IsITAR");

        return ecnItem;
    }

    internal ECNPdf GetECNPdf(int ecnNumber) {
        ECNPdf ecnItem = new();
        DynamicParameters parameters = new();
        parameters.Add("@ECNNumber", value: ecnNumber);

        using (var multipleResultItems = db.QueryMultiple("ECNGetPdfItem", parameters, commandType: CommandType.StoredProcedure)) {
            ecnItem = multipleResultItems.Read<ECNPdf>().SingleOrDefault();

            List<string> departments = multipleResultItems.Read<string>().ToList();
            List<string> modules = multipleResultItems.Read<string>().ToList();
            List<string> attachments = multipleResultItems.Read<string>().ToList();
            if (ecnItem != null && attachments != null) {
                if (attachments.Count > 0)
                    ecnItem.Attachments.AddRange(attachments);
            }

            List<ECNApprovalLog> approvalLog = multipleResultItems.Read<ECNApprovalLog>().ToList();
            if (ecnItem != null && approvalLog != null) {
                if (approvalLog.Count > 0)
                    ecnItem.Approvalog.AddRange(approvalLog);
            }

            List<string> affectedAreas = multipleResultItems.Read<string>().ToList();
            List<string> affectedTechnologies = multipleResultItems.Read<string>().ToList();
            List<string> acknowledgementBy = multipleResultItems.Read<string>().ToList();
            List<string> trainingBy = multipleResultItems.Read<string>().ToList();
            List<string> productfamilies = multipleResultItems.Read<string>().ToList();

            ecnItem.AffectedModules = string.Join(", ", modules);
            ecnItem.AffectedDepartments = string.Join(", ", departments);
            ecnItem.AffectedAreas = string.Join(",", affectedAreas);
            ecnItem.AffectedTechnologies = string.Join(",", affectedTechnologies);
            ecnItem.TrainingBy = string.Join(",", trainingBy);
            ecnItem.AcknowledgementBy = string.Join(",", acknowledgementBy);
            ecnItem.AffectedProductFamilies = string.Join(",", productfamilies);

        }
        return ecnItem;
    }

    public ECN GetECN(int ecnNumber) {
        ECN ecnItem = new();
        DynamicParameters parameters = new();
        parameters.Add("@ECNNumber", value: ecnNumber);

        ecnItem = db.Query<ECN>("ECNGetECNData", parameters, commandType: CommandType.StoredProcedure).Single();

        return ecnItem;
    }

    internal List<ECNAffectedDeparmtent> GetDepartments() {
        List<ECNAffectedDeparmtent> departments = db.Query<ECNAffectedDeparmtent>("ECNGetDepartments", null, commandType: CommandType.StoredProcedure).ToList();
        return departments;
    }

    internal List<ECNAffectedModule> GetModules() {
        List<ECNAffectedModule> modules = db.Query<ECNAffectedModule>("ECNGetModules", null, commandType: CommandType.StoredProcedure).ToList();
        return modules;
    }

    internal List<ECNCategory> GetCategories() {
        List<ECNCategory> r = db.Query<ECNCategory>("ECNGetCategories", null, commandType: CommandType.StoredProcedure).ToList();
        return r.OrderBy(l => l.CategoryName).ToList();
    }

    internal List<ECNArea> GetECNAreas() {
        StringBuilder query = new("SELECT AreaID , Area FROM ECNArea ORDER BY Area");
        return db.Query<ECNArea>(query.ToString()).ToList();
    }

    internal List<ECNTechnology> GetECNTechnologies() {
        DynamicParameters parameters = new();

        StringBuilder query = new("SELECT DISTINCT TechnologyID, Technology FROM ECNTechnology ORDER BY Technology");
        return db.Query<ECNTechnology>(query.ToString()).ToList();
    }

    internal List<ECNAcknowledgementTrainingBy> GetECNAcknowledgementTrainingBy() {
        DynamicParameters parameters = new();

        StringBuilder query = new("SELECT DISTINCT AcknowledgementTrainingByID, AcknowledgementTrainingBy FROM ECNAcknowledgementTrainingBy ORDER BY AcknowledgementTrainingBy");
        return db.Query<ECNAcknowledgementTrainingBy>(query.ToString()).ToList();
    }

    public IEnumerable<ECNAttachment> GetECNAttachments(int ecnNumber) {
        StringBuilder sql = new();
        sql.Append("SELECT A.AttachmentID, A.ECNNumber, A.FileName, A.UserID, CONVERT(VARCHAR(10), A.UploadDate, 101) AS UploadDate, U.FirstName + ' ' + U.LastName AS FullName ");
        sql.Append("FROM ECNAttachment A INNER JOIN Users U ON A.UserID  =  U.UserID WHERE ECNNumber = @ECNNumber  ");
        List<ECNAttachment> attachments = db.Query<ECNAttachment>(sql.ToString(), new { ECNNumber = ecnNumber }).ToList();
        return attachments;
    }

    public IEnumerable<ApprovalLogHistory> GetECNApprovalLogHistory(int ecnNumber) {
        DynamicParameters parameters = new();
        parameters.Add("@ECNNumber", ecnNumber);
        List<ApprovalLogHistory> approverList = db.Query<ApprovalLogHistory>("ECNGetECNApprovalLogHistory", parameters, commandType: CommandType.StoredProcedure).ToList();
        return approverList;
    }

    public IEnumerable<int> GetTECNNotificationUsers() {
        string sql = "select T.UserId from TECNNotificationsUsers T";
        List<int> result = db.Query<int>(sql).ToList();
        return result;
    }

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

    public void InsertECNAttachment(ECNAttachment attach) {
        DynamicParameters parameters = new();
        parameters.Add("@ECNNumber", attach.ECNNumber);
        parameters.Add("@UserID", attach.UserID);
        parameters.Add("@FileName", attach.FileName);

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

    public List<string> GetRejectionOrginatorEmailList(int ecnNumber) {
        DynamicParameters parameters = new();
        parameters.Add("@ECNNumber", ecnNumber);
        List<string> emailList = db.Query<string>("ECNGetRejectionOrginatorEmailList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return emailList;
    }

    public int SubmitDocument(int issueID, int userID, int documentType, out int allowedITAR) {
        allowedITAR = 1;
        string subRoles = "";
        if (documentType != (int)GlobalVars.DocumentType.EECN)
            subRoles = wfDMO.GetSubRoleItems(issueID, documentType);

        // bubble the error 
        int appoverCount = 0;
        DynamicParameters parameters = new();
        parameters.Add("@ECNNumber", issueID);
        parameters.Add("@UserID", userID);
        parameters.Add("@DocumentTypeID", documentType);
        parameters.Add("@SubRoleCategoriesClause", subRoles);
        parameters.Add("@AppoverCount", appoverCount, dbType: DbType.Int32, direction: ParameterDirection.Output);
        parameters.Add("@AllowedITAR", allowedITAR, dbType: DbType.Int32, direction: ParameterDirection.Output);
        db.Execute("ECNSubmitForApproval", parameters, commandType: CommandType.StoredProcedure);

        appoverCount = parameters.Get<int>("@AppoverCount");
        allowedITAR = parameters.Get<int>("@AllowedITAR");

        return appoverCount;
    }

    public int ReSubmitDocument(int issueID, int userID, int documentType, out int allowedITAR, string descriptionOfChange, string reasonForChange, string ecnTypeString, out int newECNNumber, int categoryId) {
        newECNNumber = 0;
        allowedITAR = 1;
        string subRoles = "";
        if (documentType != (int)GlobalVars.DocumentType.EECN)
            subRoles = wfDMO.GetSubRoleItems(issueID, documentType);

        // bubble the error 
        int appoverCount = 0;
        DynamicParameters parameters = new();
        parameters.Add("@ECNNumber", issueID);
        parameters.Add("@UserID", userID);
        parameters.Add("@DocumentTypeID", documentType);
        parameters.Add("@SubRoleCategoriesClause", subRoles);
        parameters.Add("@AppoverCount", appoverCount, dbType: DbType.Int32, direction: ParameterDirection.Output);
        parameters.Add("@DescriptionOfChange", descriptionOfChange);
        parameters.Add("@ReasonForChange", reasonForChange);
        parameters.Add("@NewECNTypeString", ecnTypeString);
        parameters.Add("NewECNNumber", newECNNumber, direction: ParameterDirection.Output);
        parameters.Add("@CategoryID", categoryId);
        db.Execute("ECNReSubmitForApproval", parameters, commandType: CommandType.StoredProcedure);

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

    public int SubmitForCancellation(int issueID, byte currentStep, int userID, int documentType, string ecnType, int TECNOperationType) {
        string subRoles = "";
        if (documentType != (int)GlobalVars.DocumentType.EECN)
            subRoles = wfDMO.GetSubRoleItems(issueID, documentType);

        // bubble the error 
        int appoverCount = 0;
        DynamicParameters parameters = new();
        parameters.Add("@ECNNumber", issueID);
        parameters.Add("@UserID", userID);
        parameters.Add("@DocumentTypeID", documentType);
        parameters.Add("@ECNType", ecnType);
        parameters.Add("@Step", currentStep);
        parameters.Add("@SubRoleCategoriesClause", subRoles);
        parameters.Add("@OperationType", TECNOperationType);
        parameters.Add("@AppoverCount", appoverCount, dbType: DbType.Int32, direction: ParameterDirection.Output);

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

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

    public int SubmitTECNExtensionDocument(int issueID, int userID, int documentType, DateTime extensionDate) {
        string subRoles = "";
        if (documentType != (int)GlobalVars.DocumentType.EECN)
            subRoles = wfDMO.GetSubRoleItems(issueID, documentType);

        // bubble the error 
        int appoverCount = 0;
        DynamicParameters parameters = new();
        parameters.Add("@ECNNumber", issueID);
        parameters.Add("@UserID", userID);
        parameters.Add("@DocumentTypeID", documentType);
        parameters.Add("@TECNExtensionDate", extensionDate);
        parameters.Add("@SubRoleCategoriesClause", subRoles);
        parameters.Add("@AppoverCount", appoverCount, dbType: DbType.Int32, direction: ParameterDirection.Output);

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

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

    public void SaveAfterSubmitByApprover(int ecnNumber, string implementationDetails) {
        DynamicParameters parameters = new();
        parameters.Add("@ECNNumber", ecnNumber);
        parameters.Add("@ImplementationDetails", implementationDetails);

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

    public void TECNExtensionLog(int ecnNumber, DateTime extensionDate) {
        DynamicParameters parameters = new();
        parameters.Add("@ECNNumber", ecnNumber);
        parameters.Add("@ExtensionDate", extensionDate);

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

    /// <summary>
    /// Cancels the document before the approval loopmis closed
    /// </summary>

    public void DeleteDocument(int ecnNumber, int userid, string ecnTypeString) {
        DynamicParameters parameters = new();
        parameters.Add("@UserID", userid);
        parameters.Add("@ECNNumber", ecnNumber);
        parameters.Add("@ECNType", ecnTypeString);

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

    public void UpdateECNType(int ecnNumber, string ecnType) {
        string updateSql = "";
        if (ecnType == "ECN")
            updateSql = "UPDATE ECN SET IsECN = 1 , IsTECN = 0, IsEmergencyTECN = 0 WHERE ECNNumber = @ECNNumber ";
        else if (ecnType == "TECN")
            updateSql = "UPDATE ECN SET IsECN = 0 , IsTECN = 1, IsEmergencyTECN = 0 WHERE ECNNumber = @ECNNumber ";

        db.Execute(updateSql, new { ECNNumber = ecnNumber }, commandType: CommandType.Text);
    }

    public void SetToExecutionStep(int ecnNumber, int userid, int documentType, string ecnTypeString) {
        DynamicParameters parameters = new();
        parameters.Add("@ECNNumber", ecnNumber);
        parameters.Add("@UserID", userid);
        parameters.Add("@DocumentType", documentType);
        parameters.Add("@ECNType", ecnTypeString);

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

    public bool ECNApproveCancelled_ExpiredDocument(int issueID, byte step, string comments, out bool lastStep, int userID, int documentType) {
        string subRolesInClause = wfDMO.GetSubRoleItems(issueID, documentType);

        lastStep = false;
        bool lastApproverInCurrentStep = false;

        DynamicParameters parameters = new();
        parameters.Add("@IssueID", issueID);
        parameters.Add("@CurrentStep", step);
        parameters.Add("@ItemStatus", (int)GlobalVars.ApprovalOption.Approved);
        parameters.Add("@UserID", userID);
        parameters.Add("@Comments", comments);
        parameters.Add("@SubRoleCategoriesClause", subRolesInClause);
        parameters.Add("@DocumentTypeID", documentType);
        parameters.Add("@LastStep", lastStep, dbType: DbType.Boolean, direction: ParameterDirection.Output);
        parameters.Add("@LastApproverInCurrentStep", lastApproverInCurrentStep, dbType: DbType.Boolean, direction: ParameterDirection.Output);

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

        lastStep = parameters.Get<bool>("@LastStep");
        lastApproverInCurrentStep = parameters.Get<bool>("@LastApproverInCurrentStep");

        return lastApproverInCurrentStep;
    }

    public IEnumerable<IssuesViewModel> GetECN_TECNPendingApprovals(int userID) {
        // later on the View Model will refer to a generic task list instead of the just Lot Disposition Items
        List<IssuesViewModel> data = db.Query<IssuesViewModel>("ECNGetECN_TECNPendingApprovalsByOriginator", new { userID }, commandType: CommandType.StoredProcedure).ToList();
        return data;
    }

    public IEnumerable<IssuesViewModel> GetMyExpiredTECNs(int userID, int maxDays) {
        // later on the View Model will refer to a generic task list instead of the just Lot Disposition Items
        List<IssuesViewModel> data = db.Query<IssuesViewModel>("ECNGetExpiredTECNByOriginator", new { userID, maxDays }, commandType: CommandType.StoredProcedure).ToList();
        return data;
    }

    public IEnumerable<IssuesViewModel> GetAllTECNs() {
        // later on the View Model will refer to a generic task list instead of the just Lot Disposition Items
        List<IssuesViewModel> data = db.Query<IssuesViewModel>("ECNGetAllTECN", commandType: CommandType.StoredProcedure).ToList();
        return data;
    }

    public IEnumerable<IssuesViewModel> GetMyConvertedTECNsToECNs(int userID, int maxDays) {
        // later on the View Model will refer to a generic task list instead of the just Lot Disposition Items
        List<IssuesViewModel> data = db.Query<IssuesViewModel>("ECNGetTECNConvertedToECNByOriginator", new { userID, maxDays }, commandType: CommandType.StoredProcedure).ToList();
        return data;
    }

    public IEnumerable<IssuesViewModel> GetMyExpiringTECNs(int userID, int maxDays) {
        // later on the View Model will refer to a generic task list instead of the just Lot Disposition Items
        List<IssuesViewModel> data = db.Query<IssuesViewModel>("ECNGetExpiringTECNByOriginator", new { userID, maxDays }, commandType: CommandType.StoredProcedure).ToList();
        return data;
    }

    public void CancelECN(int? ecnNumber) {
        DynamicParameters parameters = new();
        parameters.Add("@IssueID", ecnNumber);

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

    public void ECNResetTECNAtRejection(int ecnNumber, int userID, int docType) {
        DynamicParameters parameters = new();
        parameters.Add("@ECNNumber", ecnNumber);
        parameters.Add("@UserID", userID);
        parameters.Add("@DocumentTypeID", docType);

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

    public bool CanSubmitECN(int ecnNumber) {
        bool tecnExtensionState = false;
        DynamicParameters parameters = new();
        parameters.Add("@ECNNumber", ecnNumber);
        parameters.Add("@TECNExtensionState", value: tecnExtensionState, dbType: DbType.Boolean, direction: ParameterDirection.InputOutput);

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

        tecnExtensionState = parameters.Get<bool>("@TECNExtensionState");

        return tecnExtensionState;
    }

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

    public string GetFileName(string attachmentID) {
        DynamicParameters parameters = new();
        parameters.Add("@AttachmentID", attachmentID);
        var fileName = db.Query<string>("ECNGetFileName", parameters, commandType: CommandType.StoredProcedure).Single();
        return fileName;
    }

    public void ReassignOriginatorECN(int ecnNumber, int newOriginatorID, string comments, int userID) {
        DynamicParameters parameters = new();
        parameters.Add("@ECNNumber", ecnNumber);
        parameters.Add("@NewOriginatorID", newOriginatorID);
        parameters.Add("@Comments", comments);
        parameters.Add("@UserID", userID);

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

    internal List<ProductFamilies> GetProductFamilies() {
        List<ProductFamilies> r = db.Query<ProductFamilies>("ECNGetProductFamilies", null, commandType: CommandType.StoredProcedure).ToList();
        return r;
    }

}