public static void AddRelatedData(PolicyCoverage policyCoverage)
{
policyCoverage.Policy = Policies
.First(p => p.PolicyId == policyCoverage.PolicyId);
policyCoverage.Coverage = Coverages
.First(c => c.CoverageId == policyCoverage.CoverageId);
}
private LedgerAccount ResolveCoverageExpenseAccount(ReportingEntity entity, PolicyCoverage coverage)
{
var coverageProfile = entity.ReportingEntityProfile.CoverageProfiles.FirstOrDefault(x => x.CoverageTypeID == coverage.CoverageTypeID);
if (coverageProfile != null)
{
return(coverageProfile.ExpenseLedgerAccount);
}
throw new Exception("Coverage profile not found - " + coverageProfile.CoverageType.Name);
}
public async Task <IHttpActionResult> Update([FromBody] UpdatePolicyModel model)
{
if (model.StartDate.HasValue && model.EndDate.HasValue && model.StartDate.Value.Date >= model.EndDate.Value.Date)
{
ModelState.AddModelError("startDate", "Start date cannot be after or equal End date");
}
if (ModelState.IsValid)
{
using (IUnitOfWork unitOfWork = UnitOfWork.Create())
{
unitOfWork.BeginTransaction();
var userId = User.Identity.GetUserId();
var policyPropertyModelIds = model.PolicyProperties.Select(p => p.PropertyId).ToList();
var policyProperties = unitOfWork.PolicyPropertyRepository.GetAll()
.Where(a => policyPropertyModelIds.Contains(a.Id))
.ToList();
var policyTemplate = unitOfWork.PolicyTypeRepository.GetAll().Where(a => a.Id == model.PolicyTypeId).Select(a => a.PolicyTemplate).First();
//Update policy table
var policy = unitOfWork.PolicyRepository.GetById(model.Id);
policy.InsurerId = model.InsurerId;
policy.PolicyTypeId = model.PolicyTypeId;
policy.PolicyNumber = model.PolicyNumber;
policy.PolicyPremium = model.PolicyPremium;
policy.PolicyPaymentFrequency = model.PolicyPaymentFrequency;
policy.PolicyPaymentAmount = model.PolicyPaymentAmount;
policy.PolicyExcess = model.PolicyExcess;
policy.StartDate = model.StartDate;
policy.EndDate = model.EndDate;
//policy.Description = model.Description;
policy.ModifiedById = userId;
policy.ModifiedDate = DateTime.Now;
//Get title and subtitle from properties
var titleParts = (from templateProperty in policyProperties
join modelProperty in model.PolicyProperties on templateProperty.Id equals modelProperty.PropertyId
where templateProperty.IsTitle == true
select modelProperty.GetValueAsString(templateProperty.FieldType)).ToList();
var subtitleParts = (from templateProperty in policyProperties
join modelProperty in model.PolicyProperties on templateProperty.Id equals modelProperty.PropertyId
where templateProperty.IsSubtitle == true
select modelProperty.GetValueAsString(templateProperty.FieldType)).ToList();
titleParts.Insert(0, policyTemplate.Title);
subtitleParts.Insert(0, policyTemplate.Subtitle);
policy.Title = string.Join(" ", titleParts);
policy.SubTitle = string.Join(" ", subtitleParts);
//Update Policy
unitOfWork.PolicyRepository.Edit(policy);
#region Autopilot
if (model.IsConfirmed == true)
{
var user = unitOfWork.UserRepository.GetAll().FirstOrDefault(u => u.Id == policy.CreatedById);
if (user.AutopilotTrack)
{
ISchedulerFactory factory = new StdSchedulerFactory();
IScheduler scheduler = factory.GetScheduler();
JobDataMap dataMap = new JobDataMap();
dataMap["autopilotContactId"] = user.AutopilotContactId;
dataMap["OperationType"] = "TriggerJourney";
dataMap["journeyName"] = ConfigurationManager.AppSettings["PolicyConfirmedJourney"];
dataMap["userId"] = user.Id;
var job = JobBuilder.Create <UpdateContactJob>()
.WithIdentity("UpdateContactJob").UsingJobData(dataMap)
.Build();
var jobKey = new JobKey("UpdateContactJob");
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity("trigger1")
.StartAt(DateTime.Now)
.ForJob(jobKey)
.Build();
if (!scheduler.CheckExists(jobKey))
{
scheduler.ScheduleJob(job, trigger);
}
scheduler.Start();
}
policy.Status = PolicyStatus.Confirmed;
}
#endregion
//Delete Current Properties
foreach (var item in policy.PolicyPolicyProperties.ToList())
{
unitOfWork.PolicyPolicyPropertyRepository.Delete(item);
}
await unitOfWork.SaveAsync();
///----------------------------------
///Add new Properties
///----------------------------------
{
List <PolicyPropertyModel> propertiesFromModel = new List <PolicyPropertyModel>();
propertiesFromModel.AddRange(model.PolicyProperties);
if (model.AdditionalProperties != null)
{
propertiesFromModel.AddRange(model.AdditionalProperties);
}
foreach (var modelProperty in propertiesFromModel)
{
var propertyType = unitOfWork.PolicyPropertyRepository.GetAll().Where(f => f.Id == modelProperty.PropertyId)
.Select(a => new
{
fieldType = a.FieldType
}).FirstOrDefault();
PolicyPolicyProperty property = new PolicyPolicyProperty();
property.PolicyId = policy.Id;
property.PolicyPropertyId = modelProperty.PropertyId;
property.Value = modelProperty.GetValueAsString(propertyType.fieldType);
unitOfWork.PolicyPolicyPropertyRepository.Insert(property);
}
unitOfWork.PolicyRepository.Edit(policy);
}
///----------------------------------
///Coverages for the policy
///----------------------------------
{
///Delete Existing Coverages
foreach (var item in policy.PolicyCoverages.ToList())
{
unitOfWork.PolicyCoverageRepository.Delete(item);
}
await unitOfWork.SaveAsync();
if (model.Coverages != null)
{
//Add new coverages
foreach (var modelCoverage in model.Coverages.ToList())
{
PolicyCoverage policyCoverage = new PolicyCoverage();
policyCoverage.PolicyId = policy.Id;
policyCoverage.CoverageId = modelCoverage.CoverageId;
policyCoverage.IsActive = modelCoverage.IsActive.Value;
policyCoverage.Excess = modelCoverage.Excess;
policyCoverage.Limit = modelCoverage.Limit;
policyCoverage.CreatedById = userId;
policyCoverage.CreatedDate = DateTime.Now;
unitOfWork.PolicyCoverageRepository.Insert(policyCoverage);
}
}
}
try
{
await unitOfWork.SaveAsync();
}
catch (Exception e)
{
return(JsonError(HttpStatusCode.BadRequest, 10, "Error " + e.Message, null));
}
unitOfWork.CommitTransaction();
return(Ok());
}
}
else
{
return(JsonError(HttpStatusCode.BadRequest, 10, "Warning", ModelState));
}
}
