public void FindPurchaseOrderTotalTest()
{
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser, true);
var poh = GetTestPurchaseOrderHeader(testCompany, testUser, 1);
var model = PurchasingService.FindPurchaseOrderDetailListModel(poh);
var pod = model.Items.First();
decimal totalValue = pod.OrderQty.Value * pod.UnitPriceExTax.Value;
for (int i = 0; i < 16; i++)
{
pod = model.Items.First();
pod.Id = 0;
pod.OrderQty = RandomInt();
totalValue += pod.OrderQty.Value * pod.UnitPriceExTax.Value;
var error = PurchasingService.InsertOrUpdatePurchaseOrderDetail(pod, testUser, "");
Assert.IsTrue(!error.IsError, error.Message);
}
var result = PurchasingService.FindPurchaseOrderTotal(poh);
Assert.IsTrue(result == totalValue, $"Error: {result} was returned when {totalValue} was expected");
}
public void LockPurchaseOrderDetailTest()
{
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser, true);
// Create a record
var poh = GetTestPurchaseOrderHeader(testCompany, testUser, 1);
// Get the first detail record
var detailList = PurchasingService.FindPurchaseOrderDetailListModel(poh);
var detail = detailList.Items.First();
// Get the current Lock
string lockGuid = PurchasingService.LockPurchaseOrderDetail(detail);
Assert.IsTrue(!string.IsNullOrEmpty(lockGuid), "Error: Lock record was not found");
// Simulate another user updating the record
var otherUser = GetTestUser();
var error = PurchasingService.InsertOrUpdatePurchaseOrderDetail(detail, otherUser, lockGuid);
Assert.IsTrue(!error.IsError, error.Message);
// Now get the first user to update the record
error = PurchasingService.InsertOrUpdatePurchaseOrderDetail(detail, testUser, lockGuid);
Assert.IsTrue(error.IsError, "Error: The lock should have caused an error as it has changed");
// Try to update with the new lock
lockGuid = PurchasingService.LockPurchaseOrderDetail(detail);
error = PurchasingService.InsertOrUpdatePurchaseOrderDetail(detail, testUser, lockGuid);
Assert.IsTrue(!error.IsError, $"Error: {error.Message}");
}
public void FindSplitPurchaseDetailsListModelTest()
{
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser, true);
int itemCount = 6;
var testOrder = GetTestPurchaseOrderHeader(testCompany, testUser, itemCount);
var testDetails = PurchasingService.FindPurchaseOrderDetailListModel(testOrder)
.Items
.OrderBy(td => td.Id)
.ToList();
var splitModel = PurchasingService.FindSplitPurchaseDetailsListModel(testCompany, testOrder.Id, 0, 1, 1000)
.Items
.OrderBy(sd => sd.PurchaseOrderDetailId)
.ToList();
int expected = itemCount,
actual = splitModel.Count();
Assert.IsTrue(actual == expected, $"Error: {actual} items were returned when {expected} were expected");
// Check that all the items match
for (int i = 0; i < itemCount; i++)
{
expected = testDetails[i].Id;
actual = splitModel[i].PurchaseOrderDetailId;
Assert.IsTrue(actual == expected, $"Error: Object Id {actual} was found when Id {expected} was expected");
expected = testDetails[i].OrderQty.Value;
actual = splitModel[i].OrigOrderQty;
Assert.IsTrue(actual == expected, $"Error: Order Qty {actual} was found when {expected} was expected");
}
}
public void FindPurchaseOrderDetailListModelTest()
{
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser, true);
var poh = GetTestPurchaseOrderHeader(testCompany, testUser, 1);
var model = PurchasingService.FindPurchaseOrderDetailListModel(poh);
var dbData = db.FindPurchaseOrderDetails(testCompany.Id, poh.Id);
int expected = dbData.Count(),
actual = model.Items.Count();
Assert.IsTrue(actual == expected, $"Error: {actual} items were found when {expected} were expected");
// Check that all the items match
foreach (var item in model.Items)
{
var dbItem = dbData.Where(m => m.Id == item.Id).FirstOrDefault();
Assert.IsTrue(dbItem != null, "Error: Model item not found in db item list");
var temp = PurchasingService.MapToModel(dbItem);
AreEqual(item, temp);
}
// Add another item a make sure it is found
var newItem = createPurchaseOrderDetail(model);
var error = PurchasingService.InsertOrUpdatePurchaseOrderDetail(newItem, testUser, "");
Assert.IsTrue(!error.IsError, $"Error: {error.Message}");
model = PurchasingService.FindPurchaseOrderDetailListModel(poh);
var testItem = model.Items.Where(i => i.Id == newItem.Id).FirstOrDefault();
Assert.IsTrue(testItem != null, "Error: A NULL value was returned when a non-NULL value was expected");
// Delete it and make sure it disappears
// Detail items are removed from the temp table, not main table, hence there is
// no service API to delete them from main
db.DeletePurchaseOrderDetail(newItem.Id);
model = PurchasingService.FindPurchaseOrderDetailListModel(poh);
testItem = model.Items.Where(i => i.Id == newItem.Id).FirstOrDefault();
Assert.IsTrue(testItem == null, "Error: A non-NULL value was returned when a NULL value was expected");
}
public void FindPurchaseOrderDetailModelTest()
{
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser, true);
var poh = GetTestPurchaseOrderHeader(testCompany, testUser, 10);
var podList = PurchasingService.FindPurchaseOrderDetailListModel(poh);
Assert.IsTrue(podList != null, "Error: NULL was returned when an object was expected");
var pod = PurchasingService.FindPurchaseOrderDetailModel(podList.Items[0].Id);
Assert.IsTrue(podList != null, "Error: NULL was returned when an object was expected");
// Now delete it and check it has gone
PurchasingService.DeletePurchaseOrderDetail(pod);
pod = PurchasingService.FindPurchaseOrderDetailModel(podList.Items[0].Id);
Assert.IsTrue(pod == null, "Error: An object was returned when NULL was expected");
}
public void SplitToExistingOrderTest()
{
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser, true);
var sourceOrder = GetTestPurchaseOrderHeader(testCompany, testUser, 4);
var sourceOrderItems = PurchasingService.FindPurchaseOrderDetailListModel(sourceOrder);
// Create a model to split an item off to a new order
SplitPurchaseModel model = new SplitPurchaseModel {
PurchaseOrderHeaderId = sourceOrder.Id,
SupplierName = "",
OrderNumber = 0,
AdvertisedETA = null,
NewOrderAdvertisedETA = DateTimeOffset.Now.AddDays(20),
LocationId = 0
};
// Try to split off more items than the original order
var existingOrder = GetTestPurchaseOrderHeader(testCompany, testUser, 0);
var splitItem = createSplitItemModel(sourceOrderItems.Items[0].Id, 0, 1500, existingOrder.Id, 1);
model.SplitItems.Add(splitItem);
int updatedPOId = 0,
newPOId = 0;
var lgs = PurchasingService.LockPurchaseOrderHeader(sourceOrder);
var error = PurchasingService.SplitOrder(testCompany, model, testUser, lgs, ref updatedPOId, ref newPOId);
Assert.IsTrue(error.IsError, "$Error: An error was expected but none was returned");
// Try to split off to an invalid 'existing' order
splitItem = createSplitItemModel(sourceOrderItems.Items[0].Id, 0, 5, -1, 1);
model.SplitItems.Clear();
model.SplitItems.Add(splitItem);
error = PurchasingService.SplitOrder(testCompany, model, testUser, lgs, ref updatedPOId, ref newPOId);
Assert.IsTrue(error.IsError, "$Error: An error was expected but none was returned");
// Now try to split a valid number of items off to an existing order
int originalQty = sourceOrderItems.Items[0].OrderQty.Value,
splitQty = 10;
splitItem = createSplitItemModel(sourceOrderItems.Items[0].Id, 0, splitQty, existingOrder.Id, 1);
model.SplitItems.Clear();
model.SplitItems.Add(splitItem);
lgs = PurchasingService.LockPurchaseOrderHeader(sourceOrder);
error = PurchasingService.SplitOrder(testCompany, model, testUser, lgs, ref updatedPOId, ref newPOId);
Assert.IsTrue(!error.IsError, error.Message);
// Check the newly created copy of the original record we have split
var updatedOrder = PurchasingService.FindPurchaseOrderHeaderModel(updatedPOId, testCompany, false);
Assert.IsTrue(updatedOrder != null, "Error: A NULL value was returned when an object was expected");
var updatedPohd = PurchasingService.FindPurchaseOrderDetailListModel(updatedOrder);
int expected = originalQty - splitQty,
actual = updatedPohd.Items[0].OrderQty.Value;
Assert.IsTrue(actual == expected, $"Error: The order quantity is now {actual} when {expected} was expected");
// .. and that the updated order has a note with PDF attachment
var noteList = NoteService.FindNotesListModel(NoteType.Purchase, updatedPOId, 0, 1, 1000, "", MediaSize.Medium, 0, 0);
expected = 1;
actual = noteList.Items.Count();
Assert.IsTrue(actual == expected, $"Error: (1) Order was found to have {actual} notes when {expected} were expected");
var noteAttachments = NoteService.FindNoteAttachmentsModel(noteList.Items[0], MediaSize.Medium, 0, 0);
expected = 1;
actual = noteAttachments.Count();
Assert.IsTrue(actual == expected, $"Error: (1) Order note was found to have {actual} attachment PDFs when {expected} were expected");
// Look for the new record in the exiting order
var newPohdList = db.FindPurchaseOrderDetails(testCompany.Id, existingOrder.Id)
.OrderByDescending(ni => ni.Id)
.ToList();
Assert.IsTrue(newPohdList.Count() == 1, $"Error: {newPohdList.Count()} items were returned when 1 was expected");
expected = splitQty;
actual = newPohdList[0].OrderQty.Value;
Assert.IsTrue(actual == splitQty, $"Error: {actual} items were returned when {expected} was expected");
// .. and that the existing order has a note with PDF attachment
noteList = NoteService.FindNotesListModel(NoteType.Purchase, existingOrder.Id, 0, 1, 1000, "", MediaSize.Medium, 0, 0);
expected = 1;
actual = noteList.Items.Count();
Assert.IsTrue(actual == expected, $"Error: (2) Order was found to have {actual} notes when {expected} were expected");
noteAttachments = NoteService.FindNoteAttachmentsModel(noteList.Items[0], MediaSize.Medium, 0, 0);
expected = 1;
actual = noteAttachments.Count();
Assert.IsTrue(actual == expected, $"Error: (2) Order note was found to have {actual} attachment PDFs when {expected} were expected");
// TBD: Check that the allocations have been modified
}
public void CompleteOrderTest()
{
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser, true);
var poh = GetTestPurchaseOrderHeader(testCompany, testUser, 10);
Assert.IsTrue(poh.POStatusValue != PurchaseOrderStatus.Closed, $"Error: Purchase order status {PurchaseOrderStatus.Closed} was found when any other value was expected");
var podList = PurchasingService.FindPurchaseOrderDetailListModel(poh);
var testProd1 = ProductService.FindProductModel(podList.Items[0].ProductId.Value, null, null, false);
var testProd2 = ProductService.FindProductModel(podList.Items[1].ProductId.Value, null, null, false);
// Clear the records for the first product
db.DeleteAllocationsForProduct(testCompany.Id, testProd1.Id);
testProd1.QuantityOnHand = 0;
string lgs = ProductService.LockProduct(testProd1);
ProductService.InsertOrUpdateProduct(testProd1, testUser, lgs);
db.DeleteProductLocationsForProduct(testCompany.Id, testProd1.Id);
// Copy the order to temp
var poht = PurchasingService.CopyPurchaseOrderToTemp(testCompany, poh, testUser);
// Complete the order
var error = PurchasingService.CompleteOrder(testCompany, testUser, poht.Id);
Assert.IsTrue(!error.IsError, error.Message);
poht = PurchasingService.FindPurchaseOrderHeaderTempModel(poht.Id, testCompany, false);
Assert.IsTrue(poht.POStatusValue == PurchaseOrderStatus.Closed, $"Error: Purchase order status {poht.POStatusValue} was returned when {PurchaseOrderStatus.Closed} was expected");
// Now try to complete the order again
error = PurchasingService.CompleteOrder(testCompany, testUser, poht.Id);
Assert.IsTrue(error.IsError, "Error: No error was returned when one was expected - an order cannot be completed twice");
poht = PurchasingService.FindPurchaseOrderHeaderTempModel(poht.Id, testCompany, false);
Assert.IsTrue(poht.POStatusValue == PurchaseOrderStatus.Closed, $"Error: Purchase order status {poht.POStatusValue} was returned when {PurchaseOrderStatus.Closed} was expected");
// Check the results of the completion
// Force a reload of all objects
//ReloadDbContext();
// Check the Allocations table for the first product
// The Allocations table records quantity reservations against order lines.
var allocs1 = AllocationService.FindAllocationListModel(testCompany, testProd1);
int expected = 0, // Because it was deleted above
actual = allocs1.Items.Count();
Assert.IsTrue(actual == expected, $"Error: {actual} records were returned when {expected} were expected");
// Check the Allocations table for the second product
var allocs2 = AllocationService.FindAllocationListModel(testCompany, testProd2);
expected = 1;
actual = allocs2.Items.Count();
Assert.IsTrue(actual >= expected, $"Error: {actual} records were returned when >={expected} were expected");
expected = (int)podList.Items[1].OrderQty;
actual = (int)allocs2.Items[0].Quantity;
Assert.IsTrue(actual >= expected, $"Error: Allocation quantity {actual} was returned when {expected} was expected");
// Check that the product table has been updated
// Product.QuantityOnHand is for all locations whereas Allocation and ProductLocation
// are for individual locations so the quantity in Product will always be higher than
// the latter two.
testProd1 = ProductService.FindProductModel(podList.Items[0].ProductId.Value, null, null, false);
expected = (int)podList.Items[0].OrderQty;
actual = (int)testProd1.QuantityOnHand.Value;
Assert.IsTrue(actual >= expected, $"Error: Product quantity {actual} was returned when {expected} was expected");
testProd2 = ProductService.FindProductModel(podList.Items[1].ProductId.Value, null, null, false);
expected = (int)podList.Items[1].OrderQty;
actual = (int)testProd2.QuantityOnHand.Value;
Assert.IsTrue(actual >= expected, $"Error: Product quantity {actual} was returned when {expected} was expected");
// Check that the ProductLocation table has been updated
var prodLoc = ProductService.FindProductLocationModel(testCompany, testProd1, poh.LocationId.Value);
expected = (int)podList.Items[0].OrderQty;
actual = (int)prodLoc.QuantityOnHand;
Assert.IsTrue(actual == expected, $"Error: ProductLocation quantity {actual} was returned when {expected} was expected");
prodLoc = ProductService.FindProductLocationModel(testCompany, testProd2, poh.LocationId.Value);
expected = (int)podList.Items[1].OrderQty;
actual = (int)prodLoc.QuantityOnHand;
Assert.IsTrue(actual == expected, $"Error: ProductLocation quantity {actual} was returned when {expected} was expected");
}
