private Guid SaveAndNotifyRevenueRepresentative(ContractModification model)
 {
     try
     {
         var revenuedata = _revenueRecognitionService.GetAwardAmountDetail(model.ContractGuid);
         if (revenuedata != null)
         {
             bool isRevenueTriggered = RevenueRecognitionHelper.IsValidForRevenueRecognitionRequest(_configuration, revenuedata.ContractType, revenuedata.AwardAmount, revenuedata.FundingAmount);
             if (isRevenueTriggered)
             {
                 //Adding new revenue recognition for Mods
                 //_contractService.updateContractRevenueRecognitionGuid(model.ContractGuid, revenueRecognitionGuid);
                 Guid revenueRecognitionGuid = AddNewRevenueAndUpdateContractModRevenueGuid(model);
                 return(revenueRecognitionGuid);
             }
         }
         return(Guid.Empty);
     }
     catch (Exception ex)
     {
         var userGuid = UserHelper.CurrentUserGuid(HttpContext);
         EventLogHelper.Error(_eventLogger, new EventLog
         {
             EventGuid   = Guid.NewGuid(),
             Action      = "",
             Application = "ESS",
             EventDate   = DateTime.UtcNow,
             Message     = ex.Message,
             Resource    = ResourceType.Notification.ToString(),
             StackTrace  = ex.StackTrace,
             UserGuid    = userGuid
         });
         return(Guid.Empty);
     }
 }
        private bool AddNotificationMessage(ContractNotificationModel contractModel)
        {
            try
            {
                var     notificationModel            = new GenericNotificationViewModel();
                var     notificationTemplatesDetails = new NotificationTemplatesDetail();
                var     userList        = new List <User>();
                var     receiverInfo    = new User();
                Guid?   receiverGuid    = Guid.Empty;
                decimal thresholdAmount = 0.00M;

                notificationModel.ResourceId              = contractModel.ContractGuid;
                notificationModel.RedirectUrl             = _configuration.GetSection("SiteUrl").Value + ("/contract/Details/" + contractModel.ContractGuid);
                notificationModel.NotificationTemplateKey = contractModel.key;
                notificationModel.CurrentDate             = CurrentDateTimeHelper.GetCurrentDateTime();
                notificationModel.CurrentUserGuid         = UserHelper.CurrentUserGuid(HttpContext);
                notificationModel.SendEmail = true;


                var keyPersonnels = _contractService.GetKeyPersonnelByContractGuid(contractModel.ContractGuid);

                if (keyPersonnels?.Any() == true)
                {
                    receiverGuid = keyPersonnels.FirstOrDefault(x => x.UserRole == ContractUserRole._contractRepresentative)?.UserGuid;
                    if (receiverGuid != Guid.Empty)
                    {
                        thresholdAmount = RevenueRecognitionHelper.GetAmountByContractType(_configuration, contractModel.ContractType);

                        receiverInfo = _userService.GetUserByUserGuid(receiverGuid ?? Guid.Empty);

                        var    resourcevalue = _resourceAttributeValueService.GetResourceAttributeValueByValue(contractModel.ContractType);
                        string contracttype  = string.Empty;
                        if (resourcevalue != null)
                        {
                            contracttype = resourcevalue.Name;
                        }

                        if (receiverInfo != null)
                        {
                            userList.Add(receiverInfo);
                            notificationModel.IndividualRecipients = userList;
                        }

                        var keyList = "<ul>";
                        keyList += "<li>" + receiverInfo.DisplayName + " (" + receiverInfo.JobTitle + ")" + "</li>";
                        StringBuilder additionalUser = new StringBuilder(keyList);

                        notificationTemplatesDetails.ContractNumber   = contractModel.ContractNumber;
                        notificationTemplatesDetails.Title            = contractModel.ContractTitle;
                        notificationTemplatesDetails.ContractType     = contracttype;
                        notificationTemplatesDetails.ContractTitle    = contractModel.ContractTitle;
                        notificationTemplatesDetails.ProjectNumber    = contractModel.ProjectNumber;
                        notificationTemplatesDetails.AdditionalUser   = additionalUser.ToString();
                        notificationTemplatesDetails.ThresholdAmount  = thresholdAmount;
                        notificationTemplatesDetails.Status           = "";
                        notificationModel.NotificationTemplatesDetail = notificationTemplatesDetails;
                        _genericNotificationService.AddNotificationMessage(notificationModel);
                        return(true);
                    }
                }
                return(false);
            }
            catch (Exception ex)
            {
                var userGuid = UserHelper.CurrentUserGuid(HttpContext);
                EventLogHelper.Error(_eventLogger, new EventLog
                {
                    EventGuid   = Guid.NewGuid(),
                    Action      = "Index",
                    Application = "ESS",
                    EventDate   = DateTime.UtcNow,
                    Message     = ex.Message,
                    Resource    = ResourceType.Contract.ToString(),
                    StackTrace  = ex.StackTrace,
                    UserGuid    = userGuid
                });
                return(false);
            }
        }
        public IActionResult Edit([FromBody] ContractModificationViewModel contractModificationModel)
        {
            try
            {
                List <string> filePath      = new List <string>();
                bool          istriggered   = false;
                bool          isViewHistory = false;

                Guid   revenueGuid = Guid.Empty;
                string validation  = validateModel(contractModificationModel);
                if (validation != YesNoStatus.Yes.ToString())
                {
                    ModelState.AddModelError("", validation);
                    return(BadRequest(ModelState));
                }

                if (ModelState.IsValid)
                {
                    if (!ModelState.IsValid)
                    {
                        return(BadRequest(ModelState));
                    }
                    var contractId              = _contractService.GetContractIdByProjectId(contractModificationModel.ContractGuid);
                    var parentContractNumber    = _contractService.GetContractNumberById(contractId);
                    var taskOrderContractNumber = _contractService.GetContractNumberById(contractModificationModel.ContractGuid);
                    //var uploadPath = string.Format(
                    // $@"{parentContractNumber}\TaskOrder\{taskOrderContractNumber}\TaskOrderModification\{contractModificationModel.ModificationTitle}-{contractModificationModel.ModificationNumber}");

                    var contractModificationEntity = _mapper.Map <ContractModification>(contractModificationModel);
                    contractModificationEntity.IsTaskModification = true;
                    contractModificationEntity.UpdatedBy          = UserHelper.CurrentUserGuid(HttpContext);
                    contractModificationEntity.UpdatedOn          = CurrentDateTimeHelper.GetCurrentDateTime();

                    // for revenue and revenue notification
                    decimal?totalPreviousAwardAmount = 0.00M;
                    decimal?actualAmount             = 0.00M;
                    var     sumofAwardAmount         = _contractModificationService.GetTotalAwardAmount(contractModificationModel.ContractGuid);
                    if (sumofAwardAmount != null)
                    {
                        totalPreviousAwardAmount = (sumofAwardAmount.AwardAmount == null ? 0.00M : sumofAwardAmount.AwardAmount);
                    }
                    var previousAwardAmount = _contractModificationService.getAwardAndFundingAmountbyId(contractModificationModel.ContractModificationGuid);

                    if (previousAwardAmount.RevenueRecognitionGuid != Guid.Empty && previousAwardAmount.RevenueRecognitionGuid != null)
                    {
                        actualAmount = contractModificationModel.AwardAmount - previousAwardAmount.AwardAmount;
                    }
                    else
                    {
                        actualAmount = contractModificationModel.AwardAmount;
                    }

                    if (actualAmount < 0)
                    {
                        actualAmount = actualAmount * (-1);
                    }
                    decimal?currentAmount = totalPreviousAwardAmount + actualAmount;

                    string contractType = _contractService.GetContractType(contractModificationModel.ContractGuid);

                    if (RevenueRecognitionHelper.IsValidForRevenueRecognitionRequest(_configuration, contractType, currentAmount, 0.00M))
                    {
                        contractModificationEntity.IsUpdated = true;
                        _contractModificationService.UpdateRevenueRecognitionGuid(contractModificationEntity.ContractModificationGuid, contractModificationEntity.AwardAmount, contractModificationEntity.FundingAmount);
                        revenueGuid = AddNewRevenueAndUpdateContractModRevenueGuid(contractModificationEntity);
                        istriggered = true;



                        var historyCount = _revenueRecognitionService.DetailListCount(contractModificationEntity.ContractGuid, "");
                        if (historyCount > 0)
                        {
                            isViewHistory = true;
                        }
                    }

                    _contractModificationService.Edit(contractModificationEntity);

                    //audit log..
                    var additionalInformation    = string.Format("{0} {1} the {2}", User.FindFirst("fullName").Value, CrudTypeForAdditionalLogMessage.Edited.ToString(), "Task Order Mod");
                    var additionalInformationURl = _configuration.GetSection("SiteUrl").Value + ("/Project/Details/" + contractModificationEntity.ContractGuid);
                    var resource = string.Format("{0} </br> Mod No:{1} </br> Mod Title:{2}", "Task Order Mod", contractModificationEntity.ModificationNumber, contractModificationEntity.ModificationTitle);
                    AuditLogHandler.InfoLog(_logger, User.FindFirst("fullName").Value, UserHelper.CurrentUserGuid(HttpContext), contractModificationEntity, resource, contractModificationEntity.ContractModificationGuid, UserHelper.GetHostedIp(HttpContext), "Taskorder Mod Edited", Guid.Empty, "Successful", "", additionalInformationURl, additionalInformationURl);
                    //end of log..

                    //get file info..
                    var contractResourceFile = _contractResourceFileService.GetFilePathByResourceIdAndKeys(ContractResourceFileKey.ContractModification.ToString(), contractModificationModel.ContractGuid);

                    var jsonObject = new
                    {
                        status       = ResponseStatus.success.ToString(),
                        message      = "Successfully Updated !!",
                        revenueGuid  = revenueGuid,
                        viewHistory  = isViewHistory,
                        istriggered  = istriggered,
                        contractGuid = contractModificationEntity.ContractGuid,
                        resourceId   = contractModificationEntity.ContractModificationGuid,
                        uploadPath   = contractResourceFile.FilePath,
                        parentId     = contractResourceFile.ContractResourceFileGuid
                    };

                    return(Ok(jsonObject));
                }
                else
                {
                    return(View(contractModificationModel));
                }
            }
            catch (ArgumentException ex)
            {
                ModelState.AddModelError("", ex.Message);
                return(BadRequestFormatter.BadRequest(this, ex));
            }
            catch (Exception ex)
            {
                ModelState.Clear();
                ModelState.AddModelError("", ex.Message);
                return(BadRequestFormatter.BadRequest(this, ex));
            }
        }