public void ValidateWorkTypes(IEnumerable <DocumentDetails> documents)
{
Dictionary <int, RUTROTWorkType> availableWorkTypes = GetAvailableWorkTypes(this, this.Accessinfo.BusinessDate);
bool haveUnavailableWorkTypes = false;
for (int i = 0; i < documents.Count(); i++)
{
foreach (ARTran tran in documents.ElementAt(i).Lines)
{
ARTranRUTROT tranRR = RUTROTHelper.GetExtensionNullable <ARTran, ARTranRUTROT>(tran);
if (tranRR?.IsRUTROTDeductible == true &&
(tranRR.RUTROTItemType == RUTROTItemTypes.MaterialCost || tranRR.RUTROTItemType == RUTROTItemTypes.Service))
{
if (!availableWorkTypes.ContainsKey(tranRR.RUTROTWorkTypeID.Value))
{
haveUnavailableWorkTypes = true;
PXProcessing.SetError(i, new PXException(RUTROTMessages.CannotClaimWorkType));
}
}
}
}
if (haveUnavailableWorkTypes)
{
throw new PXException(RUTROTMessages.CannotClaimWorkType);
}
}
protected virtual void HiddenInventoryItem_RowSelected(PXCache sender, PXRowSelectedEventArgs e)
{
var item = (HiddenInventoryItem)e.Row;
if (item == null)
{
return;
}
HiddenInventoryItemRUTROT itemRR = PXCache <HiddenInventoryItem> .GetExtension <HiddenInventoryItemRUTROT>(item);
Branch branch = PXSelect <GL.Branch, Where <GL.Branch.branchID, Equal <Required <GL.Branch.branchID> > > > .Select(Base, PXAccess.GetBranchID());
BranchRUTROT branchRR = RUTROTHelper.GetExtensionNullable <Branch, BranchRUTROT>(branch);
bool allowRUTROT = branchRR?.AllowsRUTROT == true;
bool isOtherCostOrNull = itemRR.RUTROTItemType == null || itemRR.RUTROTItemType == RUTROTItemTypes.OtherCost;
PXUIFieldAttribute.SetVisible <HiddenInventoryItemRUTROT.rUTROTItemType>(Base.Item.Cache, item, allowRUTROT);
PXUIFieldAttribute.SetVisible <HiddenInventoryItemRUTROT.rUTROTType>(Base.Item.Cache, item, allowRUTROT);
PXUIFieldAttribute.SetVisible <HiddenInventoryItemRUTROT.rUTROTWorkTypeID>(Base.Item.Cache, item, allowRUTROT);
PXUIFieldAttribute.SetEnabled <HiddenInventoryItemRUTROT.rUTROTWorkTypeID>(sender, item, !isOtherCostOrNull);
PXUIFieldAttribute.SetEnabled <HiddenInventoryItemRUTROT.rUTROTItemType>(sender, item, true);
PXUIFieldAttribute.SetEnabled <HiddenInventoryItemRUTROT.rUTROTType>(sender, item, true);
if (!isOtherCostOrNull && !RUTROTHelper.IsUpToDateWorkType(itemRR.RUTROTWorkTypeID, this.Base.Accessinfo.BusinessDate ?? DateTime.Now, this.Base))
{
sender.RaiseExceptionHandling <HiddenInventoryItemRUTROT.rUTROTWorkTypeID>(item, itemRR.RUTROTWorkTypeID, new PXSetPropertyException(RUTROTMessages.ObsoleteWorkTypeWarning, PXErrorLevel.Warning));
}
else
{
sender.RaiseExceptionHandling <HiddenInventoryItemRUTROT.rUTROTWorkTypeID>(item, itemRR.RUTROTWorkTypeID, null);
}
}
public virtual void CopyOrderProc(SOOrder order, CopyParamFilter copyFilter, CopyOrderProcDelegate baseMethod)
{
RUTROT rutrotRecord = null;
PXResultset <RUTROTDistribution> rutrotDistribution = null;
SOOrderRUTROT orderRR = RUTROTHelper.GetExtensionNullable <SOOrder, SOOrderRUTROT>(order);
if (RUTROTHelper.IsRUTROTcompatibleType(order.OrderType) && orderRR?.IsRUTROTDeductible == true)
{
rutrotRecord = Rutrots.SelectSingle();
rutrotDistribution = RRDistribution.Select();
}
baseMethod(order, copyFilter);
if (RUTROTHelper.IsRUTROTcompatibleType(copyFilter.OrderType) && rutrotRecord != null && rutrotDistribution != null)
{
rutrotRecord = (RUTROT)Rutrots.Cache.CreateCopy(rutrotRecord);
rutrotRecord.RefNbr = Base.Document.Current.OrderNbr;
rutrotRecord.DocType = Base.Document.Current.OrderType;
rutrotRecord.CuryDistributedAmt = 0m;
rutrotRecord.CuryUndistributedAmt = 0m;
rutrotRecord = Rutrots.Update(rutrotRecord);
foreach (RUTROTDistribution distribution in rutrotDistribution)
{
RUTROTDistribution new_distribution = (RUTROTDistribution)RRDistribution.Cache.CreateCopy(distribution);
new_distribution.RefNbr = null;
new_distribution.DocType = null;
RRDistribution.Insert(new_distribution);
}
}
else
{
Base.Document.Cache.SetValueExt <SOOrderRUTROT.isRUTROTDeductible>(Base.Document.Current, false);
Base.Document.Update(Base.Document.Current);
}
}
protected virtual void ARInvoice_RowUpdated(PXCache sender, PXRowUpdatedEventArgs e)
{
ARInvoiceRUTROT row = RUTROTHelper.GetExtensionNullable <ARInvoice, ARInvoiceRUTROT>((ARInvoice)e.Row);
ARInvoiceRUTROT oldRow = RUTROTHelper.GetExtensionNullable <ARInvoice, ARInvoiceRUTROT>((ARInvoice)e.OldRow);
RRManager.RUTROTDeductibleUpdated(row, oldRow, Rutrots.SelectSingle());
}
public void Doc_RowUpdated(PXCache sender, PXRowUpdatedEventArgs e)
{
DocExt row = RUTROTHelper.GetExtensionNullable <Doc, DocExt>((Doc)e.Row);
DocExt oldRow = RUTROTHelper.GetExtensionNullable <Doc, DocExt>((Doc)e.OldRow);
RUTROTDeductibleUpdated(row, oldRow, Rutrots.SelectSingle());
}
public override void Initialize()
{
base.Initialize();
Base.ARDocumentList.SetProcessDelegate(
delegate(List <BalancedARDocument> list)
{
List <ARRegister> newlist = new List <ARRegister>(list.Count);
foreach (BalancedARDocument doc in list)
{
newlist.Add(doc);
}
foreach (ARRegister doc in newlist)
{
using (PXTransactionScope ts = new PXTransactionScope())
{
ARInvoiceEntry graph = PXGraph.CreateInstance <ARInvoiceEntry>();
if (RUTROTHelper.IsNeedBalancing(graph, RUTROTBalanceOn.Release))
{
BalanceProc(graph, doc);
}
ARDocumentRelease.ReleaseDoc(new List <ARRegister> {
doc
}, true);
ts.Complete();
}
}
}
);
}
public IEnumerable Release(PXAdapter adapter)
{
if (RUTROTHelper.IsNeedBalancing(Base, Base.Document.Current, RUTROTBalanceOn.Release))
{
Base.Save.Press();
ARInvoice doc = Base.Document.Current;
PXLongOperation.StartOperation(Base, delegate()
{
RUTROT rutrot = PXSelect <RUTROT, Where <RUTROT.refNbr, Equal <Required <ARInvoice.refNbr> >,
And <RUTROT.docType, Equal <Required <ARInvoice.docType> > > > > .Select(Base, doc.RefNbr, doc.DocType);
ARInvoiceEntry invoiceEntryGraph = PXGraph.CreateInstance <ARInvoiceEntry>();
RUTROTHelper.BalanceARInvoiceRUTROT(invoiceEntryGraph, doc, OnRelease: true, rutrot: rutrot);
RUTROTHelper.CreateAdjustment(Base, doc, rutrot);
Base.ReleaseProcess(new List <ARRegister> {
doc
});
});
return(new List <ARInvoice> {
Base.Document.Current
});
}
return(Base.Release(adapter));
}
public void UpdateTranDeductibleFromInventory(IRUTROTableLine line, IRUTROTable document)
{
if (line == null)
{
return;
}
InventoryItem item = PXSelect <InventoryItem, Where <InventoryItem.inventoryID, Equal <Required <InventoryItem.inventoryID> > > > .Select(Base, line.GetInventoryID());
InventoryItemRUTROT itemRR = RUTROTHelper.GetExtensionNullable <InventoryItem, InventoryItemRUTROT>(item);
if (itemRR == null)
{
return;
}
if (document?.IsRUTROTDeductible == true)
{
line.IsRUTROTDeductible = itemRR.IsRUTROTDeductible == true;
}
else
{
line.IsRUTROTDeductible = false;
}
if (itemRR.RUTROTItemType != null)
{
line.RUTROTItemType = itemRR.RUTROTItemType;
}
if (itemRR.RUTROTWorkTypeID != null)
{
line.RUTROTWorkTypeID = itemRR.RUTROTWorkTypeID;
}
}
public virtual void InvoiceCreated(ARInvoice invoice, SOOrder source, SOInvoiceEntry.InvoiceCreatedDelegate baseMethod)
{
baseMethod(invoice, source);
SOOrderRUTROT orderRR = PXCache <SOOrder> .GetExtension <SOOrderRUTROT>(source);
if (orderRR?.IsRUTROTDeductible == true && invoice != null)
{
ARInvoiceRUTROT invoiceRR = PXCache <ARInvoice> .GetExtension <ARInvoiceRUTROT>(invoice);
Base.Document.SetValueExt <ARInvoiceRUTROT.isRUTROTDeductible>(invoice, true);
Base.Document.Update(invoice);
RUTROT rutrot = PXSelect <RUTROT,
Where <RUTROT.docType, Equal <Required <SOOrder.orderType> >,
And <RUTROT.refNbr, Equal <Required <SOOrder.orderNbr> > > > > .Select(Base, source.OrderType, source.OrderNbr);
rutrot = RUTROTHelper.CreateCopy(Base.Rutrots.Cache, rutrot, invoice.DocType, invoice.RefNbr);
rutrot = Base.Rutrots.Update(rutrot);
foreach (RUTROTDistribution rutrotDetail in PXSelect <RUTROTDistribution,
Where <RUTROTDistribution.docType, Equal <Required <SOOrder.orderType> >,
And <RUTROTDistribution.refNbr, Equal <Required <SOOrder.orderNbr> > > > > .Select(Base, source.OrderType, source.OrderNbr))
{
RUTROTDistribution new_detail = (RUTROTDistribution)Base.RRDistribution.Cache.CreateCopy(rutrotDetail);
new_detail.RefNbr = null;
new_detail.DocType = null;
Base.RRDistribution.Insert(new_detail);
}
}
}
protected virtual void InventoryItem_RowSelected(PXCache sender, PXRowSelectedEventArgs e)
{
InventoryItem item = e.Row as InventoryItem;
if (item == null)
{
return;
}
InventoryItemRUTROT itemRR = PXCache <InventoryItem> .GetExtension <InventoryItemRUTROT>(item);
Branch branch = Base.CurrentBranch.SelectSingle(PXAccess.GetBranchID());
BranchRUTROT branchRR = RUTROTHelper.GetExtensionNullable <Branch, BranchRUTROT>(branch);
bool allowRUTROT = branchRR?.AllowsRUTROT == true;
bool isOtherCostOrNull = itemRR.RUTROTItemType == null || itemRR.RUTROTItemType == RUTROTItemTypes.OtherCost;
PXUIFieldAttribute.SetVisible <InventoryItemRUTROT.isRUTROTDeductible>(sender, item, allowRUTROT);
PXUIFieldAttribute.SetVisible <InventoryItemRUTROT.isRUTROTDeductible>(Base.Item.Cache, item, allowRUTROT);
PXUIFieldAttribute.SetVisible <InventoryItemRUTROT.rUTROTItemType>(Base.Item.Cache, item, allowRUTROT);
PXUIFieldAttribute.SetVisible <InventoryItemRUTROT.rUTROTType>(Base.Item.Cache, item, allowRUTROT);
PXUIFieldAttribute.SetVisible <InventoryItemRUTROT.rUTROTWorkTypeID>(Base.Item.Cache, item, allowRUTROT);
PXUIFieldAttribute.SetEnabled <InventoryItemRUTROT.rUTROTWorkTypeID>(sender, item, !isOtherCostOrNull && itemRR.IsRUTROTDeductible == true);
PXUIFieldAttribute.SetEnabled <InventoryItemRUTROT.rUTROTItemType>(sender, item, itemRR.IsRUTROTDeductible == true);
PXUIFieldAttribute.SetEnabled <InventoryItemRUTROT.rUTROTType>(sender, item, itemRR.IsRUTROTDeductible == true);
if (!isOtherCostOrNull && !RUTROTHelper.IsUpToDateWorkType(itemRR.RUTROTWorkTypeID, this.Base.Accessinfo.BusinessDate ?? DateTime.Now, this.Base))
{
sender.RaiseExceptionHandling <InventoryItemRUTROT.rUTROTWorkTypeID>(item, itemRR.RUTROTWorkTypeID, new PXSetPropertyException(RUTROTMessages.ObsoleteWorkTypeWarning, PXErrorLevel.Warning));
}
else
{
sender.RaiseExceptionHandling <InventoryItemRUTROT.rUTROTWorkTypeID>(item, itemRR.RUTROTWorkTypeID, null);
}
}
protected virtual void SOOrder_RowUpdated(PXCache sender, PXRowUpdatedEventArgs e)
{
SOOrderRUTROT row = RUTROTHelper.GetExtensionNullable <SOOrder, SOOrderRUTROT>((SOOrder)e.Row);
SOOrderRUTROT oldRow = RUTROTHelper.GetExtensionNullable <SOOrder, SOOrderRUTROT>((SOOrder)e.OldRow);
RRManager.RUTROTDeductibleUpdated(row, oldRow, Rutrots.SelectSingle());
}
public virtual void InsertSOAdjustments(SOOrder order, ARPaymentEntry docgraph, ARPayment payment, InsertSOAdjustmentsDelegate baseMethod)
{
baseMethod(order, docgraph, payment);
SOOrderRUTROT orderRR = RUTROTHelper.GetExtensionNullable <SOOrder, SOOrderRUTROT>(order);
if (orderRR.IsRUTROTDeductible == true)
{
RUTROT rutrot = PXSelect <RUTROT, Where <RUTROT.docType, Equal <Required <SOOrder.orderType> >,
And <RUTROT.refNbr, Equal <Required <SOOrder.orderNbr> > > > > .Select(Base, order.OrderType, order.OrderNbr);
foreach (SOAdjust adj in docgraph.SOAdjustments.Select())
{
SOAdjust other = PXSelectGroupBy <SOAdjust,
Where <SOAdjust.voided, Equal <False>,
And <SOAdjust.adjdOrderType, Equal <Required <SOAdjust.adjdOrderType> >,
And <SOAdjust.adjdOrderNbr, Equal <Required <SOAdjust.adjdOrderNbr> >,
And <Where <SOAdjust.adjgDocType, NotEqual <Required <SOAdjust.adjgDocType> >, Or <SOAdjust.adjgRefNbr, NotEqual <Required <SOAdjust.adjgRefNbr> > > > > > > >,
Aggregate <GroupBy <SOAdjust.adjdOrderType,
GroupBy <SOAdjust.adjdOrderNbr, Sum <SOAdjust.curyAdjdAmt, Sum <SOAdjust.adjAmt> > > > > > .Select(Base, adj.AdjdOrderType, adj.AdjdOrderNbr, adj.AdjgDocType, adj.AdjgRefNbr);
if (other == null || other.AdjdOrderNbr == null)
{
docgraph.SOAdjustments.Cache.SetValueExt <SOAdjust.curyAdjgAmt>(adj, adj.CuryAdjgAmt - rutrot.CuryTotalAmt);
docgraph.SOAdjustments.Update(adj);
}
}
}
}
protected virtual void SOLine_InventoryID_FieldVerifying(PXCache sender, PXFieldVerifyingEventArgs e)
{
if (!e.ExternalCall)
{
e.Cancel = true;
}
SOLine tran = (SOLine)e.Row;
if (tran == null)
{
return;
}
if (Base.Document.Current == null)
{
return;
}
if (e.NewValue == null)
{
return;
}
string value = Rutrots.Current?.RUTROTType;
InventoryItem item = (InventoryItem)InventoryItem.Select((int)e.NewValue);
InventoryItemRUTROT itemRR = RUTROTHelper.GetExtensionNullable <InventoryItem, InventoryItemRUTROT>(item);
if (!RUTROTHelper.IsItemMatchRUTROTType(value, item, itemRR, itemRR?.IsRUTROTDeductible == true))
{
sender.RaiseExceptionHandling <SOLine.inventoryID>(tran, item.InventoryCD, new PXSetPropertyException <SOLine.inventoryID>(RUTROTMessages.LineDoesNotMatchDoc));
e.NewValue = item.InventoryCD;
throw new PXSetPropertyException <SOLine.inventoryID>(RUTROTMessages.LineDoesNotMatchDoc);
}
}
public void Update(Doc document)
{
if (document == null)
{
return;
}
RUTROT rutrot = Rutrots.Current ?? Rutrots.SelectSingle();
DocExt documentRR = PXCache <Doc> .GetExtension <DocExt>(document);
Branch branch = PXSelect <Branch, Where <Branch.branchID, Equal <Required <Branch.branchID> > > > .Select(Base, documentRR.GetDocumentBranchID());
BranchRUTROT branchRR = RUTROTHelper.GetExtensionNullable <Branch, BranchRUTROT>(branch);
PXErrorLevel errorLevel = documentRR.GetDocumentHold() != true ? PXErrorLevel.Error : PXErrorLevel.Warning;
bool enableEdit = documentRR.GetRUTROTCompleted() != true && RUTROTHelper.CurrenciesMatch(branchRR, documentRR);
bool showSection = documentRR.IsRUTROTDeductible == true;
bool showROTSection = showSection && rutrot?.RUTROTType == RUTROTTypes.ROT;
bool isAutoDistribution = rutrot?.AutoDistribution == true;
UpdateRUTROTCheckbox(enableEdit, RUTROTHelper.IsRUTROTAllowed(branchRR, documentRR));
UpdateRUTROTSection(showSection, enableEdit, showROTSection);
UpdateDistributionControls(showSection, enableEdit, isAutoDistribution);
SetPersistingChecks(documentRR, rutrot);
WarnOnDeductionExceedsAllowance(documentRR, rutrot, errorLevel);
WarnUndistributedAmount(documentRR, rutrot, errorLevel, currencyinfo.Current ?? currencyinfo.SelectSingle());
}
public virtual void SOLine_IsRUTROTDeductible_FieldVerifying(PXCache sender, PXFieldVerifyingEventArgs e)
{
SOLine tran = (SOLine)e.Row;
if (tran == null)
{
return;
}
if (Base.Document.Current == null)
{
return;
}
if (e.NewValue == null || (bool)e.NewValue == false)
{
return;
}
string value = Rutrots.Current?.RUTROTType;
InventoryItem item = (InventoryItem)InventoryItem.Select(tran.InventoryID);
InventoryItemRUTROT itemRR = RUTROTHelper.GetExtensionNullable <InventoryItem, InventoryItemRUTROT>(item);
if (!RUTROTHelper.IsItemMatchRUTROTType(value, item, itemRR, (bool)e.NewValue))
{
sender.RaiseExceptionHandling <SOLineRUTROT.isRUTROTDeductible>(tran, false, new PXSetPropertyException <SOLineRUTROT.isRUTROTDeductible>(RUTROTMessages.LineDoesNotMatchDoc));
e.NewValue = false;
throw new PXSetPropertyException <SOLineRUTROT.isRUTROTDeductible>(RUTROTMessages.LineDoesNotMatchDoc);
}
}
protected virtual void RUTROT_RUTROTType_FieldVerifying(PXCache sender, PXFieldVerifyingEventArgs e)
{
DocExt document = RUTROTHelper.GetExtensionNullable <Doc, DocExt>(Document.Current);
RUTROT rutrot = (RUTROT)e.Row;
if (document != null && document.IsRUTROTDeductible == true)
{
string value = (string)e.NewValue;
foreach (Tran tran in Transactions.Select())
{
TranExt tranRR = RUTROTHelper.GetExtensionNullable <Tran, TranExt>(tran);
if (tranRR.GetInventoryID() != null)
{
InventoryItem item = PXSelect <InventoryItem, Where <InventoryItem.inventoryID, Equal <Required <InventoryItem.inventoryID> > > > .Select(Base, tranRR.GetInventoryID());
InventoryItemRUTROT itemRR = PXCache <InventoryItem> .GetExtension <InventoryItemRUTROT>(item);
if (!RUTROTHelper.IsItemMatchRUTROTType(value, item, itemRR, itemRR?.IsRUTROTDeductible == true))
{
sender.RaiseExceptionHandling <RUTROT.rUTROTType>(rutrot, rutrot.RUTROTType, new PXSetPropertyException <RUTROT.rUTROTType>(RUTROTMessages.LineDoesNotMatchDoc));
e.NewValue = rutrot.RUTROTType;
break;
}
}
}
}
}
protected virtual void RUTROT_RUTROTType_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e)
{
DocExt document = RUTROTHelper.GetExtensionNullable <Doc, DocExt>(Document.Current);
RUTROT rutrot = (RUTROT)e.Row;
ClearROTFields(rutrot);
ClearWorkTypes(rutrot);
RecalcFormulas(rutrot, document);
}
protected virtual void ARTran_RUTROTType_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e)
{
ARTranRUTROT row = RUTROTHelper.GetExtensionNullable <ARTran, ARTranRUTROT>((ARTran)e.Row);
if (row != null)
{
row.RUTROTWorkTypeID = null;
}
}
protected virtual void SOLine_RUTROTType_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e)
{
SOLineRUTROT row = RUTROTHelper.GetExtensionNullable <SOLine, SOLineRUTROT>((SOLine)e.Row);
if (row != null)
{
row.RUTROTWorkTypeID = null;
}
}
protected virtual void InventoryItem_RUTROTType_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e)
{
InventoryItem row = (InventoryItem)e.Row;
InventoryItemRUTROT itemRR = RUTROTHelper.GetExtensionNullable <InventoryItem, InventoryItemRUTROT>(row);
if (row != null && itemRR?.RUTROTType != (string)e.OldValue)
{
sender.SetValueExt <InventoryItemRUTROT.rUTROTWorkTypeID>(row, null);
}
}
protected virtual void HiddenInventoryItem_RUTROTItemType_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e)
{
var row = (HiddenInventoryItem)e.Row;
HiddenInventoryItemRUTROT itemRR = RUTROTHelper.GetExtensionNullable <HiddenInventoryItem, HiddenInventoryItemRUTROT>(row);
if (row != null && itemRR?.RUTROTItemType == RUTROTItemTypes.OtherCost)
{
sender.SetValueExt <HiddenInventoryItemRUTROT.rUTROTWorkTypeID>(row, null);
}
}
private static void CheckProperUnitOfMeasure(PXCache sender, PXFieldUpdatedEventArgs e)
{
InventoryItem row = (InventoryItem)e.Row;
InventoryItemRUTROT itemRR = RUTROTHelper.GetExtensionNullable <InventoryItem, InventoryItemRUTROT>(row);
if (row != null && itemRR?.RUTROTItemType == RUTROTItemTypes.Service)
{
sender.RaiseExceptionHandling <InventoryItemRUTROT.rUTROTItemType>(row, itemRR.RUTROTItemType, new PXSetPropertyException(RUTROTMessages.ServiceMustBeHour, PXErrorLevel.Warning));
}
}
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 void InventoryItem_RUTROTItemType_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e)
{
InventoryItem row = (InventoryItem)e.Row;
InventoryItemRUTROT itemRR = RUTROTHelper.GetExtensionNullable <InventoryItem, InventoryItemRUTROT>(row);
if (row != null && itemRR?.RUTROTItemType == RUTROTItemTypes.OtherCost)
{
sender.SetValueExt <InventoryItemRUTROT.rUTROTWorkTypeID>(row, null);
}
CheckProperUnitOfMeasure(sender, e);
}
protected virtual void RUTROT_RowInserted(PXCache sender, PXRowInsertedEventArgs e)
{
RUTROT rutrot = (RUTROT)e.Row;
rutrot.CuryAllowedAmt = 0m;
rutrot.CuryMaterialCost = 0m;
rutrot.CuryOtherCost = 0m;
rutrot.CuryWorkPrice = 0m;
RecalcFormulas(rutrot, RUTROTHelper.GetExtensionNullable <Doc, DocExt>(Document.Current));
}
protected virtual void SOLine_RowInserting(PXCache sender, PXRowInsertingEventArgs e)
{
if (e.Row == null)
{
return;
}
var row = (SOLine)e.Row;
SOLineRUTROT rowRR = RUTROTHelper.GetExtensionNullable <SOLine, SOLineRUTROT>(row);
rowRR.CuryRUTROTTaxAmountDeductible = decimal.Zero;
}
protected virtual void ARInvoice_RowSelected(PXCache cache, PXRowSelectedEventArgs e)
{
ARInvoiceRUTROT doc = RUTROTHelper.GetExtensionNullable <ARInvoice, ARInvoiceRUTROT>(e.Row as ARInvoice);
if (doc == null)
{
return;
}
RRManager.Update((ARInvoice)e.Row);
UpdateLinesControls(doc.IsRUTROTDeductible == true);
}
protected virtual void ARTran_RowInserting(PXCache sender, PXRowInsertingEventArgs e)
{
if (e.Row == null)
{
return;
}
ARTran row = e.Row as ARTran;
ARTranRUTROT rowRR = RUTROTHelper.GetExtensionNullable <ARTran, ARTranRUTROT>(row);
rowRR.CuryRUTROTTaxAmountDeductible = decimal.Zero;
}
protected virtual void SOOrder_IsRUTROTDeductible_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e)
{
SOOrder row = (SOOrder)e.Row;
if (row != null)
{
SOOrderRUTROT rowRR = RUTROTHelper.GetExtensionNullable <SOOrder, SOOrderRUTROT>(row);
if (rowRR.IsRUTROTDeductible == true)
{
row.BillSeparately = true;
}
}
}
protected virtual void SOLine_RUTROTItemType_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e)
{
SOLine row = (SOLine)e.Row;
SOLineRUTROT rowRR = RUTROTHelper.GetExtensionNullable <SOLine, SOLineRUTROT>(row);
if (row != null)
{
PXUIFieldAttribute.SetEnabled <SOLineRUTROT.rUTROTWorkTypeID>(sender, row, rowRR.RUTROTItemType != RUTROTItemTypes.OtherCost);
if (rowRR.RUTROTItemType == RUTROTItemTypes.OtherCost)
{
sender.SetValueExt <SOLineRUTROT.rUTROTWorkTypeID>(row, null);
}
}
}
