FieldDefaulting handlers - acumatica

I am having trouble setting default values for a filter on a processing page. I originally had code in the RowSelected handler to set the default values and set the end dates default as below:
//Local unbound filter DAC
#region StartShipDate
public abstract class startShipDate : PX.Data.IBqlField { }
protected DateTime? _StartShipDate;
[PXDate()]
[PXUIField(DisplayName = "Start Ship Date", Visibility = PXUIVisibility.SelectorVisible, Required = false)]
[PXDefault(PersistingCheck = PXPersistingCheck.Nothing)]
public virtual DateTime? StartShipDate { get; set; }
#endregion
#region EndShipDate
public abstract class endShipDate : PX.Data.IBqlField { }
protected DateTime? _EndShipDate;
[PXDate()]
[PXUIField(DisplayName = "End Ship Date", Visibility = PXUIVisibility.SelectorVisible)]
[PXDefault(typeof(AccessInfo.businessDate), PersistingCheck = PXPersistingCheck.Nothing)]
public virtual DateTime? EndShipDate { get; set; }
#endregion
#region StartImportDate
public abstract class startImportDate : PX.Data.IBqlField { }
protected DateTime? _StartImportDate;
[PXDate()]
[PXUIField(DisplayName = "Start Import Date", Visibility = PXUIVisibility.SelectorVisible, Required = false)]
[PXDefault(PersistingCheck = PXPersistingCheck.Nothing)]
public virtual DateTime? StartImportDate { get; set; }
#endregion
#region EndImportDate
public abstract class endImportDate : PX.Data.IBqlField { }
protected DateTime? _EndImportDate;
[PXDate()]
[PXUIField(DisplayName = "End Import Date", Visibility = PXUIVisibility.SelectorVisible)]
[PXDefault(typeof(AccessInfo.businessDate), PersistingCheck = PXPersistingCheck.Nothing)]
public virtual DateTime? EndImportDate { get; set; }
#endregion
//Excerpt from RowSelected handler
if (!filter.StartImportDate.HasValue && filter.EndImportDate.HasValue)
{
DateTime endDate = DateTime.Today;
DateTime begDate = endDate.AddMonths(-1);
filter.StartImportDate = begDate;
filter.EndImportDate = endDate;
}
if (!filter.StartShipDate.HasValue && filter.EndShipDate.HasValue)
{
DateTime endDate = DateTime.Today.AddMonths(1);
DateTime begDate = DateTime.Today.AddMonths(-1);
filter.StartShipDate = begDate;
filter.EndShipDate = endDate;
}
I then installed the latest Acuminator and it gave me a warning not to set DAC fields from within the RowSelected handler so I removed the code and attempted to set it in the FieldDefaulting handler. I can't seem to get the defaults to set correctly.
protected virtual void EDOrderReviewFilter_StartImportDate_FieldDefaulting(PXCache sender, PXFieldDefaultingEventArgs e)
{
EDOrderReviewFilter row = e.Row as EDOrderReviewFilter;
if (row != null)
{
if (!row.StartImportDate.HasValue && row.EndImportDate.HasValue)
{
e.NewValue = DateTime.Today.AddMonths(-1);
e.Cancel = true;
}
}
}
protected virtual void EDOrderReviewFilter_StartShipDate_FieldDefaulting(PXCache sender, PXFieldDefaultingEventArgs e)
{
EDOrderReviewFilter row = e.Row as EDOrderReviewFilter;
if (row != null)
{
if (!row.StartShipDate.HasValue && row.EndShipDate.HasValue)
{
e.NewValue = DateTime.Today.AddMonths(-1);
e.Cancel = true;
}
}
}
Is there a way to do a date calculation in the PXDefault attribute, or what is wrong with my defaulting handlers?

With Brendan's help, this is what I ended up with.
protected virtual void EDOrderReviewFilter_StartImportDate_FieldDefaulting(PXCache sender, PXFieldDefaultingEventArgs e)
{
e.NewValue = DateTime.Today.AddMonths(-1);
}
protected virtual void EDOrderReviewFilter_EndImportDate_FieldDefaulting(PXCache sender, PXFieldDefaultingEventArgs e)
{
e.NewValue = DateTime.Today;
}
protected virtual void EDOrderReviewFilter_StartShipDate_FieldDefaulting(PXCache sender, PXFieldDefaultingEventArgs e)
{
e.NewValue = DateTime.Today.AddMonths(-1);
}
protected virtual void EDOrderReviewFilter_EndShipDate_FieldDefaulting(PXCache sender, PXFieldDefaultingEventArgs e)
{
e.NewValue = DateTime.Today.AddMonths(1);
}
Since there are no PXDefault attributes on the columns the cancel was not required. Sometimes simpler is better!

Related

Acumatica - Revision

