/// <summary>
/// This should probably be moved to a service...
/// </summary>
/// <param name="order"></param>
/// <param name="result"></param>
/// <param name="finalizeModel"></param>
/// <returns></returns>
private async Task <Order> UpdateOrderFromLabworksResult(Order order, OverwriteOrderResult result, LabFinalizeModel finalizeModel = null)
{
order.ClientId = result.ClientId;
order.ClientName = "[Not Found]"; //Updated below if we find it
var orderDetails = order.GetOrderDetails();
if (!string.IsNullOrWhiteSpace(order.ClientId))
{
//TODO: update other info if we pull it: phone numbers
var clientInfo = await _labworksService.GetClientDetails(order.ClientId);
if (clientInfo != null)
{
orderDetails.ClientInfo.ClientId = order.ClientId;
orderDetails.ClientInfo.Email = clientInfo.SubEmail;
orderDetails.ClientInfo.Name = clientInfo.Name;
orderDetails.ClientInfo.PhoneNumber = clientInfo.SubPhone;
orderDetails.ClientInfo.CopyPhone = clientInfo.CopyPhone;
orderDetails.ClientInfo.Department = clientInfo.Department;
order.ClientName = clientInfo.Name;
}
order.AdditionalEmails = AdditionalEmailsHelper.AddClientInfoEmails(order, orderDetails.ClientInfo);
}
if (result.MissingTestsToAdd.Any())
{
var allTests = order.GetTestDetails();
foreach (var missingTest in result.MissingTestsToAdd)
{
allTests.Add(missingTest);
}
order.SaveTestDetails(allTests);
}
orderDetails.Quantity = result.Quantity;
orderDetails.SelectedTests = result.SelectedTests;
orderDetails.Total = orderDetails.SelectedTests.Sum(x => x.Total) + (orderDetails.Payment.IsInternalClient ? orderDetails.InternalProcessingFee : orderDetails.ExternalProcessingFee);
orderDetails.Total = orderDetails.Total * result.RushMultiplier;
orderDetails.RushMultiplier = result.RushMultiplier;
orderDetails.LabworksSampleDisposition = result.LabworksSampleDisposition;
if (finalizeModel != null)
{
orderDetails.LabComments = finalizeModel.LabComments;
orderDetails.AdjustmentAmount = finalizeModel.AdjustmentAmount;
if (orderDetails.AdjustmentAmount != 0)
{
orderDetails.AdjustmentComments = finalizeModel.AdjustmentComments;
}
}
order.SaveDetails(orderDetails);
order.SaveBackedupTestDetails(result.BackedupTests);
return(order);
}
/// <summary>
/// Get the test items from Labworks and replace the test items in our order to reflect what was actually done.
/// </summary>
/// <param name="orderToUpdate"></param>
/// <returns></returns>
public async Task <OverwriteOrderResult> OverwriteOrderFromDb(Order orderToUpdate)
{
var rtValue = new OverwriteOrderResult();
if (string.IsNullOrWhiteSpace(orderToUpdate.RequestNum))
{
throw new Exception("RequestNum not populated"); //TODO: Something better
}
OrderUpdateFromDbModel orderFromDb = null;
try
{
orderFromDb = await _labworksService.GetRequestDetails(orderToUpdate.RequestNum);
}
catch (Exception e)
{
rtValue.ErrorMessage = e.Message;
return(rtValue);
}
var allTests = orderToUpdate.GetTestDetails();
var testIds = allTests.Where(a => orderFromDb.TestCodes.Contains(a.Id)).Select(s => s.Id).ToArray();
var tests = PopulateSelectedTestsItemModel(testIds, allTests);
if (orderFromDb.TestCodes.Count != testIds.Length)
{
//Oh No!!! tests were returned that we don't know about
var foundCodes = allTests.Where(a => testIds.Contains(a.Id)).Select(s => s.Id).Distinct().ToList();
rtValue.MissingCodes = orderFromDb.TestCodes.Except(foundCodes).ToList();
return(rtValue);
}
var orderDetails = orderToUpdate.GetOrderDetails();
orderDetails.Quantity = orderFromDb.Quantity;
orderDetails.LabworksSampleDisposition = orderFromDb.Disposition; //Don't think this is doing anything
var calcualtedTests = new List <TestDetails>();
foreach (var test in tests)
{
CalculateTest(orderDetails, test, calcualtedTests);
}
rtValue.SelectedTests = calcualtedTests;
rtValue.ClientId = orderFromDb.ClientId;
rtValue.Quantity = orderFromDb.Quantity;
rtValue.RushMultiplier = orderFromDb.RushMultiplier;
rtValue.LabworksSampleDisposition = orderFromDb.Disposition;
return(rtValue);
}
/// <summary>
/// Get the test items from Labworks and replace the test items in our order to reflect what was actually done.
/// </summary>
/// <param name="orderToUpdate"></param>
/// <returns></returns>
public async Task <OverwriteOrderResult> OverwriteOrderFromDb(Order orderToUpdate)
{
var rtValue = new OverwriteOrderResult();
if (string.IsNullOrWhiteSpace(orderToUpdate.RequestNum))
{
throw new Exception("RequestNum not populated"); //TODO: Something better
}
OrderUpdateFromDbModel orderFromDb = null;
try
{
orderFromDb = await _labworksService.GetRequestDetails(orderToUpdate.RequestNum);
}
catch (Exception e)
{
rtValue.ErrorMessage = e.Message;
return(rtValue);
}
var allTests = orderToUpdate.GetTestDetails();
var testIds = allTests.Where(a => orderFromDb.TestCodes.Contains(a.Id)).Select(s => s.Id).ToArray();
if (orderFromDb.TestCodes.Count != testIds.Length)
{
//Oh No!!! tests were returned that we don't know about
var foundCodes = allTests.Where(a => testIds.Contains(a.Id)).Select(s => s.Id).Distinct().ToList();
rtValue.MissingCodes = orderFromDb.TestCodes.Except(foundCodes).ToList();
var currentPrices = await PopulateTestItemModel(true);
rtValue.MissingTestsToAdd = currentPrices.Where(a => rtValue.MissingCodes.Contains(a.Id)).ToList();
if (rtValue.MissingTestsToAdd.Count != rtValue.MissingCodes.Count)
{
return(rtValue);
}
var testIdsList = testIds.ToList();
foreach (var missingWithPrice in rtValue.MissingTestsToAdd)
{
allTests.Add(missingWithPrice);
testIdsList.Add(missingWithPrice.Id);
}
testIds = testIdsList.ToArray();
rtValue.MissingCodes = new List <string>(); //Clear it out
}
var restoreTests = orderToUpdate.GetBackedupTestDetails();
if (restoreTests.Any())
{
foreach (var restoreTest in restoreTests)
{
var test = allTests.FirstOrDefault(a => a.Id == restoreTest.Id);
if (test == null)
{
Log.Information($"Test not found to restore out: {restoreTest}");
continue;
}
test = restoreTest.ShallowCopy(); //This is doing something even if it doesn't look like it.
}
}
var groupTestIds = testIds.Where(a => a.IsGroupTest()).ToArray();
if (groupTestIds.Any())
{
var savedPrices = new List <TestItemModel>();
var testsToZeroOut = await _labworksService.GetTestsForDiscountedGroups(groupTestIds);
foreach (var zeroTest in testsToZeroOut)
{
var test = allTests.FirstOrDefault(a => a.Id == zeroTest);
if (test == null)
{
Log.Information($"Test not found to zero out: {zeroTest}");
continue;
}
savedPrices.Add(test.ShallowCopy());
test.ExternalCost = 0;
test.InternalCost = 0;
test.ExternalSetupCost = 0;
test.InternalSetupCost = 0;
}
if (savedPrices.Any())
{
rtValue.BackedupTests = savedPrices;
}
}
var tests = PopulateSelectedTestsItemModel(testIds, allTests);
var orderDetails = orderToUpdate.GetOrderDetails();
orderDetails.Quantity = orderFromDb.Quantity;
orderDetails.LabworksSampleDisposition = orderFromDb.Disposition; //Don't think this is doing anything
var calcualtedTests = new List <TestDetails>();
foreach (var test in tests)
{
CalculateTest(orderDetails, test, calcualtedTests);
}
rtValue.SelectedTests = calcualtedTests;
rtValue.ClientId = orderFromDb.ClientId;
rtValue.Quantity = orderFromDb.Quantity;
rtValue.RushMultiplier = orderFromDb.RushMultiplier;
rtValue.LabworksSampleDisposition = orderFromDb.Disposition;
return(rtValue);
}
