public async Task <Result> Modify(int policyId, MarkupPolicySettings settings)
{
var policy = await _context.MarkupPolicies.SingleOrDefaultAsync(p => p.Id == policyId);
if (policy == null)
{
return(Result.Failure("Could not find policy"));
}
return(await Result.Success()
.Bind(UpdatePolicy));
async Task <Result> UpdatePolicy()
{
policy.Description = settings.Description;
policy.Order = settings.Order;
policy.TemplateId = settings.TemplateId;
policy.TemplateSettings = settings.TemplateSettings;
policy.Currency = settings.Currency;
policy.Modified = _dateTimeProvider.UtcNow();
var validateResult = await ValidatePolicy(GetPolicyData(policy));
if (validateResult.IsFailure)
{
return(validateResult);
}
_context.Update(policy);
await _context.SaveChangesAsync();
return(Result.Success());
}
}
public async Task <IActionResult> ModifyPolicy(int id, [FromBody] MarkupPolicySettings policySettings)
{
var(_, isFailure, error) = await _policyManager.Modify(id, policySettings);
if (isFailure)
{
return(BadRequest(ProblemDetailsBuilder.Build(error)));
}
return(NoContent());
}
public async Task <IActionResult> AddPolicy([FromBody] MarkupPolicySettings settings)
{
var(_, isFailure, error) = await _policyManager.AddGlobalPolicy(settings);
if (isFailure)
{
return(BadRequest(ProblemDetailsBuilder.Build(error)));
}
return(NoContent());
}
public async Task <Result> ModifyForAgency(int agencyId, int policyId, MarkupPolicySettings settings)
{
var policy = await _context.MarkupPolicies
.FirstOrDefaultAsync(p => p.Id == policyId &&
p.SubjectScopeType == SubjectMarkupScopeTypes.Agency &&
p.SubjectScopeId == agencyId.ToString());
return(policy is null
? Result.Failure($"Policy '{policyId}' not found")
: await Modify(policyId, settings));
}
public async Task <Result> ModifyGlobalPolicy(int policyId, MarkupPolicySettings settings)
{
var isGlobalPolicy = await _context.MarkupPolicies
.AnyAsync(p =>
p.SubjectScopeType == SubjectMarkupScopeTypes.Global &&
p.Id == policyId);
return(isGlobalPolicy
? await Modify(policyId, settings)
: Result.Failure($"Policy '{policyId}' not found or not global"));
}
public async Task <Result> AddLocationPolicy(MarkupPolicySettings settings)
{
var(_, isFailure, agentMarkupScopeType, error) = await GetAgentMarkupScopeType(settings.LocationScopeId);
if (isFailure)
{
return(Result.Failure(error));
}
return(await Add(new MarkupPolicyData(MarkupPolicyTarget.AccommodationAvailability, settings,
new MarkupPolicyScope(agentMarkupScopeType, locationId: settings.LocationScopeId))));
}
public async Task <IActionResult> AddPolicy([FromRoute] int agentId, [FromBody] MarkupPolicySettings settings)
{
var agent = await _agentContext.GetAgent();
var(_, isFailure, error) = await _policyManager.Add(agentId, settings, agent);
if (isFailure)
{
return(BadRequest(ProblemDetailsBuilder.Build(error)));
}
return(NoContent());
}
public Task <Result> Add(int agentId, MarkupPolicySettings settings, AgentContext agent)
{
return(ValidateSettings(agentId, agent.AgencyId, settings)
.Bind(() => GetAgentAgencyRelation(agentId, agent.AgencyId))
.Bind(SavePolicy)
.Tap(WriteAuditLog)
.Bind(UpdateDisplayedMarkupFormula));
async Task <Result <MarkupPolicy> > SavePolicy(AgentAgencyRelation agentAgencyRelation)
{
var(_, isFailure, destinationScopeType, error) = await GetDestinationScopeType(settings.DestinationScopeId);
if (isFailure)
{
return(Result.Failure <MarkupPolicy>(error));
}
var now = _dateTimeProvider.UtcNow();
var agentInAgencyId = AgentInAgencyId.Create(agentAgencyRelation.AgentId, agentAgencyRelation.AgencyId);
var policy = new MarkupPolicy
{
Description = settings.Description,
Order = settings.Order,
Target = MarkupPolicyTarget.AccommodationAvailability,
SubjectScopeType = SubjectMarkupScopeTypes.Agent,
SubjectScopeId = agentInAgencyId.ToString(),
DestinationScopeType = destinationScopeType,
DestinationScopeId = settings.DestinationScopeId,
TemplateSettings = settings.TemplateSettings,
Currency = settings.Currency,
Created = now,
Modified = now,
TemplateId = settings.TemplateId
};
_context.MarkupPolicies.Add(policy);
await _context.SaveChangesAsync();
return(policy);
}
Task WriteAuditLog(MarkupPolicy policy)
=> _markupPolicyAuditService.Write(MarkupPolicyEventType.AgentMarkupCreated,
new AgentMarkupPolicyData(policy.Id, agentId, agent.AgencyId),
agent.ToApiCaller());
}
private Task <Result> ValidateSettings(int agentId, int agencyId, MarkupPolicySettings settings, int?policyId = null)
{
return(ValidateTemplate()
.Ensure(PolicyOrderIsUniqueForScope, "Policy with same order is already defined"));
Result ValidateTemplate() => _templateService.Validate(settings.TemplateId, settings.TemplateSettings);
async Task <bool> PolicyOrderIsUniqueForScope()
{
var isSameOrderPolicyExist = (await GetAgentPolicies(agentId, agencyId))
.Any(p => p.Order == settings.Order && p.Id != policyId);
return(!isSameOrderPolicyExist);
}
}
public async Task <Result> Modify(int policyId, MarkupPolicySettings settings, AgentContext agent)
{
var policy = await _context.MarkupPolicies.SingleOrDefaultAsync(p => p.Id == policyId);
if (policy == null)
{
return(Result.Failure("Could not find policy"));
}
return(await Result.Success()
.Bind(CheckPermissions)
.Bind(UpdatePolicy));
Task <Result> CheckPermissions()
{
var scopeData = new MarkupPolicyScope(policy.ScopeType,
policy.CounterpartyId ?? policy.AgencyId ?? policy.AgentId);
return(CheckUserManagePermissions(scopeData, agent));
}
async Task <Result> UpdatePolicy()
{
policy.Description = settings.Description;
policy.Order = settings.Order;
policy.TemplateId = settings.TemplateId;
policy.TemplateSettings = settings.TemplateSettings;
policy.Currency = settings.Currency;
policy.Modified = _dateTimeProvider.UtcNow();
var validateResult = await ValidatePolicy(GetPolicyData(policy));
if (validateResult.IsFailure)
{
return(validateResult);
}
_context.Update(policy);
await _context.SaveChangesAsync();
return(Result.Success());
}
}
public async Task <Result> Modify(int agentId, int policyId, MarkupPolicySettings settings, AgentContext agent)
{
return(await GetAgentAgencyRelation(agentId, agent.AgencyId)
.Bind(GetPolicy)
.Check(_ => ValidateSettings(agentId, agent.AgencyId, settings, policyId))
.Check(UpdatePolicy)
.Tap(WriteAuditLog)
.Bind(UpdateDisplayedMarkupFormula));
Task <Result <MarkupPolicy> > GetPolicy(AgentAgencyRelation relation) => GetAgentPolicy(relation, policyId);
async Task <Result> UpdatePolicy(MarkupPolicy policy)
{
var(_, isFailure, destinationScopeType, error) = await GetDestinationScopeType(settings.DestinationScopeId);
if (isFailure)
{
return(Result.Failure(error));
}
policy.DestinationScopeId = settings.DestinationScopeId;
policy.DestinationScopeType = destinationScopeType;
policy.Description = settings.Description;
policy.Order = settings.Order;
policy.TemplateId = settings.TemplateId;
policy.TemplateSettings = settings.TemplateSettings;
policy.Currency = settings.Currency;
policy.Modified = _dateTimeProvider.UtcNow();
_context.Update(policy);
await _context.SaveChangesAsync();
return(Result.Success());
}
Task WriteAuditLog(MarkupPolicy policy)
=> _markupPolicyAuditService.Write(MarkupPolicyEventType.AgentMarkupUpdated,
new AgentMarkupPolicyData(policy.Id, agentId, agent.AgencyId),
agent.ToApiCaller());
}
public async Task <Result> ModifyLocationPolicy(int policyId, MarkupPolicySettings settings)
{
var policy = await _context.MarkupPolicies
.FirstOrDefaultAsync(p => p.Id == policyId);
if (policy.SubjectScopeType is not(SubjectMarkupScopeTypes.Country or SubjectMarkupScopeTypes.Locality))
{
return(Result.Failure($"Policy '{policyId}' not found or not local"));
}
var(_, isFailure, agentMarkupScopeType, error) = await GetAgentMarkupScopeType(settings.LocationScopeId);
if (isFailure)
{
return(Result.Failure(error));
}
if (policy.SubjectScopeType != agentMarkupScopeType)
{
return(Result.Failure($"It is not allowed change location to a new type"));
}
return(await Modify(policyId, settings));
}
public Task <Result> AddAgencyPolicy(int agencyId, MarkupPolicySettings settings) => Add(new MarkupPolicyData(MarkupPolicyTarget.AccommodationAvailability, settings, new MarkupPolicyScope(SubjectMarkupScopeTypes.Agency, agencyId)));
public Task <Result> AddGlobalPolicy(MarkupPolicySettings settings) => Add(new MarkupPolicyData(MarkupPolicyTarget.AccommodationAvailability, settings, new MarkupPolicyScope(SubjectMarkupScopeTypes.Global)));
public async Task <Result> Modify(int policyId, MarkupPolicySettings settings)
{
var destinationScopeType = await GetDestinationScopeType(settings.DestinationScopeId);
if (destinationScopeType.IsFailure)
{
return(Result.Failure(destinationScopeType.Error));
}
var policy = await _context.MarkupPolicies.SingleOrDefaultAsync(p => p.Id == policyId);
if (policy == null)
{
return(Result.Failure("Could not find policy"));
}
var(_, isFailure, markupPolicy, error) = await ValidateSettings()
.Bind(DiscountsDontExceedMarkups)
.Bind(UpdatePolicy)
.Tap(p => WriteAuditLog(p, MarkupPolicyEventOperationType.Modified));
if (isFailure)
{
return(Result.Failure(error));
}
return(await UpdateDisplayedMarkupFormula(markupPolicy));
Result ValidateSettings() => _templateService.Validate(settings.TemplateId, settings.TemplateSettings);
async Task <Result> DiscountsDontExceedMarkups()
{
// This check is only applicable to agency scope markups
if (policy.SubjectScopeType != SubjectMarkupScopeTypes.Agency)
{
return(Result.Success());
}
var agencyId = int.Parse(policy.SubjectScopeId);
var allDiscounts = await _context.Discounts
.Where(x => x.IsActive)
.Where(x => x.TargetAgencyId == agencyId)
.Where(x => x.TargetPolicyId == policy.Id)
.Select(x => x.DiscountPercent)
.ToListAsync();
var markupFunction = _templateService.CreateFunction(policy.TemplateId, policy.TemplateSettings);
return(DiscountsValidator.DiscountsDontExceedMarkups(allDiscounts, markupFunction));
}
async Task <Result <MarkupPolicy> > UpdatePolicy()
{
policy.Description = settings.Description;
policy.Order = settings.Order;
policy.TemplateId = settings.TemplateId;
policy.TemplateSettings = settings.TemplateSettings;
policy.Currency = settings.Currency;
policy.Modified = _dateTimeProvider.UtcNow();
policy.SubjectScopeId = settings.LocationScopeId;
// No SubjectScopeType here because changing its type is not allowed
policy.DestinationScopeId = settings.DestinationScopeId;
policy.DestinationScopeType = destinationScopeType.Value;
var policyData = GetPolicyData(policy);
if (policyData.IsFailure)
{
return(Result.Failure <MarkupPolicy>(policyData.Error));
}
var(_, isFailure, error) = await ValidatePolicy(policyData.Value, policy);
if (isFailure)
{
return(Result.Failure <MarkupPolicy>(error));
}
_context.Update(policy);
await _context.SaveChangesAsync();
return(policy);
}
}
