protected virtual void DocumentSelection_RowUpdated(PXCache cache, PXRowUpdatedEventArgs e)
{
ARRegister documentAsRegister = e.Row as ARRegister;
if (documentAsRegister != null && documentAsRegister.Voided == false && documentAsRegister.Scheduled == false)
{
ARReleaseProcess.UpdateARBalances(this, documentAsRegister, -documentAsRegister.OrigDocAmt);
documentAsRegister.Scheduled = true;
documentAsRegister.ScheduleID = Schedule_Header.Current.ScheduleID;
ARReleaseProcess.UpdateARBalances(this, documentAsRegister, documentAsRegister.OrigDocAmt);
}
DocumentSelection document = e.Row as DocumentSelection;
if (document != null &&
!string.IsNullOrWhiteSpace(document.DocType) &&
!string.IsNullOrWhiteSpace(document.RefNbr) &&
PXSelectorAttribute.Select <DocumentSelection.refNbr>(cache, document) == null)
{
cache.RaiseExceptionHandling <DocumentSelection.refNbr>(
document,
document.RefNbr,
new PXSetPropertyException(AP.Messages.ReferenceNotValid));
Document_Detail.Cache.Remove(document);
}
}
protected virtual void StatusSet(PXCache sender, ARRegister doc)
{
var docExt = doc.GetExtension <MXARRegisterExtension>();
if (docExt == null)
{
return;
}
var status = CfdiStatus.Clean;
if (docExt.CancelDate.HasValue)
{
status = CfdiStatus.Canceled;
}
else if (docExt.StampDate.HasValue)
{
status = CfdiStatus.Stamped;
}
else if (docExt.Uuid.HasValue)
{
status = CfdiStatus.Blocked;
}
else
{
status = CfdiStatus.Clean;
}
sender.SetValue <MXARRegisterExtension.stampStatus>(doc, status);
}
protected virtual void ARInvoice_UsrContractID_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e, PXFieldUpdated del)
{
// Event handler body before the base BLC event handler collection
if (del != null)
{
del(sender, e);
}
// Event handler body after the base BLC event handler collection
if (e.Row != null)
{
ARRegister row = (ARRegister)e.Row;
ARRegisterExt invoiceEX = PXCache <ARRegister> .GetExtension <ARRegisterExt>(row);
if (invoiceEX.UsrContractID != null)
{
MaxQ.Products.RBRR.XRBContrHdr contract = PXSelect <MaxQ.Products.RBRR.XRBContrHdr,
Where <MaxQ.Products.RBRR.XRBContrHdr.contractID,
Equal <Required <MaxQ.Products.RBRR.XRBContrHdr.contractID> > > > .Select(Base, invoiceEX.UsrContractID);
sender.SetValue <ARRegisterExt.usrContractCD>(e.Row, contract.ContractCD);
sender.SetValue <ARRegisterExt.usrRevisionNbr>(e.Row, contract.RevisionNbr);
sender.SetValue <ARInvoice.invoiceNbr>(e.Row, contract.ContractCDRevNbr);
}
}
}
public static void Ensure(PXGraph graph, ARRegister document)
{
if (!IsDocumentSchedulable(graph, document))
{
throw new PXException(Messages.DocumentCannotBeScheduled);
}
}
public void Persist(PersistDelegate baseMethod)
{
if (SharedFunctions.isFSSetupSet(Base) == false ||
PXAccess.FeatureInstalled <FeaturesSet.equipmentManagementModule>() == false)
{
baseMethod();
return;
}
//// Invoice
ARRegister arRegisterRow = (ARRegister)Base.Caches[typeof(ARRegister)].Current;
Dictionary <int?, int?> newEquiments = new Dictionary <int?, int?>();
SMEquipmentMaint graphSMEquipmentMaint = PXGraph.CreateInstance <SMEquipmentMaint>();
if (processEquipmentAndComponents)
{
CreateEquipments(graphSMEquipmentMaint, arRegisterRow, newEquiments);
ReplaceEquipments(graphSMEquipmentMaint, arRegisterRow);
UpgradeEquipmentComponents(graphSMEquipmentMaint, arRegisterRow, newEquiments);
CreateEquipmentComponents(graphSMEquipmentMaint, arRegisterRow, newEquiments);
ReplaceComponents(graphSMEquipmentMaint, arRegisterRow);
}
baseMethod();
}
protected virtual void ARSetup_MigrationMode_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e)
{
ARSetup row = e.Row as ARSetup;
if (row == null)
{
return;
}
bool?oldvalue = (bool?)e.OldValue;
if (row.MigrationMode == true && oldvalue != true)
{
GLTran glTransactionFromModule = PXSelect <GLTran,
Where <GLTran.module, Equal <BatchModule.moduleAR> > > .SelectSingleBound(this, null);
if (glTransactionFromModule != null)
{
sender.RaiseExceptionHandling <ARSetup.migrationMode>(row, row.MigrationMode,
new PXSetPropertyException(Common.Messages.MigrationModeActivateGLTransactionFromModuleExist, PXErrorLevel.Warning));
}
}
else if (row.MigrationMode != true && oldvalue == true)
{
ARRegister unreleasedMigratedDocument = PXSelect <ARRegister,
Where <ARRegister.released, NotEqual <True>,
And <ARRegister.isMigratedRecord, Equal <True> > > > .SelectSingleBound(this, null);
if (unreleasedMigratedDocument != null)
{
sender.RaiseExceptionHandling <ARSetup.migrationMode>(row, row.MigrationMode,
new PXSetPropertyException(Common.Messages.MigrationModeDeactivateUnreleasedMigratedDocumentExist, PXErrorLevel.Warning));
}
}
}
protected static void Accumulate(ARStatement aDest, ARRegister aSrc1, ARStatementCycle aSrc2, bool isNewDoc, bool aAgeCredits)
{
ARInvoice inv = aSrc1 as ARInvoice;
Copy(aDest, aSrc2);
if (isNewDoc)
{
aDest.EndBalance = (aDest.EndBalance ?? Decimal.Zero) + ((aSrc1.Payable ?? false) ? aSrc1.OrigDocAmt : (-aSrc1.OrigDocAmt));
aDest.CuryEndBalance = (aDest.CuryEndBalance ?? Decimal.Zero) + ((aSrc1.Payable ?? false) ? aSrc1.CuryOrigDocAmt : (-aSrc1.CuryOrigDocAmt));
}
//ARDocType.SmallCreditWO - is an invoice, but it must be processed as payment
int days = 0;
if (inv != null && inv.DocType != ARDocType.SmallCreditWO)
{
TimeSpan diff = (aDest.StatementDate.Value.Subtract(inv.DueDate.Value));
days = diff.Days;
}
else
{
TimeSpan diff = (aDest.StatementDate.Value.Subtract(aSrc1.DocDate.Value));
days = diff.Days;
}
if ((inv != null && inv.DocType != ARDocType.SmallCreditWO) || aAgeCredits)
{
Decimal docBal = ((bool)aSrc1.Paying) ? -aSrc1.DocBal.Value : aSrc1.DocBal.Value;
Decimal curyDocBal = ((bool)aSrc1.Paying) ? -aSrc1.CuryDocBal.Value : aSrc1.CuryDocBal.Value;
if (days <= 0)
{
aDest.AgeBalance00 = (aDest.AgeBalance00 ?? Decimal.Zero) + docBal;
aDest.CuryAgeBalance00 = (aDest.CuryAgeBalance00 ?? Decimal.Zero) + curyDocBal;
}
else if (!aSrc2.AgeDays00.HasValue || days <= aSrc2.AgeDays00)
{
aDest.AgeBalance01 = (aDest.AgeBalance01 ?? Decimal.Zero) + docBal;
aDest.CuryAgeBalance01 = (aDest.CuryAgeBalance01 ?? Decimal.Zero) + curyDocBal;
}
else if (!aSrc2.AgeDays01.HasValue || days <= aSrc2.AgeDays01)
{
aDest.AgeBalance02 = (aDest.AgeBalance02 ?? Decimal.Zero) + docBal;
aDest.CuryAgeBalance02 = (aDest.CuryAgeBalance02 ?? Decimal.Zero) + curyDocBal;
}
else if (!aSrc2.AgeDays02.HasValue || days <= aSrc2.AgeDays02)
{
aDest.AgeBalance03 = (aDest.AgeBalance03 ?? Decimal.Zero) + docBal;
aDest.CuryAgeBalance03 = (aDest.CuryAgeBalance03 ?? Decimal.Zero) + curyDocBal;
}
else
{
aDest.AgeBalance04 = (aDest.AgeBalance04 ?? Decimal.Zero) + docBal;
aDest.CuryAgeBalance04 = (aDest.CuryAgeBalance04 ?? Decimal.Zero) + curyDocBal;
}
}
else
{
//Payments, when credits are not aged
aDest.AgeBalance04 = aDest.AgeBalance04 - aSrc1.DocBal; //After completion we must apply resedual payments to previous buckets
aDest.CuryAgeBalance04 = aDest.CuryAgeBalance04 - aSrc1.CuryDocBal;
}
}
protected virtual void CABatchDetail_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
CABatchDetail row = (CABatchDetail)e.Row;
bool isReleased = false;
bool isVoided = false;
if (row.OrigModule == GL.BatchModule.AP)
{
APRegister apDocument = PXSelect <APRegister, Where <APRegister.docType, Equal <Required <APRegister.docType> >,
And <APRegister.refNbr, Equal <Required <APRegister.refNbr> > > > > .Select(this, row.OrigDocType, row.OrigRefNbr);
isReleased = (bool)apDocument.Released;
isVoided = (bool)apDocument.Voided;
}
if (row.OrigModule == GL.BatchModule.AR)
{
ARRegister arDocument = PXSelect <ARRegister, Where <ARRegister.docType, Equal <Required <ARRegister.docType> >,
And <ARRegister.refNbr, Equal <Required <ARRegister.refNbr> > > > > .Select(this, row.OrigDocType, row.OrigRefNbr);
isReleased = (bool)arDocument.Released;
isVoided = (bool)arDocument.Voided;
}
if (isReleased && !isVoided)
{
throw new PXException(Messages.ReleasedDocumentMayNotBeDeletedFromCABatch);
}
}
/// <summary>
/// Indicates whether the record is a child Retainage document
/// with <see cref="ARRegister.IsRetainageDocument"/> flag equal to true
/// and existing reference on the original Retainage document.
/// </summary>
public static bool IsChildRetainageDocument(this ARRegister doc)
{
return
(doc.IsRetainageDocument == true &&
!string.IsNullOrEmpty(doc.OrigDocType) &&
!string.IsNullOrEmpty(doc.OrigRefNbr));
}
public virtual ARRegister OnBeforeRelease(ARRegister ardoc)
{
var invoice = ardoc as ARInvoice;
if (invoice == null || !IsExternalTax(invoice.TaxZoneID))
{
return(ardoc);
}
if (invoice.OrigModule == GL.BatchModule.SO)
{
var rg = LazySoInvoiceEntry.Value;
rg.Clear();
rg.Document.Current = PXSelect <ARInvoice, Where <ARInvoice.docType, Equal <Required <ARInvoice.docType> >, And <ARInvoice.refNbr, Equal <Required <ARInvoice.refNbr> > > > > .Select(rg, invoice.DocType, invoice.RefNbr);
rg.Document.Current.ApplyPaymentWhenTaxAvailable = invoice.ApplyPaymentWhenTaxAvailable;
rg.SODocument.Current = PXSelect <SOInvoice, Where <SOInvoice.docType, Equal <Required <SOInvoice.docType> >, And <SOInvoice.refNbr, Equal <Required <SOInvoice.refNbr> > > > > .Select(rg, invoice.DocType, invoice.RefNbr);
return(rg.CalculateExternalTax(rg.Document.Current));
}
else
{
var rg = LazyArInvoiceEntry.Value;
rg.Clear();
rg.Document.Current = PXSelect <ARInvoice, Where <ARInvoice.docType, Equal <Required <ARInvoice.docType> >, And <ARInvoice.refNbr, Equal <Required <ARInvoice.refNbr> > > > > .Select(rg, invoice.DocType, invoice.RefNbr);
return(rg.CalculateExternalTax(rg.Document.Current));
}
}
public virtual IEnumerable ViewARDocument(PXAdapter adapter)
{
CABatchDetail doc = this.BatchPayments.Current;
if (doc != null)
{
ARRegister arDoc = PXSelect <ARRegister,
Where <ARRegister.docType, Equal <Required <ARRegister.docType> >,
And <ARRegister.refNbr, Equal <Required <ARRegister.refNbr> > > > > .Select(this, doc.OrigDocType, doc.OrigRefNbr);
if (arDoc != null)
{
ARPaymentEntry apGraph = PXGraph.CreateInstance <ARPaymentEntry>();
apGraph.Document.Current = apGraph.Document.Search <ARRegister.refNbr>(arDoc.RefNbr, arDoc.DocType);
if (apGraph.Document.Current != null)
{
throw new PXRedirectRequiredException(apGraph, true, "")
{
Mode = PXBaseRedirectException.WindowMode.NewWindow
}
}
;
}
}
return(adapter.Get());
}
public virtual void CreateEquipments(SMEquipmentMaint graphSMEquipmentMaint,
ARRegister arRegisterRow,
Dictionary <int?, int?> newEquiments)
{
var inventoryItemSet = PXSelectJoin <InventoryItem,
InnerJoin <ARTran,
On <ARTran.inventoryID, Equal <InventoryItem.inventoryID>,
And <ARTran.tranType, Equal <ARDocType.invoice> > >,
LeftJoin <SOLine,
On <SOLine.orderType, Equal <ARTran.sOOrderType>,
And <SOLine.orderNbr, Equal <ARTran.sOOrderNbr>,
And <SOLine.lineNbr, Equal <ARTran.sOOrderLineNbr> > > > > >,
Where <
ARTran.tranType, Equal <Required <ARInvoice.docType> >,
And <ARTran.refNbr, Equal <Required <ARInvoice.refNbr> >,
And <FSxEquipmentModel.eQEnabled, Equal <True>,
And <FSxARTran.equipmentAction, Equal <ListField_EquipmentAction.SellingTargetEquipment>,
And <FSxARTran.sMEquipmentID, IsNull,
And <FSxARTran.newTargetEquipmentLineNbr, IsNull,
And <FSxARTran.componentID, IsNull> > > > > > >,
OrderBy <
Asc <ARTran.tranType,
Asc <ARTran.refNbr,
Asc <ARTran.lineNbr> > > > >
.Select(Base, arRegisterRow.DocType, arRegisterRow.RefNbr);
Create_Replace_Equipments(graphSMEquipmentMaint, inventoryItemSet, arRegisterRow, newEquiments, ID.Equipment_Action.SELLING_TARGET_EQUIPMENT);
}
public static ARRegister Select(PXGraph graph, ARRegister payment)
{
if (payment == null || payment.RefNbr == null || payment.DocType == null)
{
return(null);
}
return(Select(graph, ARPaymentType.GetVoidingARDocType(payment.DocType), payment.DocType, payment.RefNbr));
}
public virtual void OpenInvoiceAndRecoverBalances(ARRegister ardoc, Action <ARRegister> baseMethod)
{
if (ardoc.IsUnderCorrection == true)
{
throw new PXException(Messages.OnlyCancelCreditMemoCanBeApplied, ardoc.RefNbr);
}
baseMethod(ardoc);
}
private static bool CheckForOpenPayments(PXGraph aGraph, string aStatementCycleID)
{
ARRegister doc = PXSelectJoin <ARPayment,
InnerJoin <Customer, On <ARPayment.customerID, Equal <Customer.bAccountID> > >,
Where <Customer.statementCycleId, Equal <Required <Customer.statementCycleId> >,
And <ARPayment.openDoc, Equal <CS.boolTrue> > > > .SelectWindowed(aGraph, 0, 1, aStatementCycleID);
return(doc != null);
}
public virtual void ReverseInvoiceProc(ARRegister doc, ReverseInvoiceProcDelegate baseMethod)
{
baseMethod(doc);
Base.Document.SetValueExt <ARInvoiceRUTROT.isRUTROTDeductible>(Base.Document.Current, false);
foreach (ARTran tran in Base.Transactions.Select())
{
Base.Transactions.SetValueExt <ARTranRUTROT.isRUTROTDeductible>(tran, false);
}
}
protected static void Copy(ARStatementDetail aDest, ARRegister aSrc)
{
aDest.DocType = aSrc.DocType;
aDest.RefNbr = aSrc.RefNbr;
aDest.BranchID = aSrc.BranchID;
aDest.DocBalance = aSrc.DocBal;
aDest.CuryDocBalance = aSrc.CuryDocBal;
aDest.IsOpen = aSrc.OpenDoc;
}
public SupplyRecord Build(TExtendedInvoice extendedInvoice, ARRegister register, ARTran tran, ARTax tranTax, Customer customer, int lineNumber)
{
var supplyRecord = BuildInternal(register, tran, tranTax, lineNumber);
_supplyRecordBuilderByCustomerData.Build(supplyRecord, register, customer);
_countryBuilder.Build(supplyRecord, extendedInvoice);
return(supplyRecord);
}
private static bool CheckForUnreleasedCharges(PXGraph aGraph, string aStatementCycleID)
{
ARRegister doc = PXSelectJoin <ARRegister,
InnerJoin <Customer, On <ARRegister.customerID, Equal <Customer.bAccountID> > >,
Where <ARRegister.docType, Equal <ARDocType.finCharge>,
And <ARRegister.released, Equal <BQLConstants.BitOff>,
And <Customer.statementCycleId, Equal <Customer.statementCycleId> > > > > .SelectWindowed(aGraph, 0, 1, aStatementCycleID);
return(doc != null);
}
public virtual void ARInvoiceCreated(ARInvoice invoice, ARRegister doc, ARInvoiceEntry.ARInvoiceCreatedDelegate baseMethod)
{
baseMethod(invoice, doc);
RUTROT rutrot = PXSelect <RUTROT, Where <RUTROT.docType, Equal <Required <ARRegister.docType> >,
And <RUTROT.refNbr, Equal <Required <ARRegister.refNbr> > > > > .Select(Base, doc.DocType, doc.RefNbr);
rutrot = RUTROTHelper.CreateCopy(Base.Rutrots.Cache, rutrot, invoice.DocType, invoice.RefNbr);
rutrot = Base.Rutrots.Update(rutrot);
}
protected virtual bool CreateAndReleaseCancellationInvoice(ARRegister doc, int index, bool isMassProcess)
{
if (doc.IsCorrection != true)
{
return(true);
}
try
{
var invoiceGraph = PXGraph.CreateInstance <SOInvoiceEntry>();
ARInvoice existingCancellationInvoice = PXSelect <ARInvoice,
Where <ARInvoice.origDocType, Equal <Current <ARInvoice.origDocType> >,
And <ARInvoice.origRefNbr, Equal <Current <ARInvoice.origRefNbr> >,
And <ARInvoice.isCancellation, Equal <True> > > > >
.SelectSingleBound(invoiceGraph, new[] { doc });
if (existingCancellationInvoice != null)
{
if (existingCancellationInvoice.Released != true)
{
throw new PXException(Messages.CancellationInvoiceExists, existingCancellationInvoice.RefNbr, doc.RefNbr);
}
else
{
return(true);
}
}
invoiceGraph.GetExtension <Correction>().CancellationInvoiceCreationOnRelease = true;
invoiceGraph.Document.Current = invoiceGraph.Document.Search <ARInvoice.refNbr>(doc.OrigRefNbr, doc.OrigDocType);
invoiceGraph.Actions[nameof(cancelInvoice)].Press();
using (var scope = new PXTransactionScope())
{
invoiceGraph.Save.Press();
invoiceGraph.ReleaseInvoiceProc(
new List <ARRegister> {
invoiceGraph.Document.Current
},
isMassProcess: false);
scope.Complete();
}
return(true);
}
catch (PXException e) when(isMassProcess)
{
PXProcessing <ARRegister> .SetError(index, e);
return(false);
}
}
protected static void AccumulateAgeBalances(ARStatement statement, ARRegister document, bool ageCredits)
{
ARInvoice inv = document as ARInvoice;
//ARDocType.SmallCreditWO - is an invoice, but it must be processed as payment
int days = 0;
if (inv != null && inv.DocType != ARDocType.SmallCreditWO)
{
TimeSpan diff = (statement.StatementDate.Value.Subtract(inv.DueDate.Value));
days = diff.Days;
}
else
{
TimeSpan diff = (statement.StatementDate.Value.Subtract(document.DocDate.Value));
days = diff.Days;
}
if ((inv != null && inv.DocType != ARDocType.SmallCreditWO) || ageCredits)
{
Decimal docBal = ((bool)document.Paying) ? -document.DocBal.Value : document.DocBal.Value;
Decimal curyDocBal = ((bool)document.Paying) ? -document.CuryDocBal.Value : document.CuryDocBal.Value;
if (days <= 0)
{
statement.AgeBalance00 = (statement.AgeBalance00 ?? Decimal.Zero) + docBal;
statement.CuryAgeBalance00 = (statement.CuryAgeBalance00 ?? Decimal.Zero) + curyDocBal;
}
else if (!statement.AgeDays00.HasValue || days <= statement.AgeDays01)
{
statement.AgeBalance01 = (statement.AgeBalance01 ?? Decimal.Zero) + docBal;
statement.CuryAgeBalance01 = (statement.CuryAgeBalance01 ?? Decimal.Zero) + curyDocBal;
}
else if (!statement.AgeDays01.HasValue || days <= statement.AgeDays02)
{
statement.AgeBalance02 = (statement.AgeBalance02 ?? Decimal.Zero) + docBal;
statement.CuryAgeBalance02 = (statement.CuryAgeBalance02 ?? Decimal.Zero) + curyDocBal;
}
else if (!statement.AgeDays02.HasValue || days <= statement.AgeDays03)
{
statement.AgeBalance03 = (statement.AgeBalance03 ?? Decimal.Zero) + docBal;
statement.CuryAgeBalance03 = (statement.CuryAgeBalance03 ?? Decimal.Zero) + curyDocBal;
}
else
{
statement.AgeBalance04 = (statement.AgeBalance04 ?? Decimal.Zero) + docBal;
statement.CuryAgeBalance04 = (statement.CuryAgeBalance04 ?? Decimal.Zero) + curyDocBal;
}
}
else
{
//Payments, when credits are not aged
statement.AgeBalance04 = statement.AgeBalance04 - document.DocBal; //After completion we must apply resedual payments to previous buckets
statement.CuryAgeBalance04 = statement.CuryAgeBalance04 - document.CuryDocBal;
}
}
public static void ReleaseARDocument(IBqlTable aTable)
{
ARRegister toProc = (ARRegister)aTable;
if (!(toProc.Released ?? false))
{
List <ARRegister> list = new List <ARRegister>(1);
list.Add(toProc);
ARDocumentRelease.ReleaseDoc(list, false);
}
}
public virtual ARRegister OnBeforeRelease(ARRegister ardoc, OnBeforeReleaseDelegate del)
{
ValidatePostBatchStatus(PXDBOperation.Update, ID.Batch_PostTo.AR, ardoc.DocType, ardoc.RefNbr);
if (del != null)
{
return(del(ardoc));
}
return(null);
}
private void UpdateOriginalSingleSchedule(ARRegister originalDocument, decimal amount)
{
foreach (PXResult <ARTran, InventoryItem, INComponent, DRDeferredCode> item in ARTransactionWithItems.Select())
{
ARTran artran = item;
InventoryItem inventoryItem = item;
INComponent component = item;
DRDeferredCode deferredCode = item;
UpdateOriginalSchedule(artran, deferredCode, amount, originalDocument.DocDate, originalDocument.FinPeriodID, originalDocument.CustomerID, originalDocument.CustomerLocationID);
}
}
protected void _(Events.FieldSelecting <ARTranForDirectInvoiceExt.usrGUINbr> e)
{
var row = e.Row as ARTranForDirectInvoice;
if (row != null)
{
ARRegister register = SelectFrom <ARRegister> .Where <ARRegister.docType.IsEqual <@P.AsString>
.And <ARRegister.refNbr.IsEqual <@P.AsString> > > .View.ReadOnly.Select(Base, row.TranType, row.RefNbr);
e.ReturnValue = register.GetExtension <ARRegisterExt>().UsrGUINbr;
}
}
private ComplianceDocumentReference CreateComplianceDocumentReference(ARRegister invoice)
{
var reference = new ComplianceDocumentReference
{
ComplianceDocumentReferenceId = Guid.NewGuid(),
Type = invoice.DocType,
ReferenceNumber = invoice.RefNbr,
RefNoteId = invoice.NoteID
};
return(DocumentReference.Insert(reference));
}
public virtual void CloseInvoiceAndClearBalances(ARRegister ardoc, int?adjNbr, CloseInvoiceAndClearBalancesDelegate baseMethod)
{
RSSVWorkOrder order = SelectFrom <RSSVWorkOrder> .Where <RSSVWorkOrder.invoiceNbr.IsEqual <ARRegister.refNbr.FromCurrent> > .View.SelectSingleBound(Base, new[] { ardoc });
if (order != null)
{
order.Status = WorkOrderStatusConstants.Paid;
UpdWorkOrder.Update(order);
Base.Persist();
}
baseMethod(ardoc, adjNbr);
}
public override void UpdateARBalances(PXCache cache, object newRow, object oldRow)
{
if (oldRow != null)
{
ARRegister oldARRow = Document.Cache.GetMain((Document)oldRow) as ARRegister;
ARReleaseProcess.UpdateARBalances(cache.Graph, (ARRegister)oldARRow, -((ARRegister)oldARRow).OrigDocAmt);
}
if (newRow != null)
{
ARRegister newARRow = Document.Cache.GetMain((Document)newRow) as ARRegister;
ARReleaseProcess.UpdateARBalances(cache.Graph, (ARRegister)newARRow, ((ARRegister)newARRow).OrigDocAmt);
}
}
public static bool Verify(PXGraph graph, ARRegister payment)
{
bool? result = null;
object value = null;
new HasUnreleasedVoidPayment <ARRegister.docType, ARRegister.refNbr>().Verify(
graph.Caches[payment.GetType()],
payment,
new List <object>(0),
ref result,
ref value);
return(result == true);
}
