using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Web;
using Fab2ApprovalSystem.Models;
using Dapper;
using System.Transactions;
using Fab2ApprovalSystem.ViewModels;
using System.Reflection;
using Fab2ApprovalSystem.Misc;

namespace Fab2ApprovalSystem.DMO
{
    public class LotTravelerDMO
    {
        private IDbConnection db = new SqlConnection(ConfigurationManager.ConnectionStrings["FabApprovalConnection"].ConnectionString);
        WorkflowDMO wfDMO = new WorkflowDMO();

        /// <summary>
        /// 
        /// </summary>
        /// <param name="workRequest"></param>
        /// <returns></returns>
        /// 
        internal LTWorkRequest InsertWorkRequest(LTWorkRequest workRequest)
        {

            var parameters = new DynamicParameters();
            parameters.Add("@ID", value: workRequest.ID, dbType: DbType.Int32, direction: ParameterDirection.InputOutput);
            parameters.Add("@OriginatorID", workRequest.OriginatorID);

            this.db.Execute("LTInsertWorkRequest", parameters, commandType: CommandType.StoredProcedure);
            workRequest.ID = parameters.Get<int>("@ID");

            return workRequest;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="issueID"></param>
        /// <param name="isITAR"></param>
        /// <param name="userID"></param>
        /// <returns></returns>
        internal LTWorkRequest GetLTWorkRequestItem(int workRequestID, out int isITAR, int userID)
        {


            isITAR = 2;
            var workRequestItem = new LTWorkRequest();
            var parameters = new DynamicParameters();
            parameters.Add("@WorkRequestID", value: workRequestID);
            parameters.Add("@UserID", userID);
            parameters.Add("@IsITAR", value: isITAR, dbType: DbType.Int32, direction: ParameterDirection.InputOutput);


            using (var multipleResultItems = this.db.QueryMultiple("LTGetWorkRequestItem", parameters, commandType: CommandType.StoredProcedure))
            {
                workRequestItem = multipleResultItems.Read<LTWorkRequest>().SingleOrDefault();

                var departments = multipleResultItems.Read<int>().ToList();
                if (workRequestItem != null && departments != null)
                {
                    workRequestItem.DepartmentIDs.AddRange(departments);
                }

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

                //var holdsteps = multipleResultItems.Read<LTHoldStep>().SingleOrDefault();
                //workRequestItem.LTHoldStep = holdsteps;

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


            }

            return workRequestItem;

        }


        internal WorkRequestPdf GetLTWorkRequestItemPDF(int workRequestID)
        {


            var workRequestItem = new WorkRequestPdf();
            var parameters = new DynamicParameters();
            parameters.Add("@WorkRequestID", value: workRequestID);


            using (var multipleResultItems = this.db.QueryMultiple("LTGetWorkRequestItemPDF", parameters, commandType: CommandType.StoredProcedure))
            {
                workRequestItem = multipleResultItems.Read<WorkRequestPdf>().SingleOrDefault();

                var departments = multipleResultItems.Read<string>().ToList();
                workRequestItem.AffectedDepartments = String.Join(", ", departments) ;

                var modules = multipleResultItems.Read<string>().ToList();
                workRequestItem.AffectedModules = String.Join(", ", modules);

                var materials = multipleResultItems.Read<LTMaterial>().ToList();
                if (workRequestItem != null && materials != null)
                {
                    if (materials.Count > 0)
                        workRequestItem.LTMaterial.AddRange(materials);
                }
                
                var holdsteps = multipleResultItems.Read<LTHoldStep>().ToList();
                if (workRequestItem != null && holdsteps != null)
                {
                    if (holdsteps.Count > 0)
                        workRequestItem.LTHoldStep.AddRange(holdsteps);
                }
            }

            return workRequestItem;

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="workRequestID"></param>
        /// <param name="isITAR"></param>
        /// <param name="userID"></param>
        /// <returns></returns>
        internal LTWorkRequest GetLTWorkRequestItemForRead(int workRequestID, out int isITAR, int userID)
        {


            isITAR = 2;
            var workRequestItem = new LTWorkRequest();
            var parameters = new DynamicParameters();
            parameters.Add("@WorkRequestID", value: workRequestID);
            parameters.Add("@UserID", userID);
            parameters.Add("@IsITAR", value: isITAR, dbType: DbType.Int32, direction: ParameterDirection.InputOutput);


            using (var multipleResultItems = this.db.QueryMultiple("LTGetWorkRequestItemForRead", parameters, commandType: CommandType.StoredProcedure))
            {
                workRequestItem = multipleResultItems.Read<LTWorkRequest>().SingleOrDefault();

                var departments = multipleResultItems.Read<int>().ToList();
                if (workRequestItem != null && departments != null)
                {
                    workRequestItem.DepartmentIDs.AddRange(departments);
                }

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

                //var holdsteps = multipleResultItems.Read<LTHoldStep>().SingleOrDefault();
                //workRequestItem.LTHoldStep = holdsteps;

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


            }

            return workRequestItem;

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="data"></param>
        internal int UpdateWorkRequest(LTWorkRequest data, int userID)
        {
            int result = 0;
                var parameters = new DynamicParameters();
                using (var transanction = new TransactionScope())
                {
                    try
                    {


                        parameters.Add("@LTWorkRequestID", data.ID);
                        parameters.Add("@Title", data.Title);
                        parameters.Add("@LotType", data.LotType);
                        parameters.Add("@EngLotStartRequired", data.EngLotStartRequired);
                        parameters.Add("@LotTypeConversion", data.LotTypeConversion);
                        parameters.Add("@QualLot", data.QualLot);
                        parameters.Add("@PurposeOfRequest", data.PurposeOfRequest);
                        parameters.Add("@PlannedLotStartDate", data.PlannedLotStartDate);
                        parameters.Add("@PlannedScheduledCloseDate", data.PlannedScheduledCloseDate);
                        parameters.Add("@ChargeDepartment", data.ChargeDepartment);
                        parameters.Add("@AllocationToUse", data.AllocationToUse);
                        parameters.Add("@PredictedCyleTime", data.PredictedCyleTime);
                        parameters.Add("@DeptChargedForRawWafers", data.ChargeDepartment);
                        //parameters.Add("@EstimatedBinCLoseDate", data.EstimatedBinCLoseDate);
                        parameters.Add("@TotalQty", data.TotalQty);
                        parameters.Add("@WIPArea", data.WIPArea);
                        parameters.Add("@LotStartDate", data.LotStartDate);
                        parameters.Add("@LotNumber", data.LotNumber);
                        parameters.Add("@WIPPartNumber", data.WIPPartNumber);
                        parameters.Add("@PartDescription", data.PartDescription);
                        parameters.Add("@DefaultEPISiliconPartNumber", data.DefaultEPISiliconPartNumber);
                        parameters.Add("@RecordSiliconLotInSPNTapeTagTotrav", data.RecordSiliconLotInSPNTapeTagTotrav);
                        parameters.Add("@SiliconLotNoCassette1", data.SiliconLotNoCassette1);
                        parameters.Add("@ProcessFlow", data.ProcessFlow);
                        parameters.Add("@EmployeeID", data.EmployeeID);
                        parameters.Add("@VerbComment", data.VerbComment);
                        parameters.Add("@SiliconOnHand", data.SiliconOnHand);
                        parameters.Add("@SiliconExpectedDueDate", data.SiliconExpectedDueDate);
                        parameters.Add("@SiliconComments", data.SiliconComments);
                        parameters.Add("@ReticleOnHand", data.ReticleOnHand);
                        parameters.Add("@ReticleExpectedDueDate", data.ReticleExpectedDueDate);
                        parameters.Add("@ReticleComments", data.ReticleComments);
                        parameters.Add("@SPNTransferOnHand", data.SPNTransferOnHand);
                        parameters.Add("@SPNTransferExpectedDueDate", data.SPNTransferExpectedDueDate);
                        parameters.Add("@SPNTransferComments", data.SPNTransferComments);
                        parameters.Add("@ProbeCardOnHand", data.ProbeCardOnHand);
                        parameters.Add("@ProbeCardExpectedDueDate", data.ProbeCardExpectedDueDate);
                        parameters.Add("@ProbeCardComments", data.ProbeCardComments);
                        parameters.Add("@ProbeRecipeOnHand", data.ProbeRecipeOnHand);
                        parameters.Add("@ProbeRecipeExpectedDueDate", data.ProbeRecipeExpectedDueDate);
                        parameters.Add("@ProbeRecipeComments", data.ProbeRecipeComments);
                        parameters.Add("@ProcessChangeDetailsOnHand", data.ProcessChangeDetailsOnHand);
                        parameters.Add("@ProcessChangeDetailsDueDate", data.ProcessChangeDetailsDueDate);
                        parameters.Add("@LotStartCheckListComments", data.LotStartCheckListComments);
                        parameters.Add("@PCRBNumber", data.PCRBNumber);
                        parameters.Add("@LastUpdateBy", userID);
                        parameters.Add("@Result", result,  direction: ParameterDirection.InputOutput);
                        this.db.Execute("LTUpdateWorkRequest", parameters, commandType: CommandType.StoredProcedure);

                        result = parameters.Get<int>("@Result");

                        if (result == -1)
                        {
                            throw new Exception("In order to do the UPDATE or SUBMIT operation the record needs to exclusively locked by you.\nThe record was unlocked by the system due to inactivity for more than 30 minutes, hence the update was not successful");
                        }

                        parameters = new DynamicParameters();
                        parameters.Add("@WorkRequestID", data.ID);
                        this.db.Execute("LTDeleteAffectedDepartments", parameters, commandType: CommandType.StoredProcedure);
                        List<int> wrDepIDs = data.DepartmentIDs;
                        if (wrDepIDs != null)
                        {
                            foreach (int depId in wrDepIDs)
                            {
                                parameters = new DynamicParameters();
                                parameters.Add("@WorkRequestID", data.ID);
                                parameters.Add("@DepartmentID", depId);
                                this.db.Execute("LTInsertAffectedDepartments", parameters, commandType: CommandType.StoredProcedure);
                            }
                        }

                        parameters = new DynamicParameters();
                        parameters.Add("@WorkRequestID", data.ID);
                        this.db.Execute("LTDeleteAffectedModules", parameters, commandType: CommandType.StoredProcedure);

                        List<int> wrModuleIDs = data.ModuleIDs;
                        if (wrModuleIDs != null)
                        {
                            foreach (int moduleID in wrModuleIDs)
                            {
                                parameters = new DynamicParameters();
                                parameters.Add("@WorkRequestID", data.ID);
                                parameters.Add("@ModuleID", moduleID);
                                this.db.Execute("LTInsertAffectedModules", parameters, commandType: CommandType.StoredProcedure);
                            }
                        }
                        transanction.Complete();
                    }
                    catch (Exception ex)
                    {                        
                        transanction.Dispose();
                        throw new Exception(ex.Message + " " + ex.InnerException);
                    }

                }

                // have to do it outside of the Transaction scope because the OPENQUERY to TEMIRWAP019 LINKED server does not work 
                parameters = new DynamicParameters();
                parameters.Add("@WorkRequestID", data.ID);
                this.db.Execute("LTUpdateIsITAR", parameters, commandType: CommandType.StoredProcedure);

                return result;
    
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="wrAttachmentID"></param>
        /// <returns></returns>
        internal LTWorkRequestAttachment GetWorkRequestAttachDetail(int wrAttachmentID)
        {
            var wrAttach = this.db.Query<LTWorkRequestAttachment>("SELECT ID, FileName ,DocType, Comments FROM LTWorkRequestAttachment WHERE ID = @wrAttachmentID ", new { wrAttachmentID = wrAttachmentID }, commandType: CommandType.Text).Single();
            return wrAttach;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="workRequestID"></param>
        /// <returns></returns>
        internal IEnumerable<LTMaterialViewModel> GetMaterialDetails(int workRequestID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@workRequestID", value: workRequestID);

            var data = this.db.Query<LTMaterialViewModel>("LTGetMaterialDetails", parameters, commandType: CommandType.StoredProcedure).ToList();
            return data;
        }

        /// <summary>
        /// Update via the edit screen
        /// </summary>
        /// <param name="model"></param>
        internal void UpdateMaterialDetail(LTMaterialViewModel model, int userID)
        {
            int result = 0;           
            var parameters = new DynamicParameters();
            parameters.Add("@LTMaterialID", model.ID);
            parameters.Add("@EPISiliconPartNumber", model.@EPISiliconPartNumber);
            parameters.Add("@Quantity", model.Quantity);
            parameters.Add("@Source", model.Source);
            parameters.Add("@Supplier", model.Supplier);
            parameters.Add("@UpdatedBy", userID);
            parameters.Add("@Result", result, direction: ParameterDirection.InputOutput);

            this.db.Execute("LTUpdateMaterialDetail", parameters, commandType: CommandType.StoredProcedure);
            result = parameters.Get<int>("@Result");
            if (result == -1)
            {
                throw new Exception("In order to do the UPDATE or SUBMIT operation the record needs to exclusively locked by you.\nThe record was unlocked by the system due to inactivity for more than 30 minutes, hence the update was not successful");
            }
        }

        /// <summary>
        /// Update via the revision screen
        /// </summary>
        /// <param name="model"></param>
        internal void UpdateMaterialDetail(LTMaterial model, int userID)
        {
            int result = 0;
            var parameters = new DynamicParameters();
            parameters.Add("@LTMaterialID", model.ID);
            parameters.Add("@EPISiliconPartNumber", model.@EPISiliconPartNumber);
            parameters.Add("@Quantity", model.Quantity);
            parameters.Add("@Source", model.Source);
            parameters.Add("@Supplier", model.Supplier);
            parameters.Add("@UpdatedBy", userID);
            parameters.Add("@Result", result, direction: ParameterDirection.InputOutput);

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

            result = parameters.Get<int>("@Result");
            if (result == -1)
            {
                throw new Exception("In order to do the UPDATE or SUBMIT operation the record needs to exclusively locked by you.\nThe record was unlocked by the system due to inactivity for more than 30 minutes, hence the update was not successful");
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        /// <param name="currentWorkIDRequest"></param>
        /// <param name="newWorkRequestID"></param>
        internal void UpdateMaterialDetailRevision(LTMaterial model, int previousMaterialID)
        {

            var parameters = new DynamicParameters();
            parameters.Add("@LTMaterialID", model.ID);
            parameters.Add("@EPISiliconPartNumber", model.EPISiliconPartNumber);
            parameters.Add("@Quantity", model.Quantity);
            parameters.Add("@Source", model.Source);
            parameters.Add("@Supplier", model.Supplier);
            parameters.Add("@PreviousMaterialID", previousMaterialID);

            this.db.Execute("LTUpdateMaterialDetailRevision", parameters, commandType: CommandType.StoredProcedure);
        }
    
        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        internal void InsertMaterialDetail(LTMaterialViewModel model, int userID)
        {
            int result = 0;
            var parameters = new DynamicParameters();
            parameters.Add("@LTMaterialID", model.ID, direction: ParameterDirection.InputOutput);
            parameters.Add("@EPISiliconPartNumber", model.@EPISiliconPartNumber);
            parameters.Add("@Quantity", model.Quantity);
            parameters.Add("@Source", model.Source);
            parameters.Add("@Supplier", model.Supplier);
            parameters.Add("@LTWorkRequestID", model.LTWorkRequestID);
            parameters.Add("@UpdatedBy", userID);
            parameters.Add("@Result", result, direction: ParameterDirection.InputOutput);

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

            int id = parameters.Get<int>("@LTMaterialID");
            model.ID = id;

            result = parameters.Get<int>("@Result");
            if (result == -1)
            {
                throw new Exception("In order to do the UPDATE or SUBMIT operation the record needs to exclusively locked by you.\nThe record was unlocked by the system due to inactivity for more than 30 minutes, hence the update was not successful");
            }
        }

        /// <summary>
        /// For Revisioing the data
        /// </summary>
        /// <param name="model"></param>
        internal void InsertMaterialDetail(LTMaterial model, int userID)
        {
            int result = 0;
            var parameters = new DynamicParameters();
            parameters.Add("@LTMaterialID", model.ID, direction: ParameterDirection.InputOutput);
            parameters.Add("@EPISiliconPartNumber", model.@EPISiliconPartNumber);
            parameters.Add("@Quantity", model.Quantity);
            parameters.Add("@Source", model.Source);
            parameters.Add("@Supplier", model.Supplier);
            parameters.Add("@LTWorkRequestID", model.LTWorkRequestID);
            parameters.Add("@UpdatedBy", userID);
            parameters.Add("@Result", result, direction: ParameterDirection.InputOutput);


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

            int id = parameters.Get<int>("@LTMaterialID");
            model.ID = id;

            result = parameters.Get<int>("@Result");
            if (result == -1)
            {
                throw new Exception("In order to do the UPDATE or SUBMIT operation the record needs to exclusively locked by you.\nThe record was unlocked by the system due to inactivity for more than 30 minutes, hence the update was not successful");
            }
        }


      

        /// <summary>
        /// 
        /// </summary>
        /// <param name="LTMaterialID"></param>
        internal void DeleteMaterialDetail(int LTMaterialID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@LTMaterialID", LTMaterialID);
            this.db.Execute("LTDeleteMaterial", parameters, commandType: CommandType.StoredProcedure);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="LTMaterialID"></param>
        internal void DeleteMaterialDetailRevision(int materialID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@MaterialID", materialID);
            this.db.Execute("LTDeleteMaterialRevision", parameters, commandType: CommandType.StoredProcedure);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="processFlow"></param>
        /// <returns></returns>
        internal List<BaseFlowLocation> GetBaseFlowLocations(string processFlow)
        {
            var baseFlowLocations = this.db.Query<BaseFlowLocation>("SELECT DISTINCT LOC as Location FROM vSPNPDB_FLOWLOCS WHERE PROCESS = @ProcessFlow ORDER BY LOC ", new { ProcessFlow = processFlow }, commandType: CommandType.Text).ToList();
            return baseFlowLocations;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="materialID"></param>
        /// <returns></returns>
        internal LTMaterial GetMaterialRecord(int materialID)
        {
            var material = this.db.Query<LTMaterial>("SELECT * FROM LTMaterial WHERE ID = @materialID ", new { materialID }, commandType: CommandType.Text).Single();
            return material;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="processFlow"></param>
        /// <param name="loc"></param>
        /// <returns></returns>
        internal List<BaseFlowOperations> GetBaseFlowOperations(string processFlow, string loc)
        {
            var baseFlowOperations = this.db.Query<BaseFlowOperations>(
                "SELECT DISTINCT " + 
                "  LTRIM(RTRIM(OPER)) + '-' + LTRIM(RTRIM(SEQ))  as Operation, " +
                "  LTRIM(RTRIM(OPER)) as OperCode, " +
                "  LTRIM(RTRIM(SEQ)) as SeqCode, " +
                "  LTRIM(RTRIM([OPDESC])) + ' (' + LTRIM(RTRIM([AREA])) + ')'  AS 'OperationDesc' " + 
                "FROM vSPNPDB_FLOWLOCS " + 
                "WHERE PROCESS = @ProcessFlow AND LOC = @LOC " + 
                "ORDER BY Operation ", 
                new { ProcessFlow = processFlow, LOC = loc }, commandType: CommandType.Text).ToList();
            return baseFlowOperations;
        }


        internal List<PartNumberAttrib> GetPartNumbers()
        {
           
            var baseFlowOperations = this.db.Query<PartNumberAttrib>("SELECT DISTINCT  TOP 100 [MP_PART_NUMBER] AS PartNumber,  MP_DESCRIPTION +  ' ~ ' + MP_PART_NUMBER AS SiliconAndDesc FROM vFAB2SPN_MP_RECORD ORDER BY MP_PART_NUMBER ", commandType: CommandType.Text).ToList();
            return baseFlowOperations;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="workRequestID"></param>
        /// <returns></returns>
        internal IEnumerable<LTHoldStep> GetHoldSteps(int workRequestID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@workRequestID", value: workRequestID);

            var data = this.db.Query<LTHoldStep>("LTGetHoldSteps", parameters, commandType: CommandType.StoredProcedure).ToList();
            return data;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        internal void InsertHoldStep(LTHoldStep model)
        {
            int result = 0;
            var parameters = new DynamicParameters();
            parameters.Add("@LTHoldStepID", model.ID, dbType: DbType.Int32, direction: ParameterDirection.InputOutput);
            parameters.Add("@BaseFlow", model.BaseFlow);
            parameters.Add("@BaseFlowLocation", model.Location);
            parameters.Add("@BaseFlowOperationSeq", model.OperSequence);
            parameters.Add("@BaseFlowOperation", model.Operation);            
            parameters.Add("@OperationDescription", model.OperationDescription);
            parameters.Add("@ChangeInstruction", model.ChangeInstructions);
            parameters.Add("@LTWorkRequestID", model.LTWorkRequestID);
            parameters.Add("@UpdatedBy", model.UpdatedBy);
            parameters.Add("@Result", result, direction: ParameterDirection.InputOutput);
            this.db.Execute("LTInsertHoldStep", parameters, commandType: CommandType.StoredProcedure);

            int id = parameters.Get<int>("@LTHoldStepID");
            model.ID = id;

            result = parameters.Get<int>("@Result");

            //if (result == -1)
            //{
            //    throw new Exception("In order to do the UPDATE or SUBMIT operation the record needs to exclusively locked by you.\nThe record was unlocked by the system due to inactivity for more than 30 minutes, hence the update was not successful");
            //}

            
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        internal void UpdateHoldStep(LTHoldStep model)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@LTHoldStepID", model.ID, dbType: DbType.Int32, direction: ParameterDirection.InputOutput);
            parameters.Add("@BaseFlow", model.BaseFlow);
            parameters.Add("@BaseFlowOperationSeq", model.OperSequence);
            parameters.Add("@BaseFlowLocation", model.Location);
            parameters.Add("@BaseFlowOperation", model.Operation);
            parameters.Add("@OperationDescription", model.OperationDescription);
            parameters.Add("@ChangeInstruction", model.ChangeInstructions);
            parameters.Add("@LTWorkRequestID", model.LTWorkRequestID);
            parameters.Add("@UpdatedBy", model.UpdatedBy);

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

            //int id = parameters.Get<int>("@LTHoldStepID");
            //model.ID = id;


        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        internal void InsertHoldStepRevision(LTHoldStep model)
        {
            int result = 0;
            var parameters = new DynamicParameters();
            parameters.Add("@LTHoldStepID", model.ID, dbType: DbType.Int32, direction: ParameterDirection.InputOutput);
            parameters.Add("@BaseFlow", model.BaseFlow);
            parameters.Add("@BaseFlowLocation", model.Location);
            parameters.Add("@BaseFlowOperationSeq", model.OperSequence);
            parameters.Add("@BaseFlowOperation", model.Operation);
            parameters.Add("@OperationDescription", model.OperationDescription);
            parameters.Add("@ChangeInstruction", model.ChangeInstructions);
            parameters.Add("@LTWorkRequestID", model.LTWorkRequestID);
            parameters.Add("@UpdatedBy", model.UpdatedBy);
           

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

            int id = parameters.Get<int>("@LTHoldStepID");
            model.ID = id;


        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        internal void UpdateHoldStepRevision(LTHoldStep model)
        {
            int result = 0;
            var parameters = new DynamicParameters();
            parameters.Add("@LTHoldStepID", model.ID, dbType: DbType.Int32, direction: ParameterDirection.InputOutput);
            //parameters.Add("@BaseFlow", model.BaseFlow);
            parameters.Add("@BaseFlowLocation", model.Location);
            parameters.Add("@BaseFlowOperationSeq", model.OperSequence);
            parameters.Add("@BaseFlowOperation", model.Operation);
            parameters.Add("@OperationDescription", model.OperationDescription);
            parameters.Add("@ChangeInstruction", model.ChangeInstructions);
            parameters.Add("@LTWorkRequestID", model.LTWorkRequestID);
            parameters.Add("@UpdatedBy", model.UpdatedBy);
            //parameters.Add("@Result", result, direction: ParameterDirection.InputOutput);

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

            //result = parameters.Get<int>("@Result");
            //if (result == -1)
            //{
            //    throw new Exception("Cannot add the Hold Step as the step has already been passed in the Mfg Process.");
            //}


        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="holdStepID"></param>
        internal void DeleteHoldStep(int holdStepID, int userID)
        {
            int result = 0;
            var parameters = new DynamicParameters();
            parameters.Add("@HoldStepID", holdStepID);
            parameters.Add("@UpdatedBy", userID);
            parameters.Add("@Result", result, direction: ParameterDirection.InputOutput);

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

            result = parameters.Get<int>("@Result");
            if (result == -1)
            {
                throw new Exception("In order to do the UPDATE or SUBMIT operation the record needs to exclusively locked by you.\nThe record was unlocked by the system due to inactivity for more than 30 minutes, hence the update was not successful");
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="holdStepID"></param>
        internal void DeleteHoldStepRevision(int holdStepID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@HoldStepID", holdStepID);
            this.db.Execute("LTDeleteHoldStepRevision", parameters, commandType: CommandType.StoredProcedure);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="lotTravHoldStepID"></param>
        internal void DeleteLotTravHoldStep(int lotTravHoldStepID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@LotTravHoldStepID", lotTravHoldStepID);
            this.db.Execute("LTDeleteLotTravHoldStep", parameters, commandType: CommandType.StoredProcedure);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="holdStepID"></param>
        internal void DeleteLotTravHoldStepRevision(int lotTravHoldStepID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@LotTravHoldStepID", lotTravHoldStepID);
            this.db.Execute("LTDeleteLotTravHoldStepRevision", parameters, commandType: CommandType.StoredProcedure);
        }




        /// <summary>
        /// 
        /// </summary>
        /// <param name="holdStep"></param>
        /// <returns></returns>
        internal IEnumerable<LTWorkRequestAttachment> GetHoldStepAttachemnts(int holdStepID)
        {
            //var holdStepAttachments = this.db.Query<LTWorkRequestAttachment>("SELECT * FROM LTWorkRequestAttachment WHERE HoldStepID = @HoldStep ORDER BY UploadDateTime", new { holdStep }, commandType: CommandType.Text).ToList();
            var parameters = new DynamicParameters();
            parameters.Add("@HoldStepID", holdStepID);
            var data = this.db.Query<LTWorkRequestAttachment>("LTGetHoldStepAttachments", parameters, commandType: CommandType.StoredProcedure).ToList();
            return data;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="holdStepID"></param>
        /// <returns></returns>
        internal IEnumerable<LTWorkRequestAttachment> GetLotTravHoldStepAttachemnts(int ltHoldStepID)
        {
            //var holdStepAttachments = this.db.Query<LTWorkRequestAttachment>("SELECT * FROM LTWorkRequestAttachment WHERE HoldStepID = @HoldStep ORDER BY UploadDateTime", new { holdStep }, commandType: CommandType.Text).ToList();
            var parameters = new DynamicParameters();
            parameters.Add("@LTHoldStepID", ltHoldStepID);
            var data = this.db.Query<LTWorkRequestAttachment>("LTGetLotTravHoldStepAttachments", parameters, commandType: CommandType.StoredProcedure).ToList();
            return data;
        }
       
        /// <summary>
        /// 
        /// </summary>
        /// <param name="holdStepID"></param>
        /// <returns></returns>
        internal LTHoldStep GetHoldStep(int holdStepID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@HoldStepID", value: holdStepID);

            var data = this.db.Query<LTHoldStep>("LTGetHoldStep", parameters, commandType: CommandType.StoredProcedure).SingleOrDefault();
            return data;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="ltHoldStepID"></param>
        /// <returns></returns>
        internal LTLotTravelerHoldSteps GetLotTravHoldStep(int ltHoldStepID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@LotTravHoldStepID", value: ltHoldStepID);

            var data = this.db.Query<LTLotTravelerHoldSteps>("LTGetLotTravHoldStep", parameters, commandType: CommandType.StoredProcedure).SingleOrDefault();
            return data;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="attachment"></param>
        internal void InsertLotHoldStepAttachment(LTWorkRequestAttachment attachment)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@HoldStepID", attachment.LTHoldStepID);
            parameters.Add("@FileName", attachment.FileName);
            parameters.Add("@FileGUID", attachment.FileGUID);
            parameters.Add("@DocType", attachment.DocType);
            parameters.Add("@UploadedByID", attachment.UploadedByID);
            parameters.Add("@Comments", attachment.Comments);
            this.db.Execute("LTInsertHoldStepAttachment", parameters, commandType: CommandType.StoredProcedure);

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="attachment"></param>
        internal void InsertLotHoldStepAttachmentRevision(LTWorkRequestAttachment attachment)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@HoldStepID", attachment.LTHoldStepID);
            parameters.Add("@FileName", attachment.FileName);
            parameters.Add("@FileGUID", attachment.FileGUID);
            parameters.Add("@DocType", attachment.DocType);
            parameters.Add("@UploadedByID", attachment.UploadedByID);
            parameters.Add("@Comments", attachment.Comments);
            this.db.Execute("LTInsertHoldStepAttachmentRevision", parameters, commandType: CommandType.StoredProcedure);

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="attachment"></param>
        internal void InsertWorkRequestAttachment(LTWorkRequestAttachment attachment)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@WorkRequestID", attachment.WorkRequestID);
            parameters.Add("@FileName", attachment.FileName);
            parameters.Add("@FileGUID", attachment.FileGUID);
            parameters.Add("@DocType", attachment.DocType);
            parameters.Add("@UploadedByID", attachment.UploadedByID);
            parameters.Add("@Comments", attachment.Comments);
            this.db.Execute("LTInsertWorkRequestAttachment", parameters, commandType: CommandType.StoredProcedure);

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="attachment"></param>
        internal void InsertWorkRequestAttachmentRevision(LTWorkRequestAttachment attachment)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@WorkRequestID", attachment.WorkRequestID);
            parameters.Add("@FileName", attachment.FileName);
            parameters.Add("@FileGUID", attachment.FileGUID);
            parameters.Add("@DocType", attachment.DocType);
            parameters.Add("@UploadedByID", attachment.UploadedByID);
            parameters.Add("@Comments", attachment.Comments);
            this.db.Execute("LTInsertWorkRequestAttachmentRevision", parameters, commandType: CommandType.StoredProcedure);

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="prevHoldStepID"></param>
        /// <returns></returns>
        internal int GetRevisedWrkReqIDFromHoldStepID(int prevHoldStepID)
        {
            int workRequestID = this.db.Query<int>("SELECT LTWorkRequestID FROM LTHoldStep WHERE PreviousHoldStepID = @PrevHoldStepID", new { PrevHoldStepID = prevHoldStepID }, commandType: CommandType.Text).Single();

            return workRequestID;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="prevWorkRequestID"></param>
        /// <returns></returns>
        internal int GetRevisedWrkReqIDFromPreviousWrkReqID(int prevWorkRequestID)
        {
            int workRequestID = this.db.Query<int>("SELECT ID FROM LTWorkRequest WHERE PreviousWorkRequestID = @prevWorkRequestID", new { prevWorkRequestID = prevWorkRequestID }, commandType: CommandType.Text).Single();

            return workRequestID;
        }


        
        /// <summary>
        /// 
        /// </summary>
        /// <param name="workRequestID"></param>
        /// <returns></returns>
        internal IEnumerable<LTWorkRequestAttachment> GetWorkRequestAttachments(int workRequestID)
        {
            //var holdStepAttachments = this.db.Query<LTWorkRequestAttachment>("SELECT * FROM LTWorkRequestAttachment WHERE HoldStepID = @HoldStep ORDER BY UploadDateTime", new { holdStep }, commandType: CommandType.Text).ToList();
            var parameters = new DynamicParameters();
            parameters.Add("@WorkRequestID", workRequestID);
            var data = this.db.Query<LTWorkRequestAttachment>("LTGetWorkRequestAttachments", parameters, commandType: CommandType.StoredProcedure).ToList();
            return data;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="attachment"></param>
        internal void UpdateWorkRequestAttachment(LTWorkRequestAttachment attachment)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@WorkRequestAttachmentID", attachment.ID);
            parameters.Add("@DocType", attachment.DocType);
            parameters.Add("@Comments", attachment.Comments);

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

        /// <summary>
        /// 
        /// </summary>
        /// <param name="attachment"></param>
        internal void UpdateWorkRequestAttachmentRevision(LTWorkRequestAttachment attachment, int previousWorkRequestAttachmentID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@WorkRequestAttachmentID", attachment.ID);
            parameters.Add("@FileName", attachment.FileName);
            parameters.Add("@DocType", attachment.DocType);
            parameters.Add("@Comments", attachment.Comments);
            parameters.Add("@PreviousWorkRequestAttachmentID", previousWorkRequestAttachmentID);

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


        /// <summary>
        /// 
        /// </summary>
        /// <param name="workRequestAttachmentID"></param>
        internal void DeleteWorkRequestAttachment(int workRequestAttachmentID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@WorkRequestAttachmentID", workRequestAttachmentID);
            this.db.Execute("LTDeleteWorkRequestAttachment", parameters, commandType: CommandType.StoredProcedure);
        }


        internal void DeleteWorkRequestAttachmentRevision(int workRequestAttachmentID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@WorkRequestAttachmentID", workRequestAttachmentID);
            this.db.Execute("LTDeleteWorkRequestAttachmentRevision", parameters, commandType: CommandType.StoredProcedure);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="workRequestID"></param>
        /// <param name="userID"></param>
        /// <param name="documentType"></param>
        /// <param name="allowedITAR"></param>
        /// <returns></returns>
        public int SubmitDocument(int workRequestID, int userID, int documentType, out int allowedITAR)
        {
            allowedITAR = 1;
            string subRoles = "";
            subRoles = wfDMO.GetSubRoleItems(workRequestID, documentType);

            // bubble the error 
            int appoverCount = 0;
            var parameters = new DynamicParameters();
            parameters.Add("@WorkRequestID", workRequestID);
            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);
            this.db.Execute("LTSubmitForApproval", parameters, commandType: CommandType.StoredProcedure);

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

            return appoverCount;

        }

        /// <summary>
        /// Release lock on all the documents locked by the current user
        /// </summary>
        /// <param name="userID"></param>
        public void ReleaseLockOnDocument(int userID, int workRequestID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@WorkRequestID", workRequestID);
            parameters.Add("@UserID", userID);
            this.db.Execute("LTReleaseLockOnDocuments", parameters, commandType: CommandType.StoredProcedure);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="userID"></param>
        /// <param name="workRequestID"></param>
        public void ReleaseLockOnLotTravelerUpdateDoc(int userID, int ltLotID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@LTLotID", ltLotID);
            parameters.Add("@UserID", userID);
            this.db.Execute("LTReleaseLockOnLTUpdateDoc", parameters, commandType: CommandType.StoredProcedure);
        }


       

        /// <summary>
        /// 
        /// </summary>
        /// <param name="workRequestID"></param>
        /// <returns></returns>
        public List<string> GetRejectionOrginatorEmailList(int workRequestID)
        {

            var parameters = new DynamicParameters();
            parameters.Add("@WorkRequestID", workRequestID);
            var emailList = this.db.Query<string>("LTGetRejectionOrginatorEmailList", parameters, commandType: CommandType.StoredProcedure).ToList();
            return emailList;

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="data"></param>
        /// <param name="userID"></param>
        /// <returns></returns>
        public int CreateWorkRequestRevision(LTWorkRequest  data, int userID)
        {
            int newWorkRequestID = -1;
            var parameters = new DynamicParameters();
            parameters.Add("@UserID", userID);
            parameters.Add("@ChangeComments", data.RevisionComments);
            parameters.Add("@CurrentStep", data.CurrentStep);
            parameters.Add("@LTWorkRequestID", data.ID);
            parameters.Add("@Title", data.Title);
            parameters.Add("@LotType", data.LotType);
            parameters.Add("@EngLotStartRequired", data.EngLotStartRequired);
            parameters.Add("@LotTypeConversion", data.LotTypeConversion);
            parameters.Add("@QualLot", data.QualLot);
            parameters.Add("@PurposeOfRequest", data.PurposeOfRequest);
            parameters.Add("@PlannedLotStartDate", data.PlannedLotStartDate);
            parameters.Add("@PlannedScheduledCloseDate", data.PlannedScheduledCloseDate);
            parameters.Add("@ChargeDepartment", data.ChargeDepartment);
            parameters.Add("@AllocationToUse", data.AllocationToUse);
            parameters.Add("@PredictedCyleTime", data.PredictedCyleTime);
            parameters.Add("@DeptChargedForRawWafers", data.ChargeDepartment);
            parameters.Add("@StartQty", data.StartQty);
            parameters.Add("@TotalQty", data.TotalQty);
            parameters.Add("@WIPArea", data.WIPArea);
            parameters.Add("@LotStartDate", data.LotStartDate);
            parameters.Add("@LotNumber", data.LotNumber);
            parameters.Add("@WIPPartNumber", data.WIPPartNumber);
            parameters.Add("@PartDescription", data.PartDescription);
            parameters.Add("@DefaultEPISiliconPartNumber", data.DefaultEPISiliconPartNumber);
            parameters.Add("@ProcessFlow", data.ProcessFlow);
            parameters.Add("@EmployeeID", data.EmployeeID);
            parameters.Add("@VerbComment", data.VerbComment);
            parameters.Add("@RecordSiliconLotInSPNTapeTagTotrav", data.RecordSiliconLotInSPNTapeTagTotrav);
            parameters.Add("@SiliconLotNoCassette1", data.SiliconLotNoCassette1);
            parameters.Add("@SiliconOnHand", data.SiliconOnHand);
            parameters.Add("@SiliconExpectedDueDate", data.SiliconExpectedDueDate);
            parameters.Add("@SiliconComments", data.SiliconComments);
            parameters.Add("@ReticleOnHand", data.ReticleOnHand);
            parameters.Add("@ReticleExpectedDueDate", data.ReticleExpectedDueDate);
            parameters.Add("@ReticleComments", data.ReticleComments);
            parameters.Add("@SPNTransferOnHand", data.SPNTransferOnHand);
            parameters.Add("@SPNTransferExpectedDueDate", data.SPNTransferExpectedDueDate);
            parameters.Add("@SPNTransferComments", data.SPNTransferComments);
            parameters.Add("@ProbeCardOnHand", data.ProbeCardOnHand);
            parameters.Add("@ProbeCardExpectedDueDate", data.ProbeCardExpectedDueDate);
            parameters.Add("@ProbeCardComments", data.ProbeCardComments);
            parameters.Add("@ProbeRecipeOnHand", data.ProbeRecipeOnHand);
            parameters.Add("@ProbeRecipeExpectedDueDate", data.ProbeRecipeExpectedDueDate);
            parameters.Add("@ProbeRecipeComments", data.ProbeRecipeComments);
            parameters.Add("@LotStartCheckListComments", data.LotStartCheckListComments);             
            parameters.Add("@ProcessChangeDetailsOnHand", data.ProcessChangeDetailsOnHand);
            parameters.Add("@ProcessChangeDetailsDueDate", data.ProcessChangeDetailsDueDate);
            parameters.Add("@PCRBNumber", data.PCRBNumber);
            parameters.Add("@LotStartCheckListComments", data.LotStartCheckListComments);
            parameters.Add("@NewWorkRequestID", data.ID, direction: ParameterDirection.InputOutput);
            this.db.Execute("LTCreateWorkRequestRevision", parameters, commandType: CommandType.StoredProcedure);
            newWorkRequestID = parameters.Get<int>("@NewWorkRequestID");
            
            return newWorkRequestID;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="swrNumber"></param>
        /// <returns></returns>
        public List<Revision> GetWorkReqRevisions(int swrNumber)
        {
            var revisions = this.db.Query<Revision>("SELECT ID, Revision AS RevisionNumber FROM LTWorkRequest WHERE SWRNumber = @SWRNUmber ORDER BY Revision ", new { SWRNUmber = swrNumber }, commandType: CommandType.Text).ToList();
            return revisions;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="ltLotID"></param>
        /// <returns></returns>
        public List<Revision> GetLotTravRevisions(int ltLotID)
        {
            var revisions = this.db.Query<Revision>("SELECT ID, RevisionNumber FROM LTLotTravelerRevisionAttrib WHERE LTLotID = @ltLotID ORDER BY RevisionNumber ", new { ltLotID = ltLotID }, commandType: CommandType.Text).ToList();
            return revisions;
        }

       
        /// <summary>
        /// 
        /// </summary>
        /// <param name="lot"></param>
        /// <param name="getLotInfo"></param>
        /// <returns></returns>
        public void InsertLot(LTLot lot)
        {
            MiscDMO.GetLTLotInformation(lot);

            var parameters = new DynamicParameters();
            parameters.Add("@WorkRequestID", lot.WorkRequestID);
            parameters.Add("@LotNumber", lot.LotNumber);
            parameters.Add("@WIPPartNumber", lot.WIPPartNumber);
            parameters.Add("@WaferQty", lot.WaferQty);
            parameters.Add("@PartDescription", lot.PartDescription);
            parameters.Add("@Process", lot.Process);
            parameters.Add("@Location", lot.Location);
            parameters.Add("@Operation", lot.Operation);
            parameters.Add("@LotStatus", lot.LotStatus);
            parameters.Add("@UploadedBy", lot.LotUploadedBy);

            parameters.Add("@WRWithExistingLot", dbType: DbType.Int32, direction: ParameterDirection.Output);


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


            //int lotID = parameters.Get<int>("@LotID");
            if (parameters.Get<int>("@WRWithExistingLot") != 0)
            {

                lot.WRWithExistingLot = parameters.Get<int>("@WRWithExistingLot");
            }

            //return lotID;

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="workRequestID"></param>
        /// <returns></returns>
        public IEnumerable<LTLot> GetLotList(int workRequestID)
        {
            StringBuilder sql = new StringBuilder();
            sql.Append("SELECT L.*,    U.FirstName + ' ' + U.LastName AS UploadedByName,CASE WHEN TravelerClosed = 0 THEN 'Open' ELSE 'Closed' END AS TravelerStatus ");
            sql.Append("FROM LTLot L LEFT JOIN Users U ON L.LotUploadedBy = U.UserID ");
            sql.Append("WHERE WorkRequestID = @workRequestID ORDER BY LotNumber  ");
            var lots = this.db.Query<LTLot>(sql.ToString(), new { @workRequestID = workRequestID }, commandType: CommandType.Text).ToList();
            return lots;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="swrNumber"></param>
        /// <returns></returns>
        public IEnumerable<LTLot> GetLotListBasedOnSWRNumber(int swrNumber)
        {
            StringBuilder sql = new StringBuilder();
            sql.Append("SELECT L.*,    U.FirstName + ' ' + U.LastName AS UploadedByName,CASE WHEN TravelerClosed = 0 THEN 'Open' ELSE 'Closed' END AS TravelerStatus ");
            sql.Append("FROM LTWorkRequest WR INNER JOIN  LTLot L ON WR.ID = L.WorkRequestID  AND WR.IsCurrentRevision = 1 ");
            sql.Append("LEFT JOIN Users U ON L.LotUploadedBy = U.UserID ");
            sql.Append("WHERE WR.SWRNumber = @SWRNumber ORDER BY LotNumber  ");
            var lots = this.db.Query<LTLot>(sql.ToString(), new { @SWRNumber = swrNumber }, commandType: CommandType.Text).ToList();
            //var lots = this.db.Query<LTLot>("SELECT L.*, U.FirstName + ' ' + U.LastName AS UploadedByName FROM LTWorkRequest WR INNER JOIN  LTLot L ON WR.ID = L.WorkRequestID  AND WR.IsCurrentRevision = 1 LEFT JOIN Users U ON L.LotUploadedBy = U.UserID WHERE WR.SWRNumber = @SWRNumber ORDER BY LotNumber ", new { swrNumber }, commandType: CommandType.Text).ToList();
            return lots;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="workRequestID"></param>
        /// <returns></returns>
        public IEnumerable<LotWithTraveler> GetLotsWithTraveler(int workRequestID)
        {
            var lotList = this.db.Query<LotWithTraveler>("SELECT ID AS LotID, LotNumber FROM LTLot WHERE WorkRequestID = @workRequestID AND IsTravelerGenerated =  1 ORDER BY LotNumber ", new { workRequestID = workRequestID }, commandType: CommandType.Text).ToList();
            return lotList;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="ltLotID"></param>
        /// <param name="UserID"></param>
        /// <returns></returns>
        public void CreateTraveler(int ltLotID, int workRequestID , int UserID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@LTLotID", ltLotID);
            parameters.Add("@WorkRequestID", workRequestID);
            parameters.Add("@UserID", UserID);
            this.db.Execute("LTCreateLotTraveler", parameters, commandType: CommandType.StoredProcedure);                        
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="ltLotID"></param>
        /// <returns></returns>
        public LTLotTravelerHeaderViewModel GetLotTravelerHeaderForUpdate(int ltLotID, int UserID)
        {

            var parameters = new DynamicParameters();
            parameters.Add("@LTLotID", ltLotID);
            parameters.Add("@UserID", UserID);
            var data = this.db.Query<LTLotTravelerHeaderViewModel>("LTGetLotTravelerHeaderForUpdate", parameters, commandType: CommandType.StoredProcedure).Single();
            return data;
        
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="ltLotID"></param>
        /// <param name="UserID"></param>
        /// <returns></returns>
        public LTLotTravelerHeaderViewModel GetLotTravelerHeaderForReadOnly(int ltLotID, int revisionNumber)
        {

            var parameters = new DynamicParameters();
            parameters.Add("@LTLotID", ltLotID);
            parameters.Add("@RevisionNumber", revisionNumber);
            var data = this.db.Query<LTLotTravelerHeaderViewModel>("LTGetLotTravelerHeaderForReadOnly", parameters, commandType: CommandType.StoredProcedure).Single();
            return data;
        
        }


        /// <returns></returns>
        public IEnumerable<LTLotTravelerHoldSteps> GetLotTravHoldSteps(int ltLotID)
        {

            var parameters = new DynamicParameters();
            parameters.Add("@LTLotID", ltLotID);
            var data = this.db.Query<LTLotTravelerHoldSteps>("LTGetLotTravelerHoldSteps", parameters, commandType: CommandType.StoredProcedure).ToList();
            return data;

        }
        


        /// <summary>
        /// 
        /// </summary>
        /// <param name="ltLotID"></param>
        /// <returns></returns>
        public IEnumerable<LTLotTravelerHoldSteps> GetLotTravHoldStepsPending(int ltLotID)
        {

            var parameters = new DynamicParameters();
            parameters.Add("@LTLotID", ltLotID);
            var data = this.db.Query<LTLotTravelerHoldSteps>("LTGetLotTravelerHoldStepsPending", parameters, commandType: CommandType.StoredProcedure).ToList();
            return data;

        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="ltLotID"></param>
        /// <returns></returns>
        public IEnumerable<LTLotTravelerHoldSteps> GetLotTravHoldStepsCompleted(int ltLotID)
        {

            var parameters = new DynamicParameters();
            parameters.Add("@LTLotID", ltLotID);
            var data = this.db.Query<LTLotTravelerHoldSteps>("LTGetLotTravelerHoldStepsCompleted", parameters, commandType: CommandType.StoredProcedure).ToList();
            return data;

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="ltLotID"></param>
        /// <param name="revisionNumber"></param>
        /// <returns></returns>
        public IEnumerable<LTLotTravelerHoldSteps> GetLotTravelerHolStepsByRevision(int ltLotID, int revisionNumber)
        {

            var parameters = new DynamicParameters();
            parameters.Add("@LTLotID", ltLotID);
            parameters.Add("@RevisionNumber", revisionNumber);
            var data = this.db.Query<LTLotTravelerHoldSteps>("LTGetLotTravelerHoldStepsByRevision", parameters, commandType: CommandType.StoredProcedure).ToList();
            return data;

        }





        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int CreateLotTravelerRevision(LTLotTravelerHoldSteps model, int userID)
        {

            var parameters = new DynamicParameters();
            parameters.Add("@CurrLotTravelerRevisionID", model.LotTravelerRevisionID);
            parameters.Add("@LTLotID", model.LTLotID);
            parameters.Add("@NewUpdatedBy", userID);
            parameters.Add("@ChangeComments", model.RevisionComments);
            parameters.Add("@NewLotTravelerRevisionID", model.ID, dbType: DbType.Int32, direction: ParameterDirection.InputOutput);

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

            int newLotTravRevisionID = parameters.Get<int>("@NewLotTravelerRevisionID");
           // model.ID = id;

            return newLotTravRevisionID;

        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        /// <param name="userID"></param>
        /// <returns></returns>
        public int CanAddLocationOperation(LTLotTravelerHoldSteps model)
        {
            int result = 0;

            var parameters = new DynamicParameters();
            parameters.Add("@LTLotID", model.LTLotID);
            parameters.Add("@Location", model.Location);
            parameters.Add("@OperSequence", model.OperSequence);
            parameters.Add("@Operation", model.Operation);
            parameters.Add("@Result", result, direction: ParameterDirection.InputOutput);

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

        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="prevLotTravRevID"></param>
        /// <param name="newLotTravRevID"></param>
        /// <returns></returns>
        public void RestoreLotTravToPrevRevision(int prevLotTravRevID, int newLotTravRevID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@PrevLotTravelerRevisionID", prevLotTravRevID);
            parameters.Add("@NewLotTravelerRevisionID", newLotTravRevID);

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

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int UpdateRevisedLotTravelerHoldStep(LTLotTravelerHoldSteps model, int userID)
        {
            int result = 0;
            var parameters = new DynamicParameters();
            parameters.Add("@LotTravHoldStepID", model.ID);            
            parameters.Add("@NewLocation", model.Location);
            parameters.Add("@NewOperSequence", model.OperSequence);
            parameters.Add("@NewOperation", model.Operation);
            parameters.Add("@NewOperationDescription", model.OperationDescription);
            parameters.Add("@NewChangeInstructions", model.ChangeInstructions);
            parameters.Add("@NewUpdatedBy", userID);
            parameters.Add("@Result", result, direction: ParameterDirection.InputOutput);

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

        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        public int UpdateLotTravelerHoldStep(LTLotTravelerHoldSteps model, int userID)
        {
            int result = 0;
            var parameters = new DynamicParameters();
            parameters.Add("@LotTravHoldStepID", model.ID);
            parameters.Add("@NewLocation", model.Location);
            parameters.Add("@NewOperSequence", model.OperSequence);
            parameters.Add("@NewOperation", model.Operation);
            parameters.Add("@NewOperationDescription", model.OperationDescription);
            parameters.Add("@NewChangeInstructions", model.ChangeInstructions);
            parameters.Add("@NewUpdatedBy", userID);
            parameters.Add("@Result", result, direction: ParameterDirection.InputOutput);

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

            result = parameters.Get<int>("@Result");
            return result;
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        //public void InsertLotTravelerRevision(LTLotTravelerHoldSteps model)
        //{

        //    var parameters = new DynamicParameters();
        //    parameters.Add("@LotTravelerRevisionID", model.ID);
        //    parameters.Add("@NewLocation", model.Location);
        //    parameters.Add("@NewOperation", model.Operation);
        //    parameters.Add("@NewOperationDescription", model.OperationDescription);
        //    parameters.Add("@NewChangeInstruction", model.ChangeInstructions);

        //    this.db.Execute("LTInsertLotTravelerRevision", parameters, commandType: CommandType.StoredProcedure);
        //}

        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        public int InsertLotTravelerHoldStep(LTLotTravelerHoldSteps model, int userID)
        {
            int result = 0;
            var parameters = new DynamicParameters();
            parameters.Add("@LTLotTravHoldStepID", model.ID);
            parameters.Add("@LTLotID", model.LTLotID);
            parameters.Add("@Location", model.Location);
            parameters.Add("@OperSequence", model.OperSequence);
            parameters.Add("@Operation", model.Operation);
            parameters.Add("@OperationDescription", model.OperationDescription);
            parameters.Add("@ChangeInstructions", model.ChangeInstructions);
            parameters.Add("@UpdatedBy", userID);
            parameters.Add("@Result", result, direction: ParameterDirection.InputOutput);

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

            return result;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="ltLotID"></param>
        public void DeleteLot(int ltLotID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@LTLotID", ltLotID);
            this.db.Execute("LTDeleteLot", parameters, commandType: CommandType.StoredProcedure);
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="lotTravHoldStepID"></param>
        /// <param name="taskComments"></param>
        /// <param name="CompletedFlag"></param>
        /// <param name="userID"></param>
        public void UpdateLotTravlerExecution(int lotTravHoldStepID, string taskComments, bool CompletedFlag, int userID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@LotTravHoldStepID", lotTravHoldStepID);
            parameters.Add("@TaskComments", taskComments);
            parameters.Add("@CompletedFlag", CompletedFlag);
            parameters.Add("@UserID", userID);

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

        }

       /// <summary>
       /// 
       /// </summary>
       /// <param name="ltLotID"></param>
       /// <param name="revisionNumber"></param>
       /// <returns></returns>
        public LotTravelerPdf GetLotTravlerPdf(int ltLotID, int revisionNumber)
        {
            var data = new LotTravelerPdf();

            var parameters = new DynamicParameters();
            parameters.Add("@LTLotID", ltLotID);
            parameters.Add("@RevisionNumber", revisionNumber);

            using (var multipleResultItems = this.db.QueryMultiple("LTGetLotTravelerForPDF", parameters, commandType: CommandType.StoredProcedure))
            {
                data = multipleResultItems.Read<LotTravelerPdf>().SingleOrDefault();

                var ltTaskList = multipleResultItems.Read<LTLotTravelerHoldSteps>().ToList();
                if (data != null && ltTaskList != null)
                {
                    if (ltTaskList.Count > 0)
                        data.Tasklist.AddRange(ltTaskList);
                }


            }



            //var data = this.db.Query<LotTravelerPdf>("LTGetLotTravelerForPDF", parameters, commandType: CommandType.StoredProcedure).Single();
            return data;

        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="swrNumber"></param>
        /// <returns></returns>
        public IEnumerable<ApprovalLogHistory> GetWorkReqApprovalLogHistory(int swrNumber)
        {

            var parameters = new DynamicParameters();
            parameters.Add("@SWRNumber", swrNumber);
            var data = this.db.Query<ApprovalLogHistory>("LTGetWorkRequestApprovalLogHistory", parameters, commandType: CommandType.StoredProcedure).ToList();
            return data;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="swrNumber"></param>
        /// <returns></returns>
        public IEnumerable<RevisionHistory> GetWorkReqRevisionHistory(int swrNumber)
        {

            var parameters = new DynamicParameters();
            parameters.Add("@SWRNumber", swrNumber);
            var data = this.db.Query<RevisionHistory>("LTGetWorkRequestRevHistory", parameters, commandType: CommandType.StoredProcedure).ToList();
            return data;
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="ltLotID"></param>
        /// <returns></returns>
        public IEnumerable<RevisionHistory> GetLotTravelerRevisionHistory(int lotID)
        {

            var parameters = new DynamicParameters();
            parameters.Add("@LotID", lotID);
            var data = this.db.Query<RevisionHistory>("LTGetLotTravelerRevHistory", parameters, commandType: CommandType.StoredProcedure).ToList();
            return data;
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="attachment"></param>
        internal void InsertLotTravLotHoldStepAttachment(LTLotTravAttachment attachment)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@LTHoldStepID", attachment.LTLotTravHoldStepID);
            parameters.Add("@FileName", attachment.FileName);
            parameters.Add("@FileGUID", attachment.FileGUID);
            parameters.Add("@DocType", attachment.DocType);
            parameters.Add("@UploadedByID", attachment.UploadedByID);
            parameters.Add("@LotTravelerRevisionID", attachment.LotTravelerRevisionID);
            this.db.Execute("LTInsertLotTravHoldStepAttachment", parameters, commandType: CommandType.StoredProcedure);

        }

       /// <summary>
       /// 
       /// </summary>
       /// <param name="attachment"></param>
        internal void InsertLotTravLotHoldStepAttachmentRevision(LTLotTravAttachment attachment)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@LTHoldStepID", attachment.LTLotTravHoldStepID);
            parameters.Add("@FileName", attachment.FileName);
            parameters.Add("@FileGUID", attachment.FileGUID);
            parameters.Add("@DocType", attachment.DocType);
            parameters.Add("@UploadedByID", attachment.UploadedByID);
            parameters.Add("@LotTravelerRevisionID", attachment.LotTravelerRevisionID);
            this.db.Execute("LTInsertLotTravHoldStepAttachmentRevision", parameters, commandType: CommandType.StoredProcedure);

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="workRequestID"></param>
        /// <param name="userID"></param>
        internal int IsWorkRequestDocLockedByUser(int workRequestID, int userID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@WorkRequestID", workRequestID);
            parameters.Add("@UserID", userID);
            var data = this.db.Query<int>("LTIsWorkRequestDocLockedByUser", parameters, commandType: CommandType.StoredProcedure).Single();

            return data;

        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="ltLotID"></param>
        /// <param name="userID"></param>
        internal int CloseTraveler(int ltLotID, int userID, string reason)
        {
            int result = 0;
            var parameters = new DynamicParameters();
            parameters.Add("@LtLotID", ltLotID);
            parameters.Add("@UserID", userID);
            parameters.Add("@Reason", reason);
            parameters.Add("@Result", result, direction: ParameterDirection.InputOutput);

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

            result = parameters.Get<int>("@Result");

            return result; 


          

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="attachmentID"></param>
        /// <returns></returns>
        internal string GetFileName(string fileGUID, int typeOfDoc)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@FileGUID", fileGUID);
            parameters.Add("@TypeOfDoc", typeOfDoc);
            var fileName = this.db.Query<string>("LTGetFileName", parameters, commandType: CommandType.StoredProcedure).Single();
            return fileName;
        }

        public void ReassignOriginator(int workRequestID, int newOriginatorID, string comments, int userID)
        {
            var parameters = new DynamicParameters();
            parameters.Add("@WorkRequestID", workRequestID);
            parameters.Add("@NewOriginatorID", newOriginatorID);
            parameters.Add("@Comments", comments);
            parameters.Add("@UserID", userID);

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