930 lines
45 KiB
C#
930 lines
45 KiB
C#
using System;
|
|
using System.Threading.Tasks;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using System.Linq;
|
|
using AyaNova.Util;
|
|
using AyaNova.Api.ControllerHelpers;
|
|
using Microsoft.Extensions.Logging;
|
|
using AyaNova.Models;
|
|
using Newtonsoft.Json.Linq;
|
|
using System.Collections.Generic;
|
|
using Microsoft.EntityFrameworkCore.Storage;
|
|
|
|
namespace AyaNova.Biz
|
|
{
|
|
internal class PurchaseOrderBiz : BizObject, IJobObject, ISearchAbleObject, IReportAbleObject, IExportAbleObject, INotifiableObject
|
|
{
|
|
internal PurchaseOrderBiz(AyContext dbcontext, long currentUserId, long userTranslationId, AuthorizationRoles UserRoles)
|
|
{
|
|
ct = dbcontext;
|
|
UserId = currentUserId;
|
|
UserTranslationId = userTranslationId;
|
|
CurrentUserRoles = UserRoles;
|
|
BizType = AyaType.PurchaseOrder;
|
|
}
|
|
|
|
internal static PurchaseOrderBiz GetBiz(AyContext ct, Microsoft.AspNetCore.Http.HttpContext httpContext = null)
|
|
{
|
|
if (httpContext != null)
|
|
return new PurchaseOrderBiz(ct, UserIdFromContext.Id(httpContext.Items), UserTranslationIdFromContext.Id(httpContext.Items), UserRolesFromContext.Roles(httpContext.Items));
|
|
else
|
|
return new PurchaseOrderBiz(ct, 1, ServerBootConfig.AYANOVA_DEFAULT_TRANSLATION_ID, AuthorizationRoles.BizAdmin);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//EXISTS
|
|
internal async Task<bool> ExistsAsync(long id)
|
|
{
|
|
return await ct.PurchaseOrder.AnyAsync(z => z.Id == id);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//CREATE
|
|
//
|
|
internal async Task<PurchaseOrder> CreateAsync(PurchaseOrder newObject, bool populateDisplayFields)
|
|
{
|
|
await ValidateAsync(newObject, null);
|
|
if (HasErrors)
|
|
return null;
|
|
else
|
|
{
|
|
using (var transaction = await ct.Database.BeginTransactionAsync())
|
|
{
|
|
|
|
newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
|
|
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
|
|
await ct.PurchaseOrder.AddAsync(newObject);
|
|
await ct.SaveChangesAsync();//needs to exist so inventory adjustment accepts it as source id (biz rule checks)
|
|
await BizActionsAsync(AyaEvent.Created, newObject, null, transaction);
|
|
if (HasErrors)
|
|
{
|
|
await transaction.RollbackAsync();
|
|
return null;
|
|
}
|
|
await ct.SaveChangesAsync();
|
|
await transaction.CommitAsync();
|
|
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
|
|
await SearchIndexAsync(newObject, true);
|
|
await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
|
|
await HandlePotentialNotificationEvent(AyaEvent.Created, newObject);
|
|
if (populateDisplayFields)
|
|
await SetDisplayFields(newObject, false);
|
|
return newObject;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //DUPLICATE
|
|
// //
|
|
// internal async Task<PurchaseOrder> DuplicateAsync(long id)
|
|
// {
|
|
// //TODO: allow this but only with ZEROS set for the actual received amount and ignore woitempart requested during dupe?
|
|
|
|
// var dbObject = await GetAsync(id, false, false);
|
|
// if (dbObject == null)
|
|
// {
|
|
// AddError(ApiErrorCode.NOT_FOUND, "id");
|
|
// return null;
|
|
// }
|
|
// PurchaseOrder newObject = new PurchaseOrder();
|
|
// CopyObject.Copy(dbObject, newObject, "Wiki,Serial");
|
|
// newObject.Id = 0;
|
|
// newObject.Concurrency = 0;
|
|
// newObject.Status = PurchaseOrderStatus.OpenNotYetOrdered;
|
|
// foreach (var item in newObject.Items)
|
|
// {
|
|
// item.Id = 0;
|
|
// item.Concurrency = 0;
|
|
// item.QuantityReceived = 0;
|
|
// item.ReceivedCost = 0;
|
|
// item.ReceivedDate = null;
|
|
// item.PurchaseOrderId = 0;
|
|
// item.WorkorderItemPartRequestId = null;
|
|
// item.PartRequestedById = null;
|
|
// }
|
|
|
|
// await ct.PurchaseOrder.AddAsync(newObject);
|
|
// await ct.SaveChangesAsync();
|
|
// await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
|
|
// await SearchIndexAsync(newObject, true);
|
|
// await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
|
|
// await HandlePotentialNotificationEvent(AyaEvent.Created, newObject);
|
|
// await SetDisplayFields(newObject);
|
|
// return newObject;
|
|
// }
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//GET
|
|
//
|
|
internal async Task<PurchaseOrder> GetAsync(long id, bool populateDisplayFields, bool logTheGetEvent)
|
|
{
|
|
var ret = await ct.PurchaseOrder.Include(z => z.Items).AsNoTracking().SingleOrDefaultAsync(z => z.Id == id);
|
|
if (populateDisplayFields)
|
|
await SetDisplayFields(ret,false);
|
|
|
|
if (logTheGetEvent && ret != null)
|
|
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, id, BizType, AyaEvent.Retrieved), ct);
|
|
return ret;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//DISPLAY FIELDS
|
|
//
|
|
private async Task SetDisplayFields(PurchaseOrder po, bool forReporting)
|
|
{
|
|
//NOTE: This expects to run AFTER bizActions have been performed
|
|
if (po == null) return;
|
|
|
|
//populate server fields for client ui
|
|
//Show Warehouses
|
|
po.HasSelectableWarehouses = await ct.PartWarehouse.CountAsync() > 1;
|
|
|
|
//default hidden and show when traverse items if applicable
|
|
po.HasPartRequest = false;
|
|
po.HasTaxes = false;
|
|
po.HasReceipt = false;
|
|
po.HasVendorNumber = false;
|
|
po.HasUnreceived = false;
|
|
|
|
if (po.DropShipToCustomerId != null)
|
|
{
|
|
var ds = await ct.Customer.AsNoTracking().Where(x => x.Id == po.DropShipToCustomerId).FirstOrDefaultAsync();
|
|
|
|
po.DropShipToCustomerViz = ds.Name;
|
|
if (forReporting)
|
|
{
|
|
po.DropShipToCustomerAddressViz = ds.Address;
|
|
po.DropShipToCustomerCityViz = ds.City;
|
|
po.DropShipToCustomerRegionViz = ds.Region;
|
|
po.DropShipToCustomerCountryViz = ds.Country;
|
|
po.DropShipToCustomerLatitudeViz = ds.Latitude;
|
|
po.DropShipToCustomerLongitudeViz = ds.Longitude;
|
|
po.DropShipToCustomerPostAddressViz = ds.PostAddress;
|
|
po.DropShipToCustomerPostCityViz = ds.PostCity;
|
|
po.DropShipToCustomerPostRegionViz = ds.PostRegion;
|
|
po.DropShipToCustomerPostCountryViz = ds.PostCountry;
|
|
po.DropShipToCustomerPostCodeViz = ds.PostCode;
|
|
po.DropShipToCustomerPhone1Viz = ds.Phone1;
|
|
po.DropShipToCustomerPhone2Viz = ds.Phone2;
|
|
po.DropShipToCustomerPhone3Viz = ds.Phone3;
|
|
po.DropShipToCustomerPhone4Viz = ds.Phone4;
|
|
po.DropShipToCustomerPhone5Viz = ds.Phone5;
|
|
po.DropShipToCustomerEmailAddressViz = ds.EmailAddress;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
var vnd = await ct.Vendor.AsNoTracking().Where(x => x.Id == po.VendorId).FirstOrDefaultAsync();
|
|
|
|
po.VendorViz = vnd.Name;
|
|
if (forReporting)
|
|
{
|
|
po.VendorAddressViz = vnd.Address;
|
|
po.VendorCityViz = vnd.City;
|
|
po.VendorRegionViz = vnd.Region;
|
|
po.VendorCountryViz = vnd.Country;
|
|
po.VendorLatitudeViz = vnd.Latitude;
|
|
po.VendorLongitudeViz = vnd.Longitude;
|
|
po.VendorPostAddressViz = vnd.PostAddress;
|
|
po.VendorPostCityViz = vnd.PostCity;
|
|
po.VendorPostRegionViz = vnd.PostRegion;
|
|
po.VendorPostCountryViz = vnd.PostCountry;
|
|
po.VendorPostCodeViz = vnd.PostCode;
|
|
po.VendorPhone1Viz = vnd.Phone1;
|
|
po.VendorPhone2Viz = vnd.Phone2;
|
|
po.VendorPhone3Viz = vnd.Phone3;
|
|
po.VendorPhone4Viz = vnd.Phone4;
|
|
po.VendorPhone5Viz = vnd.Phone5;
|
|
po.VendorEmailAddressViz = vnd.EmailAddress;
|
|
po.VendorContactViz = vnd.Contact;
|
|
po.VendorContactNotesViz = vnd.ContactNotes;
|
|
}
|
|
|
|
|
|
if (po.ProjectId != null)
|
|
po.ProjectViz = await ct.Project.AsNoTracking().Where(x => x.Id == po.ProjectId).Select(x => x.Name).FirstOrDefaultAsync();
|
|
|
|
foreach (PurchaseOrderItem item in po.Items)
|
|
{
|
|
|
|
|
|
var partInfo = await ct.Part.AsNoTracking().Where(x => x.Id == item.PartId).Select(x => new { partViz = x.PartNumber, partNameViz = x.Name }).FirstOrDefaultAsync();
|
|
item.PartViz = partInfo.partViz;
|
|
item.PartNameViz = partInfo.partNameViz;
|
|
item.WarehouseViz = await ct.PartWarehouse.AsNoTracking().Where(x => x.Id == item.PartWarehouseId).Select(x => x.Name).FirstOrDefaultAsync();
|
|
if (item.WorkorderItemPartRequestId != null)
|
|
{
|
|
po.HasPartRequest = true;
|
|
item.WorkorderItemPartRequestViz = "todo:woidfromleafnode";//MIGRATE_OUTSTANDING routine to get wo id from the woitempartrequestid
|
|
if (item.PartRequestedById != null)
|
|
item.PartRequestedByViz = await ct.User.AsNoTracking().Where(x => x.Id == item.PartRequestedById).Select(x => x.Name).FirstOrDefaultAsync();
|
|
}
|
|
TaxCode tax = null;
|
|
if (item.PurchaseTaxCodeId != null)
|
|
{
|
|
tax = await ct.TaxCode.AsNoTracking().Where(x => x.Id == item.PurchaseTaxCodeId).FirstOrDefaultAsync();
|
|
item.PurchaseTaxCodeViz = tax.Name;
|
|
po.HasTaxes = true;
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(item.VendorPartNumber))
|
|
po.HasVendorNumber = true;
|
|
|
|
if (item.QuantityReceived > 0)
|
|
po.HasReceipt = true;
|
|
|
|
if (item.QuantityReceived < item.QuantityOrdered)
|
|
po.HasUnreceived = true;
|
|
|
|
//Calculate line totals
|
|
if (item.QuantityOrdered != 0 && item.PurchaseOrderCost != 0)
|
|
{
|
|
decimal dNet = item.QuantityOrdered * item.PurchaseOrderCost;
|
|
decimal dTaxA = 0M;
|
|
decimal dTaxB = 0M;
|
|
if (tax != null)
|
|
{
|
|
//Tax A is always just tax A percent times net...
|
|
dTaxA = (tax.TaxAPct / 100) * dNet;
|
|
|
|
//Tax B on the other hand could be simple or tax on tax...
|
|
if (!tax.TaxOnTax)
|
|
dTaxB = (tax.TaxBPct / 100) * dNet;//simple
|
|
else
|
|
dTaxB = (dNet + dTaxA) * (tax.TaxBPct / 100);//tax on tax
|
|
}
|
|
//set line total and taxes display values
|
|
item.TaxAViz = dTaxA;
|
|
item.TaxBViz = dTaxB;
|
|
item.NetTotalViz = dNet;
|
|
item.LineTotalViz = dNet + dTaxA + dTaxB;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//UPDATE
|
|
//
|
|
internal async Task<PurchaseOrder> PutAsync(PurchaseOrder putObject)
|
|
{
|
|
var dbObject = await GetAsync(putObject.Id, false, false);
|
|
if (dbObject == null)
|
|
{
|
|
AddError(ApiErrorCode.NOT_FOUND, "id");
|
|
return null;
|
|
}
|
|
if (dbObject.Concurrency != putObject.Concurrency)
|
|
{
|
|
AddError(ApiErrorCode.CONCURRENCY_CONFLICT);
|
|
return null;
|
|
}
|
|
putObject.Tags = TagBiz.NormalizeTags(putObject.Tags);
|
|
putObject.CustomFields = JsonUtil.CompactJson(putObject.CustomFields);
|
|
await ValidateAsync(putObject, dbObject);
|
|
if (HasErrors) return null;
|
|
using (var transaction = await ct.Database.BeginTransactionAsync())
|
|
{
|
|
await BizActionsAsync(AyaEvent.Modified, putObject, dbObject, transaction);
|
|
if (HasErrors)
|
|
{
|
|
await transaction.RollbackAsync();
|
|
return null;
|
|
}
|
|
ct.Replace(dbObject, putObject);
|
|
try
|
|
{
|
|
await ct.SaveChangesAsync();
|
|
await transaction.CommitAsync();
|
|
}
|
|
catch (DbUpdateConcurrencyException)
|
|
{
|
|
if (!await ExistsAsync(putObject.Id))
|
|
AddError(ApiErrorCode.NOT_FOUND);
|
|
else
|
|
AddError(ApiErrorCode.CONCURRENCY_CONFLICT);
|
|
return null;
|
|
}
|
|
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct);
|
|
await SearchIndexAsync(putObject, false);
|
|
await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, putObject.Tags, dbObject.Tags);
|
|
await HandlePotentialNotificationEvent(AyaEvent.Modified, putObject, dbObject);
|
|
await SetDisplayFields(putObject, false);
|
|
return putObject;
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//DELETE
|
|
//
|
|
internal async Task<bool> DeleteAsync(long id)
|
|
{
|
|
using (var transaction = await ct.Database.BeginTransactionAsync())
|
|
{
|
|
try
|
|
{
|
|
var dbObject = await GetAsync(id, false, false);
|
|
if (dbObject == null)
|
|
{
|
|
AddError(ApiErrorCode.NOT_FOUND);
|
|
return false;
|
|
}
|
|
await ValidateCanDeleteAsync(dbObject);
|
|
if (HasErrors)
|
|
return false;
|
|
ct.PurchaseOrder.Remove(dbObject);
|
|
await BizActionsAsync(AyaEvent.Deleted, null, dbObject, transaction);
|
|
if (HasErrors)
|
|
{
|
|
await transaction.RollbackAsync();
|
|
return false;
|
|
}
|
|
await ct.SaveChangesAsync();
|
|
await transaction.CommitAsync();
|
|
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Serial.ToString(), ct);
|
|
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
|
|
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
|
|
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
|
|
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
|
|
}
|
|
catch
|
|
{
|
|
//Just re-throw for now, let exception handler deal, but in future may want to deal with this more here
|
|
throw;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//SEARCH
|
|
//
|
|
private async Task SearchIndexAsync(PurchaseOrder obj, bool isNew)
|
|
{
|
|
var SearchParams = new Search.SearchIndexProcessObjectParameters(UserTranslationId, obj.Id, BizType);
|
|
DigestSearchText(obj, SearchParams);
|
|
if (isNew)
|
|
await Search.ProcessNewObjectKeywordsAsync(SearchParams);
|
|
else
|
|
await Search.ProcessUpdatedObjectKeywordsAsync(SearchParams);
|
|
}
|
|
|
|
public async Task<Search.SearchIndexProcessObjectParameters> GetSearchResultSummary(long id)
|
|
{
|
|
var obj = await GetAsync(id, false, false);
|
|
var SearchParams = new Search.SearchIndexProcessObjectParameters();
|
|
DigestSearchText(obj, SearchParams);
|
|
return SearchParams;
|
|
}
|
|
|
|
public void DigestSearchText(PurchaseOrder obj, Search.SearchIndexProcessObjectParameters searchParams)
|
|
{
|
|
if (obj != null)
|
|
searchParams.AddText(obj.Serial)
|
|
.AddText(obj.Notes)
|
|
.AddText(obj.VendorMemo)
|
|
.AddText(obj.ReferenceNumber)
|
|
.AddText(obj.Text1)
|
|
.AddText(obj.Text2)
|
|
.AddText(obj.Serial)
|
|
.AddText(obj.Wiki)
|
|
.AddText(obj.Tags)
|
|
.AddCustomFields(obj.CustomFields);
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//VALIDATION
|
|
//
|
|
|
|
private async Task ValidateAsync(PurchaseOrder proposedObj, PurchaseOrder currentObj)
|
|
{
|
|
bool isNew = currentObj == null;
|
|
|
|
//No poitem can receive negative amounts
|
|
for (int i = 0; i < proposedObj.Items.Count; i++)
|
|
{
|
|
var propPOItem = proposedObj.Items[i];
|
|
if (propPOItem.QuantityReceived < 0 || propPOItem.QuantityReceived > propPOItem.QuantityOrdered)
|
|
{
|
|
AddError(ApiErrorCode.VALIDATION_INVALID_VALUE, $"Items[{i}].QuantityReceived", "LT:PurchaseOrderReceiptItemQuantityReceivedErrorInvalid");
|
|
|
|
}
|
|
}
|
|
|
|
//Any form customizations to validate?
|
|
var FormCustomization = await ct.FormCustom.AsNoTracking().SingleOrDefaultAsync(z => z.FormKey == AyaType.PurchaseOrder.ToString());
|
|
if (FormCustomization != null)
|
|
{
|
|
//Yeppers, do the validation, there are two, the custom fields and the regular fields that might be set to required
|
|
|
|
//validate users choices for required non custom fields
|
|
RequiredFieldsValidator.Validate(this, FormCustomization, proposedObj);
|
|
|
|
//validate custom fields
|
|
CustomFieldsValidator.Validate(this, FormCustomization, proposedObj.CustomFields);
|
|
}
|
|
|
|
}
|
|
|
|
private async Task ValidateCanDeleteAsync(PurchaseOrder inObj)
|
|
{
|
|
//We allow delete even if received, will reverse automatically all inventory and affected objects
|
|
//not sure if there is anything here to check
|
|
await Task.CompletedTask;
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//BIZ ACTIONS
|
|
//A PO can now be edited in any way user wishes at any time so this method is to fix up
|
|
//any changes they make in affected objects and inventory
|
|
//
|
|
private async Task BizActionsAsync(AyaEvent ayaEvent, PurchaseOrder newObj, PurchaseOrder oldObj, IDbContextTransaction transaction)
|
|
{
|
|
//MIGRATE_OUTSTANDING - woitempart request update
|
|
//if received on woitempartrequest then need to update woitempartrequest (notification separate not a concern here)
|
|
//if workorderitempartrequest item removed, need to fixup woitempartrequest
|
|
//BUT *only* if the woitempartrequest still exists and isn't completed already
|
|
|
|
|
|
//Get inventory object for updating
|
|
PartInventoryBiz pib = new PartInventoryBiz(ct, UserId, UserTranslationId, CurrentUserRoles);
|
|
|
|
//DELETED
|
|
if (ayaEvent == AyaEvent.Deleted)
|
|
{
|
|
//REVERSE ENTIRE PO
|
|
//any received remove from inventory
|
|
var inventoryAffectingItems = oldObj.Items.Where(z => z.QuantityReceived > 0).ToList();
|
|
foreach (var poItem in inventoryAffectingItems)
|
|
{
|
|
//make reversing inventory adjustment
|
|
dtInternalPartInventory i = new dtInternalPartInventory();
|
|
i.PartId = poItem.PartId;
|
|
i.PartWarehouseId = poItem.PartWarehouseId;
|
|
i.Quantity = poItem.QuantityReceived * -1;
|
|
i.SourceType = null;//null because the po no longer exists so this is technically a manual adjustment
|
|
i.SourceId = null;//''
|
|
i.Description = await Translate("PurchaseOrder") + $" {oldObj.Serial} " + await Translate("EventDeleted");
|
|
if (await pib.CreateAsync(i) == null)
|
|
{
|
|
AddError(ApiErrorCode.API_SERVER_ERROR, "generalerror", $"Error updating inventory ({i.Description}):{pib.GetErrorsAsString()}");
|
|
return;
|
|
}
|
|
|
|
//MIGRATE_OUTSTANDING - update workorderitempart here if applicable
|
|
}
|
|
return;//done, nothing more to do here
|
|
}
|
|
|
|
|
|
//Some kind of update so fetch the parts so the default part values can be set on the poItem if necessary
|
|
var listOfPoPartIds = newObj.Items.Select(x => x.PartId).ToList();
|
|
var PoParts = await ct.Part.AsNoTracking().Where(x => listOfPoPartIds.Contains(x.Id)).ToListAsync();
|
|
|
|
//CREATED
|
|
if (ayaEvent == AyaEvent.Created)
|
|
{
|
|
//any received go into inventory
|
|
var inventoryAffectingItems = newObj.Items.Where(z => z.QuantityReceived > 0).ToList();
|
|
foreach (var poItem in inventoryAffectingItems)
|
|
{
|
|
//make inventory adjustment here
|
|
dtInternalPartInventory i = new dtInternalPartInventory();
|
|
i.PartId = poItem.PartId;
|
|
i.PartWarehouseId = poItem.PartWarehouseId;
|
|
i.Quantity = poItem.QuantityReceived;
|
|
i.SourceType = AyaType.PurchaseOrder;
|
|
i.SourceId = newObj.Id;
|
|
i.Description = await Translate("PurchaseOrder") + $" {newObj.Serial} " + await Translate("EventCreated");
|
|
if (await pib.CreateAsync(i) == null)
|
|
{
|
|
AddError(ApiErrorCode.API_SERVER_ERROR, "generalerror", $"Error updating inventory ({i.Description}):{pib.GetErrorsAsString()}");
|
|
return;
|
|
}
|
|
|
|
await PartBiz.AppendSerialsAsync(poItem.PartId, poItem.Serials, ct, UserId);
|
|
|
|
//MIGRATE_OUTSTANDING - update workorderitempart here if applicable
|
|
}
|
|
|
|
//All new so set them all
|
|
foreach (var poItem in newObj.Items)
|
|
SetPoItemDefaultPartValues(poItem, PoParts, newObj.VendorId);
|
|
return;
|
|
}
|
|
|
|
//MODIFIED
|
|
if (ayaEvent == AyaEvent.Modified)
|
|
{
|
|
|
|
//any old po items deleted?
|
|
foreach (var oldItem in oldObj.Items)
|
|
{
|
|
//get the matching new item
|
|
var newItem = newObj.Items.FirstOrDefault(z => z.Id == oldItem.Id);
|
|
|
|
//OLD ITEM DELETED
|
|
if (newItem == null)
|
|
{
|
|
//an old item with received stock was deleted, fixup inventory
|
|
if (oldItem.QuantityReceived > 0)
|
|
{
|
|
//make reversing inventory adjustment
|
|
dtInternalPartInventory i = new dtInternalPartInventory();
|
|
i.PartId = oldItem.PartId;
|
|
i.PartWarehouseId = oldItem.PartWarehouseId;
|
|
i.Quantity = oldItem.QuantityReceived * -1;
|
|
i.SourceType = AyaType.PurchaseOrder;
|
|
i.SourceId = oldObj.Id;
|
|
i.Description = await Translate("PurchaseOrder") + $" {oldObj.Serial} " + await Translate("PurchaseOrderItem") + " " + await Translate("EventDeleted");
|
|
if (await pib.CreateAsync(i) == null)
|
|
{
|
|
AddError(ApiErrorCode.API_SERVER_ERROR, "generalerror", $"Error updating inventory ({i.Description}):{pib.GetErrorsAsString()}");
|
|
return;
|
|
}
|
|
//might have serials so remove those as well
|
|
await PartBiz.RemoveSerialsAsync(oldItem.PartId, oldItem.Serials, ct, UserId);
|
|
}
|
|
}
|
|
}
|
|
|
|
//ITERATE NEW ITEMS LOOK FOR CHANGES
|
|
foreach (var newItem in newObj.Items)
|
|
{
|
|
//get the matching oldItem
|
|
var oldItem = oldObj.Items.FirstOrDefault(z => z.Id == newItem.Id);
|
|
|
|
//CHANGED THE VENDOR? (this doesn't preclude other changes as well below)
|
|
if (oldObj.VendorId != newObj.VendorId)
|
|
{
|
|
SetPoItemDefaultPartValues(newItem, PoParts, newObj.VendorId);
|
|
}
|
|
|
|
//NEW ITEM ADDED
|
|
if (oldItem == null)
|
|
{
|
|
if (newItem.QuantityReceived > 0)
|
|
{
|
|
//It's a new receipt with received amounts - add to inventory
|
|
dtInternalPartInventory i = new dtInternalPartInventory();
|
|
i.PartId = newItem.PartId;
|
|
i.PartWarehouseId = newItem.PartWarehouseId;
|
|
i.Quantity = newItem.QuantityReceived;
|
|
i.SourceType = AyaType.PurchaseOrder;
|
|
i.SourceId = newObj.Id;
|
|
i.Description = await Translate("PurchaseOrder") + $" {newObj.Serial} " + await Translate("PurchaseOrderItem") + " " + await Translate("EventCreated");
|
|
if (await pib.CreateAsync(i) == null)
|
|
{
|
|
AddError(ApiErrorCode.API_SERVER_ERROR, "generalerror", $"Error updating inventory ({i.Description}):{pib.GetErrorsAsString()}");
|
|
return;
|
|
}
|
|
|
|
await PartBiz.AppendSerialsAsync(newItem.PartId, newItem.Serials, ct, UserId);
|
|
}
|
|
|
|
SetPoItemDefaultPartValues(newItem, PoParts, newObj.VendorId);
|
|
|
|
//MIGRATE_OUTSTANDING - update workorderitempart here if applicable
|
|
continue;//on to next item no possible other changes here
|
|
}
|
|
|
|
//CHANGED PART OR WAREHOUSE ID
|
|
if (oldItem.PartId != newItem.PartId || oldItem.PartWarehouseId != newItem.PartWarehouseId)
|
|
{
|
|
|
|
if (oldItem.QuantityReceived > 0)
|
|
{
|
|
//reverse inventory
|
|
dtInternalPartInventory i = new dtInternalPartInventory();
|
|
i.PartId = oldItem.PartId;
|
|
i.PartWarehouseId = oldItem.PartWarehouseId;
|
|
i.Quantity = oldItem.QuantityReceived * -1;
|
|
i.SourceType = AyaType.PurchaseOrder;
|
|
i.SourceId = oldObj.Id;
|
|
i.Description = await Translate("PurchaseOrder") + $" {oldObj.Serial} " + await Translate("PurchaseOrderItem") + " " + await Translate("EventModified") + " " + await Translate("Part") + "/" + await Translate("PartWarehouse");
|
|
if (await pib.CreateAsync(i) == null)
|
|
{
|
|
AddError(ApiErrorCode.API_SERVER_ERROR, "generalerror", $"Error updating inventory ({i.Description}):{pib.GetErrorsAsString()}");
|
|
return;
|
|
}
|
|
|
|
await PartBiz.RemoveSerialsAsync(oldItem.PartId, oldItem.Serials, ct, UserId);
|
|
}
|
|
|
|
if (newItem.QuantityReceived > 0)
|
|
{
|
|
//set new inventory
|
|
dtInternalPartInventory i = new dtInternalPartInventory();
|
|
i.PartId = newItem.PartId;
|
|
i.PartWarehouseId = newItem.PartWarehouseId;
|
|
i.Quantity = newItem.QuantityReceived;
|
|
i.SourceType = AyaType.PurchaseOrder;
|
|
i.SourceId = newObj.Id;
|
|
i.Description = await Translate("PurchaseOrder") + $" {newObj.Serial} " + await Translate("PurchaseOrderItem") + " " + await Translate("EventModified") + " " + await Translate("Part") + "/" + await Translate("PartWarehouse");
|
|
if (await pib.CreateAsync(i) == null)
|
|
{
|
|
AddError(ApiErrorCode.API_SERVER_ERROR, "generalerror", $"Error updating inventory ({i.Description}):{pib.GetErrorsAsString()}");
|
|
return;
|
|
}
|
|
|
|
await PartBiz.AppendSerialsAsync(newItem.PartId, newItem.Serials, ct, UserId);
|
|
}
|
|
|
|
//Update part values into poitem if the part or vendor has changed
|
|
if (oldItem.PartId != newItem.PartId || oldObj.VendorId != newObj.VendorId)
|
|
SetPoItemDefaultPartValues(newItem, PoParts, newObj.VendorId);
|
|
|
|
continue;//Note: this accounts also for any change received quantities so no need to check that below
|
|
}
|
|
|
|
|
|
//CHANGED ONLY THE RECEIVED AMOUNT
|
|
if (oldItem.QuantityReceived != newItem.QuantityReceived)
|
|
{
|
|
decimal netChange = 0;
|
|
if (oldItem.QuantityReceived < newItem.QuantityReceived)
|
|
netChange = newItem.QuantityReceived - oldItem.QuantityReceived;//More received
|
|
else
|
|
netChange = newItem.QuantityReceived - oldItem.QuantityReceived;//less received
|
|
|
|
dtInternalPartInventory i = new dtInternalPartInventory();
|
|
i.PartId = newItem.PartId;
|
|
i.PartWarehouseId = newItem.PartWarehouseId;
|
|
i.Quantity = netChange;
|
|
i.SourceType = AyaType.PurchaseOrder;
|
|
i.SourceId = newObj.Id;
|
|
i.Description = await Translate("PurchaseOrder") + $" {newObj.Serial} " + await Translate("PurchaseOrderItem") + " " + await Translate("EventModified") + " " + await Translate("PurchaseOrderItemQuantityReceived");
|
|
if (await pib.CreateAsync(i) == null)
|
|
{
|
|
AddError(ApiErrorCode.API_SERVER_ERROR, "generalerror", $"Error updating inventory ({i.Description}):{pib.GetErrorsAsString()}");
|
|
return;
|
|
}
|
|
|
|
//MIGRATE_OUTSTANDING - update workorderitempart here if applicable
|
|
|
|
//Update part values into poitem if the vendor has changed
|
|
if (oldObj.VendorId != newObj.VendorId)
|
|
SetPoItemDefaultPartValues(newItem, PoParts, newObj.VendorId);
|
|
|
|
//Set received cost if appropriate but don't overwrite an existing one
|
|
if (newItem.QuantityReceived > 0 && newItem.ReceivedCost == 0 && newItem.PurchaseOrderCost != 0)
|
|
newItem.ReceivedCost = newItem.PurchaseOrderCost;
|
|
|
|
//update serials if they have changed
|
|
if (oldItem.Serials != newItem.Serials)
|
|
{
|
|
await PartBiz.RemoveSerialsAsync(oldItem.PartId, oldItem.Serials, ct, UserId);
|
|
await PartBiz.AppendSerialsAsync(newItem.PartId, newItem.Serials, ct, UserId);
|
|
}
|
|
continue;//on to next
|
|
}
|
|
|
|
//SERIALS CHANGED
|
|
if (oldItem.Serials != newItem.Serials)
|
|
{
|
|
await PartBiz.RemoveSerialsAsync(oldItem.PartId, oldItem.Serials, ct, UserId);
|
|
await PartBiz.AppendSerialsAsync(newItem.PartId, newItem.Serials, ct, UserId);
|
|
}
|
|
|
|
|
|
//### BEFORE ADDING MORE CHECKS HERE MAKE SURE LOGIC WORKS WITH ABOVE (and add continue statement) ###
|
|
|
|
}
|
|
}//modified block
|
|
}
|
|
|
|
//Called to update Part values into poitem like VendorNumber and costs etc
|
|
private void SetPoItemDefaultPartValues(PurchaseOrderItem poItem, List<Part> poParts, long vendorId)
|
|
{
|
|
var ThisPart = poParts.Single(x => x.Id == poItem.PartId);//part should always be there, if it isn't we have deeper problems
|
|
//VendorPartNumber
|
|
if (ThisPart.ManufacturerId == vendorId)
|
|
poItem.VendorPartNumber = ThisPart.ManufacturerNumber;
|
|
else if (ThisPart.WholeSalerId == vendorId)
|
|
poItem.VendorPartNumber = ThisPart.WholeSalerNumber;
|
|
else if (ThisPart.AlternativeWholeSalerId == vendorId)
|
|
poItem.VendorPartNumber = ThisPart.AlternativeWholeSalerNumber;
|
|
|
|
//Costs
|
|
poItem.PurchaseOrderCost = ThisPart.Cost;
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//REPORTING
|
|
//
|
|
public async Task<JArray> GetReportData(DataListSelectedRequest dataListSelectedRequest)
|
|
{
|
|
var idList = dataListSelectedRequest.SelectedRowIds;
|
|
JArray ReportData = new JArray();
|
|
while (idList.Any())
|
|
{
|
|
var batch = idList.Take(IReportAbleObject.REPORT_DATA_BATCH_SIZE);
|
|
idList = idList.Skip(IReportAbleObject.REPORT_DATA_BATCH_SIZE).ToArray();
|
|
//query for this batch, comes back in db natural order unfortunately
|
|
var batchResults = await ct.PurchaseOrder.Include(x => x.Items).AsNoTracking().Where(z => batch.Contains(z.Id)).ToArrayAsync();
|
|
//order the results back into original
|
|
var orderedList = from id in batch join z in batchResults on id equals z.Id select z;
|
|
foreach (PurchaseOrder w in orderedList)
|
|
{
|
|
await SetDisplayFields(w, true);
|
|
var jo = JObject.FromObject(w);
|
|
if (!JsonUtil.JTokenIsNullOrEmpty(jo["CustomFields"]))
|
|
jo["CustomFields"] = JObject.Parse((string)jo["CustomFields"]);
|
|
ReportData.Add(jo);
|
|
}
|
|
}
|
|
return ReportData;
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// IMPORT EXPORT
|
|
//
|
|
public async Task<JArray> GetExportData(DataListSelectedRequest dataListSelectedRequest)
|
|
{
|
|
//for now just re-use the report data code
|
|
//this may turn out to be the pattern for most biz object types but keeping it seperate allows for custom usage from time to time
|
|
return await GetReportData(dataListSelectedRequest);
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//JOB / OPERATIONS
|
|
//
|
|
public async Task HandleJobAsync(OpsJob job)
|
|
{
|
|
//Hand off the particular job to the corresponding processing code
|
|
//NOTE: If this code throws an exception the caller (JobsBiz::ProcessJobsAsync) will automatically set the job to failed and log the exeption so
|
|
//basically any error condition during job processing should throw up an exception if it can't be handled
|
|
switch (job.JobType)
|
|
{
|
|
case JobType.BatchCoreObjectOperation:
|
|
await ProcessBatchJobAsync(job);
|
|
break;
|
|
default:
|
|
throw new System.ArgumentOutOfRangeException($"PurchaseOrderBiz.HandleJob-> Invalid job type{job.JobType.ToString()}");
|
|
}
|
|
}
|
|
|
|
|
|
|
|
private async Task ProcessBatchJobAsync(OpsJob job)
|
|
{
|
|
await JobsBiz.UpdateJobStatusAsync(job.GId, JobStatus.Running);
|
|
await JobsBiz.LogJobAsync(job.GId, $"LT:StartJob {job.SubType}");
|
|
List<long> idList = new List<long>();
|
|
long FailedObjectCount = 0;
|
|
JObject jobData = JObject.Parse(job.JobInfo);
|
|
if (jobData.ContainsKey("idList"))
|
|
idList = ((JArray)jobData["idList"]).ToObject<List<long>>();
|
|
else
|
|
idList = await ct.PurchaseOrder.AsNoTracking().Select(z => z.Id).ToListAsync();
|
|
bool SaveIt = false;
|
|
foreach (long id in idList)
|
|
{
|
|
try
|
|
{
|
|
SaveIt = false;
|
|
ClearErrors();
|
|
PurchaseOrder o = null;
|
|
//save a fetch if it's a delete
|
|
if (job.SubType != JobSubType.Delete)
|
|
o = await GetAsync(id, false, false);
|
|
switch (job.SubType)
|
|
{
|
|
case JobSubType.TagAddAny:
|
|
case JobSubType.TagAdd:
|
|
case JobSubType.TagRemoveAny:
|
|
case JobSubType.TagRemove:
|
|
case JobSubType.TagReplaceAny:
|
|
case JobSubType.TagReplace:
|
|
SaveIt = TagBiz.ProcessBatchTagOperation(o.Tags, (string)jobData["tag"], jobData.ContainsKey("toTag") ? (string)jobData["toTag"] : null, job.SubType);
|
|
break;
|
|
case JobSubType.Delete:
|
|
if (!await DeleteAsync(id))
|
|
{
|
|
await JobsBiz.LogJobAsync(job.GId, $"LT:Errors {GetErrorsAsString()} id {id}");
|
|
FailedObjectCount++;
|
|
}
|
|
break;
|
|
default:
|
|
throw new System.ArgumentOutOfRangeException($"ProcessBatchJobAsync -> Invalid job Subtype{job.SubType}");
|
|
}
|
|
if (SaveIt)
|
|
{
|
|
o = await PutAsync(o);
|
|
if (o == null)
|
|
{
|
|
await JobsBiz.LogJobAsync(job.GId, $"LT:Errors {GetErrorsAsString()} id {id}");
|
|
FailedObjectCount++;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
await JobsBiz.LogJobAsync(job.GId, $"LT:Errors id({id})");
|
|
await JobsBiz.LogJobAsync(job.GId, ExceptionUtil.ExtractAllExceptionMessages(ex));
|
|
}
|
|
}
|
|
await JobsBiz.LogJobAsync(job.GId, $"LT:BatchJob {job.SubType} {idList.Count}{(FailedObjectCount > 0 ? " - LT:Failed " + FailedObjectCount : "")}");
|
|
await JobsBiz.UpdateJobStatusAsync(job.GId, JobStatus.Completed);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// NOTIFICATION PROCESSING
|
|
//
|
|
public async Task HandlePotentialNotificationEvent(AyaEvent ayaEvent, ICoreBizObjectModel proposedObj, ICoreBizObjectModel currentObj = null)
|
|
{
|
|
ILogger log = AyaNova.Util.ApplicationLogging.CreateLogger<PurchaseOrderBiz>();
|
|
if (ServerBootConfig.SEEDING) return;
|
|
log.LogDebug($"HandlePotentialNotificationEvent processing: [AyaType:{this.BizType}, AyaEvent:{ayaEvent}]");
|
|
|
|
bool isNew = currentObj == null;
|
|
|
|
var p = (PurchaseOrder)proposedObj;
|
|
proposedObj.Name = p.Serial.ToString();
|
|
|
|
//STANDARD EVENTS FOR ALL OBJECTS
|
|
await NotifyEventHelper.ProcessStandardObjectEvents(ayaEvent, proposedObj, ct);
|
|
|
|
//SPECIFIC EVENTS FOR THIS OBJECT
|
|
|
|
//CREATED / MODIFIED
|
|
if (ayaEvent == AyaEvent.Created || ayaEvent == AyaEvent.Modified)
|
|
{
|
|
|
|
var c = (PurchaseOrder)currentObj;
|
|
|
|
//# PartRequestReceived
|
|
{
|
|
//get a list of all items with part requests and received inventory
|
|
var proposedRequestItems = p.Items.Where(z => z.WorkorderItemPartRequestId != null && z.QuantityReceived != 0);
|
|
//are there any potential notify items?
|
|
if (proposedRequestItems.Count() > 0)
|
|
{
|
|
//Look for new receipts of requested parts
|
|
foreach (var proposedRequestItem in proposedRequestItems)
|
|
{
|
|
//Get the matching item from db collection
|
|
var currentMatchingRequestItem = c.Items.FirstOrDefault(z => z.Id == proposedRequestItem.Id);
|
|
//if it doesn't exist or received less than the proposed item then we have actionable notification
|
|
if (currentMatchingRequestItem == null || currentMatchingRequestItem.QuantityReceived < proposedRequestItem.QuantityReceived)
|
|
{
|
|
//is there a subscriber for this user id and event?
|
|
var sub = await ct.NotifySubscription.FirstOrDefaultAsync(z => z.EventType == NotifyEventType.PartRequestReceived && z.UserId == proposedRequestItem.PartRequestedById);
|
|
if (sub != null)
|
|
{
|
|
//yes. So we have a subscriber, a change in received for a request, time to notify
|
|
//not for inactive users
|
|
if (!await UserBiz.UserIsActive(sub.UserId)) continue;
|
|
|
|
NotifyEvent n = new NotifyEvent()
|
|
{
|
|
EventType = NotifyEventType.PartRequestReceived,
|
|
UserId = sub.UserId,
|
|
AyaType = AyaType.WorkOrderItemPartRequest,
|
|
ObjectId = (long)proposedRequestItem.WorkorderItemPartRequestId,
|
|
NotifySubscriptionId = sub.Id,
|
|
Name = BizObjectNameFetcherDirect.Name(AyaType.WorkOrderItemPartRequest, (long)proposedRequestItem.WorkorderItemPartRequestId, ct)
|
|
};
|
|
await ct.NotifyEvent.AddAsync(n);
|
|
log.LogDebug($"Adding NotifyEvent: [{n.ToString()}]");
|
|
await ct.SaveChangesAsync();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}//end of process notifications
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
}//eoc
|
|
|
|
|
|
}//eons
|
|
|