public async ValueTask <PriceProcessFunction> Get(MarkupPolicy policy, MarkupSubjectInfo subject)
{
// Discounts are only supported for global markups for now
if (policy.SubjectScopeType != SubjectMarkupScopeTypes.Global)
{
return(price => new ValueTask <MoneyAmount>(price));
}
return(moneyAmount =>
{
var currentAmount = moneyAmount;
foreach (var discount in GetAgentDiscounts())
{
currentAmount = new MoneyAmount
{
Amount = currentAmount.Amount * (100 - discount.DiscountPercent) / 100,
Currency = currentAmount.Currency
};
}
return new ValueTask <MoneyAmount>(currentAmount);
});
List <Discount> GetAgentDiscounts()
=> _discountStorage.Get(d => d.TargetPolicyId == policy.Id &&
d.TargetAgencyId == subject.AgencyId &&
d.IsActive);
}
public Task <Result> Add(MarkupPolicyData policyData)
{
return(ValidatePolicy(policyData)
.Bind(SavePolicy));
async Task <Result> SavePolicy()
{
var now = _dateTimeProvider.UtcNow();
var(type, counterpartyId, agencyId, agentId) = policyData.Scope;
var policy = new MarkupPolicy
{
Description = policyData.Settings.Description,
Order = policyData.Settings.Order,
ScopeType = type,
Target = policyData.Target,
AgencyId = agencyId,
CounterpartyId = counterpartyId,
AgentId = agentId,
TemplateSettings = policyData.Settings.TemplateSettings,
Currency = policyData.Settings.Currency,
Created = now,
Modified = now,
TemplateId = policyData.Settings.TemplateId
};
_context.MarkupPolicies.Add(policy);
await _context.SaveChangesAsync();
return(Result.Success());
}
}
private PriceProcessFunction GetPriceProcessFunction(MarkupPolicy policy)
{
var policyFunction = GetPolicyFunction(policy);
return(async initialPrice =>
{
var amount = initialPrice.Amount;
var(_, _, currencyRate, _) = await _currencyRateService.Get(initialPrice.Currency, policyFunction.Currency);
amount = policyFunction.Function(amount * currencyRate) / currencyRate;
return new MoneyAmount(amount, initialPrice.Currency);
});
}
public async Task <Result> Add(MarkupPolicyData policyData)
{
var destinationScopeType = await GetDestinationScopeType(policyData.Settings.DestinationScopeId);
if (destinationScopeType.IsFailure)
{
return(Result.Failure(destinationScopeType.Error));
}
var(_, isFailure, markupPolicy, error) = await ValidatePolicy(policyData)
.Map(SavePolicy)
.Tap(p => WriteAuditLog(p, MarkupPolicyEventOperationType.Created));
if (isFailure)
{
return(Result.Failure(error));
}
return(await UpdateDisplayedMarkupFormula(markupPolicy));
async Task <MarkupPolicy> SavePolicy()
{
var now = _dateTimeProvider.UtcNow();
var(type, agencyId, agentId, agentScopeId) = policyData.Scope;
var settings = policyData.Settings;
var policy = new MarkupPolicy
{
Description = settings.Description,
Order = settings.Order,
Target = policyData.Target,
TemplateSettings = settings.TemplateSettings,
Currency = settings.Currency,
Created = now,
Modified = now,
TemplateId = settings.TemplateId,
SubjectScopeType = type,
SubjectScopeId = agentScopeId,
DestinationScopeId = settings.DestinationScopeId,
DestinationScopeType = destinationScopeType.Value
};
_context.MarkupPolicies.Add(policy);
await _context.SaveChangesAsync();
return(policy);
}
}
public static MarkupPolicySettings GetSettings(this MarkupPolicy policy)
{
// TODO Cleanup the model: https://github.com/happy-travel/agent-app-project/issues/777
var locationScopeId = policy.SubjectScopeType == SubjectMarkupScopeTypes.Country || policy.SubjectScopeType == SubjectMarkupScopeTypes.Locality
? policy.SubjectScopeId
: null;
return(new(description : policy.Description,
templateId : policy.TemplateId,
templateSettings : policy.TemplateSettings,
order : policy.Order,
currency : policy.Currency,
locationScopeId : locationScopeId,
destinationScopeId : policy.DestinationScopeId));
}
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 MarkupPolicyFunction GetPolicyFunction(MarkupPolicy policy)
{
return(_flow
.GetOrSet(BuildKey(policy),
() =>
{
return new MarkupPolicyFunction
{
Currency = policy.Currency,
Function = _templateService
.CreateFunction(policy.TemplateId, policy.TemplateSettings)
};
},
MarkupPolicyFunctionCachingTime));
string BuildKey(MarkupPolicy policyWithFunc)
=> _flow.BuildKey(nameof(MarkupService),
nameof(GetPolicyFunction),
policyWithFunc.Id.ToString(),
policyWithFunc.Modified.ToString(CultureInfo.InvariantCulture));
}
static bool IsApplicableBySubject(MarkupPolicy policy, MarkupSubjectInfo info) => policy.SubjectScopeType switch
{
private Task <Result> UpdateDisplayedMarkupFormula(MarkupPolicy policy)
{
var agentInAgencyId = AgentInAgencyId.Create(policy.SubjectScopeId);
return(_displayedMarkupFormulaService.UpdateAgentFormula(agentInAgencyId.AgentId, agentInAgencyId.AgencyId));
}
public MarkupApplicationResult(TDetails before, MarkupPolicy policy, TDetails after)
{
Before = before;
Policy = policy;
After = after;
}
