private decimal ResolveAmount(IDataContext db, TransactionTrigger transactionTrigger, Public resolvedPublic, JournalTemplateTxn templateTxn)
{
decimal?result = null;
if (templateTxn.Amount.HasValue)
{
result = templateTxn.Amount.Value;
}
if (templateTxn.AmountInputID.HasValue)
{
var amountInput = transactionTrigger.Inputs.First(x => x.JournalTemplateInputID == templateTxn.AmountInputID);
result = Convert.ToDecimal(amountInput.Value);
}
if (templateTxn.AmountContextParameterID.HasValue)
{
result = ResolveContextParameter(db, transactionTrigger, templateTxn, resolvedPublic);
}
if (!result.HasValue)
{
throw new Exception("Unable to resolve amount");
}
if (templateTxn.InvertPercentage)
{
result = (1 - result.Value);
}
return(result.Value);
}
private void BuildCoverageTxns(IDataContext db, TransactionTrigger transactionTrigger, Public resolvedPublic, Journal journal, JournalTemplateTxn templateTxn, decimal percentage)
{
if (transactionTrigger.PolicyTransactionTrigger != null)
{
var policyTransactionTrigger = (transactionTrigger.PolicyTransactionTrigger);
foreach (var coverage in policyTransactionTrigger.Policy.Coverages)
{
if (!coverage.Premium.HasValue)
{
throw new Exception("Coverage premium not set");
}
JournalTxn txn = new JournalTxn();
txn.Amount = ((ResolveAmount(db, transactionTrigger, resolvedPublic, templateTxn) * coverage.Premium.Value) * percentage);
txn.Description = templateTxn.Description + " - " + coverage.CoverageType.Name;
txn.Policy = policyTransactionTrigger.Policy;
txn.Public = resolvedPublic;
//sp ??
txn.ReportingEntityBranch = transactionTrigger.ReportingEntityBranch;
//txn.TransactionOrigin = transactionTrigger.TransactionOrigin;
txn.TxnDate = transactionTrigger.TxnDate.Value.Date;
txn.JournalTemplateTxn = templateTxn;
txn.PolicyCoverage = coverage;
txn.Agent = journal.Agent;
journal.JournalTxns.Add(txn);
}
}
}
private void BuildStandardTxn(IDataContext db, TransactionTrigger transactionTrigger, Public resolvedPublic, Journal journal, JournalTemplateTxn templateTxn, decimal percentage)
{
JournalTxn txn = new JournalTxn();
if (templateTxn.JournalTxnClass.IsDefinedAmount)
{
txn.Amount = (ResolveAmount(db, transactionTrigger, resolvedPublic, templateTxn) * percentage);
}
if (templateTxn.JournalTxnClass.OfLedgerAccount)
{
txn.Amount = ((ResolveAmount(db, transactionTrigger, resolvedPublic, templateTxn) * ResolveLedgerBalance(db, transactionTrigger, templateTxn, resolvedPublic)) * percentage);
}
txn.Description = templateTxn.Description;
if (transactionTrigger.PolicyTransactionTrigger != null)
{
txn.Policy = transactionTrigger.PolicyTransactionTrigger.Policy;
}
txn.Public = resolvedPublic;
txn.ReportingEntityBranch = transactionTrigger.ReportingEntityBranch;
//txn.TransactionOrigin = transactionTrigger.TransactionOrigin;
txn.TxnDate = transactionTrigger.TxnDate.Value.Date;
txn.JournalTemplateTxn = templateTxn;
txn.Agent = journal.Agent;
journal.JournalTxns.Add(txn);
}
private decimal ResolveContextParameter(IDataContext db, TransactionTrigger trigger, JournalTemplateTxn templateTxn, Public resolvedPublic)
{
if (trigger.PolicyTransactionTrigger != null)
{
var policyTransactionTrigger = (trigger.PolicyTransactionTrigger);
if (policyTransactionTrigger.Policy != null)
{
return(_contextParameterResolver.Resolve(db, trigger.TxnDate.Value, templateTxn.AmountContextParameterID.Value, policyTransactionTrigger.Policy));
}
}
throw new NotImplementedException();
}
public static Transaction New(Wallet wallet, TransactionType transactionType, decimal amount,
string currency, TransactionTrigger transactionTrigger, DateTime transactionDate)
{
return(new Transaction
{
Wallet = wallet,
WalletId = wallet.Id,
TransactionType = transactionType,
Amount = amount,
Currency = currency,
TransactionTrigger = transactionTrigger,
CreationDate = transactionDate,
SystemRefId = Guid.NewGuid()
});
}
private string ResolveReference(IDataContext db, TransactionTrigger transactionTrigger)
{
if (transactionTrigger.JournalTemplate.ReferenceInputID.HasValue)
{
var refInput = transactionTrigger.Inputs.First(x => x.JournalTemplateInputID == transactionTrigger.JournalTemplate.ReferenceInputID);
return(refInput.Value);
}
if (transactionTrigger.JournalTemplate.SequenceNumberID.HasValue)
{
return(_sequenceNumberGeneator.GetNextNumber(db, transactionTrigger.JournalTemplate.SequenceNumberID.Value));
}
return(null);
}
private decimal ResolveLedgerBalance(IDataContext db, TransactionTrigger transactionTrigger, JournalTemplateTxn templateTxn, Public resolvedPublic)
{
if (templateTxn.AmountLedgerAccount == null)
{
throw new Exception("Ledger account not specified");
}
PolicyTransactionTrigger policyTransactionTrigger = null;
if (transactionTrigger.PolicyTransactionTrigger != null)
{
policyTransactionTrigger = (transactionTrigger.PolicyTransactionTrigger);
}
var query = db.LedgerTxns.Where(x => x.ReportingEntityID == transactionTrigger.ReportingEntityID && x.LedgerAccountID == templateTxn.AmountLedgerAccountID && x.TxnDate <= transactionTrigger.TxnDate);
switch (templateTxn.BalanceOrigin)
{
case "P":
query = query.Where(x => x.PolicyID == policyTransactionTrigger.PolicyID);
break;
case "U":
if (resolvedPublic == null)
{
throw new Exception("No public to resolve ledger balance for");
}
query = query.Where(x => x.PublicID == resolvedPublic.ID);
break;
case "X":
if (resolvedPublic == null)
{
throw new Exception("No public to resolve ledger balance for");
}
query = query.Where(x => x.PublicID == resolvedPublic.ID && x.PolicyID == policyTransactionTrigger.PolicyID);
break;
//todo: agents, sps, etc...
}
return(query.Sum(x => x.Amount));
}
public override void Init(ReceivedMessage message, int threadNumber)
{
base.Init(message, threadNumber);
_db = IoC.Container.Resolve <IDataContext>();
_controlDb = IoC.Container.Resolve <IDataContext>();
trigger = _db.TransactionTriggers.Find(message.Payload);
if (trigger == null)
{
return;
}
_lockKeys.Add("TransactionTrigger:" + trigger.ID.ToString());
if (trigger.PolicyTransactionTrigger != null)
{
var policyTransactionTrigger = (trigger.PolicyTransactionTrigger);
//if (policyTransactionTrigger.PolicyID.HasValue)
_lockKeys.Add("Policy:" + policyTransactionTrigger.PolicyID.ToString());
}
}
private Journal BuildJournal(IDataContext db, TransactionTrigger transactionTrigger, Public resolvedPublic, ServiceProvider serviceProvider, Agent agent, decimal percentage)
{
Journal journal = new Journal();
journal.Description = transactionTrigger.Description;
journal.JournalType = transactionTrigger.JournalTemplate.JournalType;
journal.ReportingEntity = transactionTrigger.ReportingEntity;
//journal.TransactionOrigin = transactionTrigger.TransactionOrigin;
if (transactionTrigger.PolicyTransactionTrigger != null)
{
journal.Policy = transactionTrigger.PolicyTransactionTrigger.Policy;
}
journal.Public = resolvedPublic;
journal.ServiceProvider = serviceProvider;
journal.Agent = agent;
journal.TxnDate = transactionTrigger.TxnDate.Value.Date;
journal.Reference = ResolveReference(db, transactionTrigger);
db.Journals.Add(journal);
foreach (var templateTxn in transactionTrigger.JournalTemplate.JournalTemplateTxns)
{
if (templateTxn.JournalTxnClass.OfCoveragePremium)
{
BuildCoverageTxns(db, transactionTrigger, resolvedPublic, journal, templateTxn, percentage);
}
else
{
BuildStandardTxn(db, transactionTrigger, resolvedPublic, journal, templateTxn, percentage);
}
}
journal.Amount = journal.JournalTxns.Sum(x => x.Amount);
return(journal);
}
private void IncrementTrigger(IDataContext db, TransactionTrigger transactionTrigger)
{
switch (transactionTrigger.TransactionTriggerFrequency.Code)
{
case "O":
transactionTrigger.Status = db.TransactionTriggerStatuses.First(x => x.Code == "S");
break;
case "D":
transactionTrigger.NextExecutionDate = transactionTrigger.NextExecutionDate.Value.AddDays(1);
transactionTrigger.TxnDate = transactionTrigger.TxnDate.Value.AddDays(1);
break;
case "BW":
transactionTrigger.NextExecutionDate = transactionTrigger.NextExecutionDate.Value.AddDays(14);
transactionTrigger.TxnDate = transactionTrigger.TxnDate.Value.AddDays(14);
break;
case "M":
transactionTrigger.NextExecutionDate = transactionTrigger.NextExecutionDate.Value.AddMonths(1);
transactionTrigger.TxnDate = transactionTrigger.TxnDate.Value.AddMonths(1);
break;
case "A":
transactionTrigger.NextExecutionDate = transactionTrigger.NextExecutionDate.Value.AddYears(1);
transactionTrigger.TxnDate = transactionTrigger.TxnDate.Value.AddYears(1);
break;
}
if (transactionTrigger.EffectiveTo.HasValue)
{
if (transactionTrigger.EffectiveTo.Value < DateTime.Now)
{
transactionTrigger.Status = db.TransactionTriggerStatuses.First(x => x.Code == "S");
}
}
}
public PolicyTransitionResponse Transition(Policy policy, PolicyTransitionRequest request, IDataContext db)
{
PolicyTransitionResponse response = new PolicyTransitionResponse();
try
{
var transition = db.PolicyTypeTransitions.Find(request.PolicyTypeTransitionID);
foreach (var journal in transition.JournalTemplates)
{
var targetEntities = policy.ReportingEntities.Where(x => x.PolicyTypeEntityRequirementID == journal.EntityRequirementID).ToList();
foreach (var entity in targetEntities)
{
if (!String.IsNullOrEmpty(journal.Condition))
{
Dictionary <string, object> exprParameters = new Dictionary <string, object>();
exprParameters.Add("policy", policy);
exprParameters.Add("request", request);
if (!_scriptEngine.ResolveExpression <bool>(exprParameters, db, journal.Condition, "Python"))
{
continue;
}
}
TransactionTrigger txnTrigger = new TransactionTrigger();
PolicyTransactionTrigger ptxTrigger = new PolicyTransactionTrigger();
ptxTrigger.TransactionTrigger = txnTrigger;
policy.TransactionTriggers.Add(ptxTrigger);
txnTrigger.ReportingEntity = entity.ReportingEntity;
txnTrigger.Description = journal.JournalTemplate.Description;
txnTrigger.JournalTemplate = journal.JournalTemplate;
txnTrigger.Status = journal.TransactionTriggerStatus;
txnTrigger.TransactionTriggerFrequency = journal.TransactionTriggerFrequency;
if (journal.TxnDateInputID.HasValue)
{
var strValue = request.Inputs.First(x => x.PolicyTypeTransitionInputID == journal.TxnDateInputID.Value).Value;
txnTrigger.NextExecutionDate = DateTime.Parse(strValue);
txnTrigger.TxnDate = DateTime.Parse(strValue);
}
foreach (var input in journal.Inputs)
{
TransactionTriggerInput txInput = new TransactionTriggerInput();
txnTrigger.Inputs.Add(txInput);
txInput.JournalTemplateInputID = input.JournalTemplateInputID;
if (input.PolicyTypeTransitionInputID.HasValue)
{
var strValue = request.Inputs.First(x => x.PolicyTypeTransitionInputID == input.PolicyTypeTransitionInputID.Value).Value;
txInput.Value = strValue;
}
if (!String.IsNullOrEmpty(input.Expression))
{
var exprResult = _scriptEngine.ResolveExpression <TransactionTriggerInput>(txInput, "input", db, input.Expression, "Python");
txInput.Value = Convert.ToString(exprResult);
}
}
}
}
if (!String.IsNullOrEmpty(transition.Script))
{
Dictionary <string, object> scriptParameters = new Dictionary <string, object>();
scriptParameters.Add("policy", policy);
scriptParameters.Add("request", request);
var scriptResult = _scriptEngine.Run(scriptParameters, db, transition.Script, "Python");
if (!scriptResult.Success)
{
string errMsg = string.Empty;
foreach (var s in scriptResult.Log)
{
errMsg += s;
}
throw new Exception(errMsg);
}
}
policy.Status = transition.TargetStatus;
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public JournalRunResult Run(IDataContext db, TransactionTrigger transactionTrigger)
{
JournalRunResult result = new JournalRunResult();
if (transactionTrigger.ReportingEntityTransactionTrigger != null)
{
var resolvedPublic = transactionTrigger.Public;
if (transactionTrigger.JournalTemplate.PublicRequirement != null)
{
if (transactionTrigger.JournalTemplate.PublicRequirement.IsServiceProvider)
{
resolvedPublic = transactionTrigger.ServiceProvider.Public;
}
if (transactionTrigger.JournalTemplate.PublicRequirement.IsAgent)
{
resolvedPublic = transactionTrigger.Agent.Public;
}
}
Journal journal = BuildJournal(db, transactionTrigger, resolvedPublic, transactionTrigger.ServiceProvider, transactionTrigger.Agent, 1);
_journalPoster.Run(db, journal);
result.Journals.Add(journal);
}
if (transactionTrigger.AgentTransactionTrigger != null)
{
var resolvedPublic = transactionTrigger.AgentTransactionTrigger.Agent.Public;
Journal journal = BuildJournal(db, transactionTrigger, resolvedPublic, transactionTrigger.ServiceProvider, transactionTrigger.AgentTransactionTrigger.Agent, 1);
_journalPoster.Run(db, journal);
result.Journals.Add(journal);
}
if (transactionTrigger.PolicyTransactionTrigger != null)
{
var policyTransactionTrigger = (transactionTrigger.PolicyTransactionTrigger);
if (transactionTrigger.JournalTemplate.PublicRequirement != null)
{
if (transactionTrigger.JournalTemplate.PublicRequirement.IsPolicyHolder)
{
decimal totalPerc = 0;
foreach (var policyHolder in policyTransactionTrigger.Policy.PolicyHolders)
{
if (policyHolder.BillingPercent.HasValue)
{
if (policyHolder.BillingPercent.Value != 0)
{
Journal journal = BuildJournal(db, transactionTrigger, policyHolder.Public, null, null, policyHolder.BillingPercent.Value);
_journalPoster.Run(db, journal);
result.Journals.Add(journal);
}
totalPerc += policyHolder.BillingPercent.Value;
}
}
if (totalPerc != 1)
{
throw new Exception("Policy holder split does not add up to 100%");
}
}
if (transactionTrigger.JournalTemplate.PublicRequirement.IsServiceProvider)
{
decimal totalPerc = 0;
foreach (var sp in policyTransactionTrigger.Policy.ServiceProviders.Where(x => x.ServiceProviderTypeID == transactionTrigger.JournalTemplate.ServiceProviderTypeID))
{
if (sp.Percentage != 0)
{
Journal journal = BuildJournal(db, transactionTrigger, sp.ServiceProvider.Public, sp.ServiceProvider, null, sp.Percentage);
_journalPoster.Run(db, journal);
result.Journals.Add(journal);
}
totalPerc += sp.Percentage;
}
if ((totalPerc != 1) && (totalPerc != 0))
{
throw new Exception("Service Provider split does not add up to 100%");
}
}
if (transactionTrigger.JournalTemplate.PublicRequirement.IsAgent)
{
decimal totalPerc = 0;
foreach (var agent in policyTransactionTrigger.Policy.Agents.Where(x => x.AgentTypeID == transactionTrigger.JournalTemplate.AgentTypeID))
{
if (agent.Percentage != 0)
{
Journal journal = BuildJournal(db, transactionTrigger, agent.Agent.Public, null, agent.Agent, agent.Percentage);
_journalPoster.Run(db, journal);
result.Journals.Add(journal);
}
totalPerc += agent.Percentage;
}
if ((totalPerc != 1) && (totalPerc != 0))
{
throw new Exception("Agent split does not add up to 100%");
}
}
}
else
{
Journal journal = BuildJournal(db, transactionTrigger, transactionTrigger.Public, transactionTrigger.ServiceProvider, transactionTrigger.Agent, 1);
_journalPoster.Run(db, journal);
result.Journals.Add(journal);
}
}
IncrementTrigger(db, transactionTrigger);
return(result);
}