We have 2 DAC - Master and Child
Master DAC
#region MasterID
public abstract class masterID:PX.Data.BQL.BqlInt.Field<masterID> { }
protected int? _MasterID;
[PXDBIdentity()]
[PXUIField(Visibility = PXUIVisibility.Invisible)]
[PXReferentialIntegrityCheck]
public virtual int? MasterID
{
get {return this._MasterID;}
set {this._MasterID = value;}
}
#endregion
#region MasterCD
public abstract class masterRoutingCD:PX.Data.BQL.BqlString.Field<masterCD> { }
protected string _MasterRoutingCD;
[BomID(DisplayName = "Master #", IsKey = true, Required = true,
Visibility = PXUIVisibility.SelectorVisible)]
[PXDefault]
[Rev.Key(typeof(Setup.pMMasterNumberSequenceID),
typeof(Master.masterCD),
typeof(Master.revisionNo),
typeof(Master.masterCD),
typeof(Master.revisionNo)
)]
public virtual string MasterCD
{
get {return this._MasterCD;}
set {this._MasterCD = value;}
}
#endregion
#region RevisionNo
public abstract class revisionNo:PX.Data.IBqlField { }
protected string _RevisionNo;
[RevisionIDField(IsKey = true, Visibility = PXUIVisibility.SelectorVisible,
Required = true)]
[PXDefault(typeof(Master.defaultRevisionNo),
PersistingCheck = PXPersistingCheck.Nothing)]
[Rev.ID(typeof(Master.defaultRevisionNo),
typeof(Master.masterCD),
typeof(Master.revisionNo),
typeof(Master.revisionNo),
typeof(Master.description),
typeof(Master.fromDate),
typeof(Master.toDate))]
public virtual string RevisionNo
{
get {return this._RevisionNo;}
set {this._RevisionNo = value;}
}
#endregion
Child DAC
public abstract class childID:PX.Data.BQL.BqlInt.Field<childID> { }
protected int? _ChildID;
[PXDBIdentity()]
//[PXReferentialIntegrityCheck]
public virtual int? ChildID
{
get {return this._ChildID;}
set {this._ChildID = value;}
}
#endregion
#region MasterID
public abstract class masterID:PX.Data.BQL.BqlInt.Field<masterID> { }
protected int? _MasterID;
[PXDBInt()]
[PXDBDefault(typeof(Master.masterID))]
[PXParent(typeof(Select<Master, Where<Master.masterRoutingCD, Equal<Current<masterCD>>,
And<Master.revisionNo, Equal<Current<revisionNo>>>>>))]
public virtual int? MasterID
{
get {return _MasterID;}
set {_MasterID = value;}
}
#endregion MasterID
#region MasterCD
public abstract class masterCD:PX.Data.BQL.BqlString.Field<masterCD> { }
protected string _MasterCD;
[PXDBDefault(typeof(Master.masterCD))]
[PXDBString(IsKey = true, IsUnicode = true)]
public virtual string MasterCD
{
get {return this._MasterCD;}
set {this._MasterCD = value;}
}
#endregion
#region Revision
public abstract class revisionNo:PX.Data.BQL.BqlString.Field<revisionNo> {}
[PXDBString(15, IsKey = true, IsUnicode = true)]
[PXDBDefault(typeof(Master.revisionNo))]
public virtual string RevisionNo { get; set; }
#endregion Revision
public abstract class stepsID:PX.Data.BQL.BqlInt.Field<stepsID> { }
[OperationCDField(IsKey =true, DisplayName = "Steps ID",
Visibility = PXUIVisibility.SelectorVisible)]
[PXDefault(PersistingCheck = PXPersistingCheck.NullOrBlank)]
//[PXUIField(DisplayName = "Process Steps ID")]
public virtual string StepsID { get; set; }
Graph - MasterMaint
public class MasterMaint:PXRevisionableGraph<MasterMaint, Master,
Master.masterCD, Master.revisionNo>
{
public PXSelect<Child, Where<Child.masterCD, Equal<Current<Master.masterCD>>,
And<Child.revisionNo, Equal<Current<Master.revisionNo>>>>> ChildRecords;
#region Override
public override bool CanClipboardCopyPaste()
{
return false;
}
public override bool CanCreateNewRevision(MasterMaint fromGraph, MasterMaint toGraph,
string keyValue, string revisionValue, out string error)
{
// Always returns true as new revisions can be created at any time
error = string.Empty;
return true;
}
public override void CopyRevision(MasterMaint fromGraph, MasterMaint toGraph,
string keyValue, string revisionValue)
{
if(toGraph?.Documents?.Current == null || fromGraph?.Documents?.Current == null)
{
// api calls should create new revs on their own - this causes issues
// when calling from api so we need to turn the copy rev logic off
return;
}
toGraph.Documents.Cache.SetDefaultExt<EWPMMasterRouting.status>
(toGraph.Documents.Current);
if(SkipAutoCreateNewRevision())
{
return;
}
CopyChildRecords(fromGraph.Documents.Current.MasterRoutingCD,
fromGraph.Documents.Current.RevisionNo, toGraph.Documents.Current.MasterID,
keyValue, revisionValue, false);
}
internal virtual void CopyChildRecords(string sourceID, string sourceRevisionNo,
int? newMasterID, string newMasterCD, string newRevisionID, bool copyNotes)
{
foreach(Child fromRow in PXSelect<Child,
Where<Child.masterCD, Equal<Required<Child.masterCD>>,
And<Child.revisionNo, Equal<Required<Child.revisionNo>>>>>
.Select(this, sourceID, sourceRevisionNo))
{
var toRow = PXCache<Child>.CreateCopy(fromRow);
toRow.MasterID = newMasterRoutingID;
toRow.ChildID = null;
toRow.MasterCD = newMasterCD;
toRow.RevisionNo= newRevisionID;
toRow = ChildRecords.Insert(toRow);
}
}
#endregion
}
Issue - When the value is changed in the Revision the record is displayed with new revision number keeping the CD fields as for previous revision and all the child.
That is all correct, But when the record is saved, there is error "Another process has updated the Record, your changes will be lost"
Why there is a Error
In Acuamtica we have NoteID column unique across the system If you try to create a record with duplicating NoteID field value you'll get "Another process has updated the record" exception because it consider that you are updating the same record.
In you case when you copy revision you do not reset the NoteID value for the record so you actually try to insert another record with the same value.
You'll need to add the following line to CopyRevision method
toGraph.Documents.Cache.SetDefaultExt<EWPMMasterRouting.noteID>(toGraph.Documents.Current);

Creating multiple records from button press but only a single record is created

