public ResponseModel UpdatePolicy(UpdatePolicyModel model)
{
var resp = new ResponseModel();
try
{
var company = _companyRepository.GetCompanyWithPolicyById(Guid.Parse(model.CompanyId));
if (company == null)
{
resp.Result = "Não foi posível encontrar a empresa ou a política requisitadas";
return(resp);
}
Policy policy = company.Policy;
policy.LimitCancelHours = model.LimitCancelHours;
policy.LastUpdatedAt = DateTimeUtil.UtcToBrasilia();
_policyRepository.Edit(policy);
resp.Success = true;
resp.Message = "Atualizado com sucesso";
return(resp);
}
catch (Exception)
{
resp.Message = "Não foi possível alterar a política da empresa";
}
return(resp);
}
public IHttpActionResult UpdatePolicy(string domainName, UpdatePolicyModel policy)
{
if (policy.policyId == 0)
{
return(BadRequest("enter a value for Policy ID"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
long output = Storage.updatePolicy(domainName, policy.parentPolicyName, policy.policyId, policy.groups, policy.roles);
return(new StatusCodeResult(HttpStatusCode.NoContent, this));
}
public static async Task <long> UpdateAsync(string domainName, string parentPolicyName, long policyId, List <policySecurity> groups, List <policySecurity> roles)
{
UpdatePolicyModel fromBodyPolicy = new UpdatePolicyModel();
fromBodyPolicy.domainName = domainName;
fromBodyPolicy.policyId = policyId;
fromBodyPolicy.groups = groups;
fromBodyPolicy.roles = roles;
long output = -1;
HttpResponseMessage response = await MyClient.client.PostAsJsonAsync(string.Format("security/policy/{0}", domainName), fromBodyPolicy);
if (response.IsSuccessStatusCode)
{
output = await response.Content.ReadAsAsync <long>();
}
return(output);
}
public ActionResult UpdateCompanyPolicy(UpdatePolicyModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = _companyService.UpdatePolicy(model);
return(Ok(result));
}
catch (ArgumentException e)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, e.Message));
}
}
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));
}
}
