public async Task <StaffApprovalRegRespObj> Handle(PRNStaffApprovalCommand request, CancellationToken cancellationToken)
        {
            try
            {
                if (request.ApprovalStatus == (int)ApprovalStatus.Revert && request.ReferredStaffId < 1)
                {
                    return(new StaffApprovalRegRespObj
                    {
                        Status = new APIResponseStatus {
                            IsSuccessful = false, Message = new APIResponseMessage {
                                FriendlyMessage = "Please select staff to revert to"
                            }
                        }
                    });
                }
                var allSuppliers = await _dataContext.cor_supplier.ToListAsync();

                var currentUserId = _accessor.HttpContext.User?.FindFirst(x => x.Type == "userId").Value;
                var user          = await _serverRequest.UserDataAsync();

                var prn = await _repo.GetPurchaseRequisitionNoteAsync(request.TargetId);

                var detail = BuildApprovalDetailObject(request, prn, user.StaffId);

                var req = new IndentityServerApprovalCommand
                {
                    ApprovalComment = request.ApprovalComment,
                    ApprovalStatus  = request.ApprovalStatus,
                    TargetId        = request.TargetId,
                    WorkflowToken   = prn.WorkflowToken,
                    ReferredStaffId = request.ReferredStaffId
                };

                using (var _trans = await _dataContext.Database.BeginTransactionAsync())
                {
                    try
                    {
                        var result = await _serverRequest.StaffApprovalRequestAsync(req);

                        if (!result.IsSuccessStatusCode)
                        {
                            var stringData2 = await result.Content.ReadAsStringAsync();

                            response = JsonConvert.DeserializeObject <StaffApprovalRegRespObj>(stringData2);
                            return(new StaffApprovalRegRespObj
                            {
                                Status = response.Status
                            });
                        }

                        var stringData = await result.Content.ReadAsStringAsync();

                        response = JsonConvert.DeserializeObject <StaffApprovalRegRespObj>(stringData);

                        if (!response.Status.IsSuccessful)
                        {
                            return(new StaffApprovalRegRespObj
                            {
                                Status = response.Status
                            });
                        }
                        if (response.ResponseId == (int)ApprovalStatus.Processing)
                        {
                            await _detailService.AddUpdateApprovalDetailsAsync(detail);

                            prn.ApprovalStatusId = (int)ApprovalStatus.Processing;
                            await _repo.AddUpdatePurchaseRequisitionNoteAsync(prn);

                            await _trans.CommitAsync();

                            return(new StaffApprovalRegRespObj
                            {
                                ResponseId = (int)ApprovalStatus.Processing,
                                Status = new APIResponseStatus {
                                    IsSuccessful = true, Message = response.Status.Message
                                }
                            });
                        }
                        if (response.ResponseId == (int)ApprovalStatus.Revert)
                        {
                            await _detailService.AddUpdateApprovalDetailsAsync(detail);

                            prn.ApprovalStatusId = (int)ApprovalStatus.Revert;
                            await _repo.AddUpdatePurchaseRequisitionNoteAsync(prn);

                            await _trans.CommitAsync();

                            return(new StaffApprovalRegRespObj
                            {
                                ResponseId = (int)ApprovalStatus.Revert,
                                Status = new APIResponseStatus {
                                    IsSuccessful = true, Message = response.Status.Message
                                }
                            });
                        }
                        if (response.ResponseId == (int)ApprovalStatus.Approved)
                        {
                            await _detailService.AddUpdateApprovalDetailsAsync(detail);

                            prn.ApprovalStatusId = (int)ApprovalStatus.Approved;
                            var prnDetails = await _repo.GetPrnDetailsByPrnId(prn.PurchaseReqNoteId);

                            EmailMessageObj email = new EmailMessageObj {
                                ToAddresses = new List <EmailAddressObj>()
                            };

                            foreach (var item in prnDetails)
                            {
                                item.LPONumber = _repo.LpoNubmer(prn.PurchaseReqNoteId + item.PRNDetailsId);

                                if (await _repo.AddUpdatePrnDetailsAsync(item))
                                {
                                    var lpoObject = _repo.BuildLPODomianObject(item, prn.DeliveryLocation, prn.ExpectedDeliveryDate ?? DateTime.Today);
                                    item.PurchaseReqNoteId = prn.PurchaseReqNoteId;
                                    if (await _repo.AddUpdateLPOAsync(lpoObject))
                                    {
                                        var SuggestedSupplierList = lpoObject.SupplierIds.Split(',').Select(int.Parse);
                                        foreach (var supplierId in SuggestedSupplierList)
                                        {
                                            var supplier = await _supRepo.GetSupplierAsync(supplierId);

                                            if (supplier != null)
                                            {
                                                var bidAndTenderObject = _repo.BuildBidAndTenderDomianObject(supplier, lpoObject, prn.DepartmentId, item);
                                                bidAndTenderObject.CompanyId         = prn.CompanyId;
                                                bidAndTenderObject.PurchaseReqNoteId = prn.PurchaseReqNoteId;
                                                if (await _repo.AddUpdateBidAndTender(bidAndTenderObject))
                                                {
                                                    email.ToAddresses.Add(new EmailAddressObj {
                                                        Address = supplier.Email, Name = supplier.Name
                                                    });
                                                }
                                            }
                                        }
                                        var otherSupplierbid = _repo.BuildBidAndTenderDomianObjectForNonSelectedSuppliers(lpoObject, prn.DepartmentId, item);
                                        await _repo.AddUpdateBidAndTender(otherSupplierbid);
                                    }
                                }
                            }
                            email.ToAddresses.Distinct();
                            await _repo.SendEmailToSuppliersAsync(email, prn.Description);

                            await _repo.AddUpdatePurchaseRequisitionNoteAsync(prn);

                            await _repo.SendEmailToInitiatingStaffAsync(prn);

                            await _trans.CommitAsync();

                            return(new StaffApprovalRegRespObj
                            {
                                ResponseId = (int)ApprovalStatus.Approved,
                                Status = new APIResponseStatus {
                                    IsSuccessful = true, Message = new APIResponseMessage {
                                        FriendlyMessage = "Final Approval </br> Successfully created Supplier Bids"
                                    }
                                }
                            });
                        }
                        if (response.ResponseId == (int)ApprovalStatus.Disapproved)
                        {
                            await _detailService.AddUpdateApprovalDetailsAsync(detail);

                            prn.ApprovalStatusId = (int)ApprovalStatus.Disapproved;
                            await _repo.AddUpdatePurchaseRequisitionNoteAsync(prn);

                            await _trans.CommitAsync();

                            return(new StaffApprovalRegRespObj
                            {
                                ResponseId = (int)ApprovalStatus.Disapproved,
                                Status = new APIResponseStatus {
                                    IsSuccessful = true, Message = response.Status.Message
                                }
                            });
                        }
                    }
                    catch (Exception ex)
                    {
                        await _trans.RollbackAsync();

                        throw ex;
                    }
                    finally { await _trans.DisposeAsync(); }
                }

                return(new StaffApprovalRegRespObj
                {
                    ResponseId = detail.ApprovalDetailId,
                    Status = response.Status
                });
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public async Task <RequisitionNoteRegRespObj> Handle(AddUpdateRequisitionNoteCommand request, CancellationToken cancellationToken)
        {
            try
            {
                var apiResponse = new RequisitionNoteRegRespObj {
                    Status = new APIResponseStatus {
                        IsSuccessful = false, Message = new APIResponseMessage()
                    }
                };
                var user = await _serverRequest.UserDataAsync();

                if (user == null)
                {
                    return(new RequisitionNoteRegRespObj
                    {
                        Status = new APIResponseStatus {
                            IsSuccessful = false, Message = new APIResponseMessage {
                                FriendlyMessage = " Unable To Process This User"
                            }
                        }
                    });
                }

                List <purch_prndetails> prnDetails = new List <purch_prndetails>();
                using (var _trans = await _dataContext.Database.BeginTransactionAsync())
                {
                    try
                    {
                        var prn = _repo.BuildPurchRequisionNoteObject(request, user.StaffId, user.CompanyId);
                        await _repo.AddUpdatePurchaseRequisitionNoteAsync(prn);

                        if (request.PRNDetails.Count() > 0)
                        {
                            prnDetails = _repo.BuildListOfPrnDetails(request.PRNDetails, prn.CompanyId);
                        }
                        var targetList = new List <int>();
                        targetList.Add(prn.PurchaseReqNoteId);
                        GoForApprovalRequest wfRequest = new GoForApprovalRequest
                        {
                            Comment                = "Purchase PRN",
                            OperationId            = (int)OperationsEnum.PurchasePRNApproval,
                            TargetId               = targetList,
                            ApprovalStatus         = (int)ApprovalStatus.Pending,
                            DeferredExecution      = true,
                            StaffId                = user.StaffId,
                            CompanyId              = user.CompanyId,
                            EmailNotification      = true,
                            ExternalInitialization = false,
                            StatusId               = (int)ApprovalStatus.Processing,
                        };
                        var result = await _serverRequest.GotForApprovalAsync(wfRequest);

                        if (!result.IsSuccessStatusCode)
                        {
                            apiResponse.Status.Message.FriendlyMessage = $"{result.ReasonPhrase} {result.StatusCode}";
                            return(apiResponse);
                        }
                        var stringData = await result.Content.ReadAsStringAsync();

                        var res = JsonConvert.DeserializeObject <GoForApprovalRespObj>(stringData);
                        if (res.ApprovalProcessStarted)
                        {
                            prn.ApprovalStatusId = (int)ApprovalStatus.Processing;
                            prn.WorkflowToken    = res.Status.CustomToken;

                            await _repo.AddUpdatePurchaseRequisitionNoteAsync(prn);

                            foreach (var item in prnDetails)
                            {
                                item.PurchaseReqNoteId = prn.PurchaseReqNoteId;
                                await _repo.AddUpdatePrnDetailsAsync(item);
                            }
                            await _trans.CommitAsync();

                            apiResponse.PurchaseReqNoteId   = prn.PurchaseReqNoteId;
                            apiResponse.Status.IsSuccessful = res.Status.IsSuccessful;
                            apiResponse.Status.Message      = res.Status.Message;
                            return(apiResponse);
                        }

                        if (res.EnableWorkflow || !res.HasWorkflowAccess)
                        {
                            await _trans.CommitAsync();

                            apiResponse.PurchaseReqNoteId              = prn.PurchaseReqNoteId;
                            apiResponse.Status.IsSuccessful            = true;
                            apiResponse.Status.Message.FriendlyMessage = "Successful";
                            return(apiResponse);
                        }
                        if (!res.EnableWorkflow)
                        {
                            prn.ApprovalStatusId = (int)ApprovalStatus.Approved;
                            EmailMessageObj email = new EmailMessageObj {
                                ToAddresses = new List <EmailAddressObj>()
                            };
                            var lponum = 0;
                            foreach (var item in prnDetails)
                            {
                                if (await _repo.AddUpdatePrnDetailsAsync(item))
                                {
                                    item.LPONumber         = _repo.LpoNubmer(prn.PurchaseReqNoteId + item.PRNDetailsId);
                                    item.PurchaseReqNoteId = prn.PurchaseReqNoteId;
                                    await _repo.AddUpdatePrnDetailsAsync(item);

                                    var lpoObject = _repo.BuildLPODomianObject(item, prn.DeliveryLocation, prn.ExpectedDeliveryDate ?? DateTime.Today);
                                    if (await _repo.AddUpdateLPOAsync(lpoObject))
                                    {
                                        var SuggestedSupplierList = lpoObject.SupplierIds.Split(',').Select(int.Parse);
                                        foreach (var supplierId in SuggestedSupplierList)
                                        {
                                            var supplier = await _suprepo.GetSupplierAsync(supplierId);

                                            if (supplier != null)
                                            {
                                                var bidAndTenderObject = _repo.BuildBidAndTenderDomianObject(supplier, lpoObject, prn.DepartmentId, item);
                                                bidAndTenderObject.CompanyId         = prn.CompanyId;
                                                bidAndTenderObject.PurchaseReqNoteId = prn.PurchaseReqNoteId;
                                                if (await _repo.AddUpdateBidAndTender(bidAndTenderObject))
                                                {
                                                    email.ToAddresses.Add(new EmailAddressObj {
                                                        Address = supplier.Email, Name = supplier.Name
                                                    });
                                                }
                                            }
                                        }
                                        var otherSupplierbid = _repo.BuildBidAndTenderDomianObjectForNonSelectedSuppliers(lpoObject, prn.DepartmentId, item);
                                        otherSupplierbid.PurchaseReqNoteId = prn.PurchaseReqNoteId;
                                        otherSupplierbid.CompanyId         = prn.CompanyId;
                                        await _repo.AddUpdateBidAndTender(otherSupplierbid);
                                    }
                                }
                            }
                            email.ToAddresses.Distinct();
                            await _repo.SendEmailToSuppliersAsync(email, prn.Description);

                            await _repo.AddUpdatePurchaseRequisitionNoteAsync(prn);

                            await _trans.CommitAsync();

                            apiResponse.Status.IsSuccessful            = true;
                            apiResponse.Status.Message.FriendlyMessage = "Successful";
                            return(apiResponse);
                        }
                    }
                    catch (SqlException ex)
                    {
                        await _trans.RollbackAsync();

                        var errorCode = ErrorID.Generate(4);
                        _logger.Error($"ErrorID : {errorCode} Ex : {ex?.Message ?? ex?.InnerException?.Message} ErrorStack : {ex?.StackTrace}");
                        throw ex;
                    }
                    finally { await _trans.DisposeAsync(); }
                }
                return(new RequisitionNoteRegRespObj
                {
                    Status = new APIResponseStatus
                    {
                        IsSuccessful = true,
                        Message = new APIResponseMessage
                        {
                            FriendlyMessage = "Success"
                        }
                    }
                });
            }
            catch (Exception ex)
            {
                #region Log error to file
                var errorCode = ErrorID.Generate(4);
                _logger.Error($"ErrorID : {errorCode} Ex : {ex?.Message ?? ex?.InnerException?.Message} ErrorStack : {ex?.StackTrace}");
                return(new RequisitionNoteRegRespObj
                {
                    Status = new APIResponseStatus
                    {
                        IsSuccessful = false,
                        Message = new APIResponseMessage
                        {
                            FriendlyMessage = "Error occured!! Unable to process item",
                            MessageId = errorCode,
                            TechnicalMessage = $"ErrorID : {errorCode} Ex : {ex?.Message ?? ex?.InnerException?.Message} ErrorStack : {ex?.StackTrace}"
                        }
                    }
                });

                #endregion
            }
        }