I am attempting to create multiple records when a button is pressed and display it in a grid. These records are created when the button is pressed, however only a single record is created and displayed. I have determined in testing that only the final record that would be created by this process is created. I don't receive any errors when the button is pressed, but still only a single record is resulted.
public PXSelect<TestDocument> Documents; //View of Grid
protected void CreateDocument(ARInvoice invoice, ARPayment payment)
{
TestDocument testDoc = new TestDocument();
//Creating TestDocument
testDoc.CustomerID = invoice.CustomerID;
testDoc.InvoiceID = invoice.RefNbr;
testDoc.PaymentID = payment.RefNbr;
testDoc.InvoiceTotal = invoice.CuryLineTotal;
testDoc.PaymentTotal = payment.CuryLineTotal;
testDoc.InvoiceDate = invoice.DocDate;
testDoc.PaymentDate = payment.DocDate;
Documents.Insert(testDoc);
Persist();
}
public PXAction<FilterTable> Preview;
[PXButton(CommitChanges = true)]
[PXUIField(DisplayName = "Preview")]
protected void preview()
{
foreach(PXResult<ARPayment> paymentResult in PXSelect<ARPayment,
Where<ARPayment.openDoc, Equal<True>>>.Select())
{
ARPayment payment = (ARPayment) paymentResult;
//ARInvoices that are open and share CustomerID with the ARPayment
foreach(PXResult<ARInvoice> invoiceResult in PXSelect<ARInvoice, Where<ARInvoice.customerID,
Equal<Required<ARPayment.customerID>>, And<ARInvoice.openDoc,Equal<True>>>>
.Select(this, payment.CustomerID))
{
ARInvoice invoice = (ARInvoice) invoiceResult;
CreateTransaction(invoice, payment);
}
}
}
public class TestDocument : IBqlTable
{
#region TransactionID
public abstract class transactionID : PX.Data.BQL.BqlInt.Field<transactionID> { }
[PXDBIdentity]
public virtual Int32? TransactionID { get; set; }
protected Int32? tranID;
#endregion
#region InvoiceID
[PXDBString(15, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Invoice Ref. Nbr.")]
public virtual string InvoiceRefNbr{ get; set; }
public abstract class invoiceRefNbr: PX.Data.BQL.BqlString.Field<invoiceRefNbr> { }
#endregion
#region PaymentID
[PXDBString(15, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Payment Ref. Nbr.")]
public virtual string PaymentRefNbr{ get; set; }
public abstract class paymentRefNbr: PX.Data.BQL.BqlString.Field<paymentRefNbr> { }
#endregion
#region CustomerID
[PXDBInt()]
[PXUIField(DisplayName = "CustomerID")]
[PXSelector(typeof(Customer.bAccountID), DescriptionField = typeof(Customer.acctCD))]
public virtual int? CustomerID{ get; set; }
public abstract class customerID: PX.Data.BQL.BqlInt.Field<customerID> { }
#endregion
#region InvoiceDate
[PXDBDate()]
[PXUIField(DisplayName = "Invoice Date")]
public virtual DateTime? InvoiceDate{ get; set; }
public abstract class invoiceDate: PX.Data.BQL.BqlDateTime.Field<invoiceDate> { }
#endregion
#region PaymentDate
[PXDBDate()]
[PXUIField(DisplayName = "Payment Date")]
public virtual DateTime? PaymentDate{ get; set; }
public abstract class paymentDate: PX.Data.BQL.BqlDateTime.Field<paymentDate> { }
#endregion
#region InvoiceTotal
[PXDBDecimal()]
[PXUIField(DisplayName = "Invoice Total")]
public virtual Decimal? InvoiceTotal{ get; set; }
public abstract class invoiceTotal: PX.Data.BQL.BqlDecimal.Field<invoiceTotal> { }
#endregion
#region PaymentTotal
[PXDBDecimal()]
[PXUIField(DisplayName = "Payment Total")]
public virtual Decimal? PaymentTotal{ get; set; }
public abstract class paymentTotal: PX.Data.BQL.BqlDecimal.Field<paymentTotal> { }
#endregion
}
It appears that your DAC is missing the Key fields.
Define the TransactionID column with this attribute instead:
[PXDBIdentity(IsKey = true)]

Navigating to next page on grid does not refresh the data

I have a grid that displays rows based on the form's filters. When navigated to the next page the data remains the same. I have exported the data into excel which gets all the rows. Only the first page and last page navigation change the rows. Please help on what am I missing in the ASPX
Graph containing view delegate and DAC
public class InventorySales : PXGraph<InventorySales>
{
[Serializable]
public class Filter : IBqlTable
{
public abstract class wareHouse : IBqlField { }
[PXDefault()]
[PXUIField(DisplayName = "Warehouse")]
[PX.Objects.IN.POSiteAvail(typeof(POReceiptLine.inventoryID), typeof(POReceiptLine.subItemID))]
public virtual int? WareHouse { get; set; }
#region InventoryID
public abstract class inventoryCD : PX.Data.IBqlField
{
}
protected Int32? _InventoryCD;
[PXInt()]
[PXUIField(DisplayName = "SKU", Visibility = PXUIVisibility.SelectorVisible)]
[PXSelector(typeof(Search<
InventoryItem.inventoryID,
Where<InventoryItem.itemStatus, Equal<InventoryItemStatus.active>>>),
new Type[] { typeof(InventoryItem.inventoryID), typeof(InventoryItem.inventoryCD),
typeof(InventoryItem.itemStatus),
typeof(InventoryItem.descr)},
SubstituteKey = typeof(InventoryItem.inventoryCD),
DescriptionField = typeof(InventoryItem.descr))]
public virtual Int32? InventoryCD
{
get
{
return this._InventoryCD;
}
set
{
this._InventoryCD = value;
}
}
#endregion
#region BeginDate
public abstract class beginDate : IBqlField
{
}
protected DateTime? _BeginDate;
[PXDBDate]
[PXDefault(typeof(AccessInfo.businessDate))]
[PXUIField(DisplayName = "Start Date")]
public virtual DateTime? BeginDate
{
get
{
return _BeginDate;
}
set
{
_BeginDate = value;
}
}
#endregion
#region EndDate
public abstract class endDate : IBqlField { }
[PXDBDate]
[PXDefault(typeof(AccessInfo.businessDate))]
[PXUIField(DisplayName = "End Date")]
public virtual DateTime? EndDate { get; set; }
#endregion
#region Sales
public abstract class sales : PX.Data.IBqlField
{
}
protected Int32? _Sales;
[PXInt()]
[PXUnboundDefault("30")]
[PXUIField(DisplayName = "Sales")]
[InvSales.List]
public virtual Int32? Sales
{
get
{
return this._Sales;
}
set
{
this._Sales = value;
}
}
#endregion
}
public PXCancel<Filter> Cancel;
public PXFilter<Filter> MasterView;
public PXSelectJoin<
POReceiptLine,
InnerJoin<POReceipt,
On<POReceiptLine.receiptType, Equal<POReceipt.receiptType>,
And<POReceiptLine.receiptNbr, Equal<POReceipt.receiptNbr>>>,
InnerJoin<INSiteStatus,
On<INSiteStatus.inventoryID, Equal<POReceiptLine.inventoryID>,
And<INSiteStatus.siteID, Equal<POReceiptLine.siteID>>>>>,
Where2<
Where2<
Where<POReceiptLine.siteID, Equal<Current<Filter.wareHouse>>,
And<POReceipt.receiptType, Equal<POReceiptType.poreceipt>>>,
And<Where<POReceiptLine.inventoryID, Equal<Current<Filter.inventoryCD>>,
Or<Current<Filter.inventoryCD>, IsNull>>>>,
And<Where<POReceiptLine.receiptDate, GreaterEqual<Current<Filter.beginDate>>,
And<POReceiptLine.receiptDate, LessEqual<Current<Filter.endDate>>>>>>>
DetailsView;
public PXSelectJoin<
SOLine,
InnerJoin<SOOrder,
On<SOLine.orderType, Equal<SOOrder.orderType>,
And<SOOrder.orderNbr, Equal<SOLine.orderNbr>>>>,
Where<SOOrder.status, NotEqual<SOStatus>,
And<SOOrder.orderDate, GreaterEqual<Sub<Current<AccessInfo.businessDate>,Current<Filter.sales>>>,
And<SOOrder.orderDate, LessEqual<Current<AccessInfo.businessDate>>>>>> ss;
List<PXResult<SOLine>> list = new List<PXResult<SOLine>>();
public IEnumerable detailsView()
{
list = PXSelectJoin<
SOLine,
InnerJoin<SOOrder,
On<SOLine.orderType, Equal<SOOrder.orderType>,
And<SOOrder.orderNbr, Equal<SOLine.orderNbr>>>>,
Where<SOOrder.status, NotEqual<SOStatus>,
And<SOOrder.orderDate, GreaterEqual<Sub<Current<AccessInfo.businessDate>, Current<Filter.sales>>>,
And<SOOrder.orderDate, LessEqual<Current<AccessInfo.businessDate>>>>>>.Select(this).ToList();
Int32 startrow = PXView.StartRow;
List<POReceiptLine> poReceiptLineList = new List<POReceiptLine>();
PXView.StartRow = 0;
foreach (PXResult<POReceiptLine, POReceipt, INSiteStatus> result in PXSelectJoin<
POReceiptLine,
InnerJoin<POReceipt,
On<POReceiptLine.receiptType, Equal<POReceipt.receiptType>,
And<POReceiptLine.receiptNbr, Equal<POReceipt.receiptNbr>>>,
InnerJoin<INSiteStatus,
On<INSiteStatus.inventoryID, Equal<POReceiptLine.inventoryID>,
And<INSiteStatus.siteID, Equal<POReceiptLine.siteID>>>>>,
Where2<
Where2<
Where<POReceiptLine.siteID, Equal<Current<Filter.wareHouse>>,
And<POReceipt.receiptType, Equal<POReceiptType.poreceipt>>>,
And<Where<POReceiptLine.inventoryID, Equal<Current<Filter.inventoryCD>>,
Or<Current<Filter.inventoryCD>, IsNull>>>>,
And<Where<POReceiptLine.receiptDate, GreaterEqual<Current<Filter.beginDate>>,
And<POReceiptLine.receiptDate, LessEqual<Current<Filter.endDate>>>>>>>
.Select(this))
{
decimal? sum = 0.00M;
POReceiptLine objsalesprice = (POReceiptLine)result;
INSiteStatus objInSiteStatus = (INSiteStatus)result;
if (objsalesprice != null)
{
POReceiptLineExt obj = objsalesprice.GetExtension<POReceiptLineExt>();
foreach (PXResult<SOLine> res in list)
{
SOLine so = (SOLine)res;
if (so.InventoryID == objsalesprice.InventoryID)
sum = sum + so.CuryLineAmt;
}
obj.UsrSales = sum;
obj.UsrQtyAvail = objInSiteStatus.QtyAvail;
if (!poReceiptLineList.Any(x => x.InventoryID == objsalesprice.InventoryID))
{
poReceiptLineList.Add(objsalesprice);
}
else if (poReceiptLineList.Any(x => x.InventoryID == objsalesprice.InventoryID && x.ReceiptDate.Value.Date < objsalesprice.ReceiptDate.Value.Date))
{
var itemToRemove = poReceiptLineList.Single(r => (r.InventoryID == objsalesprice.InventoryID));
poReceiptLineList.Remove(itemToRemove);
poReceiptLineList.Add(objsalesprice);
}
else if (poReceiptLineList.Any(x => x.InventoryID == objsalesprice.InventoryID
&& x.ReceiptDate.Value.Date == objsalesprice.ReceiptDate.Value.Date && x.CreatedDateTime < objsalesprice.CreatedDateTime))
{
var itemToRemove = poReceiptLineList.Single(r => (r.InventoryID == objsalesprice.InventoryID));
poReceiptLineList.Remove(itemToRemove);
poReceiptLineList.Add(objsalesprice);
}
}
}
return poReceiptLineList;
}
}
You will have to re-work the 'detailsView' delegate method so that it uses the PXView pattern to handle paging.
Detailed instructions on using PXView with Paging in delegate can be found here: https://asiablog.acumatica.com/2016/06/using-pxview-in-dataview-delegate.html
Here's the relevant code excerpt from that page:
public PXSelect<DAC> DataView;
public IEnumerable dataView()
{
PXView select = new PXView(this, true, DataView.View.BqlSelect);
Int32 totalrow = 0;
Int32 startrow = PXView.StartRow;
List<object> result = select.Select(PXView.Currents, PXView.Parameters,
PXView.Searches, PXView.SortColumns, PXView.Descendings,
PXView.Filters, ref startrow, PXView.MaximumRows, ref totalrow);
PXView.StartRow = 0;
foreach (PXResult<DAC> row in result)
{
// Do any dynamic calculations
yield return row;
}
}
Alternatively you can remove paging on the grid by setting the AllowPaging="false" property of the Grid element if you don't need paging.

Unbound DAC Processing Screen

I am having trouble getting the individual select check to work on my processing screen. The DAC is unbound composed of data from several tables. Process All works correctly, but I cannot check individual rows. I get an error stating "Error: The argument is out of range. Parameter name: table.
Process All results:
I have tried a variety of combinations of attributes and have had no luck. My code is below. Any help would be appreciated.
using System;
using System.Collections;
using System.Collections.Generic;
using PX.SM;
using PX.Data;
using PX.Objects.AR;
using PX.Objects.CS;
using PX.Objects.SO;
using PX.Objects.CR;
using PX.Objects.IN;
using PX.Objects.SM;
using CRLocation = PX.Objects.CR.Standalone.Location;
using PX.Data.ReferentialIntegrity.Attributes;
using LingoInterface;
using System.Text.RegularExpressions;
namespace EDIASNs
{
public class EDInventoryProcess : PXGraph<EDInventoryProcess>
{
public PXCancel<EDInventoryFilter> Cancel;
public PXFilter<EDInventoryFilter> Filter;
[PXFilterable]
public PXFilteredProcessingOrderBy<EDInventory, EDInventoryFilter,
OrderBy<Asc<EDInventory.partnerID, Asc<EDInventory.inventoryCD>>>> EDItem;
protected virtual IEnumerable eDItem()
{
int ii = 0;
foreach (var row in EDItem.Cache.Cached)
{
ii++;
yield return row;
}
Int32 rowCntr = 0;
if (ii == 0)
{
var cmd = new PXSelectJoin<InventoryItem,
InnerJoin<INItemXRef, On<InventoryItem.inventoryID, Equal<INItemXRef.inventoryID>>,
InnerJoin<EDPartnerInfo, On<INItemXRef.bAccountID, Equal<EDPartnerInfo.customerID>>>>,
Where<INItemXRef.alternateType, Equal<INAlternateType.cPN>,
And<InventoryItem.itemStatus, Equal<InventoryItemStatus.active>>>>(this);
if (this.Filter.Current.TradingPartner != null)
{
cmd.WhereAnd<Where<EDPartnerInfo.partnerID, Equal<Current<EDInventoryFilter.tradingPartner>>>>();
}
cmd.View.Clear();
var ret = cmd.Select();
if (ret != null)
{
EDInventoryFilter filt = (EDInventoryFilter)Filter.Cache.Current;
EDInventory edInv = new EDInventory();
foreach (PXResult<InventoryItem, INItemXRef, EDPartnerInfo> record in ret)
{
edInv = new EDInventory();
InventoryItem item = (InventoryItem)record;
INItemXRef xref = (INItemXRef)record;
EDPartnerInfo partner = (EDPartnerInfo)record;
edInv.InvID = Guid.NewGuid();
rowCntr++;
edInv.IntID = rowCntr;
edInv.PartnerID = partner.PartnerID;
edInv.InventoryID = item.InventoryID;
edInv.InventoryCD = item.InventoryCD;
edInv.ItemDescr = item.Descr;
edInv.ItemStatus = item.ItemStatus;
edInv.BaseUnit = item.BaseUnit;
edInv.SalesUnit = item.SalesUnit;
edInv.PurchaseUnit = item.PurchaseUnit;
edInv.BasePrice = Convert.ToDecimal(item.BasePrice);
edInv.BaseWeight = item.BaseWeight;
edInv.BaseVolume = item.BaseVolume;
edInv.BaseItemWeight = item.BaseItemWeight;
edInv.BaseItemVolume = item.BaseItemVolume;
edInv.WeightUOM = item.WeightUOM;
edInv.VolumeUOM = item.VolumeUOM;
//edInv.NoteID = item.NoteID;
edInv.PartnerCustomerID = partner.CustomerID;
edInv.CustomerItem = xref.AlternateID;
edInv.CustomerItemDescr = xref.Descr;
var cmdAttrib = new PXSelect<CSAnswers,
Where<CSAnswers.refNoteID, Equal<Required<CSAnswers.refNoteID>>>>(this);
cmdAttrib.View.Clear();
var retAttrib = cmdAttrib.Select(item.NoteID);
if (retAttrib != null)
{
foreach (PXResult<CSAnswers> recAttrib in retAttrib)
{
CSAnswers ans = (CSAnswers)recAttrib;
switch (ans.AttributeID)
{
case "CASEQTY":
edInv.CaseQty = Convert.ToInt32(ans.Value);
break;
case "CASEL":
edInv.CaseL = Convert.ToDecimal(ans.Value);
break;
case "CASEW":
edInv.CaseW = Convert.ToDecimal(ans.Value);
break;
case "CASEH":
edInv.CaseH = Convert.ToDecimal(ans.Value);
break;
case "UPC":
edInv.UPC = ans.Value;
break;
}
}
}
var cmdPrice = new PXSelect<ARSalesPrice,
Where<ARSalesPrice.priceType, Equal<PriceTypes.customer>,
And<ARSalesPrice.customerID, Equal<Required<ARSalesPrice.customerID>>,
And<ARSalesPrice.inventoryID, Equal<Required<ARSalesPrice.inventoryID>>,
And<ARSalesPrice.expirationDate, GreaterEqual<Required<ARSalesPrice.expirationDate>>>>>>>(this);
cmdPrice.View.Clear();
var retPrice = cmdPrice.Select(partner.CustomerID, item.InventoryID, this.Accessinfo.BusinessDate);
if (retPrice != null)
{
foreach (PXResult<ARSalesPrice> recPrice in retPrice)
{
ARSalesPrice price = (ARSalesPrice)recPrice;
edInv.CustomerPrice = price.SalesPrice;
}
}
int intOnHand = 0;
int intCommitted = 0;
int intOnOrder = 0;
var cmdStock = new PXSelectJoin<INSiteStatus,
InnerJoin<INSite, On<INSiteStatus.siteID, Equal<INSite.siteID>>>,
Where<INSite.active, Equal<True>,
And<INSiteStatus.inventoryID, Equal<Required<INSiteStatus.inventoryID>>>>>(this);
cmdStock.View.Clear();
var retStock = cmdStock.Select(item.InventoryID);
if (retStock != null)
{
foreach (PXResult<INSiteStatus> recStock in retStock)
{
INSiteStatus stock = (INSiteStatus)recStock;
intOnHand += Convert.ToInt32(stock.QtyOnHand);
intCommitted += Convert.ToInt32(stock.QtySOShipped + stock.QtySOShipping);
intOnOrder += Convert.ToInt32(stock.QtyPOPrepared + stock.QtyPOReceipts);
}
edInv.OnHand = intOnHand;
edInv.Committed = intCommitted;
edInv.OnOrder = intOnOrder;
}
edInv = EDItem.Insert(edInv);
EDItem.Cache.SetStatus(edInv, PXEntryStatus.Held);
yield return edInv;
}
}
EDItem.Cache.IsDirty = false;
}
}
public void EDInventoryFilter_RowUpdated(PXCache sender, PXRowUpdatedEventArgs e)
{
EDInventoryFilter filterOld = (EDInventoryFilter)e.OldRow;
EDInventoryFilter filterNew = (EDInventoryFilter)e.Row;
if (filterOld.Action == filterNew.Action) //Don't clear cache if only action changes
EDItem.Cache.Clear();
}
public void EDInventoryFilter_RowSelected(PXCache sender, PXRowSelectedEventArgs e)
{
//Get list of partners to set filter
List<string> strPartnerList = new List<string>();
strPartnerList.Clear();
var filter = (EDInventoryFilter)e.Row;
foreach (EDPartnerInfo partner in PXSelect<EDPartnerInfo>.Select(this))
{
strPartnerList.Add(partner.PartnerID);
}
if (strPartnerList.Count > 0)
PXStringListAttribute.SetList<EDInventoryFilter.tradingPartner>
(sender, filter, strPartnerList.ToArray(), strPartnerList.ToArray());
else
{
throw new PXException("No active partners found");
}
EDItem.SetProcessDelegate
(
delegate (List<EDInventory> list)
{
var graph = PXGraph.CreateInstance<EDInventoryProcess>();
graph.InventorySync(filter, list);
}
);
//Action must be selected for Process buttons to be available
if (filter.Action == null || filter.Action == "")
{
EDItem.SetProcessVisible(false);
EDItem.SetProcessAllVisible(false);
}
}
public void EDInventory_RowSelected(PXCache sender, PXRowSelectedEventArgs e)
{
var row = (EDInventory)e.Row;
}
public void InventorySync(EDInventoryFilter filter, List<EDInventory> list)
{
//Create Lingo API object and login
bool ediDemo = false;
bool bolAtLeastOneError = false;
Int32 cntr = 0;
EDCompanyData edCompanyData = new EDCompanyData();
foreach (EDCompanyData data in PXSelect<EDCompanyData,
Where<EDCompanyData.active, Equal<Required<EDCompanyData.active>>>>.Select(this, true))
{
cntr++;
if (data.Service == "DEMO")
ediDemo = true;
edCompanyData = data;
}
if (cntr == 0)
throw new PXException("No active Service Data entries!");
if (cntr > 1)
throw new PXException("More than one active Service Data entry!");
var lingo = new LingoApi();
//Set url for service
lingo.Url = edCompanyData.Url;
if (!ediDemo)
{
if (!lingo.Login(edCompanyData.EDIAccount, edCompanyData.EDILoginName, edCompanyData.EDIPassword, edCompanyData.EDIApiKey))
throw new PXException("Login to EDI system failed.");
}
//Initialize variables
EdiItem updateItem = new EdiItem();
bool bolNewItem = false;
Regex rxNonDigits = new Regex(#"[^\d]+");
foreach (EDInventory acItem in list)
{
//Check for existing item in EDI
if (lingo.Login() || ediDemo) //Refresh the login session
{
if (!ediDemo)
{
LingoRetItem itemRet = lingo.RetrieveItem(acItem.PartnerID, acItem.InventoryCD);
if (itemRet && itemRet.Count != 0) //Found Item
{
if (itemRet.Count > 1)
{
PXProcessing<EDInventory>.SetError(list.IndexOf(acItem), String.Format("More than 1 occurrence found: {0}", itemRet.Message));
bolAtLeastOneError = true;
}
else
{
updateItem = itemRet.DataItem; //Load existing item data and set flag
bolNewItem = false;
}
}
else
{
updateItem = new EdiItem(); //Clear item object for new item and set flag
bolNewItem = true;
}
}
updateItem.account = edCompanyData.EDIAccount;
updateItem.partner = acItem.PartnerID;
if (bolNewItem)
updateItem.createDate = DateTime.Today.ToString("yyyyMMdd");
updateItem.upcCode = rxNonDigits.Replace(acItem.UPC, ""); //Remove non-numeric characters
updateItem.upcCodeType = "UPC";
updateItem.vendorItem = acItem.InventoryCD;
updateItem.vendorItemType = "VNDR";
updateItem.customerItem = acItem.CustomerItem;
if (string.IsNullOrEmpty(acItem.CustomerItemDescr))
updateItem.itemDesc = acItem.ItemDescr;
else
updateItem.itemDesc = acItem.CustomerItemDescr;
if (acItem.BaseItemWeight > 0)
updateItem.itemWeight = acItem.BaseItemWeight.ToString();
else
updateItem.itemWeight = acItem.BaseWeight.ToString();
//Inventory Information
updateItem.qtyOnHand = acItem.OnHand.ToString();
updateItem.qtyCommitted = acItem.Committed.ToString();
updateItem.qtyOnOrder = acItem.OnOrder.ToString();
//Item Pricing Information
if (acItem.CustomerPrice > 0)
updateItem.unitPrice = acItem.CustomerPrice.ToString();
else
updateItem.unitPrice = acItem.BasePrice.ToString();
updateItem.priceBasis = acItem.SalesUnit;
//Item Packing and Carton Information
updateItem.unitMeasure = acItem.BaseUnit;
updateItem.packSize = acItem.CaseQty.ToString();
updateItem.cartonLength = acItem.CaseL.ToString();
updateItem.cartonWidth = acItem.CaseW.ToString();
updateItem.cartonHeight = acItem.CaseH.ToString();
LingoRet itemMaintResult = new LingoRet();
if (!ediDemo)
itemMaintResult = lingo.MaintainItem(updateItem, bolNewItem);
else
{
itemMaintResult.Code = "OK";
itemMaintResult.Message = "Success";
}
//Check result
if (itemMaintResult.Code == "OK" || ediDemo)
{
PXProcessing<EDInventory>.SetInfo(list.IndexOf(acItem),
String.Format(" Item {0} EDI: {1}", bolNewItem ? "added to" : "updated in",itemMaintResult.Message));
}
else
{
PXProcessing<EDInventory>.SetError(list.IndexOf(acItem), String.Format(" Item maintenance failed: {0}", itemMaintResult.Message));
bolAtLeastOneError = true;
}
}
else
{
PXProcessing<EDInventory>.SetError(list.IndexOf(acItem), String.Format(" Lingo login failed: {0}", lingo.ResMessage));
bolAtLeastOneError = true;
}
}
if (bolAtLeastOneError)
throw new PXException("At least one item had exceptions");
}
[Serializable]
public partial class EDInventoryFilter : IBqlTable
{
#region TradingPartner
public abstract class tradingPartner : PX.Data.IBqlField
{
}
protected string _TradingPartner;
[PXString(15)]
[PXUIField(DisplayName = "Trading Partner")]
[PXStringList(new string[] { }, new string[] { })]
public virtual String TradingPartner { get; set; }
#endregion
#region Action
public abstract class action : PX.Data.IBqlField { }
protected string _Action;
[PXDefault("P")]
[PXString(15)]
[PXUIField(DisplayName = "Action")]
[PXStringList(new string[] { "P" }, new string[] { "Push to EDI" })]
public virtual String Action { get; set; }
#endregion
}
[Serializable]
public partial class EDInventory : IBqlTable
{
#region Selected
public abstract class selected : IBqlField { }
protected bool? _Selected = false;
[PXBool]
[PXDefault(false)]
[PXUIField(DisplayName = "Selected")]
public virtual bool? Selected { get; set; }
#endregion
#region InvID
public abstract class invID : PX.Data.IBqlField { }
protected Guid? _InvID;
[PXGuid]
[PXUIField(DisplayName = "ID")]
public virtual Guid? InvID { get; set; }
#endregion
#region intID
public abstract class intID : PX.Data.IBqlField { }
protected int? _IntID;
[PXInt(IsKey = true)]
[PXUIField(DisplayName = "intID")]
public virtual int? IntID { get; set; }
#endregion
#region PartnerID
public abstract class partnerID : IBqlField { }
[PXDBString(30, IsUnicode = true, IsKey = true)]
[PXDefault("")]
[PXUIField(DisplayName = "Partner")]
public virtual string PartnerID { get; set; }
#endregion
#region InventoryID
public abstract class inventoryID : PX.Data.IBqlField { }
protected Int32? _InventoryID;
[PXDBInt(IsKey = true)]
[PXUIField(DisplayName = "Inventory ID", Visibility = PXUIVisibility.Visible, Visible = false)]
public virtual Int32? InventoryID { get; set; }
#endregion
#region InventoryCD
public abstract class inventoryCD : PX.Data.IBqlField { }
protected String _InventoryCD;
[PXDefault()]
[InventoryRaw(IsKey = true, DisplayName = "Inventory ID")]
public virtual String InventoryCD { get; set; }
#endregion
#region ItemDescr
public abstract class itemDescr : PX.Data.IBqlField { }
protected String _ItemDescr;
[PXDBString(255, IsUnicode = true)]
[PXUIField(DisplayName = "Item Description")]
public virtual String ItemDescr { get; set; }
#endregion
#region ItemStatus
public abstract class itemStatus : PX.Data.IBqlField { }
protected String _ItemStatus;
[PXDBString(2, IsFixed = true)]
[PXDefault("AC")]
[PXUIField(DisplayName = "Item Status", Visibility = PXUIVisibility.SelectorVisible)]
public virtual String ItemStatus { get; set; }
#endregion
#region BaseUnit
public abstract class baseUnit : PX.Data.IBqlField { }
protected String _BaseUnit;
[PXDBString]
[PXDefault("")]
[PXUIField(DisplayName = "Base Unit", Visibility = PXUIVisibility.SelectorVisible)]
public virtual String BaseUnit { get; set; }
#endregion
#region SalesUnit
public abstract class salesUnit : PX.Data.IBqlField { }
protected String _SalesUnit;
[PXDBString(6)]
[PXDefault("")]
[PXUIField(DisplayName = "Sales Unit", Visibility = PXUIVisibility.SelectorVisible)]
public virtual String SalesUnit { get; set; }
#endregion
#region PurchaseUnit
public abstract class purchaseUnit : PX.Data.IBqlField { }
protected String _PurchaseUnit;
[PXDBString(6)]
[PXDefault("")]
[PXUIField(DisplayName = "Purchase Unit", Visibility = PXUIVisibility.SelectorVisible)]
public virtual String PurchaseUnit { get; set; }
#endregion
#region BasePrice
public abstract class basePrice : PX.Data.IBqlField { }
protected Decimal? _BasePrice;
[PXPriceCost()]
[PXDefault(TypeCode.Decimal, "0.0")]
[PXUIField(DisplayName = "Default Price", Visibility = PXUIVisibility.SelectorVisible)]
public virtual Decimal? BasePrice { get; set; }
#endregion
#region BaseWeight
public abstract class baseWeight : PX.Data.IBqlField { }
protected Decimal? _BaseWeight;
[PXDBDecimal(6)]
[PXUIField(DisplayName = "Base Weight")]
[PXDefault(TypeCode.Decimal, "0.0")]
public virtual Decimal? BaseWeight { get; set; }
#endregion
#region BaseVolume
public abstract class baseVolume : PX.Data.IBqlField { }
protected Decimal? _BaseVolume;
[PXDBDecimal(6)]
[PXDefault(TypeCode.Decimal, "0.0")]
[PXUIField(DisplayName = "Base Volume")]
public virtual Decimal? BaseVolume { get; set; }
#endregion
#region BaseItemWeight
public abstract class baseItemWeight : PX.Data.IBqlField { }
protected Decimal? _BaseItemWeight;
[PXDBDecimal(6)]
[PXDefault(TypeCode.Decimal, "0.0")]
[PXUIField(DisplayName = "Weight")]
public virtual Decimal? BaseItemWeight { get; set; }
#endregion
#region BaseItemVolume
public abstract class baseItemVolume : PX.Data.IBqlField { }
protected Decimal? _BaseItemVolume;
[PXDBDecimal(6)]
[PXDefault(TypeCode.Decimal, "0.0")]
[PXUIField(DisplayName = "Volume")]
public virtual Decimal? BaseItemVolume { get; set; }
#endregion
#region WeightUOM
public abstract class weightUOM : PX.Data.IBqlField { }
protected String _WeightUOM;
[PXDBString(6)]
[PXUIField(DisplayName = "Weight UOM")]
[PXDefault("")]
public virtual String WeightUOM { get; set; }
#endregion
#region VolumeUOM
public abstract class volumeUOM : PX.Data.IBqlField { }
protected String _VolumeUOM;
[PXDBString(6)]
[PXUIField(DisplayName = "Volume UOM")]
[PXDefault("")]
public virtual String VolumeUOM { get; set; }
#endregion
/*
#region NoteID
public abstract class noteID : PX.Data.IBqlField { }
[PXGuid(IsKey = true)]
[PXDefault(PersistingCheck = PXPersistingCheck.Nothing)]
[PXNote]
public virtual Guid? NoteID { get; set; }
#endregion
*/
#region PartnerCustomerID
public abstract class partnerCustomerID : PX.Data.IBqlField { }
[PXDBInt]
[PXUIField(DisplayName = "Customer")]
[Customer(DescriptionField = typeof(Customer.acctName))]
public virtual Int32? PartnerCustomerID { get; set; }
#endregion
#region CustomerItem
public abstract class customerItem : PX.Data.IBqlField { }
protected string _CustomerItem;
[PXDBString(50)]
[PXDefault("")]
[PXUIField(DisplayName = "Customer Item")]
public virtual String CustomerItem { get; set; }
#endregion
#region CustomerItemDescr
public abstract class customerItemDescr : PX.Data.IBqlField { }
[PXDBString(60, IsUnicode = true)]
[PXDefault("")]
[PXUIField(DisplayName = "Customer Item Description")]
public virtual String CustomerItemDescr { get; set; }
#endregion
#region CaseQty
public abstract class caseQty : PX.Data.IBqlField { }
protected int? _CaseQty;
[PXDBInt]
[PXDefault(0)]
[PXUIField(DisplayName = "Case Qty")]
public virtual Int32? CaseQty { get; set; }
#endregion
#region CaseL
public abstract class caseL : PX.Data.IBqlField { }
protected decimal? _CaseL;
[PXDBDecimal(6)]
[PXDefault(TypeCode.Decimal, "0.0")]
[PXUIField(DisplayName = "Case Length")]
public virtual Decimal? CaseL { get; set; }
#endregion
#region CaseW
public abstract class caseW : PX.Data.IBqlField { }
protected decimal? _CaseW;
[PXDBDecimal(6)]
[PXDefault(TypeCode.Decimal, "0.0")]
[PXUIField(DisplayName = "Case Width")]
public virtual Decimal? CaseW { get; set; }
#endregion
#region CaseH
public abstract class caseH : PX.Data.IBqlField { }
protected decimal? _CaseH;
[PXDBDecimal(6)]
[PXDefault(TypeCode.Decimal, "0.0")]
[PXUIField(DisplayName = "Case Height")]
public virtual Decimal? CaseH { get; set; }
#endregion
#region CaseL
public abstract class customerPrice : PX.Data.IBqlField { }
protected int? _CustomerPrice;
[PXDBDecimal(6)]
[PXDefault(TypeCode.Decimal, "0.0")]
[PXUIField(DisplayName = "Customer Price")]
public virtual Decimal? CustomerPrice { get; set; }
#endregion
#region UPC
public abstract class uPC : PX.Data.IBqlField { }
protected string _UPC;
[PXDBString(20)]
[PXDefault("")]
[PXUIField(DisplayName = "UPC Code")]
public virtual String UPC { get; set; }
#endregion
#region OnHand
public abstract class onHand : PX.Data.IBqlField { }
protected int? _OnHand;
[PXDBInt]
[PXDefault(0)]
[PXUIField(DisplayName = "On Hand")]
public virtual Int32? OnHand { get; set; }
#endregion
#region Committed
public abstract class committed : PX.Data.IBqlField { }
protected int? _Committed;
[PXDBInt]
[PXDefault(0)]
[PXUIField(DisplayName = "Committed")]
public virtual Int32? Committed { get; set; }
#endregion
#region OnOrder
public abstract class onOrder : PX.Data.IBqlField { }
protected int? _OnOrder;
[PXDBInt]
[PXDefault(0)]
[PXUIField(DisplayName = "On Order")]
public virtual Int32? OnOrder { get; set; }
#endregion
}
}
}
I see you have both DB Filed attributes and Non DB Field attributes. Besides, You even have a combination of Non DB and DB key fields in one DAC. It is not recommended.
So, first of all, make sure you have all key fields marked with either DB field or Non DB field attributes, but not a mixture of both.
Second, you can put [PXVirtualDAC] attribute to your EDItem view. It will prevent it from trying to go to a database.

InventoryItem BasePrice causing "cast not valid"

I am trying to create a processing page to extract data from several tables which will be used to update the EDI service item list. I keep getting an error that states the specified cast for BasePrice is not valid.
This is simply an internal DAC in the BLC. There is no physical table in the database. If I exclude my BasePrice field everything works fine. If I include it, the insert gets the error. See the code below.
public class EDInventoryProcess : PXGraph<EDInventoryProcess>
{
public PXCancel<EDInventoryFilter> Cancel;
public PXFilter<EDInventoryFilter> Filter;
[PXFilterable]
public PXFilteredProcessingOrderBy<EDInventory, EDInventoryFilter,
OrderBy<Asc<EDInventory.partnerID, Asc<EDInventory.inventoryCD>>>> EDItem;
protected virtual IEnumerable eDItem()
{
EDItem.Cache.Clear();
var cmd = new PXSelectJoin<InventoryItem,
InnerJoin<INItemXRef, On<InventoryItem.inventoryID, Equal<INItemXRef.inventoryID>>,
InnerJoin<EDPartnerInfo, On<INItemXRef.bAccountID, Equal<EDPartnerInfo.customerID>>>>,
Where<INItemXRef.alternateType, Equal<INAlternateType.cPN>,
And<InventoryItem.itemStatus, Equal<InventoryItemStatus.active>>>>(this);
cmd.View.Clear();
var ret = cmd.Select();
if (ret != null)
{
EDInventoryFilter filt = (EDInventoryFilter)Filter.Cache.Current;
EDInventory edInv = new EDInventory();
foreach (PXResult<InventoryItem, INItemXRef, EDPartnerInfo> record in ret)
{
edInv = new EDInventory();
InventoryItem item = (InventoryItem)record;
INItemXRef xref = (INItemXRef)record;
EDPartnerInfo partner = (EDPartnerInfo)record;
edInv.PartnerID = partner.PartnerID;
edInv.InventoryID = item.InventoryID;
edInv.InventoryCD = item.InventoryCD;
edInv.ItemDescr = item.Descr;
edInv.ItemStatus = item.ItemStatus;
edInv.BaseUnit = item.BaseUnit;
edInv.SalesUnit = item.SalesUnit;
edInv.PurchaseUnit = item.PurchaseUnit;
edInv.BasePrice = Convert.ToDecimal(item.BasePrice);
//This is the lint that generates the error.
edInv = EDItem.Insert(edInv);
EDItem.Cache.SetStatus(edInv, PXEntryStatus.Held);
yield return edInv;
}
}
EDItem.Cache.IsDirty = false;
}
Here is the DAC definition:
[Serializable]
public partial class EDInventoryFilter : IBqlTable
{
#region TradingPartner
public abstract class tradingPartner : PX.Data.IBqlField
{
}
protected string _TradingPartner;
[PXString(15)]
[PXUIField(DisplayName = "Trading Partner")]
[PXStringList(new string[] { }, new string[] { })]
public virtual String TradingPartner { get; set; }
#endregion
#region Action
public abstract class action : PX.Data.IBqlField { }
protected string _Action;
[PXString(15)]
[PXUIField(DisplayName = "Action")]
[PXStringList(new string[] { "P" }, new string[] { "Push to EDI" })]
public virtual String Action { get; set; }
#endregion
}
[Serializable]
public partial class EDInventory : IBqlTable
{
#region PartnerID
public abstract class partnerID : IBqlField { }
[PXString(30, IsUnicode = true, IsKey = true)]
[PXDefault("")]
[PXUIField(DisplayName = "Partner")]
public virtual string PartnerID { get; set; }
#endregion
#region InventoryID
public abstract class inventoryID : PX.Data.IBqlField { }
protected Int32? _InventoryID;
[PXInt]
[PXUIField(DisplayName = "Inventory ID", Visibility = PXUIVisibility.Visible, Visible = false)]
public virtual Int32? InventoryID { get; set; }
#endregion
#region InventoryCD
public abstract class inventoryCD : PX.Data.IBqlField { }
protected String _InventoryCD;
[PXDefault()]
[InventoryRaw(IsKey = true, DisplayName = "Inventory ID")]
public virtual String InventoryCD { get; set; }
#endregion
#region ItemDescr
public abstract class itemDescr : PX.Data.IBqlField { }
protected String _ItemDescr;
[PXString(255, IsUnicode = true)]
[PXUIField(DisplayName = "Item Description")]
public virtual String ItemDescr { get; set; }
#endregion
#region ItemStatus
public abstract class itemStatus : PX.Data.IBqlField { }
protected String _ItemStatus;
[PXString(2, IsFixed = true)]
[PXDefault("AC")]
[PXUIField(DisplayName = "Item Status", Visibility = PXUIVisibility.SelectorVisible)]
public virtual String ItemStatus { get; set; }
#endregion
#region BaseUnit
public abstract class baseUnit : PX.Data.IBqlField { }
protected String _BaseUnit;
[PXString]
[PXDefault("")]
[PXUIField(DisplayName = "Base Unit", Visibility = PXUIVisibility.SelectorVisible)]
public virtual String BaseUnit { get; set; }
#endregion
#region SalesUnit
public abstract class salesUnit : PX.Data.IBqlField { }
protected String _SalesUnit;
[PXString]
[PXDefault("")]
[PXUIField(DisplayName = "Sales Unit", Visibility = PXUIVisibility.SelectorVisible)]
public virtual String SalesUnit { get; set; }
#endregion
#region PurchaseUnit
public abstract class purchaseUnit : PX.Data.IBqlField { }
protected String _PurchaseUnit;
[PXString]
[PXDefault("")]
[PXUIField(DisplayName = "Purchase Unit", Visibility = PXUIVisibility.SelectorVisible)]
public virtual String PurchaseUnit { get; set; }
#endregion
#region BasePrice
public abstract class basePrice : PX.Data.IBqlField { }
protected Decimal? _BasePrice;
[PXPriceCost()]
[PXDefault(0.0)]
[PXUIField(DisplayName = "Default Price", Visibility = PXUIVisibility.SelectorVisible)]
public virtual Decimal? BasePrice { get; set; }
#endregion
}
I just discovered what might be the answer. I was listing the default value as
[PXDefault(0.0)]
but I found another reference for decimal default as
[PXDefault(TypeCode.Decimal, "0.0")]
which seems to work. I no longer get the error and my processing screen displays as expected. I had assumed the default value drew its type from the object.
Yes for Decimal fields set [PXDefault(TypeCode.Decimal, "0.0")] attribute to avoid casting issues.

Resources