public void ConstructorFailsIfProductArgumentIsNull()
{
var exception = Record.Exception(() => { PurchaseOrderLine line = new PurchaseOrderLine(null); });
Assert.NotNull(exception);
Assert.IsType <ArgumentNullException>(exception);
}
// GET: PurchaseOrderLine/Create
public IActionResult Create(string masterid, string id)
{
var check = _context.PurchaseOrderLine.SingleOrDefault(m => m.purchaseOrderLineId == id);
var selected = _context.PurchaseOrder.SingleOrDefault(m => m.purchaseOrderId == masterid);
var productList =
from Product in _context.Product
join VendorCatalogLine in _context.VendorCatalogLine on Product.productId equals VendorCatalogLine.ProductId
join VendorCatalog in _context.VendorCatalog on VendorCatalogLine.VendorCatalogId equals VendorCatalog.VendorCatalogId
select new
{
Product.productId,
Product.productCode,
VendorCatalog.VendorId
};
ViewData["purchaseOrderId"] = new SelectList(_context.PurchaseOrder, "purchaseOrderId", "purchaseOrderId");
if (check == null)
{
PurchaseOrderLine objline = new PurchaseOrderLine();
objline.purchaseOrder = selected;
objline.purchaseOrderId = masterid;
ViewData["productId"] = new SelectList(productList.Where(x => x.VendorId == selected.vendorId), "productId", "productCode");
return(View(objline));
}
else
{
ViewData["productId"] = new SelectList(_context.Product, "productId", "productCode");
return(View(check));
}
}
public async Task <IHttpActionResult> Post(PurchaseOrderLine item)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
item.ObjectState = ObjectState.Added;
_service.Insert(item);
try
{
await _unitOfWorkAsync.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (ItemExists(item.PurchaseOrderLineID))
{
return(Conflict());
}
throw;
}
return(Created(item));
}
public async Task <IActionResult> PutPurchaseOrderLine(Guid id, PurchaseOrderLine purchaseOrderLine)
{
if (id != purchaseOrderLine.PurchaseOrderLineId)
{
return(BadRequest());
}
_context.Entry(purchaseOrderLine).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PurchaseOrderLineExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private PurchaseOrderLine CommissionInvoiceLineToPOLine(InvoiceLine line)
{
PurchaseOrderLine convertedLine = null;
if (line.IsFlatCommission)
{
convertedLine = new PurchaseOrderLine()
{
Description = line.Description,
Item = line.FileNumber,
Qty = 1,
Rate = decimal.Parse(line.CommissionRate)
};
}
else
{
convertedLine = new PurchaseOrderLine()
{
Description = line.Description,
Item = line.FileNumber,
Qty = Math.Round(line.CompanyAmount, 2),
Rate = decimal.Parse(line.CommissionRate) / 100
};
}
return(convertedLine);
}
public async Task <CommandResult> Handle(
Command request,
CancellationToken cancellationToken)
{
Document doc = await store.GetAsync <Document>(
request.PurchaseOrderLineId.ToString());
PurchaseOrderLine aggregate = new PurchaseOrderLine(doc);
ReviewOutcome reviewResult = aggregate.Review();
CommandResult result = CommandResult.Void;
if (reviewResult is CancellationSuggested)
{
result = result
.WithNotification(
new CancellationSuggestedEvent
{
PurchaseOrderLineId = request.PurchaseOrderLineId
});
}
return(result);
}
private void ProcessPurchaseOrderLines(OrderRequest orderRequest, PurchaseOrder poResult, PurchaseOrder purchaseOrder)
{
foreach (var orderIdQuantPair in orderRequest.ProductIds)
{
var poLine = new PurchaseOrderLine
{
ProductId = orderIdQuantPair.Key.Id,
Quantity = orderIdQuantPair.Value,
Subtotal = orderIdQuantPair.Key.UnitCost * orderIdQuantPair.Value,
PurchaseOrderId = poResult.Id,
DateAdded = DateTime.Now,
DateModified = DateTime.Now
};
var poLineResult = _purchaseOrderRequestRepository.AddPurchaseOrderLine(poLine);
if (poLineResult == null)
{
throw new ArgumentNullException(nameof(poLineResult));
}
// Wait for success, then check for product type and handle business rules as requirements directed
ProductResolver(purchaseOrder, poLineResult);
}
}
private PurchaseOrderLine[][] GetAllPremutations(IRequirement requirement, IList <Stock> stocks)
{
var vendors = new PurchaseOrderLine[stocks.Count][];
var maxAvailable = 0;
for (int i = 0; i < stocks.Count; i++)
{
vendors[i] = GetLines(requirement.Quantity, stocks[i]);
maxAvailable += stocks[i].Quantity;
}
if (maxAvailable == 0)
{
return(new PurchaseOrderLine[0][]);
}
var premuter = new Premuting <PurchaseOrderLine>(vendors);
var result = new List <PurchaseOrderLine[]>();
var target = Math.Min(maxAvailable, requirement.Quantity);
premuter.Premute((x, y, z) =>
{
if (IsValidCombination(x, target))
{
result.Add(x.Where(y => y.Quantity > 0).ToArray());
}
});
return(result.ToArray());
}
private void InitPurshaseOrderValues(string selectedCustomerAccount, string iputProductNumber, Resources context)
{
//Purchase Order Header
PurchaseOrderHeader purchaseOrder = new PurchaseOrderHeader();
DataServiceCollection <PurchaseOrderHeader> purchaseOrderCollection = new DataServiceCollection <PurchaseOrderHeader>(context);
purchaseOrderCollection.Add(purchaseOrder);
purchaseOrder.CurrencyCode = "USD";
purchaseOrder.PurchaseOrderNumber = ImputOrderNumber;
purchaseOrder.InvoiceVendorAccountNumber = selectedCustomerAccount;
purchaseOrder.OrderVendorAccountNumber = selectedCustomerAccount;
purchaseOrder.LanguageId = "en-us";
purchaseOrder.dataAreaId = "USMF";
//Purchase Order Line
PurchaseOrderLine purchaseOrderLine = new PurchaseOrderLine();
DataServiceCollection <PurchaseOrderLine> purchaseOrderLineCollection = new DataServiceCollection <PurchaseOrderLine>(context);
purchaseOrderLineCollection.Add(purchaseOrderLine);
purchaseOrderLine.PurchaseOrderNumber = ImputOrderNumber;
purchaseOrderLine.ItemNumber = iputProductNumber;
purchaseOrderLine.OrderedPurchaseQuantity = ImputOrderQuantity;
purchaseOrderLine.dataAreaId = "USMF";
}
public async Task <IActionResult> Edit(string id, [Bind("purchaseOrderLineId,purchaseOrderId,productId,qty,price,discountAmount,totalAmount,createdAt")] PurchaseOrderLine purchaseOrderLine)
{
if (id != purchaseOrderLine.purchaseOrderLineId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(purchaseOrderLine);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PurchaseOrderLineExists(purchaseOrderLine.purchaseOrderLineId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["productId"] = new SelectList(_context.Product, "productId", "productId", purchaseOrderLine.productId);
ViewData["purchaseOrderId"] = new SelectList(_context.PurchaseOrder, "purchaseOrderId", "purchaseOrderId", purchaseOrderLine.purchaseOrderId);
return(View(purchaseOrderLine));
}
public async Task <ActionResult <PurchaseOrderLine> > PostPurchaseOrderLine(PurchaseOrderLine purchaseOrderLine)
{
_context.PurchaseOrderLine.Add(purchaseOrderLine);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetPurchaseOrderLine", new { id = purchaseOrderLine.PurchaseOrderLineId }, purchaseOrderLine));
}
public async Task <IActionResult> Edit(int id, [Bind("PurchaseOrderLineId,PurchaseOrderId,ProductId,Description,Quantity,Price,Amount,DiscountPercentage,DiscountAmount,SubTotal,TaxPercentage,TaxAmount,Total")] PurchaseOrderLine purchaseOrderLine)
{
if (id != purchaseOrderLine.PurchaseOrderLineId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(purchaseOrderLine);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PurchaseOrderLineExists(purchaseOrderLine.PurchaseOrderLineId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["PurchaseOrderId"] = new SelectList(_context.PurchaseOrder, "PurchaseOrderId", "PurchaseOrderId", purchaseOrderLine.PurchaseOrderId);
return(View(purchaseOrderLine));
}
public PurchaseOrderLine AddPurchaseOrderLine(PurchaseOrderLine purchaseOrderLine)
{
var polResult = _context.PurchaseOrderLines.Add(purchaseOrderLine);
_context.SaveChanges();
return(polResult);
}
public async Task ProcessesOnlyMembershipTypes()
{
CustomerAddress addr = new CustomerAddress("name", "street1", null, "zip", "city", "country");
Customer customer = new Customer("first", "last");
customer.Addresses.Add(addr);
Product bookMembership = new Product("book membership", new BookMembershipProductType());
Product videoMembership = new Product("video membership", new VideoMembershipProductType());
Product book = new Product("a book", new BookProductType());
MembershipTypeProcessor proc = new MembershipTypeProcessor();
PurchaseOrder validorder1 = new PurchaseOrder(1, customer, addr);
PurchaseOrderLine validLine1 = new PurchaseOrderLine(bookMembership);
validorder1.OrderLines.Add(validLine1);
var ex1 = await Record.ExceptionAsync(async() => {
await proc.ProcessAsync(validorder1, validLine1);
});
Assert.Null(ex1);
PurchaseOrder validorder2 = new PurchaseOrder(1, customer, addr);
PurchaseOrderLine validLine2 = new PurchaseOrderLine(bookMembership);
validorder2.OrderLines.Add(validLine2);
var ex2 = await Record.ExceptionAsync(async() => {
await proc.ProcessAsync(validorder1, validLine2);
});
Assert.Null(ex2);
}
public string ConvertPurchaseOrderLine(PurchaseOrderLine line)
{
var template = GetTemplateText(PurchaseOrderLineAddTemplate);
string xml = "";
if (template != null)
{
//there's a negative number in disbursements, which POs don't allow
if (line.Item == "Disbursements")
{
xml = template
.Replace("{{ItemName}}", line.Item.ToXmlString())
.Replace("{{Rate}}", line.Qty.ToString().ToXmlString())
.Replace("{{Quantity}}", line.Rate.ToString().ToXmlString());
}
else
{
xml = template
.Replace("{{ItemName}}", line.Item.ToXmlString())
.Replace("{{Quantity}}", line.Qty.ToString().ToXmlString())
.Replace("{{Rate}}", line.Rate.ToString().ToXmlString());
}
}
return(xml);
}
public async Task <IActionResult> PostPurchaseOrderLine([FromBody] PurchaseOrderLine purchaseOrderLine)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
PurchaseOrder purchaseOrder = await _context.PurchaseOrder.Where(x => x.purchaseOrderId.Equals(purchaseOrderLine.purchaseOrderId)).FirstOrDefaultAsync();
if (purchaseOrder.purchaseOrderStatus == PurchaseOrderStatus.Completed)
{
return(Json(new { success = false, message = "Error. Can not edit [Completed] order" }));
}
purchaseOrderLine.totalAmount = (decimal)purchaseOrderLine.qty * purchaseOrderLine.price;
if (purchaseOrderLine.purchaseOrderLineId == string.Empty)
{
purchaseOrderLine.purchaseOrderLineId = Guid.NewGuid().ToString();
_context.PurchaseOrderLine.Add(purchaseOrderLine);
await _context.SaveChangesAsync();
return(Json(new { success = true, message = "Add new data success." }));
}
else
{
_context.Update(purchaseOrderLine);
await _context.SaveChangesAsync();
return(Json(new { success = true, message = "Edit data success." }));
}
}
public async Task ProcessingFailsWhenNotSupportedTypePassed()
{
CustomerAddress addr = new CustomerAddress("name", "street1", null, "zip", "city", "country");
Customer customer = new Customer("first", "last");
customer.Addresses.Add(addr);
Product bookMembership = new Product("book membership", new BookMembershipProductType());
Product videoMembership = new Product("video membership", new VideoMembershipProductType());
Product book = new Product("a book", new BookProductType());
MembershipTypeProcessor proc = new MembershipTypeProcessor();
PurchaseOrder invalidOrder = new PurchaseOrder(1, customer, addr);
PurchaseOrderLine invalidLine = new PurchaseOrderLine(book);
invalidOrder.OrderLines.Add(invalidLine);
var ex3 = await Record.ExceptionAsync(async() => {
await proc.ProcessAsync(invalidOrder, invalidLine);
});
Assert.NotNull(ex3);
Assert.IsType <NotSupportedException>(ex3);
}
public async Task ProcessAsync(PurchaseOrder order, PurchaseOrderLine line)
{
if (order == null)
{
throw new ArgumentNullException(nameof(order));
}
if (line == null)
{
throw new ArgumentNullException(nameof(line));
}
order.Validate();
if (!CanProcess(line.Product))
{
throw new NotSupportedException(nameof(line.Product));
}
await Task.Factory.StartNew(() =>
{
// order membership type if necessary
if (order.Customer.MembershipType == CustomerMembershipType.None)
{
// set to the one from order
order.Customer.MembershipType = ((IMembershipProductType)line.Product.Type).MembershipType;
}
else if (order.Customer.MembershipType != ((IMembershipProductType)line.Product.Type).MembershipType)
{
// set as premium
order.Customer.MembershipType = CustomerMembershipType.Premium;
}
});
}
public async Task <IActionResult> AutoPO()
{
PurchaseOrder po = new PurchaseOrder();
foreach (Product p in _context.Product)
{
int productId = p.ProductId;
double total = _context.SalesOrderLine.Where(l => l.ProductId == p.ProductId && l.SalesOrder.OrderDate.AddDays(+90) > DateTime.Now).Sum(l => l.Quantity);
double average = total / 3;
double buyQty = average - p.Balance;
if (buyQty > 0)
{
PurchaseOrderLine pol = new PurchaseOrderLine();
pol.ProductId = p.ProductId;
pol.Quantity = average;
pol.PurchaseOrder = po;
_context.PurchaseOrderLine.Add(pol);
}
}
_context.PurchaseOrder.Add(po);
_context.SaveChanges();
return(Ok(new { }));
}
public async Task <IActionResult> PostPurchaseOrderLine([FromBody] PurchaseOrderLine purchaseOrderLine)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
PurchaseOrder purchaseOrder = await _context.PurchaseOrder.Where(x => x.purchaseOrderId.Equals(purchaseOrderLine.purchaseOrderId)).FirstOrDefaultAsync();
if (purchaseOrder.purchaseOrderStatus == PurchaseOrderStatus.Completed)
{
return(Json(new { success = false, message = "Σφάλμα. Δεν είναι δυνατή η επεξεργασία παραγγελίας που είναι [Ολοκληρωμένη]" }));
}
purchaseOrderLine.totalAmount = (decimal)purchaseOrderLine.qty * purchaseOrderLine.price;
if (purchaseOrderLine.purchaseOrderLineId == string.Empty)
{
purchaseOrderLine.purchaseOrderLineId = Guid.NewGuid().ToString();
_context.PurchaseOrderLine.Add(purchaseOrderLine);
await _context.SaveChangesAsync();
return(Json(new { success = true, message = "Η Προσθήκη στοιχείου στην Παραγγελία Αγοράς, έγινε με επιτυχία." }));
}
else
{
_context.Update(purchaseOrderLine);
await _context.SaveChangesAsync();
return(Json(new { success = true, message = "Η Επεξεργασία του στοιχείου στην Παραγγελία Αγοράς, έγινε με επιτυχία." }));
}
}
private int AddNewRawMaterialToRawMaterialTable(PurchaseOrderLine line)
{
_context.RawMaterials.Add(new RawMaterial {
Name = line.RawMaterialStringTemp, RawMaterialCategoryId = 1
});
_context.SaveChanges();
return(_context.RawMaterials.SingleOrDefault(r => r.Name == line.RawMaterialStringTemp).Id);
}
private int AddNewSupplierToSupplierTable(PurchaseOrderLine line)
{
_context.Suppliers.Add(new Supplier {
Name = line.SupplierStringTemp, Active = true
});
_context.SaveChanges();
return(_context.Suppliers.SingleOrDefault(s => s.Name == line.SupplierStringTemp).Id);
}
public IActionResult Remove([FromBody] CrudViewModel <PurchaseOrderLine> payload)
{
PurchaseOrderLine poline = _functionalService.GetById <PurchaseOrderLine>(Convert.ToInt32(payload.key));
var result = _functionalService.Delete <PurchaseOrderLine>(poline);
this.UpdatePurchaseOrder(poline.PurchaseOrderId);
return(Ok());
}
public static void DeleteById(int id)
{
PurchaseOrderLine o = GetById(id);
if (o != null)
{
o.Delete();
}
}
public void OrderLineValidWhenAllDataFilledOut()
{
var ex = Record.Exception(() => {
PurchaseOrderLine line = new PurchaseOrderLine();
line.Product = new Product("somethin", new BookProductType());
});
Assert.Null(ex);
}
/// <summary>
/// Get a list of QueryFilter that represent changed fields.
/// </summary>
/// <param name="original">Original Entity. The unchanged entity.</param>
/// <param name="changed">Changed Entity. The entity holding the changed fields.</param>
/// <returns>QueryFilters of PurchaseOrderLineProperty</returns>
public static QueryFilters <PurchaseOrderLineProperty> GetChanges(PurchaseOrderLine original, PurchaseOrderLine changed)
{
// this method returns a list of changes.
var changes = new QueryFilters <PurchaseOrderLineProperty>(12);
#region Detect Changes
if (original.PurchaseOrderLineID != changed.PurchaseOrderLineID)
{
changes.Add(QueryFilter.New(PurchaseOrderLineProperty.PurchaseOrderLineID, FilterConditions.Equals, changed.PurchaseOrderLineID));
}
if (original.PurchaseOrderID != changed.PurchaseOrderID)
{
changes.Add(QueryFilter.New(PurchaseOrderLineProperty.PurchaseOrderID, FilterConditions.Equals, changed.PurchaseOrderID));
}
if (original.StockItemID != changed.StockItemID)
{
changes.Add(QueryFilter.New(PurchaseOrderLineProperty.StockItemID, FilterConditions.Equals, changed.StockItemID));
}
if (original.OrderedOuters != changed.OrderedOuters)
{
changes.Add(QueryFilter.New(PurchaseOrderLineProperty.OrderedOuters, FilterConditions.Equals, changed.OrderedOuters));
}
if (string.CompareOrdinal(original.Description, changed.Description) != 0)
{
changes.Add(QueryFilter.New(PurchaseOrderLineProperty.Description, FilterConditions.Equals, changed.Description));
}
if (original.ReceivedOuters != changed.ReceivedOuters)
{
changes.Add(QueryFilter.New(PurchaseOrderLineProperty.ReceivedOuters, FilterConditions.Equals, changed.ReceivedOuters));
}
if (original.PackageTypeID != changed.PackageTypeID)
{
changes.Add(QueryFilter.New(PurchaseOrderLineProperty.PackageTypeID, FilterConditions.Equals, changed.PackageTypeID));
}
if (original.ExpectedUnitPricePerOuter != changed.ExpectedUnitPricePerOuter)
{
changes.Add(QueryFilter.New(PurchaseOrderLineProperty.ExpectedUnitPricePerOuter, FilterConditions.Equals, changed.ExpectedUnitPricePerOuter));
}
if (original.LastReceiptDate != changed.LastReceiptDate)
{
changes.Add(QueryFilter.New(PurchaseOrderLineProperty.LastReceiptDate, FilterConditions.Equals, changed.LastReceiptDate));
}
if (original.IsOrderLineFinalized != changed.IsOrderLineFinalized)
{
changes.Add(QueryFilter.New(PurchaseOrderLineProperty.IsOrderLineFinalized, FilterConditions.Equals, changed.IsOrderLineFinalized));
}
if (original.LastEditedBy != changed.LastEditedBy)
{
changes.Add(QueryFilter.New(PurchaseOrderLineProperty.LastEditedBy, FilterConditions.Equals, changed.LastEditedBy));
}
if (original.LastEditedWhen != changed.LastEditedWhen)
{
changes.Add(QueryFilter.New(PurchaseOrderLineProperty.LastEditedWhen, FilterConditions.Equals, changed.LastEditedWhen));
}
#endregion
return(changes.Count > 0 ? changes : null);
}
public void OrderLineNotValidWhenProductIsNull()
{
var ex = Record.Exception(() => {
PurchaseOrderLine line = new PurchaseOrderLine();
line.Validate();
});
Assert.NotNull(ex);
Assert.IsType <ValidationErrorException>(ex);
}
public IActionResult Insert([FromBody] CrudViewModel <PurchaseOrderLine> payload)
{
PurchaseOrderLine purchaseOrderLine = payload.value;
purchaseOrderLine = this.Recalculate(purchaseOrderLine);
_context.PurchaseOrderLine.Add(purchaseOrderLine);
_context.SaveChanges();
this.UpdatePurchaseOrder(purchaseOrderLine.PurchaseOrderId);
return(Ok(purchaseOrderLine));
}
public PurchaseOrderLine addPurchaseOrderLine(int qty, string prod, PurchaseOrder s)
{
PurchaseOrderLine pol = new PurchaseOrderLine();
pol.ProductCode = prod;
pol.Quantity = qty;
s.addLine(pol);
return(pol);
}
private async Task UpdateProductIfChanged(PurchaseOrderLine lineItem, EditLineItemCommand command)
{
if (lineItem.Product.Id != command.ProductId)
{
var newProduct = await _context.Product.SingleAsync(p => p.SupplierId == lineItem.Product.SupplierId &&
p.Id == command.ProductId);
lineItem.Product = newProduct;
}
}