private void SendResponse(Subtransaction subtransaction)
{
PrescribedDrug pd = new PrescribedDrug
{
Id = subtransaction.Id,
CoveredAmount = subtransaction.AmountPaid,
};
string json = JsonSerializer.Serialize(pd);
var bytes = Encoding.UTF8.GetBytes(json);
#if DEBUG
var request = (HttpWebRequest)WebRequest.Create("https://localhost:44381/api/PrescribedDrugsAPI");
#else
var request = (HttpWebRequest)WebRequest.Create("https://wngcsp86.intra.uwlax.edu:8080/api/PrescribedDrugsAPI");
#endif
request.Method = "POST";
request.ContentLength = bytes.Length;
request.ContentType = "application/json";
Stream stream = request.GetRequestStream();
stream.Write(bytes, 0, bytes.Length);
stream.Close();
WebResponse subtransactionResponse = request.GetResponse();
}
private bool?isTransactionProcessed(PTransaction transaction, Subtransaction subtransaction = null)
{
List <Subtransaction> allSubtransactions = _transactionContext.Subtransactions.Where(s => s.PTransactionId == transaction.Id).ToList();
bool anyProcessed = false;
bool allProcessed = true;
foreach (Subtransaction s in allSubtransactions)
{
if (subtransaction != null && s.Id == subtransaction.Id)
{
continue;
}
if (s.Accepted != 0)
{
anyProcessed = true;
}
else
{
allProcessed = false;
}
}
if (!anyProcessed)
{
return(false);
}
if (anyProcessed && !allProcessed)
{
return(null);
}
//else allProcessed = true
return(true);
}
public async Task <ActionResult <Subtransaction> > PostSubtransaction(Subtransaction subtransaction)
{
_context.Subtransactions.Add(subtransaction);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetSubtransaction), new { id = subtransaction.Id }, subtransaction));
}
public async Task <IActionResult> PutSubtransaction(int id, Subtransaction subtransaction)
{
if (id != subtransaction.Id)
{
return(BadRequest());
}
_context.Entry(subtransaction).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SubtransactionExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private double getTotalCost(Drug d, Policy p, PolicyHolder h, Subtransaction s)
{
if (s.Accepted == 1)
{
return(Math.Min(h.AmountRemaining, Math.Round(d.CostPer * s.Count * p.PercentCoverage, 2)));
}
return(0);
}
/// <summary>
/// Maps a <see cref="Subtransaction"/> to a <see cref="Sale"/>.
/// </summary>
/// <param name="subtransaction">The subtransactions to be mapped.</param>
/// <param name="rate">The commission rate to apply to the subtransactions.</param>
/// <returns>Mapped <see cref="Sale"/> object.</returns>
public static Sale FromTransaction(Subtransaction subtransaction, decimal rate)
{
var subTotal = subtransaction.Subtotal;
var commission = subTotal * rate;
var sale = new Sale
{
ProductCode = subtransaction.Product.ProductCode,
ProductName = subtransaction.Product.ProductName,
Quantity = subtransaction.Quantity,
UnitPrice = subtransaction.TransactionUnitPrice,
Subtotal = subTotal,
Commission = -commission,
Total = subTotal - commission,
};
return(sale);
}
private IObservable <Subtransaction> CreateSubtransactionFromFee(OrderServiceCharge serviceCharge)
{
Product product;
if (serviceCharge.Name?.Equals("Shipping", StringComparison.OrdinalIgnoreCase) == true)
{
product = new Product("TLM-DELIVERY", "TLM-DELIVERY", "Shipping Fees", "Delivery costs charged to customers.", 0.01m);
}
else
{
product = new Product("TLM-FEES", "TLM-" + serviceCharge.Name, serviceCharge.Name, "Unknown Fee.", 0.01m);
}
var quantity = serviceCharge.TotalMoney.Amount ?? 0;
var amount = decimal.Divide(quantity, 100);
var transaction = new Subtransaction(product, (int)quantity, amount);
return(Observable.Return(transaction));
}
private IObservable <Subtransaction> CreateSubtransactionFromDiscount(OrderLineItemDiscount orderLineItemDiscount)
{
Product product;
if (orderLineItemDiscount.Name.Contains("macaron", StringComparison.OrdinalIgnoreCase))
{
product = new Product("BUN-DCM", "BUN-DCM", "Box of Macarons Discount", "Buy 6 macarons for \"£12.00\"", -0.01m);
}
else if (orderLineItemDiscount.Name.Contains("pocky", StringComparison.OrdinalIgnoreCase))
{
product = new Product("BUN-DCP", "BUN-DCP", "Box of Pocky Discount", "Discount on buying multiple packs of Pocky.", -0.01m);
}
else
{
product = new Product("TLM-D", "TLM-D", "Other discounts", "Discounts that aren't tracked.", -0.01m);
}
var quantity = orderLineItemDiscount.AppliedMoney.Amount ?? 0;
var amount = decimal.Divide(quantity, 100);
var subtransaction = new Subtransaction(product, (int)quantity, -amount);
return(Observable.Return(subtransaction));
}
private IActionResult SendPrescription(Prescription prescription, List <PrescribedDrug> prescribedDrugs)
{
int holderId = _verificationContext.VerifiedPatients.First(p => p.Name == prescription.PatientName).Id;
PTransaction transaction = new PTransaction
{
Id = prescription.Id,
Date = prescription.IssuedDate,
HolderId = holderId
};
string json = JsonSerializer.Serialize(transaction);
var bytes = Encoding.UTF8.GetBytes(json);
#if DEBUG
var httpRequest = (HttpWebRequest)WebRequest.Create("https://localhost:44306/api/PTransactionsAPI");
#else
var httpRequest = (HttpWebRequest)WebRequest.Create("https://wngcsp86.intra.uwlax.edu:81/api/PTransactionsAPI");
#endif
httpRequest.Method = "POST";
httpRequest.ContentLength = bytes.Length;
httpRequest.ContentType = "application/json";
Stream dataStream = httpRequest.GetRequestStream();
dataStream.Write(bytes, 0, bytes.Length);
dataStream.Close();
try
{
WebResponse response = httpRequest.GetResponse();
}
catch (WebException e)
{
if (e.Message == "The remote server returned an error: (404) Not Found.")
{
prescription.SentToInsurance = true;
foreach (PrescribedDrug pd in prescribedDrugs)
{
pd.Returned = true;
pd.CoveredAmount = 0;
_prescriptionContext.PrescribedDrugs.Update(pd);
}
_prescriptionContext.Prescriptions.Update(prescription);
_prescriptionContext.SaveChanges();
return(RedirectToAction("Details", new { id = prescription.Id }));
}
}
foreach (PrescribedDrug pd in prescribedDrugs)
{
Subtransaction subtransaction = new Subtransaction
{
Id = pd.Id,
PTransactionId = prescription.Id,
DrugId = pd.DrugId,
Count = pd.Count,
AmountPaid = 0,
Accepted = 0,
};
string subtransactionJson = JsonSerializer.Serialize(subtransaction);
var subtransactionBytes = Encoding.UTF8.GetBytes(subtransactionJson);
#if DEBUG
var request = (HttpWebRequest)WebRequest.Create("https://localhost:44306/api/SubtransactionsAPI");
#else
var request = (HttpWebRequest)WebRequest.Create("https://wngcsp86.intra.uwlax.edu:81/api/SubtransactionsAPI");
#endif
request.Method = "POST";
request.ContentLength = subtransactionBytes.Length;
request.ContentType = "application/json";
Stream stream = request.GetRequestStream();
stream.Write(subtransactionBytes, 0, subtransactionBytes.Length);
stream.Close();
WebResponse subtransactionResponse = request.GetResponse();
}
return(null);
}
private static void getTransactions(UmlActivityDiagram actDiagram, List <Transaction> transactions, List <Request> requests, UmlModel model)
{
Transaction transaction = new Transaction();
UmlActionState aux_first = new UmlActionState();
UmlActionState aux_last = new UmlActionState();
foreach (UmlActionState act in actDiagram.UmlObjects.OfType <UmlActionState>())
{
try
{
if (!((act is UmlInitialState) || (act is UmlFinalState) || (act is UmlPseudoState)))
{
String diagramName = act.TaggedValues["jude.hyperlink"];
foreach (UmlActivityDiagram actDiagram2 in model.Diagrams.OfType <UmlActivityDiagram>())
{
if (actDiagram2.Name.Equals(diagramName))
{
getTransactions(actDiagram2, transactions, requests, model);
}
}
}
}
catch
{
if (act.ParentLane == null || act.ParentLane.Name.Equals(""))
{
transaction = new Transaction();
foreach (Request req in requests)
{
if (req.Name.Equals(act.Name))
{
transaction.Name = act.Name;
transaction.Begin = req;
transaction.End = req;
transactions.Add(transaction);
break;
}
}
}
else
{
Boolean exist = false;
if (transactions.Count() > 0)
{
for (int i = 0; i < transactions.Count; i++)
{
Transaction auxTransaction = transactions[i];
if (auxTransaction.Name.Equals(act.ParentLane.Name))
{
foreach (Subtransaction sub in auxTransaction.Subtransactions)
{
foreach (UmlActionState element in act.ParentLane.GetElements())
{
if (element.Name.Equals(sub.Name))
{
exist = true;
}
}
}
if (!(auxTransaction.Name.Equals(transaction.Name)))
{
transaction = auxTransaction;
}
}
}
}
if (!exist)
{
transaction = new Transaction();
transactions.Add(transaction);
transaction.Name = act.ParentLane.Name;
transaction.Requests = new List <Request>();
transaction.Subtransactions = new List <Subtransaction>();
aux_first = getLaneFirstState(act.ParentLane, actDiagram);
aux_last = getLaneLastState(act.ParentLane, actDiagram);
}
Subtransaction subtransaction = new Subtransaction();
foreach (Request req in requests)
{
if (req.Name.Equals(act.Name))
{
if (req.Name.Equals(aux_first.Name))
{
transaction.Begin = req;
}
if (req.Name.Equals(aux_last.Name))
{
transaction.End = req;
}
subtransaction.Name = act.Name;
subtransaction.Begin = req;
subtransaction.End = req;
transaction.Requests.Add(req);
transaction.Subtransactions.Add(subtransaction);
break;
}
}
}
}
}
}
private TestCase FillTestCase(Plets.Modeling.FiniteStateMachine.FiniteStateMachine machine, List <Transition> listTransition)
{
TestCase testCase = new TestCase();
testCase.Name = machine.Name;
testCase.Probability = actualTestCaseProb;
Transaction transaction = null;
bool existsLane = false;
foreach (Transition t in listTransition)
{
State s = machine.States.Where(x => x.Name.Equals(t.SourceState.Name)).FirstOrDefault();
try {
existsLane = !String.IsNullOrEmpty(s.TaggedValues["Lane"]);
} catch {
existsLane = false;
}
if (existsLane)
{
List <Transaction> transactions = testCase.Transactions.Where(x => x.Name.Equals(s.TaggedValues["Lane"])).ToList();
if (transactions.Count == 0)
{
transaction = new Transaction();
transaction.Name = s.TaggedValues["Lane"];
Subtransaction subtransaction = new Subtransaction();
subtransaction.Name = t.SourceState.Name;
Request request = new Request();
request.Name = t.SourceState.Name;
GetRequestTags(t, request);
subtransaction.Begin = request;
subtransaction.End = request;
transaction.Subtransactions.Add(subtransaction);
testCase.Transactions.Add(transaction);
}
else
{
transaction = transactions.FirstOrDefault();
Subtransaction subtransaction = new Subtransaction();
subtransaction.Name = t.SourceState.Name;
Request request = new Request();
request.Name = t.SourceState.Name;
GetRequestTags(t, request);
subtransaction.Begin = request;
subtransaction.End = request;
transaction.Subtransactions.Add(subtransaction);
}
}
else
{
transaction = new Transaction();
transaction.Name = t.SourceState.Name;
Request request = new Request();
GetRequestTags(t, request);
transaction.Begin = request;
transaction.End = request;
testCase.Transactions.Add(transaction);
}
AddRequestsToTestCase(testCase, t);
}
return(testCase);
}
// GET: PTransactions/Details/5
public async Task <IActionResult> Process(int?id)
{
if (id == null)
{
return(NotFound());
}
Subtransaction subtransaction = await _transactionContext.Subtransactions.FirstAsync(s => s.Id == id);
PTransaction transaction = await _transactionContext.PTransactions.FirstAsync(m => m.Id == subtransaction.PTransactionId);
PolicyHolder policyHolder = await _policyHolderContext.PolicyHolders.FirstAsync(p => p.Id == transaction.HolderId);
Policy policy = await _policyContext.Policies.FirstAsync(p => p.Id == policyHolder.Id);
Drug drug = await _drugContext.Drugs.FirstAsync(d => d.Id == subtransaction.DrugId);
IQueryable <PolicyDrug> coveredDrugs = _policyDrugContext.PolicyDrugs.Where(pd => pd.PolicyId == policy.Id);
PolicyDrug pd = coveredDrugs.FirstOrDefault(cd => cd.DrugId == drug.Id);
bool inDate = policyHolder.StartDate < DateTime.Now && DateTime.Now < policyHolder.EndDate;
bool inPolicy = pd != null;
if (!inDate)
{
subtransaction.Accepted = -2;
}
else if (!inPolicy)
{
subtransaction.Accepted = -1;
}
else
{
subtransaction.Accepted = 1;
}
transaction.Processed = isTransactionProcessed(transaction, subtransaction);
if (subtransaction.Accepted == 1)
{
subtransaction.AmountPaid = getTotalCost(drug, policy, policyHolder, subtransaction);
policyHolder.AmountPaid += subtransaction.AmountPaid;
policyHolder.AmountRemaining = policy.MaxCoverage - policyHolder.AmountPaid;
_policyHolderContext.PolicyHolders.Update(policyHolder);
_policyHolderContext.SaveChanges();
}
_transactionContext.PTransactions.Update(transaction);
_transactionContext.Subtransactions.Update(subtransaction);
_transactionContext.SaveChanges();
// Send response to pharmacy
SendResponse(subtransaction);
string holderName = "";
if (policyHolder.Name == HttpContext.Session.GetString(HomeController.HolderName))
{
holderName = policyHolder.Name;
}
bool includeProcessed = false;
if (!string.IsNullOrEmpty(HttpContext.Session.GetString(HomeController.IncludeProcessed)))
{
includeProcessed = bool.Parse(HttpContext.Session.GetString(HomeController.IncludeProcessed));
}
return(RedirectToAction("Details", new { id = transaction.Id }));
}
private void UpdateTransactions()
{
// add transactions
var now = DateTime.Now;
var accounts = _accountRepository.GetAll().ToList();
var vendors = _vendorRepository.GetAll().ToList();
var mappedVendors = _importDescriptionVendorMapRepository.GetAll().ToList();
var transactions = _transactionRepository.GetAll().ToList();
var importedTransactions = new List<Transaction>();
var maxTransactionDate = transactions.Any() ? transactions.Max(x => x.OriginalTimestamp) : DateTime.MinValue;
foreach (ImportRecord row in _transactions.Where(x => x.Date >= maxTransactionDate).OrderBy(x => x.Date))
{
// is amount credit or debit?
var amount = row.Amount * (row.TransactionType.Equals("debit") ? -1.0M : 1.0M);
// has this transaction already been imported?
var existingTransaction = transactions.FirstOrDefault(x => x.Amount == amount && x.OriginalTimestamp == row.Date && x.Subtransactions.Any(y => y.Notes.Equals(row.OriginalDescription, StringComparison.CurrentCultureIgnoreCase)));
if (existingTransaction != null)
{
Console.WriteLine("FOUND {0} {1} : {2}", row.Date.ToShortDateString(), amount, row.OriginalDescription);
importedTransactions.Add(existingTransaction);
continue;
}
Console.WriteLine("create {0} {1} : {2}", row.Date.ToShortDateString(), amount, row.OriginalDescription);
// find the account in the local cache
var account = accounts.SingleOrDefault(x => x.AccountNameMaps.Any(y => y.Name.Equals(row.AccountName, StringComparison.CurrentCultureIgnoreCase)));
// if we didn't find one, make one
if (account == null)
{
account = new Account()
{
Name = row.AccountName,
AccountGroup = accounts.Any() ? accounts.FirstOrDefault().AccountGroup : new AccountGroup() { Name = row.AccountName },
BalanceTimestamp = now
};
account.AccountNameMaps = new List<AccountNameMap>() { new AccountNameMap() { Account = account, Name = row.AccountName } };
_accountRepository.Add(account);
_unitOfWork.Commit();
accounts.Add(account);
}
account.BalanceTimestamp = now;
// find the vendor in the local cache
var vendor = vendors.SingleOrDefault(x => x.Name.Equals(row.Description, StringComparison.CurrentCultureIgnoreCase));
// find the vendor in the description map
var mappedVendor = mappedVendors.Where(x => x.Description.Equals(row.Description, StringComparison.CurrentCultureIgnoreCase));
if (mappedVendor.Any())
{
vendor = mappedVendor.FirstOrDefault().Vendor;
}
// if we didn't find one, make one
if (vendor == null)
{
vendor = new Vendor() { Name = row.Description };
_vendorRepository.Add(vendor);
_unitOfWork.Commit();
vendors.Add(vendor);
}
Transaction transaction = new Transaction()
{
Timestamp = row.Date,
OriginalTimestamp = row.Date,
Amount = amount,
Vendor = vendor,
};
Subtransaction subtransaction = new Subtransaction()
{
Amount = amount,
Memo = row.Description,
Notes = row.OriginalDescription,
CategoryId = account.DefaultCategoryId,
IsTransfer = row.Description.StartsWith("Transfer from") || row.Description.StartsWith("Transfer to")
};
transaction.Subtransactions.Add(subtransaction);
account.Transactions.Add(transaction);
_newTransactions.Add(transaction);
_unitOfWork.Commit();
}
}
