private int?GetSubcontractBillsGeneratedCount(POOrder purchaseOrder) { return(PXSelectGroupBy <APTran, Where <APTran.pONbr, Equal <Required <POOrder.orderNbr> >, And <APTran.pOOrderType, Equal <Required <POOrder.orderType> > > >, Aggregate <Count> > .Select(this, purchaseOrder.OrderNbr, purchaseOrder.OrderType).RowCount); }
public static void Process(POOrder doc) { List <POOrder> list = new List <POOrder>(); list.Add(doc); Process(list, false); }
protected void POOrder_Status_FieldUpdated(PXCache cache, PXFieldUpdatedEventArgs e) { POOrder pOOrder = (POOrder)e.Row; if (pOOrder.Status == POOrderStatus.Open) { string poNbr = pOOrder.OrderNbr; bool isPOExists = reviewPO(pOOrder); if (isPOExists) { foreach (POLine pOLine in PXSelect <POLine, Where <POLine.orderNbr, Equal <Required <POLine.orderNbr> > > > .Select(Base, pOOrder.OrderNbr)) { modifyPO(pOOrder, pOLine); } } else { foreach (POLine pOLine in PXSelect <POLine, Where <POLine.orderNbr, Equal <Required <POLine.orderNbr> > > > .Select(Base, pOOrder.OrderNbr)) { int?pOLineNbr = pOLine.POLineNbr; int?lineNbr = pOLine.LineNbr; createPO(pOOrder, pOLine); } } } }
private int?GetSubcontractReceiptsCount(POOrder purchaseOrder) { return(PXSelectGroupBy <POOrderReceipt, Where <POOrderReceipt.pONbr, Equal <Required <POOrder.orderNbr> >, And <POOrderReceipt.pOType, Equal <Required <POOrder.orderType> > > >, Aggregate <Count> > .Select(this, purchaseOrder.OrderNbr, purchaseOrder.OrderType).RowCount); }
protected virtual void POOrder_RowPersisted(PXCache cache, PXRowPersistedEventArgs e) { if (e.TranStatus == PXTranStatus.Open && e.Operation == PXDBOperation.Update) { POOrder poOrderRow = (POOrder)e.Row; string poOrderOldStatus = (string)cache.GetValueOriginal <POOrder.status>(poOrderRow); PXCache poLineCache = Base.Caches[typeof(POLineUOpen)]; bool updateLines = false; List <POLine> poLineUpdatedList = new List <POLine>(); foreach (object row in poLineCache.Updated) { if ((bool?)poLineCache.GetValue <POLineUOpen.completed>(row) != false) { updateLines = true; } poLineUpdatedList.Add(SharedFunctions.ConvertToPOLine((POLineUOpen)row)); } if (poOrderOldStatus != poOrderRow.Status || updateLines == true) { SharedFunctions.UpdateFSSODetReferences(cache.Graph, serviceOrderView.Cache, poOrderRow, poLineUpdatedList); } } }
private static void UpdatePurchaseOrderBasedOnPreferences(PXCache cache, POOrder order, PoSetupExt setup) { order.RequestApproval = setup.SubcontractRequestApproval; var isControlTotalVisible = setup.RequireSubcontractControlTotal == true; PXUIFieldAttribute.SetVisible <POOrder.curyControlTotal>(cache, order, isControlTotalVisible); }
public virtual void UpdateOrdersStatus(IEnumerable <Tuple <string, string> > orderCheckClosed) { foreach (Tuple <string, string> orderNbr in orderCheckClosed) { POLineUOpen minStatusLine = PXSelect <POLineUOpen, Where <POLineUOpen.orderType, Equal <Required <POLineUOpen.orderType> >, And <POLineUOpen.orderNbr, Equal <Required <POLineUOpen.orderNbr> >, And <POLineUOpen.lineType, NotEqual <POLineType.description> > > >, OrderBy <Asc <POLineUOpen.completed, Asc <POLineUOpen.closed> > > > .Select(_graph, orderNbr.Item1, orderNbr.Item2); string newStatus = (minStatusLine == null || minStatusLine.Closed == true) ? POOrderStatus.Closed : (minStatusLine.Completed == true) ? POOrderStatus.Completed : POOrderStatus.Open; POOrder order = PXSelect <POOrder, Where <POOrder.orderType, Equal <Required <POOrder.orderType> >, And <POOrder.orderNbr, Equal <Required <POOrder.orderNbr> > > > > .Select(_graph, orderNbr.Item1, orderNbr.Item2); if (order != null && order.Status != newStatus && order.Hold != true) { PXCache orderCache = _graph.Caches[typeof(POOrder)]; POOrder upd = (POOrder)orderCache.CreateCopy(order); upd.Status = newStatus; orderCache.Update(upd); } } }
protected override PMCommitment FromRecord(PXCache sender, object row) { POLineUOpen poline = (POLineUOpen)row; POOrder order = (POOrder)PXParentAttribute.SelectParent(sender.Graph.Caches[detailEntity], row, typeof(POOrder)); PMCommitment commitment = new PMCommitment(); commitment.Type = PMCommitmentType.Internal; commitment.CommitmentID = poline.CommitmentID ?? Guid.NewGuid(); commitment.AccountGroupID = GetAccountGroup(sender, row); commitment.ProjectID = poline.ProjectID; commitment.ProjectTaskID = poline.TaskID; commitment.UOM = poline.UOM; commitment.Qty = poline.OrderQty; commitment.Amount = poline.ExtCost; commitment.OpenQty = poline.OpenQty; commitment.OpenAmount = poline.OpenAmt; commitment.ReceivedQty = poline.ReceivedQty; commitment.InvoicedQty = 0; commitment.InvoicedAmount = 0; commitment.InvoicedIsReadonly = true; commitment.RefNoteID = order.NoteID; commitment.InventoryID = poline.InventoryID ?? PMInventorySelectorAttribute.EmptyInventoryID; commitment.CostCodeID = poline.CostCodeID ?? CostCodeAttribute.GetDefaultCostCode(); return(commitment); }
private static void ApproveSingleSubcontract(SubcontractEntry graph, POOrder subcontract) { SetupGraphForApproval(graph, subcontract); CheckActionExisting(graph); PressApprove(graph, subcontract); graph.Persist(); }
private static string GetEntityDescription(EntityHelper entityHelper, POOrder commitment, PXGraph graph) { var status = entityHelper.GetFieldString(commitment, commitment.GetType(), StatusFieldName); var vendorName = GetVendorName(commitment.VendorID, graph); return(string.Format(SubcontractDescription, commitment.OrderNbr, vendorName, commitment.OrderDate, status)); }
private static bool IsProjectUpdateRequired(POOrder subcontract, IReadOnlyCollection <POLine> subcontractLines) { var nonZeroOpenAmount = subcontract.LineTotal > 0; var nonZeroNumberOfLines = subcontractLines.Count > 0; var allLinesWithTheSameProject = subcontractLines.GroupBy(x => x.ProjectID).Count() == 1; return(nonZeroOpenAmount && nonZeroNumberOfLines && allLinesWithTheSameProject); }
private List <POLine> GetSubcontractLines(POOrder subcontract) { var query = new PXSelect <POLine, Where <POLine.orderType, Equal <POOrderType.regularSubcontract>, And <POLine.orderNbr, Equal <Required <POLine.orderNbr> > > > >(Base); return(query.Select(subcontract.OrderNbr).FirstTableItems.ToList()); }
public virtual void AddPOOrderProc(POOrder order, bool createNew) { APInvoice prepayment; if (createNew) { prepayment = Base.Document.Insert(new APInvoice { DocType = APDocType.Prepayment }); prepayment.DocDesc = order.OrderDesc; if (PXAccess.FeatureInstalled <FeaturesSet.vendorRelations>()) { prepayment.VendorID = order.PayToVendorID; prepayment.VendorLocationID = (order.VendorID == order.PayToVendorID) ? order.VendorLocationID : null; prepayment.SuppliedByVendorID = order.VendorID; prepayment.SuppliedByVendorLocationID = order.VendorLocationID; } else { prepayment.VendorID = prepayment.SuppliedByVendorID = order.VendorID; prepayment.VendorLocationID = prepayment.SuppliedByVendorLocationID = order.VendorLocationID; } prepayment.CuryID = order.CuryID; Base.Document.Update(prepayment); prepayment.TaxCalcMode = order.TaxCalcMode; prepayment.InvoiceNbr = order.OrderNbr; prepayment.DueDate = order.OrderDate; prepayment.TaxZoneID = order.TaxZoneID; Base.Document.Update(prepayment); } else { prepayment = Base.Document.Current; } TaxBaseAttribute.SetTaxCalc <APTran.taxCategoryID, TaxAttribute>(Base.Transactions.Cache, null, TaxCalc.ManualCalc); var orderLines = PXSelectReadonly <POLineRS, Where <POLineRS.orderType, Equal <Required <POOrder.orderType> >, And <POLineRS.orderNbr, Equal <Required <POOrder.orderNbr> > > >, OrderBy <Asc <POLineRS.sortOrder, Asc <POLineRS.lineNbr> > > > .Select(Base, order.OrderType, order.OrderNbr) .RowCast <POLineRS>() .ToList(); bool hasAdded = AddPOOrderLines(orderLines); if (!hasAdded) { throw new PXException(Messages.APInvoicePOOrderCreation_NoApplicableLinesFound); } Base.AddOrderTaxes(order); TaxBaseAttribute.SetTaxCalc <APTran.taxCategoryID, TaxAttribute>(Base.Transactions.Cache, null, TaxCalc.ManualLineCalc); }
private void InitializePOOrderDocument(POOrderEntry graphPOOrderEntry, POOrder poOrderRow, POEnabledFSSODet firstPOEnabledFSSODetRow) { poOrderRow = new POOrder(); poOrderRow = graphPOOrderEntry.Document.Current = graphPOOrderEntry.Document.Insert(poOrderRow); poOrderRow.OrderType = POOrderType.RegularOrder; poOrderRow.VendorID = firstPOEnabledFSSODetRow.POVendorID; poOrderRow.VendorLocationID = firstPOEnabledFSSODetRow.POVendorLocationID; graphPOOrderEntry.Document.Update(poOrderRow); }
protected virtual void POOrder_RowDeleting(PXCache sender, PXRowDeletingEventArgs e) { POOrder doc = (POOrder)e.Row; if (doc.Hold != true && doc.Behavior == POBehavior.ChangeOrder) { throw new PXException(PX.Objects.PO.Messages.CanNotDeleteWithChangeOrderBehavior); } }
private static PXAdapter CreateAdapter(SubcontractEntry graph, POOrder subcontract) { var dummyView = new DummyView(graph, subcontract); return(new PXAdapter(dummyView) { Menu = nameof(Approve) }); }
private void UpdateSubcontractIfRequired(POOrder subcontract) { var subcontractLines = GetSubcontractLines(subcontract); if (IsProjectUpdateRequired(subcontract, subcontractLines)) { UpdateSubcontractProject(subcontract, subcontractLines); } }
protected virtual void InsertUpdatePOAdjust(APAdjust apadjust) { if (Base.Document.Current?.DocType.IsNotIn(APDocType.Prepayment, APDocType.VoidCheck) == true || apadjust?.AdjdDocType != APDocType.Prepayment) { return; } var prepaymentRequests = new PXSelectJoin <POOrderPrepayment, InnerJoin <POOrder, On <POOrderPrepayment.orderType, Equal <POOrder.orderType>, And <POOrderPrepayment.orderNbr, Equal <POOrder.orderNbr> > > >, Where <POOrderPrepayment.aPDocType, Equal <Required <APAdjust.adjdDocType> >, And <POOrderPrepayment.aPRefNbr, Equal <Required <APAdjust.adjdRefNbr> >, And <POOrderPrepayment.aPDocType, Equal <APDocType.prepayment> > > > >(Base) .Select(apadjust.AdjdDocType, apadjust.AdjdRefNbr); foreach (PXResult <POOrderPrepayment, POOrder> row in prepaymentRequests) { POOrder order = row; POOrderPrepayment prepaymentRequest = row; POAdjust poadjustment = new PXSelect <POAdjust, Where <POAdjust.adjgDocType, Equal <Current <APPayment.docType> >, And <POAdjust.adjgRefNbr, Equal <Current <APPayment.refNbr> >, And <POAdjust.adjNbr, Equal <Current <APPayment.adjCntr> >, And <POAdjust.adjdDocType, Equal <Required <APInvoice.docType> >, And <POAdjust.adjdRefNbr, Equal <Required <APInvoice.refNbr> > > > > > > >(Base) .Select(apadjust.AdjdDocType, apadjust.AdjdRefNbr); if (poadjustment == null) { poadjustment = POAdjustments.Insert(new POAdjust() { AdjgDocType = Base.Document.Current.DocType, AdjgRefNbr = Base.Document.Current.RefNbr, AdjdOrderType = prepaymentRequest.OrderType, AdjdOrderNbr = prepaymentRequest.OrderNbr, AdjdDocType = apadjust.AdjdDocType, AdjdRefNbr = apadjust.AdjdRefNbr, AdjNbr = Base.Document.Current.AdjCntr, IsRequest = true, }); } if (order.CuryID == Base.Document.Current.CuryID) { POAdjustments.Cache.SetValueExt <POAdjust.curyAdjgAmt>(poadjustment, apadjust.CuryAdjgAmt); } else { PXCurrencyAttribute.CuryConvCury(Base.Document.Cache, Base.Document.Current, apadjust.AdjAmt ?? 0, out decimal curyamount); POAdjustments.Cache.SetValueExt <POAdjust.curyAdjgAmt>(poadjustment, curyamount); } POAdjustments.Update(poadjustment); } }
private static void RedirectToSubcontractEntry(POOrder commitment) { var graph = PXGraph.CreateInstance <SubcontractEntry>(); graph.Document.Current = commitment; throw new PXRedirectRequiredException(graph, string.Empty) { Mode = PXBaseRedirectException.WindowMode.NewWindow }; }
private string GetSubcontractProjectName(POOrder subcontract) { var query = new PXSelectJoin <Contract, LeftJoin <POLine, On <POLine.projectID, Equal <Contract.contractID> > >, Where <POLine.orderNbr, Equal <Required <POLine.orderNbr> >, And <POLine.orderType, Equal <POOrderType.regularSubcontract> > >, OrderBy <Asc <POLine.lineNbr> > >(Base); return(query.SelectSingle(subcontract.OrderNbr)?.ContractCD); }
private string GetRewrittenEntityRowValues(POOrder subcontract) { var cache = Base.Caches <POOrder>(); PXUIFieldAttribute.SetVisibility <POOrder.orderType>(cache, null, PXUIVisibility.Invisible); var description = entityHelper.DescriptionEntity(typeof(POOrder), subcontract); PXUIFieldAttribute.SetVisibility <POOrder.orderType>(cache, null, PXUIVisibility.SelectorVisible); return(description); }
private static void PressApprove(SubcontractEntry graph, POOrder subcontract) { var action = graph.Actions[ActionsMessages.Action]; var adapter = CreateAdapter(graph, subcontract); // method Press is lazy, foreach needed for full completion foreach (var dummy in action.Press(adapter)) { } }
private void FillPurchaseOrderInfo(ComplianceDocument complianceDocument, POOrder poOrder, POLine poLine) { complianceDocument.VendorID = poOrder.VendorID; complianceDocument.VendorName = GetVendorName(complianceDocument.VendorID); complianceDocument.ProjectID = poLine?.ProjectID; complianceDocument.CostTaskID = poLine?.TaskID; complianceDocument.AccountID = poLine?.ExpenseAcctID; complianceDocument.CostCodeID = poLine?.CostCodeID; SetComplianceDocumentReference(complianceDocument, poOrder); }
private ComplianceDocumentReference CreateComplianceDocumentReference(POOrder pOrder) { var reference = new ComplianceDocumentReference { ComplianceDocumentReferenceId = Guid.NewGuid(), Type = pOrder.OrderType, ReferenceNumber = pOrder.OrderNbr, RefNoteId = pOrder.NoteID }; return(DocumentReference.Insert(reference)); }
private void SetControlTotalIfRequired(PXCache cache, POOrder order) { if (order.Cancelled == false && POSetup.Current.RequireOrderControlTotal == false && order.CuryOrderTotal != order.CuryControlTotal) { var controlTotal = order.CuryOrderTotal.IsNullOrZero() ? decimal.Zero : order.CuryOrderTotal; cache.SetValueExt <POOrder.curyControlTotal>(order, controlTotal); } }
public override void DocumentRowUpdated(PXCache sender, PXRowUpdatedEventArgs e) { POOrder row = e.Row as POOrder; POOrder oldRow = e.OldRow as POOrder; if (IsCommitmentSyncRequired(sender, row, oldRow)) { var selectDetails = new PXSelect <POLine, Where <POLine.orderType, Equal <Current <POOrder.orderType> >, And <POLine.orderNbr, Equal <Optional <POOrder.orderNbr> > > >, OrderBy <Asc <POLine.orderType, Asc <POLine.orderNbr, Asc <POLine.lineNbr> > > > >(sender.Graph); foreach (POLine line in selectDetails.Select()) { this.SyncCommitment(sender, line); } } }
private decimal?GetCurrencyUnitCost(POOrder subcontract, POLine subcontractLine, PXCache cache) { if (subcontractLine.ManualPrice == true || subcontractLine.UOM == null || subcontractLine.InventoryID == null || subcontract?.VendorID == null) { return(subcontractLine.CuryUnitCost.GetValueOrDefault()); } var currencyInfo = currencyinfo.Search <CurrencyInfo.curyInfoID>(subcontract.CuryInfoID); return(APVendorPriceMaint.CalculateUnitCost( cache, subcontractLine.VendorID, subcontract.VendorLocationID, subcontractLine.InventoryID, subcontractLine.SiteID, currencyInfo, subcontractLine.UOM, subcontractLine.OrderQty, subcontract.OrderDate.GetValueOrDefault(), subcontractLine.CuryUnitCost)); }
protected override bool EraseCommitment(PXCache sender, object row) { POLineUOpen poline = (POLineUOpen)row; POOrder order = (POOrder)PXParentAttribute.SelectParent(sender.Graph.Caches[detailEntity], row, typeof(POOrder)); if (order.OrderType == POOrderType.Blanket || order.OrderType == POOrderType.StandardBlanket || order.Hold == true || order.Approved != true || order.Cancelled == true || poline.Cancelled == true || poline.TaskID == null) { return(true); } else { return(GetAccountGroup(sender, row) == null); } }
protected virtual void _(Events.RowPersisted <POOrder> e) { POOrder poOrderRow = (POOrder)e.Row; PXCache cache = e.Cache; if (poOrderRow.OrderType != POOrderType.RegularOrder) { return; } if (e.TranStatus == PXTranStatus.Open) { if (e.Operation == PXDBOperation.Delete) { ClearFSSODetReferences(cache.Graph, poOrderRow); } else if (e.Operation == PXDBOperation.Update) { string poOrderOldStatus = (string)cache.GetValueOriginal <POOrder.status>(poOrderRow); bool updateLines = false; List <POLine> poLineUpdatedList = new List <POLine>(); foreach (object row in Base.Transactions.Cache.Updated) { if ((bool?)Base.Transactions.Cache.GetValue <POLine.completed>(row) != (bool?)Base.Transactions.Cache.GetValueOriginal <POLine.completed>(row)) { updateLines = true; } poLineUpdatedList.Add((POLine)row); } if (poOrderOldStatus != poOrderRow.Status || updateLines == true) { if (poOrderRow.Status == POOrderStatus.Cancelled || poOrderRow.Status == POOrderStatus.Voided) { ClearFSSODetReferences(cache.Graph, poOrderRow); } else { SharedFunctions.UpdateFSSODetReferences(cache.Graph, serviceOrderView.Cache, poOrderRow, poLineUpdatedList); } } } } }
public override INItemPlan DefaultValues(PXCache sender, INItemPlan plan_Row, object orig_Row) { string orderType = (string)sender.GetValue <POLine.orderType>(orig_Row); string orderNbr = (string)sender.GetValue <POLine.orderNbr>(orig_Row); int? inventoryID = (int?)sender.GetValue <POLine.inventoryID>(orig_Row); int? siteID = (int?)sender.GetValue <POLine.siteID>(orig_Row); bool? cancelled = (bool?)sender.GetValue <POLine.cancelled>(orig_Row); bool? completed = (bool?)sender.GetValue <POLine.completed>(orig_Row); if (orderType.IsNotIn(POOrderType.RegularOrder, POOrderType.DropShip, POOrderType.Blanket) || inventoryID == null || siteID == null || cancelled == true || completed == true) { return(null); } PXCache parentCache = sender.Graph.Caches[BqlCommand.GetItemType(_ParentNoteID)]; POOrder currentOrder = (POOrder)parentCache.Current; POOrder order = currentOrder?.OrderType == orderType && currentOrder.OrderNbr == orderNbr ? currentOrder : (POOrder)PXParentAttribute.SelectParent(sender, orig_Row, typeof(POOrder));; bool IsOnHold = IsOrderOnHold(order); string newPlanType; if (!TryCalcPlanType(sender, orig_Row, IsOnHold, out newPlanType)) { return(null); } plan_Row.PlanType = newPlanType; plan_Row.BAccountID = (int?)sender.GetValue <POLine.vendorID>(orig_Row); plan_Row.InventoryID = inventoryID; plan_Row.SubItemID = (int?)sender.GetValue <POLine.subItemID>(orig_Row); plan_Row.SiteID = siteID; plan_Row.PlanDate = (DateTime?)sender.GetValue <POLine.promisedDate>(orig_Row); plan_Row.PlanQty = (decimal?)sender.GetValue <POLine.baseOpenQty>(orig_Row); plan_Row.RefNoteID = (Guid?)parentCache.GetValue(order, _ParentNoteID.Name); plan_Row.Hold = IsOnHold; if (string.IsNullOrEmpty(plan_Row.PlanType)) { return(null); } return(plan_Row); }