public async Task IssueSalesOrderUpdateNotification(
ISalesOrderRepository salesOrderRepository,
SalesOrderWorkItem salesOrderWorkItem,
SalesOrderWorkflow workflow,
decimal itemQuantity,
decimal updatedItemQuantity)
{
var salesOrder = await salesOrderRepository.TryGetSalesOrder(salesOrderWorkItem.SalesOrderNumber).ConfigureAwait(false);
var branchId = _configurationService.GetString(Config.BranchId);
var branch = await _branchRepository.ReadAsync(b => b.BranchId == branchId).ConfigureAwait(false);
var salesOrderUpdateNotice = BuildEmailRecord(
salesOrderWorkItem,
workflow,
itemQuantity,
updatedItemQuantity,
branch.BranchEmail,
branch.BranchSvcRepEmail,
salesOrder.SalesRepEmail
);
var emailString = JsonConvert.SerializeObject(salesOrderUpdateNotice);
if (_networkService.IsConnected)
{
//await SendMessage(emailString).ConfigureAwait(false);
await ProcessUnsentSalesOrderUpdateNotification().ConfigureAwait(false);
}
else
{
await _salesOrderUpdateNoticeRepository.CreateAsync(new SalesOrderUpdateNoticeString { Body = emailString }).ConfigureAwait(false);
}
}
private SalesOrderUpdateNotice BuildEmailRecord(
SalesOrderWorkItem salesOrderWorkItem,
SalesOrderWorkflow workflow,
decimal itemQuantity,
decimal updatedItemQuantity,
string branchEmail,
string branchSvcRepEmail,
string salesRepEmail
)
{
return(new SalesOrderUpdateNotice
{
SalesOrderNumber = salesOrderWorkItem.SalesOrderNumber,
ItemDescription = salesOrderWorkItem.ItemDescription,
Uom = salesOrderWorkItem.Uom,
CustomerNumber = salesOrderWorkItem.CustomerNumber,
CustomerName = salesOrderWorkItem.CustomerName,
ItemNumber = salesOrderWorkItem.ItemNumber,
LotNumber = salesOrderWorkItem.LotNumber,
OriginalQuantity = salesOrderWorkItem.OriginalQuantity,
QuantityDelta = salesOrderWorkItem.QuantityDelta,
PickedQuantity = salesOrderWorkItem.PickedQuantity,
DeliveredQuantity = salesOrderWorkItem.DeliveredQuantity,
UserId = _configurationService.GetString(Config.UserId),
BranchId = _configurationService.GetString(Config.BranchId),
UpdatedWhen = DateTime.Now,
ItemQuantity = itemQuantity,
UpdatedItemQuantity = updatedItemQuantity,
BranchEmail = branchEmail,
BranchSvcRepEmail = branchSvcRepEmail,
SalesRepEmail = salesRepEmail
});
}
/// <summary>
/// Get the item description without "extra" information.
/// </summary>
/// <param name="salesOrderWorkItem">A sales order work item instance.</param>
/// <param name="salesOrderItem">A sales order item instance.</param>
/// <returns>An item description.</returns>
public static string GetDescriptionWithoutExtra(
SalesOrderWorkItem salesOrderWorkItem,
SalesOrderItem salesOrderItem
) => ItemDescriptionHelper.GetDescriptionWithoutExtra(
salesOrderWorkItem == null
? salesOrderItem?.ItemDescription
: salesOrderWorkItem.ItemDescription
);
/// <summary>
/// Get the UOM combined summary.
/// </summary>
/// <param name="workflow">The current workflow.</param>
/// <param name="salesOrderWorkItem">A sales order work item instance.</param>
/// <param name="salesOrderItem">A sales order item instance.</param>
/// <returns>An OUM combined summary.</returns>
public static string GetUomCombined(
SalesOrderWorkflow workflow,
SalesOrderWorkItem salesOrderWorkItem,
SalesOrderItem salesOrderItem
) => ItemDescriptionHelper.GetUomCombined(
salesOrderWorkItem == null
? salesOrderItem?.ItemQuantity ?? 0
: GetSalesOrderWorkDescriptionQuantity(workflow, salesOrderWorkItem),
salesOrderWorkItem?.ItemDescription ?? salesOrderItem?.ItemDescription,
salesOrderWorkItem?.Uom ?? salesOrderItem?.Uom
);
/// <inheritdoc />
public async Task <bool> TryDeleteSalesOrderWorkItem(SalesOrderWorkItem salesOrderWorkItem)
{
try
{
await _cloudTable.DeleteItemAsync(salesOrderWorkItem).ConfigureAwait(false);
return(true);
}
catch (Exception ex)
{
_logService.WriteErrorLogEntry($"Failed to delete SalesOrderWorkItem ({salesOrderWorkItem.Id}): {ex}");
ex.Report();
return(false);
}
}
// This is a method to temporarily filter out the sales order workitems that had lot number pre-populated in GP.
// We want to ignore all such sales order workitems from being submitted back to GP. The proper solution will
// make changes to the schema of the Salesorder workitem record and save the original lot number and use that to
// perform the check.
private bool HasDifferentLotNumber(SalesOrderWorkItem item)
{
List <SalesOrderItem> soItems = new List <SalesOrderItem>();
Task.Run(async() =>
{
soItems = (await _salesOrderItemRepository.TryGetSalesOrderItems(item.SalesOrderNumber)).Where(
soItem => soItem.ItemNumber == item.ItemNumber).ToList();
}).Wait();
if ((soItems.Count == 1) && soItems.First().LotNumber == item.LotNumber)
{
return(false);
}
return(true);
}
/// <summary>
/// Convert a SalesOrderWorkItem instance to a PickListItem.
/// </summary>
/// <param name="salesOrderWorkItem">The SalesOrderWorkItem instance to convert.</param>
/// <returns>A new PickListItem instance.</returns>
public static PickListItem ToPickListItem(
SalesOrderWorkflow workflow,
SalesOrderWorkItem salesOrderWorkItem
) => salesOrderWorkItem == null
? null
: new PickListItem
{
SalesOrderWorkItemId = salesOrderWorkItem.Id,
ItemNumber = salesOrderWorkItem.ItemNumber,
ItemDescription = salesOrderWorkItem.ItemDescription,
LotNumber = salesOrderWorkItem.LotNumber,
IsLotControlled = salesOrderWorkItem.IsLotControlled,
ItemQuantity = SalesOrderItemDisplayHelper
.GetSalesOrderWorkDescriptionQuantity(workflow, salesOrderWorkItem),
Uom = salesOrderWorkItem.Uom,
Seq = salesOrderWorkItem.OriginalSequence
};
/// <summary>
/// Get the sales order work item quantity by using the status of the work item.
/// </summary>
/// <param name="workflow">The current workflow.</param>
/// <param name="salesOrderWorkItem">
/// The sales order work item to get the quantity of.
/// </param>
/// <returns></returns>
public static decimal GetSalesOrderWorkItemQuantityByStatus(
SalesOrderWorkflow workflow,
SalesOrderWorkItem salesOrderWorkItem
)
{
switch (workflow)
{
case SalesOrderWorkflow.Pick:
return(salesOrderWorkItem.PickedQuantity);
case SalesOrderWorkflow.Deliver:
return(salesOrderWorkItem.DeliveredQuantity == 0 ?
salesOrderWorkItem.PickedQuantity : salesOrderWorkItem.DeliveredQuantity);
default:
throw new ArgumentOutOfRangeException(nameof(workflow), workflow, null);
}
}
/// <inheritdoc />
public async Task <SalesOrderWorkItem> TryUpdateSalesOrderWorkItem(
SalesOrderWorkItem salesOrderWorkItem
)
{
try
{
var table = await GetCloudTable().ConfigureAwait(false);
// Add the user here
var userName = PinnacleApp.Get <IAuthService>().CurrentUser.Name;
return(await table.UpdateItemAsync(salesOrderWorkItem).ConfigureAwait(false));
}
catch (Exception ex)
{
_logService.WriteErrorLogEntry($"Failed to update SalesOrderWorkItem ({salesOrderWorkItem?.Id}): {ex}");
ex.Report();
return(null);
}
}
/// <summary>
/// Set the provided SalesOrderWorkItem insance to delivered. This is done by updating the
/// item delivered latitude and longitude properties as well as its status.
/// </summary>
/// <param name="salesOrderWorkItemRepository">An ISalesOrderWorkItemRepository instnace.</param>
/// <param name="salesOrderWorkItem">The item to set as delivered.</param>
/// <param name="position">The location of the device at the time of delivery.</param>
/// <returns>An asynchronous Task.</returns>
private static async Task SetSalesOrderWorkItemToDelivered(
ISalesOrderWorkItemRepository salesOrderWorkItemRepository,
SalesOrderWorkItem salesOrderWorkItem,
Location position,
string deliveredByUser
)
{
salesOrderWorkItem.DeliveredLatitude = position?.Latitude ?? 0;
salesOrderWorkItem.DeliveredLongitude = position?.Longitude ?? 0;
salesOrderWorkItem.DeliveredBy = deliveredByUser;
salesOrderWorkItem.DeliveredByName = PinnacleApp.Get <IAuthService>().CurrentUser.Name;
salesOrderWorkItem.DeliveredWhen = DateTime.UtcNow;
if (salesOrderWorkItem.DeliveredQuantity == 0)
{
salesOrderWorkItem.DeliveredQuantity = salesOrderWorkItem.PickedQuantity;
}
salesOrderWorkItem.Status = SalesOrderWorkItemStatus.Delivered;
await salesOrderWorkItemRepository
.TryUpdateSalesOrderWorkItem(salesOrderWorkItem).ConfigureAwait(false);
}
/// <summary>
/// Get the quantity of the sales order work item using the
/// newly selected lot number.
/// </summary>
/// <param name="workItem">The sales order work item to get a quantity for.</param>
/// <param name="lotNumber">The newly selected (or cleared) lot number.</param>
/// <returns></returns>
private static decimal GetQuantity(
SalesOrderWorkflow workflow,
SalesOrderWorkItem workItem,
string lotNumber
)
{
// Get the quantity by the status of the work item.
var quantityByStatus =
SalesOrderItemDisplayHelper.GetSalesOrderWorkItemQuantityByStatus(workflow, workItem);
// Lot number is null, use the quantity by status value.
if (string.IsNullOrWhiteSpace(lotNumber))
{
return(quantityByStatus);
}
return(quantityByStatus == 0
// Nothing set, use original quantity.
? workItem.OriginalQuantity
// Value was set, use it.
: quantityByStatus);
}
/// <summary>
/// Try to set the provided SalesOrderWorkItem instance status.
/// </summary>
/// <param name="salesOrderWorkItem">The sales order work item.</param>
/// <param name="position">The pick-up location.</param>
/// <returns>An asynchronous Task instance.</returns>
private async Task TrySetSalesOrderWorkItemAsPicked(
SalesOrderWorkItem salesOrderWorkItem,
Location position
)
{
salesOrderWorkItem.Status = SalesOrderWorkItemStatus.Picked;
salesOrderWorkItem.PickedLatitude = position?.Latitude ?? 0;
salesOrderWorkItem.PickedLongitude = position?.Longitude ?? 0;
salesOrderWorkItem.PickedWhen = DateTime.UtcNow;
var table = await GetCloudTable().ConfigureAwait(false);
try
{
await table.UpdateItemAsync(salesOrderWorkItem).ConfigureAwait(false);
}
catch (Exception ex)
{
_logService.WriteErrorLogEntry("Failed to update sales order work item status " +
$"({salesOrderWorkItem.Id}): {ex}");
ex.Report();
}
}
/// <summary>
/// Get the sales order work item display state description quantity.
/// </summary>
/// <param name="workflow">The current workflow.</param>
/// <param name="salesOrderWorkItem">The sales order work item.</param>
/// <returns>The display state quantity.</returns>
public static decimal GetSalesOrderWorkItemTakenQuantity(
SalesOrderWorkflow workflow,
SalesOrderWorkItem salesOrderWorkItem
) => string.IsNullOrWhiteSpace(salesOrderWorkItem.LotNumber)
? 0
: GetSalesOrderWorkItemQuantityByStatus(workflow, salesOrderWorkItem);
/// <summary>
/// Get the sales order work item display state taken quantity.
/// </summary>
/// <param name="workflow">The current workflow.</param>
/// <param name="salesOrderWorkItem">The sales order work item.</param>
/// <returns>The display state quantity.</returns>
public static decimal GetSalesOrderWorkDescriptionQuantity(
SalesOrderWorkflow workflow,
SalesOrderWorkItem salesOrderWorkItem
) => GetSalesOrderWorkItemQuantityByStatus(workflow, salesOrderWorkItem);
