protected void grid_OnRowDataBound(object sender, PX.Web.UI.PXGridRowEventArgs e)
{
var graph = (StoragePlaceEnq)((PXGrid)sender).DataGraph;
StoragePlaceStatus tran;
PXResult record = e.Row.DataItem as PXResult;
if (record != null)
{
tran = (StoragePlaceStatus)record[typeof(StoragePlaceStatus)];
}
else
{
tran = e.Row.DataItem as StoragePlaceStatus;
}
if (tran == null)
{
return;
}
//if (graph.Filter.Current.With(_ => _.ExpandByLotSerialNbr) == true && tran.IsOverall == true)
//{
// e.Row.Style.CssClass = PickCss.Splitting;
//}
//else
//{
// e.Row.Style.Reset();
//}
}
protected virtual FinPeriod BuildFinPeriod(int?organizationID, object record)
{
if (organizationID == FinPeriod.organizationID.MasterValue &&
MasterPeriodBasedOnOrganizationPeriods)
{
MasterFinPeriod baseFinPeriod = (record as PXResult).GetItem <MasterFinPeriod>();
return(new FinPeriod()
{
FinPeriodID = baseFinPeriod.FinPeriodID,
StartDateUI = baseFinPeriod.StartDateUI,
EndDateUI = baseFinPeriod.EndDateUI,
Descr = baseFinPeriod.Descr,
NoteID = baseFinPeriod.NoteID
});
}
else
{
PXResult resultRecord = record as PXResult;
FinPeriod orgFinPeriod = resultRecord != null
? resultRecord.GetItem <FinPeriod>()
: (FinPeriod)record;
return(new FinPeriod
{
FinPeriodID = orgFinPeriod.FinPeriodID,
StartDateUI = orgFinPeriod.StartDateUI,
EndDateUI = orgFinPeriod.EndDateUI,
Descr = orgFinPeriod.Descr,
NoteID = orgFinPeriod.NoteID
});
}
}
public static int?PeriodMinusPeriod(PXGraph graph, string FiscalPeriodID1, string FiscalPeriodID2, int?BookID)
{
// TODO: AC-106141
// Use BranchID (OrganizationID) passed as parameter
int count = PXSelect <
FABookPeriod,
Where <FABookPeriod.bookID, Equal <Required <FABookPeriod.bookID> >,
And <Where <FABookPeriod.finPeriodID, Equal <Required <FABookPeriod.finPeriodID> >,
Or <FABookPeriod.finPeriodID, Equal <Required <FABookPeriod.finPeriodID> > > > > > >
.Select(graph, BookID, FiscalPeriodID1, FiscalPeriodID2)
.Count;
if (count < 2 && string.Equals(FiscalPeriodID1, FiscalPeriodID2) == false)
{
throw new PXException(Messages.NoCalendarDefined);
}
// TODO: AC-106141
// Use BranchID (OrganizationID) passed as parameter
PXResult res = PXSelectGroupBy <
FABookPeriod,
Where <FABookPeriod.bookID, Equal <Required <FABookPeriod.bookID> >,
And <FABookPeriod.finPeriodID, LessEqual <Required <FABookPeriod.finPeriodID> >,
And <FABookPeriod.finPeriodID, Greater <Required <FABookPeriod.finPeriodID> >,
And <FABookPeriod.endDate, Greater <FABookPeriod.startDate> > > > >,
Aggregate <
GroupBy <FABookPeriod.bookID, Count> > >
.Select(graph, BookID, FiscalPeriodID1, FiscalPeriodID2);
return(res != null ? res.RowCount : null);
}
/// <summary> SOPackageDetailEx_qty Updated Event </summary>
protected void _(Events.FieldUpdated <SOPackageDetail.qty> e)
{
var _splitLineNbr = e.Cache.GetExtension <SOPackageDetailExt>(e.Row).UsrShipmentSplitLineNbr;
if (e.NewValue == null || _splitLineNbr == null)
{
return;
}
if ((decimal?)e.NewValue == 0)
{
e.Cache.SetValueExt <SOPackageDetail.weight>(e.Row, 0);
return;
}
var row = (SOPackageDetailEx)e.Row;
var _shipLine = Base.Transactions.Cache.Cached.RowCast <SOShipLine>().Where(x => x.LineNbr == _splitLineNbr).SingleOrDefault();
PXResult <InventoryItem, CSAnswers> _sotockItemData = GetStockInfo(_shipLine.InventoryID.Value, _QTYINBOX);
decimal _qtyInBox = 1;
try
{
_qtyInBox = decimal.Parse(_sotockItemData.GetItem <CSAnswers>()?.Value);
}
catch (Exception)
{
_qtyInBox = 1;
}
e.Cache.SetValueExt <SOPackageDetail.weight>(e.Row, row.Qty * _sotockItemData.GetItem <InventoryItem>().BaseItemWeight / _qtyInBox);
}
protected virtual IEnumerable viewHandler()
{
if (intView == null)
{
intView = CreateIntView(View.Graph);
}
int startRow = PXView.StartRow;
int num = 0;
PXDelegateResult pXDelegateResult = new PXDelegateResult();
foreach (object obj in intView.Select(null, null, PXView.Searches, PXView.SortColumns, PXView.Descendings, PXView.Filters, ref startRow, PXView.MaximumRows, ref num))
{
var statu = PXResult.Unwrap <RowToSelect>(obj);
var statu1 = statu;
var statu2 = (Cache.Locate(statu) as RowToSelect);
if (statu2 != null)
{
bool?value = (Cache.GetValue(statu2, Selected) as bool?);
if (value.GetValueOrDefault() & value.HasValue)
{
Cache.RestoreCopy(statu2, statu);
Cache.SetValue(statu2, Selected, true);
statu1 = statu2;
}
}
pXDelegateResult.Add(statu1);
}
PXView.StartRow = 0;
if (PXView.ReverseOrder)
{
pXDelegateResult.Reverse();
}
pXDelegateResult.IsResultSorted = true;
return(pXDelegateResult);
}
public virtual IEnumerable export(PXAdapter adapter)
{
CheckPrevOperation();
CABatch document = this.Document.Current;
if (document != null && document.Released == true && document.Hold == false)
{
PXResult <PaymentMethod, SYMapping> res = (PXResult <PaymentMethod, SYMapping>) PXSelectJoin <PaymentMethod,
LeftJoin <SYMapping, On <SYMapping.mappingID, Equal <PaymentMethod.aPBatchExportSYMappingID> > >,
Where <PaymentMethod.paymentMethodID, Equal <Optional <CABatch.paymentMethodID> > > > .Select(this, document.PaymentMethodID);
PaymentMethod pt = res;
SYMapping map = res;
if (pt != null && pt.APCreateBatchPayment == true && pt.APBatchExportSYMappingID != null && map != null)
{
string defaultFileName = this.GenerateFileName(document);
PXLongOperation.StartOperation(this, delegate()
{
PX.Api.SYExportProcess.RunScenario(map.Name,
SYMapping.RepeatingOption.All,
true,
true,
new PX.Api.PXSYParameter(ExportProviderParams.FileName, defaultFileName),
new PX.Api.PXSYParameter(ExportProviderParams.BatchNbr, document.BatchNbr));
});
}
else
{
throw new PXException(Messages.CABatchExportProviderIsNotConfigured);
}
}
return(adapter.Get());
}
protected virtual IEnumerable documentList()
{
foreach (PXResult <APInvoiceExt> result in PXSelect <APInvoiceExt,
Where2 <
Where <Current2 <APRetainageFilter.vendorID>, IsNull, Or <APInvoiceExt.vendorID, Equal <Current2 <APRetainageFilter.vendorID> > > >,
And2 <Where <Current2 <APRetainageFilter.projectID>, IsNull, Or <APInvoiceExt.projectID, Equal <Current2 <APRetainageFilter.projectID> > > >,
And2 <Where <Current2 <APRetainageFilter.branchID>, IsNull, Or <APInvoiceExt.branchID, Equal <Current2 <APRetainageFilter.branchID> > > >,
And2 <Where <Current <APRetainageFilter.showBillsWithOpenBalance>, Equal <True>,
Or <Where <APInvoiceExt.curyDocBal, Equal <decimal0>,
And <Current <APRetainageFilter.showBillsWithOpenBalance>, NotEqual <True> > > > >,
And <APInvoiceExt.curyRetainageUnreleasedAmt, Greater <decimal0>,
And <APInvoiceExt.curyRetainageTotal, Greater <decimal0>,
And <APInvoiceExt.docType, Equal <APDocType.invoice>,
And <APInvoiceExt.retainageApply, Equal <True>,
And <APInvoiceExt.released, Equal <True>,
And <APInvoiceExt.docDate, LessEqual <Current <APRetainageFilter.docDate> > > > > > > > > > > >,
OrderBy <Asc <APInvoiceExt.refNbr> > > .Select(this))
{
APInvoiceExt doc = result;
PXResult <APRetainageInvoice> NotReleasedRetainageInvoice = PXSelect <APRetainageInvoice,
Where <APRetainageInvoice.isRetainageDocument, Equal <True>,
And <APRetainageInvoice.origDocType, Equal <Required <APInvoice.docType> >,
And <APRetainageInvoice.origRefNbr, Equal <Required <APInvoice.refNbr> >,
And <APRetainageInvoice.released, NotEqual <True> > > > > > .SelectSingleBound(this, null, doc.DocType, doc.RefNbr);
if (NotReleasedRetainageInvoice == null)
{
yield return(doc);
}
}
}
private bool DoesJointPayeeInternalIdMatchGenerationKey(PXResult jointPayeePayment)
{
var jointPayee = jointPayeePayment.GetItem <JointPayee>();
return(jointPayee.JointPayeeInternalId != null &&
jointPayee.JointPayeeInternalId == generationKey.JointPayeeVendorId);
}
protected virtual void FixedAsset_RowPersisting(PXCache sender, PXRowPersistingEventArgs e)
{
FixedAsset header = (FixedAsset)e.Row;
if (header == null)
{
return;
}
if (header.Depreciable == true && (header.UsefulLife ?? 0m) == 0m)
{
sender.RaiseExceptionHandling <FixedAsset.usefulLife>(header, header.UsefulLife, new PXSetPropertyException(CS.Messages.Entry_GT, PXErrorLevel.Error, 0m));
}
if (header.Active != true)
{
PXSelectBase <FixedAsset> selectStatement = new PXSelectJoin <FixedAsset,
InnerJoin <FADetails, On <FixedAsset.assetID, Equal <FADetails.assetID> > >,
Where <FixedAsset.classID, Equal <Required <FixedAsset.classID> >,
And <Where <FADetails.status, Equal <FixedAssetStatus.active> > > > >(this);
PXResult <FixedAsset, FADetails> res = (PXResult <FixedAsset, FADetails>)selectStatement.View.SelectSingle(header.AssetID);
if ((FixedAsset)res != null)
{
sender.RaiseExceptionHandling <FixedAsset.active>(header, header.Active, new PXSetPropertyException(Messages.FixedAssetClassCannotBeDeactivated));
}
}
}
private (List <object> PerUnitInclusiveTaxes, List <object> PerUnitLevel1Taxes) GetNonExcludedPerUnitTaxesByCalculationLevel(List <object> allPerUnitTaxes)
{
List <object> perUnitLevel1Taxes = new List <object>(capacity: allPerUnitTaxes.Count);
List <object> perUnitInclusiveTaxes = new List <object>(capacity: allPerUnitTaxes.Count);
foreach (object taxRow in allPerUnitTaxes)
{
Tax perUnitTax = PXResult.Unwrap <Tax>(taxRow);
if (perUnitTax.TaxCalcLevel2Exclude != false)
{
continue;
}
switch (perUnitTax.TaxCalcLevel)
{
case CSTaxCalcLevel.CalcOnItemQtyInclusively:
perUnitInclusiveTaxes.Add(taxRow);
continue;
case CSTaxCalcLevel.CalcOnItemQtyExclusively:
perUnitLevel1Taxes.Add(taxRow);
continue;
}
}
return(perUnitInclusiveTaxes, perUnitLevel1Taxes);
}
public virtual void ARTranSplit_LotSerialNbr_FieldDefaulting(PXCache sender, PXFieldDefaultingEventArgs e)
{
PXResult <InventoryItem, INLotSerClass> item = ReadInventoryItem(sender, ((ARTranAsSplit)e.Row).InventoryID);
if (item != null)
{
object InvtMult = ((ARTranAsSplit)e.Row).InvtMult;
if (InvtMult == null)
{
sender.RaiseFieldDefaulting <ARTranAsSplit.invtMult>(e.Row, out InvtMult);
}
INLotSerTrack.Mode mode = GetTranTrackMode((ILSMaster)e.Row, item);
if (mode == INLotSerTrack.Mode.None || (mode & INLotSerTrack.Mode.Create) > 0)
{
ILotSerNumVal lotSerNum = ReadLotSerNumVal(sender, item);
foreach (ARTranAsSplit lssplit in INLotSerialNbrAttribute.CreateNumbers <ARTranAsSplit>(sender, item, lotSerNum, mode, 1m))
{
e.NewValue = lssplit.LotSerialNbr;
e.Cancel = true;
}
}
//otherwise default via attribute
}
}
public virtual void RenumberAll(IComparer <PXResult> comparer)
{
PXResultset <Table> res = Select();
List <PXResult> list = new List <PXResult>(res.Count);
foreach (PXResult item in res)
{
list.Add(item);
}
list.Sort(comparer);
int sortorder = 0;
foreach (PXResult item in list)
{
sortorder++;
Table line = PXResult.Unwrap <Table>(item);
if (line.SortOrder != sortorder)
{
Cache.SetValue(line, nameof(ISortOrder.SortOrder), sortorder);
Cache.SmartSetStatus(line, PXEntryStatus.Updated);
Cache.IsDirty = true;
}
}
View.Clear(); //clears stored cache so that grid lines are reordered.
}
void ICustomerDataReader.ReadData(Dictionary <string, string> aData)
{
PXResult <Customer, CR.Address, CR.Contact> result = null;
if (_customerID != 0)
{
result = (PXResult <Customer, CR.Address, CR.Contact>) PXSelectJoin <Customer,
LeftJoin <CR.Address, On <CR.Address.addressID, Equal <Customer.defBillAddressID> >,
LeftJoin <CR.Contact, On <CR.Contact.contactID, Equal <Customer.defBillContactID> > > >,
Where <Customer.bAccountID, Equal <Required <Customer.bAccountID> > > > .Select(_graph, _customerID);
}
else if (!string.IsNullOrEmpty(_customerCD))
{
result = (PXResult <Customer, CR.Address, CR.Contact>) PXSelectJoin <Customer,
LeftJoin <CR.Address, On <CR.Address.addressID, Equal <Customer.defBillAddressID> >,
LeftJoin <CR.Contact, On <CR.Contact.contactID, Equal <Customer.defBillContactID> > > >,
Where <Customer.acctCD, Equal <Required <Customer.acctCD> > > > .Select(_graph, _customerCD);
}
PXResult <CustomerPaymentMethod> pmResult = PXSelect <CustomerPaymentMethod,
Where <CustomerPaymentMethod.pMInstanceID, Equal <Required <CustomerPaymentMethod.pMInstanceID> > > >
.Select(_graph, _pminstanceID);
if (result != null)
{
CustomerPaymentMethod customerPaymentMethod = pmResult;
Customer customer = result;
Address billAddress = null;
Address address = PXSelect <Address, Where <Address.addressID, Equal <Required <Address.addressID> > > > .Select(_graph,
customerPaymentMethod.BillAddressID);
billAddress = address ?? result;
Contact billContact = null;
Contact contact = PXSelect <Contact, Where <CR.Contact.contactID, Equal <Required <Contact.contactID> > > > .Select(_graph,
customerPaymentMethod.BillContactID);
billContact = contact ?? result;
aData[key_CustomerCD] = (_prefixForCustomerCD ?? String.Empty) + (customer.AcctCD ?? String.Empty);
aData[key_CustomerName] = customer.AcctName;
if (pmResult != null && !string.IsNullOrEmpty(((CustomerPaymentMethod)pmResult).CustomerCCPID))
{
aData[Key_Customer_CCProcessingID] = ((CustomerPaymentMethod)pmResult).CustomerCCPID;
}
aData[key_Country] = billAddress?.CountryID;
aData[key_State] = billAddress?.State;
aData[key_City] = billAddress?.City;
aData[key_Address] = CCProcessingHelper.ExtractStreetAddress(billAddress);
aData[key_PostalCode] = billAddress?.PostalCode;
aData[key_Customer_FirstName] = billContact?.FirstName;
aData[key_Customer_LastName] = billContact?.LastName;
aData[key_Phone] = billContact?.Phone1;
aData[key_Fax] = billContact?.Fax;
aData[key_Email] = billContact?.EMail;
}
}
protected void grid_OnRowDataBound(object sender, PX.Web.UI.PXGridRowEventArgs e)
{
GLTranReclHist tran;
PXResult record = e.Row.DataItem as PXResult;
if (record != null)
{
tran = (GLTranReclHist)record[typeof(GLTranReclHist)];
}
else
{
tran = e.Row.DataItem as GLTranReclHist;
}
if (tran == null)
{
return;
}
if (tran.IsCurrent == true)
{
e.Row.Style.CssClass = "CssCurrentLine";
}
}
public override object Map(KCMapObjectRequest request)
{
foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(request.Target))
{
PXResult <KCMapping> exportMappingRow = _mappingMaint.ExportMappingRow.Select(request.EntityType, property.Name, request.ViewName).FirstOrDefault();
if (exportMappingRow == null)
{
continue;
}
KCMapping mapping = exportMappingRow.GetItem <KCMapping>();
KCAcumaticaMappingField acumaticaField = exportMappingRow.GetItem <KCAcumaticaMappingField>();
string formula = mapping.RuleType == KCRuleTypesConstants.Expression
? mapping.SourceExpression
: acumaticaField?.FieldName;
IDictionary <string, object> mappingValue = GetMappingValue(request, property);
if (mappingValue == null || (property.PropertyType != typeof(bool?) && property.PropertyType != typeof(bool) && mappingValue.GetValue(formula) == null))
{
continue;
}
MapField(request.EntityType, request.Target, property, mappingValue, formula);
}
return(request.Target);
}
protected virtual void SPWikiCategoryTags_RowUpdated(PXCache sender, PXRowUpdatedEventArgs e)
{
SPWikiCategoryTags row = e.Row as SPWikiCategoryTags;
if (row == null || row.PageName == null)
{
return;
}
PXResult <WikiPage, WikiPageLanguage> currentrow = (PXResult <WikiPage, WikiPageLanguage>) PXSelectJoin <WikiPage,
LeftJoin <WikiPageLanguage, On <WikiPage.pageID, Equal <WikiPageLanguage.pageID> > >,
Where <WikiPage.name, Equal <Required <WikiPage.name> > > > .SelectWindowed(this, 0, 1, row.PageName);
if (currentrow != null)
{
WikiPage wp = currentrow[typeof(WikiPage)] as WikiPage;
WikiPageLanguage wpl = currentrow[typeof(WikiPageLanguage)] as WikiPageLanguage;
if (wp != null)
{
row.PageName = wp.Name;
row.PageID = wp.PageID;
}
if (wpl != null)
{
row.PageTitle = wpl.Title;
}
else
{
row.PageTitle = row.PageName;
}
}
}
protected virtual void TaxTotal_CuryTaxableAmt_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e)
{
TaxTotal taxdetOrig = sender.GetExtension <TaxTotal>(e.Row);
if (taxdetOrig == null)
{
return;
}
decimal newValue = (decimal)(sender.GetValue(e.Row, typeof(TaxTotal.curyTaxableAmt).Name) ?? 0m);
decimal oldValue = (decimal)(e.OldValue ?? 0m);
if (CurrentDocument.TaxCalc != TaxCalc.NoCalc && e.ExternalCall &&
newValue != oldValue)
{
foreach (object taxrow in SelectTaxes <
Where <Tax.taxID, Equal <Required <Tax.taxID> > > >(sender.Graph, null, PXTaxCheck.RecalcTotals, taxdetOrig.RefTaxID))
{
TaxTotal taxdet = sender.GetExtension <TaxTotal>(((PXResult)taxrow)[0]);
Tax tax = PXResult.Unwrap <Tax>(taxrow);
TaxRev taxrev = PXResult.Unwrap <TaxRev>(taxrow);
CalculateTaxSumTaxAmt(taxdet, tax, taxrev);
}
}
}
public override void ProccessItem(PXGraph graph, TPrimary item)
{
PXCache cache = graph.Caches[typeof(TPrimary)];
TPrimary newItem = (TPrimary)cache.CreateInstance();
PXCache <TPrimary> .RestoreCopy(newItem, item);
string entityType = CSAnswerType.GetAnswerType(cache.GetItemType());
string entityID = CSAnswerType.GetEntityID(cache.GetItemType());
PXView primaryView = graph.Views[graph.PrimaryView];
object[] searches = new object[primaryView.Cache.BqlKeys.Count];
string[] sortcolumns = new string[primaryView.Cache.BqlKeys.Count];
for (int i = 0; i < cache.BqlKeys.Count(); i++)
{
sortcolumns[i] = cache.BqlKeys[i].Name;
searches[i] = cache.GetValue(newItem, sortcolumns[i]);
}
int startRow = 0, totalRows = 0;
List <object> result = primaryView.Select(null, null, searches, sortcolumns, null, null, ref startRow, 1, ref totalRows);
newItem = (TPrimary)cache.CreateCopy(PXResult.Unwrap <TPrimary>(result[0]));
foreach (FieldValue fieldValue in Fields.Cache.Cached.Cast <FieldValue>().Where(o => o.AttributeID == null && o.Selected == true))
{
PXFieldState state = cache.GetStateExt(newItem, fieldValue.Name) as PXFieldState;
PXIntState intState = state as PXIntState;
PXStringState strState = state as PXStringState;
if ((intState != null && intState.AllowedValues != null && intState.AllowedValues.Length > 0 &&
intState.AllowedValues.All(v => v != int.Parse(fieldValue.Value)))
||
(strState != null && strState.AllowedValues != null && strState.AllowedValues.Length > 0 &&
strState.AllowedValues.All(v => v != fieldValue.Value)))
{
throw new PXSetPropertyException(ErrorMessages.UnallowedListValue, fieldValue.Value, fieldValue.Name);
}
if (state != null && !Equals(state.Value, fieldValue.Value))
{
cache.SetValueExt(newItem, fieldValue.Name, fieldValue.Value);
cache.Update(newItem);
}
result = primaryView.Select(null, null, searches, sortcolumns, null, null, ref startRow, 1, ref totalRows);
newItem = (TPrimary)cache.CreateCopy(PXResult.Unwrap <TPrimary>(result[0]));
}
PXCache attrCache = cache.Graph.Caches[typeof(CSAnswers)];
foreach (FieldValue attrValue in Attributes.Cache.Cached.Cast <FieldValue>().Where(o => o.AttributeID != null && o.Selected == true))
{
CSAnswers attr = (CSAnswers)attrCache.CreateInstance();
attr.AttributeID = attrValue.AttributeID;
attr.EntityID = cache.GetValue(newItem, entityID) as int?;
attr.EntityType = entityType;
attr.Value = attrValue.Value;
attrCache.Update(attr);
}
}
public override void CacheAttached(PXCache sender)
{
base.CacheAttached(sender);
PXView outerview = new PXView(sender.Graph, true, _Select);
PXView view = sender.Graph.Views[_ViewName] = new PXView(sender.Graph, true, _Select, (PXSelectDelegate) delegate()
{
int startRow = PXView.StartRow;
int totalRows = 0;
List <object> res;
using (new PXReadBranchRestrictedScope())
{
res = outerview.Select(PXView.Currents, PXView.Parameters, PXView.Searches, PXView.SortColumns, PXView.Descendings, PXView.Filters, ref startRow, PXView.MaximumRows, ref totalRows);
PXView.StartRow = 0;
}
PXCache cache = outerview.Graph.Caches[typeof(INSite)];
return(res.FindAll((item) =>
{
return _RestrictedSelect.Meet(cache, item is PXResult ? PXResult.Unwrap <INSite>(item) : item);
}));
});
if (_DirtyRead)
{
view.IsReadOnly = false;
}
}
/// <summary> Get Current Value to Report Parameter </summary>
public Dictionary <string, string> GetCurrentRowToParameter(bool isOutter = false)
{
var _CurrentRow = this.GetCacheCurrent <LumShipmentPlan>().Current;
PXResultset <InventoryItem> data =
SelectFrom <InventoryItem>
.LeftJoin <INItemXRef> .On <INItemXRef.inventoryID.IsEqual <InventoryItem.inventoryID> >
.LeftJoin <CSAnswers> .On <InventoryItem.noteID.IsEqual <CSAnswers.refNoteID> >
.Where <InventoryItem.inventoryID.IsEqual <P.AsInt> > .View.Select(this, _CurrentRow.InventoryID);
PXResult <AMProdItem, SOLine> soData =
(PXResult <AMProdItem, SOLine>)SelectFrom <AMProdItem>
.LeftJoin <SOLine> .On <AMProdItemExt.usrSOLineNbr.IsEqual <SOLine.lineNbr>
.And <AMProdItemExt.usrSOOrderNbr.IsEqual <SOLine.orderNbr> >
.And <AMProdItemExt.usrSOOrderType.IsEqual <SOLine.orderType> > >
.Where <AMProdItem.prodOrdID.IsEqual <P.AsString> > .View.Select(this, _CurrentRow.ProdOrdID);
var ENDCDescr = new PXGraph().Select <CSAttributeDetail>().Where(x => x.ValueID == _CurrentRow.Customer).FirstOrDefault()?.Description;
ENDCDescr = ENDCDescr ?? _CurrentRow.Customer;
Dictionary <string, string> parameters = new Dictionary <string, string>
{
["ShipmentPlanID"] = _CurrentRow.ShipmentPlanID,
["ProdOrdID"] = _CurrentRow.ProdOrdID,
["Customer"] = ENDCDescr,
["CustomerPartNo"] = soData.GetItem <SOLine>()?.AlternateID,
["Description"] = data.FirstOrDefault().GetItem <InventoryItem>().Descr,
["Resistor"] = data.RowCast <CSAnswers>().Where(x => x.AttributeID == "RESISTOR").FirstOrDefault()?.Value,
["DATE"] = _CurrentRow.PlannedShipDate?.ToString("yyyy/MM/dd")
};
return(parameters);
}
public virtual void InvoiceOrder(DateTime invoiceDate, PXResult <SOOrderShipment, SOOrder, CurrencyInfo, SOAddress, SOContact, SOOrderType> order, PXResultset <SOShipLine, SOLine> details, Customer customer, DocumentList <ARInvoice, SOInvoice> list, InvoiceOrderDelegate baseMethod)
{
baseMethod(invoiceDate, order, details, customer, list);
SOOrder soorder = (SOOrder)order;
SOOrderRUTROT orderRR = PXCache <SOOrder> .GetExtension <SOOrderRUTROT>(soorder);
if (orderRR?.IsRUTROTDeductible == true && Base.Document.Current != null)
{
Base.Document.SetValueExt <ARInvoiceRUTROT.isRUTROTDeductible>(Base.Document.Current, true);
Base.Document.Update(Base.Document.Current);
RUTROT rutrot = PXSelect <RUTROT, Where <RUTROT.docType, Equal <Required <SOOrder.orderType> >,
And <RUTROT.refNbr, Equal <Required <SOOrder.orderNbr> > > > > .Select(Base, soorder.OrderType, soorder.OrderNbr);
rutrot = (RUTROT)Base.Rutrots.Cache.CreateCopy(rutrot);
rutrot.DocType = Base.Document.Current.DocType;
rutrot.RefNbr = Base.Document.Current.RefNbr;
rutrot.CuryDistributedAmt = 0m;
rutrot.CuryUndistributedAmt = 0m;
rutrot = Base.Rutrots.Update(rutrot);
RecalcFormulas(rutrot, PXCache <ARInvoice> .GetExtension <ARInvoiceRUTROT>(Base.Document.Current));
foreach (RUTROTDistribution rutrotDetail in PXSelect <RUTROTDistribution, Where <RUTROTDistribution.docType, Equal <Required <SOOrder.orderType> >,
And <RUTROTDistribution.refNbr, Equal <Required <SOOrder.orderNbr> > > > > .Select(Base, soorder.OrderType, soorder.OrderNbr))
{
RUTROTDistribution new_detail = (RUTROTDistribution)Base.RRDistribution.Cache.CreateCopy(rutrotDetail);
new_detail.RefNbr = null;
new_detail.DocType = null;
Base.RRDistribution.Insert(new_detail);
}
Base.Save.Press();
}
}
protected IEnumerable <TRefItem> RefItemsForAction(TInstance leaveInstance, ICollection <TInstance> deletingInstances, bool forDeleting)
{
// Constraint
if (deletingInstances.Count < 1)
{
yield break;
}
// Compose command
BqlCommand command = GetCommand(leaveInstance, deletingInstances, forDeleting);
if (command == null)
{
yield break;
}
// Compose parameters
object[] deletingIDs = GetInstancesKeys(leaveInstance, deletingInstances, forDeleting);
// Select
PXView view = new PXView(Graph, false, command);
foreach (object item in view.SelectMulti(deletingIDs))
{
PXResult record = item as PXResult;
if (record != null)
{
yield return(record[typeof(TRefItem)] as TRefItem);
}
else
{
yield return(item as TRefItem);
}
}
}
protected void PackGrid_RowDataBound(object sender, PX.Web.UI.PXGridRowEventArgs e)
{
var shipLine = (SOShipLineSplit)PXResult.UnwrapMain(e.Row.DataItem);
if (shipLine == null)
{
return;
}
SOPickPackShipSetup setup = ((PX.Web.UI.PXGrid)sender).DataGraph.GetExtension <PickPackShip>().Setup.With(s => s.Current ?? s.Select());
bool noPick = setup.ShowPickTab == false;
if (shipLine.PickedQty > 0 && shipLine.PackedQty > (noPick ? shipLine.Qty : shipLine.PickedQty))
{
e.Row.Style.CssClass = PickCss.Overpick;
}
else if (shipLine.PickedQty > 0 && shipLine.PackedQty == (noPick ? shipLine.Qty : shipLine.PickedQty))
{
e.Row.Style.CssClass = PickCss.Complete;
}
else if (shipLine.PackedQty > 0)
{
e.Row.Style.CssClass = PickCss.Partial;
}
}
protected override TaxDetail CalculateTaxSum(PXCache sender, object taxrow, object row)
{
TaxRev taxrev = PXResult.Unwrap <TaxRev>(taxrow);
Tax tax = PXResult.Unwrap <Tax>(taxrow);
bool propagateCustomRate = false;
var origTaxRate = taxrev.TaxRate;
if (taxrev.TaxID != null && tax != null)
{
SOTaxAmazonExt taxExt = tax.GetExtension <SOTaxAmazonExt>();
if (taxExt.UsrAMPropagateTaxAmt == true)
{
SOTaxTran soTax = PXResult <SOTaxTran> .Current;
if (soTax != null && taxrev.TaxID == soTax.TaxID && soTax.CuryTaxableAmt.GetValueOrDefault() > 0)
{
var taxRate = soTax.CuryTaxAmt / soTax.CuryTaxableAmt * 100;
if (taxRate != origTaxRate && taxRate > 0)
{
taxrev.TaxRate = taxRate;
propagateCustomRate = true;
}
}
}
}
TaxDetail result = base.CalculateTaxSum(sender, taxrow, row);
if (result != null && propagateCustomRate)
{
result.TaxRate = origTaxRate;
taxrev.TaxRate = origTaxRate;
}
return(result);
}
public static Tuple <T0, T1, T2> ToTuple <T0, T1, T2>(this PXResult <T0, T1, T2> result)
where T0 : class, IBqlTable, new()
where T1 : class, IBqlTable, new()
where T2 : class, IBqlTable, new()
{
return(Tuple.Create <T0, T1, T2>(result, result, result));
}
protected virtual IEnumerable Cancel(PXAdapter adapter)
{
BAccountLocation bAccountLocationRow = LocationRecords.Current;
if (bAccountLocationRow != null && bAccountLocationRow.CustomerID != null &&
adapter.Searches.Length == 2 && adapter.Searches[0] != null)
{
if (bAccountLocationRow.CustomerCD.Trim() != adapter.Searches[0].ToString().Trim())
{
PXResult <BAccount, Location> BaccountLocationResultSet = (PXResult <BAccount, Location>)
PXSelectJoin <BAccount,
InnerJoin <Location,
On <
Location.bAccountID, Equal <BAccount.bAccountID> > >,
Where <
BAccount.acctCD, Equal <Required <BAccount.acctCD> > > >
.SelectWindowed(this, 0, 1, adapter.Searches[0]);
Location locationRow = BaccountLocationResultSet;
adapter.Searches[1] = locationRow.LocationCD;
}
}
foreach (BAccountLocation loc in (new PXCancel <BAccountLocation>(this, "Cancel")).Press(adapter))
{
return(new object[] { loc });
}
return(new object[0]);
}
public static IEnumerable GetPMdetails(PXGraph graph, int?PMInstanceID, bool CCPIDCondition, bool OtherDetailsCondition)
{
var items = PXSelectJoin <CustomerPaymentMethodDetail, InnerJoin <PaymentMethodDetail, On <PaymentMethodDetail.paymentMethodID, Equal <CustomerPaymentMethodDetail.paymentMethodID>,
And <PaymentMethodDetail.detailID, Equal <CustomerPaymentMethodDetail.detailID>,
And <PaymentMethodDetail.useFor, Equal <PaymentMethodDetailUsage.useForARCards> > > > >,
Where <CustomerPaymentMethodDetail.pMInstanceID, Equal <Required <CustomerPaymentMethod.pMInstanceID> > > > .Select(graph, PMInstanceID);
if (PMInstanceID > 0)
{
PXResult <CustomerPaymentMethodDetail, PaymentMethodDetail> stored = HasSavedPaymentProfile(items);
if (stored != null)
{
yield return(stored);
yield break;
}
}
foreach (PXResult <CustomerPaymentMethodDetail, PaymentMethodDetail> item in items)
{
PaymentMethodDetail pmd = item;
bool isCCPid = pmd.IsCCProcessingID == true;
if (CCPIDCondition && isCCPid ||
OtherDetailsCondition && !isCCPid)
{
yield return(item);
}
}
}
public static CCProcessingCenter GetProcessingCenter(PXGraph graph, int?PMInstanceID, bool UsePMFromCacheDeleted)
{
if (PMInstanceID == null && !UsePMFromCacheDeleted)
{
return(null);
}
CCProcessingCenter processingCenter = null;
if (PMInstanceID != null)
{
PXResult <CustomerPaymentMethod, CCProcessingCenter> res =
(PXResult <CustomerPaymentMethod, CCProcessingCenter>) PXSelectJoin <
CustomerPaymentMethod,
InnerJoin <CCProcessingCenter,
On <CCProcessingCenter.processingCenterID, Equal <CustomerPaymentMethod.cCProcessingCenterID> > >,
Where <CustomerPaymentMethod.pMInstanceID, Equal <Required <CustomerPaymentMethod.pMInstanceID> > > >
.Select(graph, PMInstanceID);
processingCenter = (CCProcessingCenter)res;
}
if (processingCenter == null && UsePMFromCacheDeleted)
{
//assuming that payment method was just deleted
IEnumerator cpmEnumerator = graph.Caches[typeof(CustomerPaymentMethod)].Deleted.GetEnumerator();
if (cpmEnumerator.MoveNext())
{
CustomerPaymentMethod customerPaymentMethod = (CustomerPaymentMethod)cpmEnumerator.Current;
processingCenter = GetProcessingCenter(graph, customerPaymentMethod.CCProcessingCenterID);
}
}
return(processingCenter);
}
public virtual void CCTransactionsHistoryFilter_RowUpdated(PXCache sender, PXRowUpdatedEventArgs e)
{
CCTransactionsHistoryFilter row = (CCTransactionsHistoryFilter)e.Row;
CCTransactionsHistoryFilter oldRow = (CCTransactionsHistoryFilter)e.OldRow;
if (oldRow.PaymentMethodID != row.PaymentMethodID || oldRow.CardNumber != row.CardNumber || oldRow.PartialCardNumber != row.PartialCardNumber)
{
this.RecalcRow(row);
}
if (row.MaskedCardNumber != oldRow.MaskedCardNumber || row.DBSearchName != oldRow.DBSearchName)
{
PXResult <CustomerPaymentMethod> cnt = PXSelectJoinGroupBy <CustomerPaymentMethod, InnerJoin <Customer,
On <Customer.bAccountID, Equal <CustomerPaymentMethod.bAccountID> > >,
Where <CustomerPaymentMethod.paymentMethodID, Equal <Current <CCTransactionsHistoryFilter.paymentMethodID> >,
And <CustomerPaymentMethod.descr, Like <Optional <CCTransactionsHistoryFilter.maskedCardNumber> >,
And <Customer.acctName, Like <Optional <CCTransactionsHistoryFilter.dBSearchName> >,
And <CustomerPaymentMethod.isActive, Equal <True> > > > >,
Aggregate <Count <CustomerPaymentMethod.pMInstanceID> > > .Select(this, row.MaskedCardNumber, row.DBSearchName);
int count = 0;
if (cnt != null && cnt.RowCount != null)
{
count = (int)cnt.RowCount;
row.NumberOfCards = cnt.RowCount;
}
row.PMInstanceID = count == 1 ? ((CustomerPaymentMethod)cnt).PMInstanceID : null;
}
}
public override object Map(KCMapObjectRequest request)
{
foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(request.Target))
{
PXResult <KCMapping> importMappingRow = _mappingMaint.ImportMappingRow.Select(request.EntityType, property.Name, request.ViewName).FirstOrDefault();
if (importMappingRow == null)
{
continue;
}
KCMapping mapping = importMappingRow.GetItem <KCMapping>();
KCChannelAdvisorMappingField caField = importMappingRow.GetItem <KCChannelAdvisorMappingField>();
string formula = mapping.RuleType == KCRuleTypesConstants.Expression
? mapping.SourceExpression
: caField?.FieldName;
IDictionary <string, object> mappingValue = GetMappingValue(request, property);
if (string.IsNullOrWhiteSpace(formula) ||
mappingValue == null ||
(mapping.RuleType == KCRuleTypesConstants.Simple && mappingValue.GetValue(formula) == null))
{
continue;
}
MapField(request.EntityType, request.Target, property, mappingValue, formula);
}
return(request.Target);
}
public virtual void InvoiceOrder(DateTime invoiceDate, PXResult<SOOrderShipment, SOOrder, CurrencyInfo, SOAddress, SOContact, SOOrderType> order, Customer customer, DocumentList<ARInvoice, SOInvoice> list)
{
InvoiceOrder(invoiceDate, order, null, customer, list);
}
public virtual void InvoiceOrder(DateTime invoiceDate, PXResult<SOOrderShipment, SOOrder, CurrencyInfo, SOAddress, SOContact, SOOrderType> order, PXResultset<SOShipLine, SOLine> details, Customer customer, DocumentList<ARInvoice, SOInvoice> list)
{
ARInvoice newdoc;
SOOrder soOrder = order;
SOOrderType ordertype = order;
decimal ApprovedBalance = 0;
decimal PrevDocBal = 0;
PXRowUpdated ApprovedBalanceCollector = delegate(PXCache sender, PXRowUpdatedEventArgs e)
{
ARInvoice ARDoc = (ARInvoice)e.Row;
if ((decimal)ARDoc.DocBal > (decimal)ARDoc.ApprovedCreditAmt)
{
if ((bool)((SOOrder)order).ApprovedCredit && (decimal)ARDoc.DocBal > PrevDocBal)
{
ApprovedBalance += (decimal)ARDoc.DocBal - PrevDocBal;
ARDoc.ApprovedCreditAmt = ApprovedBalance;
}
ARDoc.ApprovedCredit = (ApprovedBalance == (decimal)ARDoc.DocBal ? true : false);
PrevDocBal = (decimal)ARDoc.DocBal;
}
};
this.RowUpdated.AddHandler(typeof(ARInvoice), ApprovedBalanceCollector);
if (list != null)
{
bool iscc = false;
DateTime? orderInvoiceDate = (sosetup.Current.UseShipDateForInvoiceDate == true ? ((SOOrderShipment)order).ShipDate : soOrder.InvoiceDate);
if (soOrder.BillSeparately == false)
{
iscc = PXSelectReadonly<CCProcTran, Where<CCProcTran.origDocType, Equal<Required<CCProcTran.origDocType>>, And<CCProcTran.origRefNbr, Equal<Required<CCProcTran.origRefNbr>>, And<CCProcTran.refNbr, IsNull>>>>.Select(this, soOrder.OrderType, soOrder.OrderNbr).Count > 0;
}
if (soOrder.PaymentCntr == 0 && soOrder.BillSeparately == false && iscc == false)
{
if(soOrder.PaymentMethodID == null && soOrder.CashAccountID == null)
newdoc = list.Find<ARInvoice.docType, ARInvoice.docDate, ARInvoice.branchID, ARInvoice.customerID, ARInvoice.customerLocationID, SOInvoice.billAddressID, SOInvoice.billContactID, SOInvoice.extRefNbr, ARInvoice.curyID, ARInvoice.termsID, ARInvoice.hidden>(((SOOrderType)order).ARDocType, orderInvoiceDate ?? invoiceDate, soOrder.BranchID, soOrder.CustomerID, soOrder.CustomerLocationID, soOrder.BillAddressID, soOrder.BillContactID, soOrder.ExtRefNbr, soOrder.CuryID, soOrder.TermsID, false) ?? (ARInvoice)new ARInvoice();
else if (soOrder.CashAccountID == null)
newdoc = list.Find<ARInvoice.docType, ARInvoice.docDate, ARInvoice.branchID, ARInvoice.customerID, ARInvoice.customerLocationID, SOInvoice.billAddressID, SOInvoice.billContactID, SOInvoice.pMInstanceID, SOInvoice.extRefNbr, ARInvoice.curyID, ARInvoice.termsID, ARInvoice.hidden>(((SOOrderType)order).ARDocType, orderInvoiceDate ?? invoiceDate, soOrder.BranchID, soOrder.CustomerID, soOrder.CustomerLocationID, soOrder.BillAddressID, soOrder.BillContactID, soOrder.PMInstanceID, soOrder.ExtRefNbr, soOrder.CuryID, soOrder.TermsID, false) ?? (ARInvoice)new ARInvoice();
else
newdoc = list.Find<ARInvoice.docType, ARInvoice.docDate, ARInvoice.branchID, ARInvoice.customerID, ARInvoice.customerLocationID, SOInvoice.billAddressID, SOInvoice.billContactID, SOInvoice.pMInstanceID, SOInvoice.cashAccountID, SOInvoice.extRefNbr, ARInvoice.curyID, ARInvoice.termsID, ARInvoice.hidden>(((SOOrderType)order).ARDocType, orderInvoiceDate ?? invoiceDate, soOrder.BranchID, soOrder.CustomerID, soOrder.CustomerLocationID, soOrder.BillAddressID, soOrder.BillContactID, soOrder.PMInstanceID, soOrder.CashAccountID, soOrder.ExtRefNbr, soOrder.CuryID, soOrder.TermsID, false) ?? (ARInvoice)new ARInvoice();
}
else
{
newdoc = list.Find<ARInvoice.hidden, ARInvoice.hiddenOrderType, ARInvoice.hiddenOrderNbr>(true, soOrder.OrderType, soOrder.OrderNbr);
if (newdoc == null)
{
newdoc = new ARInvoice();
newdoc.HiddenOrderType = soOrder.OrderType;
newdoc.HiddenOrderNbr = soOrder.OrderNbr;
newdoc.Hidden = true;
}
}
if (newdoc.RefNbr != null)
{
Document.Current = this.Document.Search<ARInvoice.refNbr>(newdoc.RefNbr, newdoc.DocType);
}
else
{
this.Clear();
string docType = ((SOOrderType)order).ARDocType;
if (((SOOrderShipment)order).Operation == ((SOOrderType)order).DefaultOperation)
{
newdoc.DocType = docType;
}
else
{
//for RMA switch document type if previous shipment was not invoiced previously in the current run, i.e. list.Find() returned null
newdoc.DocType =
docType == ARDocType.Invoice ? ARDocType.CreditMemo :
docType == ARDocType.DebitMemo ? ARDocType.CreditMemo :
docType == ARDocType.CreditMemo ? ARDocType.Invoice :
docType == ARDocType.CashSale ? ARDocType.CashReturn :
docType == ARDocType.CashReturn ? ARDocType.CashSale :
null;
}
newdoc.DocDate = orderInvoiceDate ?? invoiceDate;
if (string.IsNullOrEmpty(soOrder.FinPeriodID) == false)
{
newdoc.FinPeriodID = soOrder.FinPeriodID;
}
if (soOrder.InvoiceNbr != null)
{
newdoc.RefNbr = soOrder.InvoiceNbr;
newdoc.RefNoteID = soOrder.NoteID;
}
if (((SOOrderType)order).UserInvoiceNumbering == true && string.IsNullOrEmpty(newdoc.RefNbr))
{
throw new PXException(ErrorMessages.FieldIsEmpty, PXUIFieldAttribute.GetDisplayName<SOOrder.invoiceNbr>(soorder.Cache));
}
AutoNumberAttribute.SetNumberingId<ARInvoice.refNbr>(Document.Cache, ((SOOrderType)order).ARDocType, ((SOOrderType)order).InvoiceNumberingID);
newdoc = (ARInvoice)Document.Cache.CreateCopy(this.Document.Insert(newdoc));
newdoc.BranchID = soOrder.BranchID;
newdoc.CustomerID = ((SOOrder)order).CustomerID;
newdoc.CustomerLocationID = ((SOOrder)order).CustomerLocationID;
newdoc.TermsID = ((SOOrder)order).TermsID;
newdoc.DiscDate = ((SOOrder)order).DiscDate;
newdoc.DueDate = ((SOOrder)order).DueDate;
newdoc.TaxZoneID = ((SOOrder)order).TaxZoneID;
newdoc.AvalaraCustomerUsageType = ((SOOrder)order).AvalaraCustomerUsageType;
newdoc.SalesPersonID = ((SOOrder)order).SalesPersonID;
newdoc.DocDesc = ((SOOrder)order).OrderDesc;
newdoc.InvoiceNbr = ((SOOrder)order).CustomerOrderNbr;
newdoc.CuryID = ((SOOrder)order).CuryID;
newdoc.ProjectID = ((SOOrder)order).ProjectID ?? PM.ProjectDefaultAttribute.NonProject(this);
newdoc.Hold = ordertype.InvoiceHoldEntry;
if (((SOOrderType)order).MarkInvoicePrinted == true)
{
newdoc.Printed = true;
}
if (((SOOrderType)order).MarkInvoiceEmailed == true)
{
newdoc.Emailed = true;
}
if (soOrder.PMInstanceID != null || string.IsNullOrEmpty(soOrder.PaymentMethodID) == false)
{
newdoc.PMInstanceID = soOrder.PMInstanceID;
newdoc.PaymentMethodID = soOrder.PaymentMethodID;
newdoc.CashAccountID = soOrder.CashAccountID;
}
newdoc = this.Document.Update(newdoc);
if (soOrder.PMInstanceID != null || string.IsNullOrEmpty(soOrder.PaymentMethodID) == false)
{
SODocument.Current.PMInstanceID = soOrder.PMInstanceID;
SODocument.Current.PaymentMethodID = soOrder.PaymentMethodID;
SODocument.Current.CashAccountID = soOrder.CashAccountID;
if(SODocument.Current.CashAccountID == null)
SODocument.Cache.SetDefaultExt<SOInvoice.cashAccountID>(SODocument.Current);
SODocument.Current.ExtRefNbr = soOrder.ExtRefNbr;
//clear error in case invoice currency different from default cash account for customer
SODocument.Cache.RaiseExceptionHandling<SOInvoice.cashAccountID>(SODocument.Current, null, null);
}
foreach (CurrencyInfo info in this.currencyinfo.Select())
{
if (((SOOrder)order).InvoiceDate != null)
{
PXCache<CurrencyInfo>.RestoreCopy(info, (CurrencyInfo)order);
info.CuryInfoID = newdoc.CuryInfoID;
}
}
AddressAttribute.CopyRecord<ARInvoice.billAddressID>(this.Document.Cache, newdoc, (SOAddress)order, true);
ContactAttribute.CopyRecord<ARInvoice.billContactID>(this.Document.Cache, newdoc, (SOContact)order, true);
}
}
else
{
newdoc = (ARInvoice)Document.Cache.CreateCopy(Document.Current);
if (Transactions.SelectSingle() == null)
{
newdoc.CustomerID = ((SOOrder)order).CustomerID;
newdoc.ProjectID = ((SOOrder)order).ProjectID;
newdoc.CustomerLocationID = ((SOOrder)order).CustomerLocationID;
newdoc.SalesPersonID = ((SOOrder)order).SalesPersonID;
newdoc.TaxZoneID = ((SOOrder)order).TaxZoneID;
newdoc.AvalaraCustomerUsageType = ((SOOrder)order).AvalaraCustomerUsageType;
newdoc.DocDesc = ((SOOrder)order).OrderDesc;
newdoc.InvoiceNbr = ((SOOrder)order).CustomerOrderNbr;
newdoc.TermsID = ((SOOrder)order).TermsID;
foreach (CurrencyInfo info in this.currencyinfo.Select())
{
PXCache<CurrencyInfo>.RestoreCopy(info, (CurrencyInfo)order);
info.CuryInfoID = newdoc.CuryInfoID;
newdoc.CuryID = info.CuryID;
}
}
newdoc = this.Document.Update(newdoc);
AddressAttribute.CopyRecord<ARInvoice.billAddressID>(this.Document.Cache, newdoc, (SOAddress)order, true);
ContactAttribute.CopyRecord<ARInvoice.billContactID>(this.Document.Cache, newdoc, (SOContact)order, true);
}
PXSelectBase<SOInvoiceDiscountDetail> selectInvoiceDiscounts = new PXSelect<SOInvoiceDiscountDetail,
Where<SOInvoiceDiscountDetail.tranType, Equal<Current<SOInvoice.docType>>,
And<SOInvoiceDiscountDetail.refNbr, Equal<Current<SOInvoice.refNbr>>,
And<SOInvoiceDiscountDetail.orderType, Equal<Required<SOInvoiceDiscountDetail.orderType>>,
And<SOInvoiceDiscountDetail.orderNbr, Equal<Required<SOInvoiceDiscountDetail.orderNbr>>>>>>>(this);
foreach (SOInvoiceDiscountDetail detail in selectInvoiceDiscounts.Select(((SOOrderShipment)order).OrderType, ((SOOrderShipment)order).OrderNbr))
{
DiscountDetails.Delete(detail);
}
TaxAttribute.SetTaxCalc<ARTran.taxCategoryID>(this.Transactions.Cache, null, TaxCalc.ManualCalc);
if (details != null)
{
foreach (SOShipLine shipline in details)
{
this.Caches[typeof(SOShipLine)].Insert(shipline);
}
}
DateTime? origInvoiceDate = null;
foreach (PXResult<SOShipLine, SOLine, SOOrderTypeOperation, ARTran> res in PXSelectJoin<SOShipLine, InnerJoin<SOLine, On<SOLine.orderType, Equal<SOShipLine.origOrderType>, And<SOLine.orderNbr, Equal<SOShipLine.origOrderNbr>, And<SOLine.lineNbr, Equal<SOShipLine.origLineNbr>>>>, InnerJoin<SOOrderTypeOperation, On<SOOrderTypeOperation.orderType, Equal<SOLine.orderType>, And<SOOrderTypeOperation.operation, Equal<SOLine.operation>>>, LeftJoin<ARTran, On<ARTran.sOShipmentNbr, Equal<SOShipLine.shipmentNbr>, And<ARTran.sOShipmentType, Equal<SOShipLine.shipmentType>, And<ARTran.sOShipmentLineNbr, Equal<SOShipLine.lineNbr>, And<ARTran.sOOrderType, Equal<SOShipLine.origOrderType>, And<ARTran.sOOrderNbr, Equal<SOShipLine.origOrderNbr>, And<ARTran.sOOrderLineNbr, Equal<SOShipLine.origLineNbr>>>>>>>>>>, Where<SOShipLine.shipmentNbr, Equal<Required<SOShipLine.shipmentNbr>>, And<SOShipLine.origOrderType, Equal<Required<SOShipLine.origOrderType>>, And<SOShipLine.origOrderNbr, Equal<Required<SOShipLine.origOrderNbr>>, And<ARTran.refNbr, IsNull>>>>>.Select(this, ((SOOrderShipment)order).ShipmentNbr, ((SOOrderShipment)order).OrderType, ((SOOrderShipment)order).OrderNbr))
{
SOLine orderline = (SOLine)res;
SOShipLine shipline = (SOShipLine)res;
if (Math.Abs((decimal)shipline.BaseShippedQty) < 0.0000005m)
{
continue;
}
if (origInvoiceDate == null && orderline.InvoiceDate != null)
origInvoiceDate = orderline.InvoiceDate;
ARTran newtran = new ARTran();
newtran.BranchID = orderline.BranchID;
newtran.AccountID = orderline.SalesAcctID;
newtran.SubID = orderline.SalesSubID;
newtran.SOOrderType = shipline.OrigOrderType;
newtran.SOOrderNbr = shipline.OrigOrderNbr;
newtran.SOOrderLineNbr = shipline.OrigLineNbr;
newtran.SOShipmentNbr = shipline.ShipmentNbr;
newtran.SOShipmentType = shipline.ShipmentType;
newtran.SOShipmentLineNbr = shipline.LineNbr;
newtran.LineType = orderline.LineType;
newtran.InventoryID = shipline.InventoryID;
newtran.SiteID = orderline.SiteID;
newtran.UOM = shipline.UOM;
newtran.Qty = shipline.ShippedQty;
newtran.BaseQty = shipline.BaseShippedQty;
newtran.Commissionable = orderline.Commissionable;
newtran.GroupDiscountRate = orderline.GroupDiscountRate;
decimal shippedQtyInBaseUnits = INUnitAttribute.ConvertToBase(Transactions.Cache, newtran.InventoryID, shipline.UOM, shipline.ShippedQty.Value, INPrecision.QUANTITY);
decimal shippedQtyInOrderUnits = INUnitAttribute.ConvertFromBase(Transactions.Cache, newtran.InventoryID, orderline.UOM, shippedQtyInBaseUnits, INPrecision.QUANTITY);
if (shippedQtyInOrderUnits != orderline.OrderQty || shipline.UOM != orderline.UOM)
{
decimal curyUnitPriceInBaseUnits = INUnitAttribute.ConvertFromBase(Transactions.Cache, newtran.InventoryID, orderline.UOM, orderline.CuryUnitPrice.Value, INPrecision.UNITCOST);
decimal curyUnitPriceInShippedUnits = INUnitAttribute.ConvertToBase(Transactions.Cache, newtran.InventoryID, shipline.UOM, curyUnitPriceInBaseUnits, INPrecision.UNITCOST);
if (arsetup.Current.LineDiscountTarget == LineDiscountTargetType.SalesPrice)
{
decimal? salesPriceAfterDiscount = curyUnitPriceInShippedUnits * (1m - orderline.DiscPct / 100m);
newtran.CuryTranAmt = shipline.ShippedQty * PXCurrencyAttribute.Round(Transactions.Cache, newtran, salesPriceAfterDiscount ?? 0, CMPrecision.TRANCURY);
}
else
{
decimal? curyTranAmt = shipline.ShippedQty * curyUnitPriceInShippedUnits * (1m - orderline.DiscPct / 100m);
newtran.CuryTranAmt = PXCurrencyAttribute.Round(Transactions.Cache, newtran, curyTranAmt ?? 0, CMPrecision.TRANCURY);
}
newtran.CuryUnitPrice = curyUnitPriceInShippedUnits;
newtran.CuryDiscAmt = (shipline.ShippedQty * curyUnitPriceInShippedUnits) - newtran.CuryTranAmt;
}
else
{
newtran.CuryUnitPrice = orderline.CuryUnitPrice;
newtran.CuryTranAmt = orderline.CuryLineAmt;
newtran.CuryDiscAmt = orderline.CuryDiscAmt;
}
if (newdoc.DocType == ((SOOrderType)order).ARDocType && ((SOOrderType)order).DefaultOperation != ((SOOrderTypeOperation)res).Operation)
{
//keep BaseQty positive for PXFormula
newtran.Qty = -newtran.Qty;
newtran.CuryDiscAmt = -newtran.CuryDiscAmt;
newtran.CuryTranAmt = -newtran.CuryTranAmt;
}
newtran.ProjectID = orderline.ProjectID;
newtran.TaskID = orderline.TaskID;
newtran.TranDesc = orderline.TranDesc;
newtran.SalesPersonID = orderline.SalesPersonID;
newtran.TaxCategoryID = orderline.TaxCategoryID;
newtran.DiscPct = orderline.DiscPct;
newtran.ManualDisc = orderline.ManualDisc == true || orderline.IsFree == true;
newtran.FreezeManualDisc = true;
newtran.DiscountID = orderline.DiscountID;
newtran.DiscountSequenceID = orderline.DiscountSequenceID;
newtran.DetDiscIDC1 = orderline.DetDiscIDC1;
newtran.DetDiscIDC2 = orderline.DetDiscIDC2;
newtran.DetDiscSeqIDC1 = orderline.DetDiscSeqIDC1;
newtran.DetDiscSeqIDC2 = orderline.DetDiscSeqIDC2;
newtran.DetDiscApp = orderline.DetDiscApp;
newtran.DocDiscIDC1 = orderline.DocDiscIDC1;
newtran.DocDiscIDC2 = orderline.DocDiscIDC2;
newtran.DocDiscSeqIDC1 = orderline.DocDiscSeqIDC1;
newtran.DocDiscSeqIDC2 = orderline.DocDiscSeqIDC2;
foreach (ARTran existing in Transactions.Cache.Inserted)
{
if (Transactions.Cache.ObjectsEqual<ARTran.sOShipmentNbr, ARTran.sOShipmentType, ARTran.sOShipmentLineNbr, ARTran.sOOrderType, ARTran.sOOrderNbr, ARTran.sOOrderLineNbr>(newtran, existing))
{
Transactions.Cache.RestoreCopy(newtran, existing);
break;
}
}
if (newtran.LineNbr == null)
{
newtran = this.Transactions.Insert(newtran);
if (((SOOrderType)order).CopyLineNotesToInvoice == true)
{
if (((SOOrderType)order).CopyLineNotesToInvoiceOnlyNS == false || orderline.LineType == SOLineType.NonInventory)
{
PXNoteAttribute.SetNote(Caches[typeof(ARTran)], newtran, PXNoteAttribute.GetNote(Caches[typeof(SOLine)], orderline));
}
}
if (((SOOrderType)order).CopyLineFilesToInvoice == true)
{
if (((SOOrderType)order).CopyLineFilesToInvoiceOnlyNS == false || orderline.LineType == SOLineType.NonInventory)
{
PXNoteAttribute.SetFileNotes(Caches[typeof(ARTran)], newtran, PXNoteAttribute.GetFileNotes(Caches[typeof(SOLine)], orderline));
}
}
}
else
{
newtran = this.Transactions.Update(newtran);
TaxAttribute.Calculate<ARTran.taxCategoryID>(Transactions.Cache, new PXRowUpdatedEventArgs(newtran, null, true));
}
}
PXSelectBase<ARTran> cmd = new PXSelect<ARTran, Where<ARTran.tranType, Equal<Current<ARInvoice.docType>>, And<ARTran.refNbr, Equal<Current<ARInvoice.refNbr>>, And<ARTran.sOOrderType, Equal<Current<SOMiscLine2.orderType>>, And<ARTran.sOOrderNbr, Equal<Current<SOMiscLine2.orderNbr>>, And<ARTran.sOOrderLineNbr, Equal<Current<SOMiscLine2.lineNbr>>>>>>>>(this);
foreach (SOMiscLine2 orderline in PXSelect<SOMiscLine2, Where<SOMiscLine2.orderType, Equal<Required<SOMiscLine2.orderType>>, And<SOMiscLine2.orderNbr, Equal<Required<SOMiscLine2.orderNbr>>, And<Where<SOMiscLine2.curyUnbilledAmt, Greater<decimal0>, Or<SOMiscLine2.curyLineAmt, LessEqual<decimal0>>>>>>>.Select(this, ((SOOrderShipment)order).OrderType, ((SOOrderShipment)order).OrderNbr))
{
if (cmd.View.SelectSingleBound(new object[] { Document.Current, orderline }) == null)
{
ARTran newtran = new ARTran();
newtran.BranchID = orderline.BranchID;
newtran.AccountID = orderline.SalesAcctID;
newtran.SubID = orderline.SalesSubID;
newtran.SOOrderType = orderline.OrderType;
newtran.SOOrderNbr = orderline.OrderNbr;
newtran.SOOrderLineNbr = orderline.LineNbr;
newtran.SOShipmentNbr = ((SOOrderShipment)order).ShipmentNbr;
newtran.SOShipmentType = ((SOOrderShipment)order).ShipmentType;
newtran.SOShipmentLineNbr = null;
newtran.LineType = SOLineType.MiscCharge;
newtran.InventoryID = orderline.InventoryID;
newtran.TaskID = orderline.TaskID;
newtran.SalesPersonID = orderline.SalesPersonID;
newtran.Commissionable = orderline.Commissionable;
newtran.UOM = orderline.UOM;
newtran.Qty = orderline.UnbilledQty;
newtran.BaseQty = orderline.BaseUnbilledQty;
newtran.CuryUnitPrice = orderline.CuryUnitPrice;
newtran.CuryDiscAmt = orderline.CuryDiscAmt;
newtran.CuryTranAmt = orderline.CuryUnbilledAmt;
newtran.TranDesc = orderline.TranDesc;
newtran.TaxCategoryID = orderline.TaxCategoryID;
newtran.DiscPct = orderline.DiscPct;
newtran.ManualDisc = orderline.ManualDisc == true || orderline.IsFree == true;
newtran.FreezeManualDisc = true;
newtran.DiscountID = orderline.DiscountID;
newtran.DiscountSequenceID = orderline.DiscountSequenceID;
newtran.DetDiscIDC1 = orderline.DetDiscIDC1;
newtran.DetDiscIDC2 = orderline.DetDiscIDC2;
newtran.DetDiscSeqIDC1 = orderline.DetDiscSeqIDC1;
newtran.DetDiscSeqIDC2 = orderline.DetDiscSeqIDC2;
newtran.DetDiscApp = orderline.DetDiscApp;
newtran.DocDiscIDC1 = orderline.DocDiscIDC1;
newtran.DocDiscIDC2 = orderline.DocDiscIDC2;
newtran.DocDiscSeqIDC1 = orderline.DocDiscSeqIDC1;
newtran.DocDiscSeqIDC2 = orderline.DocDiscSeqIDC2;
newtran = this.Transactions.Insert(newtran);
if (((SOOrderType)order).CopyLineNotesToInvoice == true)
{
PXNoteAttribute.SetNote(Caches[typeof(ARTran)], newtran, PXNoteAttribute.GetNote(Caches[typeof(SOMiscLine2)], orderline));
}
if (((SOOrderType)order).CopyLineFilesToInvoice == true)
{
PXNoteAttribute.SetFileNotes(Caches[typeof(ARTran)], newtran, PXNoteAttribute.GetFileNotes(Caches[typeof(SOMiscLine2)], orderline));
}
}
}
SODocument.Current = (SOInvoice)SODocument.Select() ?? (SOInvoice)SODocument.Cache.Insert();
SODocument.Current.BillAddressID = soOrder.BillAddressID;
SODocument.Current.BillContactID = soOrder.BillContactID;
SODocument.Current.ShipAddressID = soOrder.ShipAddressID;
SODocument.Current.ShipContactID = soOrder.ShipContactID;
SODocument.Current.IsCCCaptured = soOrder.IsCCCaptured;
SODocument.Current.IsCCCaptureFailed = soOrder.IsCCCaptureFailed;
SODocument.Current.PaymentProjectID = PM.ProjectDefaultAttribute.NonProject(this);
if (soOrder.IsCCCaptured == true)
{
SODocument.Current.CuryCCCapturedAmt = soOrder.CuryCCCapturedAmt;
SODocument.Current.CCCapturedAmt = soOrder.CCCapturedAmt;
}
SODocument.Current.RefTranExtNbr = soOrder.RefTranExtNbr;
SOOrderShipment shipment = PXCache<SOOrderShipment>.CreateCopy((SOOrderShipment)order);
shipment.InvoiceType = SODocument.Current.DocType;
shipment.InvoiceNbr = SODocument.Current.RefNbr;
shipmentlist.Cache.Update(shipment);
FillFreightDetails((SOOrder)order, shipment);
/*In case Discounts were not recalculated add prorated Doc discounts */
if (ordertype.RecalculateDiscOnPartialShipment != true)
{
//add prorated document discount details from invoice:
PXSelectBase<SOOrderDiscountDetail> selectOrderDocGroupDiscounts = new PXSelect<SOOrderDiscountDetail,
Where<SOOrderDiscountDetail.orderType, Equal<Required<SOOrderDiscountDetail.orderType>>,
And<SOOrderDiscountDetail.orderNbr, Equal<Required<SOOrderDiscountDetail.orderNbr>>>>>(this);
decimal? rate = 1m;
if (soOrder.LineTotal > 0m)
rate = shipment.LineTotal / soOrder.LineTotal;
foreach (SOOrderDiscountDetail docGroupDisc in selectOrderDocGroupDiscounts.Select(((SOOrderShipment)order).OrderType, ((SOOrderShipment)order).OrderNbr))
{
SOInvoiceDiscountDetail dd = new SOInvoiceDiscountDetail();
dd.Type = docGroupDisc.Type;
dd.DiscountID = docGroupDisc.DiscountID;
dd.DiscountSequenceID = docGroupDisc.DiscountSequenceID;
dd.OrderType = docGroupDisc.OrderType;
dd.OrderNbr = docGroupDisc.OrderNbr;
dd.TranType = newdoc.DocType;
dd.RefNbr = newdoc.RefNbr;
dd.DiscountPct = docGroupDisc.DiscountPct;
dd.FreeItemID = docGroupDisc.FreeItemID;
dd.FreeItemQty = docGroupDisc.FreeItemQty;
if (docGroupDisc.Type == DiscountType.Group)
{
SOOrderEntry soOrderQ = (SOOrderEntry)PXGraph.CreateInstance(typeof(SOOrderEntry));
soOrderQ.Document.Current = order;
Dictionary<DiscountSequenceKey, DiscountEngine<SOLine>.DiscountDetailToLineCorrelation<SOOrderDiscountDetail>> grLinesOrderCorrelation = DiscountEngine<SOLine>.CollectGroupDiscountToLineCorrelation(soOrderQ.Transactions.Cache, soOrderQ.Transactions, soOrderQ.DiscountDetails, soOrder.CustomerLocationID, (DateTime)soOrder.OrderDate, false);
foreach (KeyValuePair<DiscountSequenceKey, DiscountEngine<SOLine>.DiscountDetailToLineCorrelation<SOOrderDiscountDetail>> dsGroup in grLinesOrderCorrelation)
{
if (dsGroup.Key.DiscountID == docGroupDisc.DiscountID && dsGroup.Key.DiscountSequenceID == docGroupDisc.DiscountSequenceID)
{
decimal invoicedGroupAmt = 0m;
foreach (SOLine soLine in dsGroup.Value.listOfApplicableLines)
{
foreach (ARTran tran in Transactions.Select())
{
if (soLine.LineNbr == tran.SOOrderLineNbr)
invoicedGroupAmt += (tran.CuryLineAmt ?? 0m);
}
}
rate = (invoicedGroupAmt / (decimal)dsGroup.Value.discountDetailLine.CuryDiscountableAmt);
}
}
}
SOInvoiceDiscountDetail located = DiscountDetails.Locate(dd);
if (located != null)
{
located.DiscountAmt += docGroupDisc.DiscountAmt * rate;
located.CuryDiscountAmt += docGroupDisc.CuryDiscountAmt * rate;
located.DiscountableAmt += docGroupDisc.DiscountableAmt * rate;
located.CuryDiscountableAmt += docGroupDisc.CuryDiscountableAmt * rate;
located.DiscountableQty += docGroupDisc.DiscountableQty * rate;
DiscountDetails.Update(located);
}
else
{
dd.DiscountAmt = docGroupDisc.DiscountAmt * rate;
dd.CuryDiscountAmt = docGroupDisc.CuryDiscountAmt * rate;
dd.DiscountableAmt = docGroupDisc.DiscountableAmt * rate;
dd.CuryDiscountableAmt = docGroupDisc.CuryDiscountableAmt * rate;
dd.DiscountableQty = docGroupDisc.DiscountableQty * rate;
DiscountDetails.Insert(dd);
}
}
}
else
{
//Recalculate all discounts
foreach (ARTran tran in Transactions.Select())
{
RecalculateDiscounts(this.Transactions.Cache, tran);
}
}
RecalculateTotalDiscount();
foreach (PXResult<SOTaxTran, Tax> res in PXSelectJoin<SOTaxTran,
InnerJoin<Tax, On<SOTaxTran.taxID, Equal<Tax.taxID>>>,
Where<SOTaxTran.orderType, Equal<Required<SOTaxTran.orderType>>, And<SOTaxTran.orderNbr, Equal<Required<SOTaxTran.orderNbr>>>>>.Select(this, ((SOOrderShipment)order).OrderType, ((SOOrderShipment)order).OrderNbr))
{
SOTaxTran tax = (SOTaxTran)res;
ARTaxTran newtax = new ARTaxTran();
newtax.Module = BatchModule.AR;
Taxes.Cache.SetDefaultExt<ARTaxTran.origTranType>(newtax);
Taxes.Cache.SetDefaultExt<ARTaxTran.origRefNbr>(newtax);
Taxes.Cache.SetDefaultExt<ARTaxTran.lineRefNbr>(newtax);
newtax.TranType = Document.Current.DocType;
newtax.RefNbr = Document.Current.RefNbr;
newtax.TaxID = tax.TaxID;
newtax.TaxRate = 0m;
this.Taxes.Delete(newtax);
newtax = this.Taxes.Insert(newtax);
}
decimal? CuryApplAmt = 0m;
bool Calculated = false;
foreach (SOAdjust soadj in PXSelectJoin<SOAdjust, InnerJoin<AR.ARPayment, On<AR.ARPayment.docType, Equal<SOAdjust.adjgDocType>, And<AR.ARPayment.refNbr, Equal<SOAdjust.adjgRefNbr>>>>, Where<SOAdjust.adjdOrderType, Equal<Required<SOAdjust.adjdOrderType>>, And<SOAdjust.adjdOrderNbr, Equal<Required<SOAdjust.adjdOrderNbr>>, And<AR.ARPayment.openDoc, Equal<True>>>>>.Select(this, ((SOOrderShipment)order).OrderType, ((SOOrderShipment)order).OrderNbr))
{
ARAdjust prev_adj = null;
bool found = false;
foreach (ARAdjust adj in Adjustments.Select())
{
if (Calculated)
{
CuryApplAmt -= adj.CuryAdjdAmt;
}
if (string.Equals(adj.AdjgDocType, soadj.AdjgDocType) && string.Equals(adj.AdjgRefNbr, soadj.AdjgRefNbr))
{
if (soadj.CuryAdjdAmt > 0m)
{
ARAdjust copy = PXCache<ARAdjust>.CreateCopy(adj);
copy.CuryAdjdAmt += (soadj.CuryAdjdAmt > adj.CuryDocBal) ? adj.CuryDocBal : soadj.CuryAdjdAmt;
copy.AdjdOrderType = soadj.AdjdOrderType;
copy.AdjdOrderNbr = soadj.AdjdOrderNbr;
prev_adj = Adjustments.Update(copy);
}
found = true;
if (Calculated)
{
CuryApplAmt += adj.CuryAdjdAmt;
break;
}
}
CuryApplAmt += adj.CuryAdjdAmt;
}
//if soadjust is not available in adjustments mark as billed
if (!found)
{
/*
soadj.Billed = true;
soadjustments.Cache.SetStatus(soadj, PXEntryStatus.Updated);
*/
}
Calculated = true;
if (!IsExternalTax)
{
if (CuryApplAmt > Document.Current.CuryDocBal - Document.Current.CuryOrigDiscAmt && prev_adj != null)
{
prev_adj = PXCache<ARAdjust>.CreateCopy(prev_adj);
if (prev_adj.CuryAdjdAmt > (CuryApplAmt - (Document.Current.CuryDocBal - Document.Current.CuryOrigDiscAmt)))
{
prev_adj.CuryAdjdAmt -= (CuryApplAmt - (Document.Current.CuryDocBal - Document.Current.CuryOrigDiscAmt));
CuryApplAmt = Document.Current.CuryDocBal - Document.Current.CuryOrigDiscAmt;
}
else
{
CuryApplAmt -= prev_adj.CuryAdjdAmt;
prev_adj.CuryAdjdAmt = 0m;
}
prev_adj = Adjustments.Update(prev_adj);
}
}
}
newdoc = (ARInvoice)Document.Cache.CreateCopy(Document.Current);
newdoc.OrigDocDate = origInvoiceDate;
SOInvoice socopy = (SOInvoice)SODocument.Cache.CreateCopy(SODocument.Current);
PXFormulaAttribute.CalcAggregate<ARAdjust.curyAdjdAmt>(Adjustments.Cache, SODocument.Current, false);
Document.Cache.RaiseFieldUpdated<SOInvoice.curyPaymentTotal>(SODocument.Current, null);
PXDBCurrencyAttribute.CalcBaseValues<SOInvoice.curyPaymentTotal>(SODocument.Cache, SODocument.Current);
SODocument.Cache.RaiseRowUpdated(SODocument.Current, socopy);
List<string> ordersdistinct = new List<string>();
foreach (SOOrderShipment shipments in PXSelect<SOOrderShipment, Where<SOOrderShipment.invoiceType, Equal<Current<ARInvoice.docType>>, And<SOOrderShipment.invoiceNbr, Equal<Current<ARInvoice.refNbr>>>>>.Select(this))
{
string key = string.Format("{0}|{1}", shipments.OrderType, shipments.OrderNbr);
if (!ordersdistinct.Contains(key))
{
ordersdistinct.Add(key);
}
if (ordersdistinct.Count > 1)
{
newdoc.InvoiceNbr = null;
newdoc.SalesPersonID = null;
newdoc.DocDesc = null;
break;
}
#region Update FreeItemQty for DiscountDetails based on shipments
PXSelectBase<SOShipmentDiscountDetail> selectShipmentDiscounts = new PXSelect<SOShipmentDiscountDetail,
Where<SOShipmentDiscountDetail.orderType, Equal<Required<SOShipmentDiscountDetail.orderType>>,
And<SOShipmentDiscountDetail.orderNbr, Equal<Required<SOShipmentDiscountDetail.orderNbr>>,
And<SOShipmentDiscountDetail.shipmentNbr, Equal<Required<SOShipmentDiscountDetail.shipmentNbr>>>>>>(this);
foreach (SOShipmentDiscountDetail sdd in selectShipmentDiscounts.Select(shipments.OrderType, shipments.OrderNbr, shipments.ShipmentNbr))
{
SOInvoiceDiscountDetail idd = PXSelect<SOInvoiceDiscountDetail,
Where<SOInvoiceDiscountDetail.tranType, Equal<Current<ARInvoice.docType>>,
And<SOInvoiceDiscountDetail.refNbr, Equal<Current<ARInvoice.refNbr>>,
And<SOInvoiceDiscountDetail.orderType, Equal<Required<SOInvoiceDiscountDetail.orderType>>,
And<SOInvoiceDiscountDetail.orderNbr, Equal<Required<SOInvoiceDiscountDetail.orderNbr>>,
And<SOInvoiceDiscountDetail.discountID, Equal<Required<SOInvoiceDiscountDetail.discountID>>,
And<SOInvoiceDiscountDetail.discountSequenceID, Equal<Required<SOInvoiceDiscountDetail.discountSequenceID>>>>>>>>>.Select(this, shipments.OrderType, shipments.OrderNbr, sdd.DiscountID, sdd.DiscountSequenceID);
if (idd != null)
{
if (idd.FreeItemID == null)
{
idd.FreeItemID = sdd.FreeItemID;
idd.FreeItemQty = sdd.FreeItemQty;
}
else
idd.FreeItemQty = sdd.FreeItemQty;
DiscountDetails.Update(idd);
}
else
{
idd = new SOInvoiceDiscountDetail();
idd.Type = DiscountType.Line;
idd.TranType = newdoc.DocType;
idd.RefNbr = newdoc.RefNbr;
idd.OrderType = sdd.OrderType;
idd.OrderNbr = sdd.OrderNbr;
idd.DiscountID = sdd.DiscountID;
idd.DiscountSequenceID = sdd.DiscountSequenceID;
idd.FreeItemID = sdd.FreeItemID;
idd.FreeItemQty = sdd.FreeItemQty;
DiscountDetails.Insert(idd);
}
}
#endregion
}
this.Document.Update(newdoc);
if (list != null)
{
if (Transactions.Search<ARTran.sOOrderType, ARTran.sOOrderNbr, ARTran.sOShipmentType, ARTran.sOShipmentNbr>(shipment.OrderType, shipment.OrderNbr, shipment.ShipmentType, shipment.ShipmentNbr).Count > 0)
{
try
{
this.Document.Current.ApplyPaymentWhenTaxAvailable = true;
this.Save.Press();
}
finally
{
this.Document.Current.ApplyPaymentWhenTaxAvailable = false;
}
if (list.Find(this.Document.Current) == null)
{
list.Add(this.Document.Current, this.SODocument.Current);
}
}
else
{
this.Clear();
}
}
this.RowUpdated.RemoveHandler(typeof(ARInvoice), ApprovedBalanceCollector);
}
