protected virtual IEnumerable assets()
{
DisposalFilter filter = Filter.Current;
PXSelectBase <FixedAsset> cmd = new PXSelectJoin <FixedAsset,
InnerJoin <FADetails, On <FixedAsset.assetID, Equal <FADetails.assetID> >,
LeftJoin <Account, On <FixedAsset.fAAccountID, Equal <Account.accountID> > > >,
Where <FADetails.status, NotEqual <FixedAssetStatus.disposed>,
And <FADetails.status, NotEqual <FixedAssetStatus.hold>,
And <FADetails.status, NotEqual <FixedAssetStatus.suspended> > > > >(this);
if (filter.BookID != null)
{
cmd.Join <InnerJoin <FABookBalance, On <FABookBalance.assetID, Equal <FixedAsset.assetID> > > >();
cmd.WhereAnd <Where <FABookBalance.bookID, Equal <Current <DisposalFilter.bookID> > > >();
}
if (filter.ClassID != null)
{
cmd.WhereAnd <Where <FixedAsset.classID, Equal <Current <DisposalFilter.classID> > > >();
}
if (PXAccess.FeatureInstalled <FeaturesSet.multipleCalendarsSupport>() || filter.OrgBAccountID != null)
{
cmd.WhereAnd <Where <FixedAsset.branchID, Inside <Current <DisposalFilter.orgBAccountID> > > >();
}
if (filter.ParentAssetID != null)
{
cmd.WhereAnd <Where <FixedAsset.parentAssetID, Equal <Current <DisposalFilter.parentAssetID> > > >();
}
int startRow = PXView.StartRow;
int totalRows = 0;
List <PXFilterRow> newFilters = new List <PXFilterRow>();
foreach (PXFilterRow f in PXView.Filters)
{
if (f.DataField.ToLower() == "status")
{
f.DataField = "FADetails__Status";
}
newFilters.Add(f);
}
List <object> list = cmd.View.Select(PXView.Currents, null, PXView.Searches, PXView.SortColumns, PXView.Descendings, newFilters.ToArray(), ref startRow, PXView.MaximumRows, ref totalRows);
PXView.StartRow = 0;
return(list);
}
public virtual void VerifyPrepaidContractRelated(PXCache cache, FSBillingCycle fsBillingCycleRow)
{
if (fsBillingCycleRow.BillingBy == (string)cache.GetValueOriginal <FSBillingCycle.billingBy>(fsBillingCycleRow))
{
return;
}
if (Setup.Current != null)
{
int count = 0;
if (Setup.Current.CustomerMultipleBillingOptions == false)
{
count = PXSelectJoin <Customer,
InnerJoin <FSBillingCycle,
On <FSBillingCycle.billingCycleID, Equal <FSxCustomer.billingCycleID> >,
InnerJoin <FSServiceOrder,
On <FSServiceOrder.customerID, Equal <Customer.bAccountID> > > >,
Where <
FSServiceOrder.billContractPeriodID, IsNotNull,
And <
FSBillingCycle.billingCycleID, Equal <Required <FSBillingCycle.billingCycleID> > > > >
.Select(this, fsBillingCycleRow.BillingCycleID).Count;
}
else
{
count = PXSelectJoin <FSCustomerBillingSetup,
InnerJoin <FSSrvOrdType,
On <FSSrvOrdType.srvOrdType, Equal <FSCustomerBillingSetup.srvOrdType> >,
InnerJoin <FSServiceOrder,
On <FSServiceOrder.srvOrdType, Equal <FSSrvOrdType.srvOrdType>,
And <FSServiceOrder.cBID, Equal <FSCustomerBillingSetup.cBID> > > > >,
Where <
FSServiceOrder.billContractPeriodID, IsNotNull,
And <
FSCustomerBillingSetup.billingCycleID, Equal <Required <FSCustomerBillingSetup.billingCycleID> > > > >
.Select(this, fsBillingCycleRow.BillingCycleID).Count;
}
if (count > 0)
{
cache.RaiseExceptionHandling <FSBillingCycle.billingCycleCD>(fsBillingCycleRow,
fsBillingCycleRow.BillingCycleCD,
new PXSetPropertyException(TX.Error.NO_UPDATE_BILLING_CYCLE_SERVICE_CONTRACT_RELATED, PXErrorLevel.Error));
throw new PXException(TX.Error.NO_UPDATE_BILLING_CYCLE_SERVICE_CONTRACT_RELATED);
}
}
}
public IEnumerable <PXResult <TaxTran, APRegister> > GetReportedTaxTransWithAdjdDocumentForAPPayments(string docType, string[] refNbrs, int?taxAgencyID, string taxPeriodID)
{
return(PXSelectJoin <TaxTran,
InnerJoin <APRegister,
On <TaxTran.adjdDocType, Equal <APRegister.docType>,
And <TaxTran.adjdRefNbr, Equal <APRegister.refNbr> > > >,
Where <TaxTran.tranType, Equal <Required <TaxTran.tranType> >,
And <TaxTran.refNbr, In <Required <TaxTran.refNbr> >,
And <TaxTran.vendorID, Equal <Required <TaxTran.vendorID> >,
And <TaxTran.taxPeriodID, Equal <Required <TaxTran.taxPeriodID> >,
And <TaxTran.voided, Equal <False>,
And <TaxTran.released, Equal <True>,
And <TaxTran.module, Equal <BatchModule.moduleAP> > > > > > > > >
.Select(_graph, docType, refNbrs, taxAgencyID, taxPeriodID)
.Cast <PXResult <TaxTran, APRegister> >());
}
protected new virtual IEnumerable Cancel(PXAdapter a)
{
if (a.Searches.Length == 1)
{
PXResult <SOOrderType> orderType = PXSelectJoin <SOOrderType,
LeftJoin <SOOrderTypeOperation,
On2 <SOOrderTypeOperation.FK.OrderType, And <SOOrderTypeOperation.operation, Equal <SOOrderType.defaultOperation> > > >,
Where <SOOrderType.requireShipping, Equal <boolFalse>, Or <FeatureInstalled <FeaturesSet.inventory> > > > .Search <SOOrderType.orderType>(this, a.Searches[0]);
if (orderType != null && (!soordertype.View.BqlSelect.Meet(soordertype.Cache, (SOOrderType)orderType) || !soordertype.View.BqlSelect.Meet(operations.Cache, PXResult.Unwrap <SOOrderTypeOperation>(orderType))))
{
a.Searches[0] = null;
}
}
return((new PXCancel <SOOrderType>(this, "Cancel")).Press(a));
}
protected virtual IEnumerable items()
{
ScheduleProjectionFilter filter = Filter.Current;
PXSelectBase <DRScheduleDetail> select = new PXSelectJoin <DRScheduleDetail,
InnerJoin <DRSchedule, On <DRScheduleDetail.scheduleID, Equal <DRSchedule.scheduleID> >,
InnerJoin <DRDeferredCode, On <DRDeferredCode.deferredCodeID, Equal <DRScheduleDetail.defCode> > > >,
Where <DRDeferredCode.method, Equal <DeferredMethodType.cashReceipt> > >(this);
if (!string.IsNullOrEmpty(filter.DeferredCode))
{
select.WhereAnd <Where <DRScheduleDetail.defCode, Equal <Current <ScheduleProjectionFilter.deferredCode> > > >();
}
return(select.Select());
}
protected virtual void _(Events.FieldVerifying <PMChangeOrderClass, PMChangeOrderClass.isRevenueBudgetEnabled> e)
{
if ((bool?)e.NewValue != true)
{
var select = new PXSelectJoin <PMChangeOrderBudget,
InnerJoin <PMChangeOrder, On <PMChangeOrderBudget.refNbr, Equal <PMChangeOrder.refNbr> > >,
Where <PMChangeOrderBudget.type, Equal <GL.AccountType.income>,
And <PMChangeOrder.classID, Equal <Current <PMChangeOrderClass.classID> > > > >(this);
PMChangeOrderBudget res = select.SelectWindowed(0, 1);
if (res != null)
{
throw new PXSetPropertyException <PMChangeOrderClass.isRevenueBudgetEnabled>(Messages.ClassContainsRevenueBudget);
}
}
}
protected IEnumerable preferredVendorItem()
{
foreach (var item in PXSelectJoin <POVendorInventory,
InnerJoin <InventoryItem, On <InventoryItem.inventoryID, Equal <POVendorInventory.inventoryID> > >,
Where <POVendorInventory.inventoryID, Equal <Current <INItemSite.inventoryID> >,
And <POVendorInventory.vendorID, Equal <Current <INItemSite.preferredVendorID> >,
And <POVendorInventory.subItemID, Equal <Current <InventoryItem.defaultSubItemID> >,
And <POVendorInventory.purchaseUnit, Equal <InventoryItem.purchaseUnit>,
And <Where <POVendorInventory.vendorLocationID, Equal <Current <INItemSite.preferredVendorLocationID> >,
Or <POVendorInventory.vendorLocationID, IsNull> > > > > > >,
OrderBy <Desc <POVendorInventory.vendorLocationID,
Asc <POVendorInventory.recordID> > > > .SelectSingleBound(this, null))
{
yield return(item);
}
}
protected virtual IAddressBase GetToAddress(POOrder order)
{
if (order.OrderType.IsIn(POOrderType.RegularOrder, POOrderType.Blanket, POOrderType.StandardBlanket, POOrderType.DropShip))
{
return((POShipAddress)PXSelect <POShipAddress, Where <POShipAddress.addressID, Equal <Required <POOrder.shipAddressID> > > > .Select(Base, order.ShipAddressID));
}
return
(PXSelectJoin <Branch,
InnerJoin <BAccountR, On <BAccountR.bAccountID, Equal <Branch.bAccountID> >,
InnerJoin <Address, On <Address.addressID, Equal <BAccountR.defAddressID> > > >,
Where <Branch.branchID, Equal <Required <Branch.branchID> > > >
.Select(Base, order.BranchID)
.RowCast <Address>()
.FirstOrDefault());
}
protected virtual void INKitSpecHdr_KitInventoryID_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e)
{
INKitSpecHdr row = e.Row as INKitSpecHdr;
if (row != null)
{
INLotSerClass kitLotSerClass = PXSelectJoin <INLotSerClass,
InnerJoin <InventoryItem, On <InventoryItem.lotSerClassID, Equal <INLotSerClass.lotSerClassID> > >,
Where <InventoryItem.inventoryID, Equal <Required <InventoryItem.inventoryID> > > > .Select(this, row.KitInventoryID);
if (kitLotSerClass != null)
{
row.LotSerTrack = kitLotSerClass.LotSerTrack;
}
}
}
public void SOOrder_OrderType_FieldDefaulting(PXCache sender, PXFieldDefaultingEventArgs e)
{
var query = new PXSelectJoin <SOOrderType,
InnerJoin <PX.SM.UsersInRoles,
On <PX.SM.UsersInRoles.rolename,
Equal <SOOrderTypeExt.usrUserRole> > >,
Where <PX.SM.UsersInRoles.username,
Equal <Current <AccessInfo.userName> > > >(Base);
var orderType = query.SelectSingle();
if (orderType != null)
{
e.NewValue = orderType.OrderType;
e.Cancel = true;
}
}
protected virtual IAddressBase GetToAddress(POOrder order, POLine line)
{
if (order.OrderType.IsIn(POOrderType.RegularOrder, POOrderType.Blanket, POOrderType.StandardBlanket))
{
return
(PXSelectJoin <Address,
InnerJoin <INSite, On <INSite.FK.Address> >,
Where <INSite.siteID, Equal <Current <POLine.siteID> > > >
.SelectSingleBound(Base, new[] { line })
.RowCast <Address>()
.FirstOrDefault()
?? GetToAddress(order));
}
return(GetToAddress(order));
}
protected virtual void Users_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
Users user = (Users)e.Row;
if (user == null)
{
return;
}
PXResultset <EPAssignmentRoute> res = PXSelectJoin <EPAssignmentRoute, InnerJoin <EPAssignmentMap, On <EPAssignmentRoute.assignmentMapID, Equal <EPAssignmentMap.assignmentMapID> > >, Where <EPAssignmentRoute.ownerID, Equal <Current <Users.pKID> > > > .Select(this, new object[] { user });
foreach (PXResult <EPAssignmentRoute, EPAssignmentMap> result in res)
{
throw new PXSetPropertyException(PX.Objects.EP.Messages.UserParticipateInAssignmentMap, user.Username, ((EPAssignmentMap)result).Name);
}
}
protected virtual void EPPosition_RowDeleting(PXCache cache, PXRowDeletingEventArgs e)
{
EPPosition row = e.Row as EPPosition;
if (row != null)
{
EPEmployee p = PXSelectJoin <EPEmployee,
LeftJoin <EPEmployeePosition, On <EPEmployee.bAccountID, Equal <EPEmployeePosition.employeeID> > >,
Where <EPEmployeePosition.positionID, Equal <Required <EPPosition.positionID> > > > .SelectSingleBound(this, null, row.PositionID);
if (p != null)
{
throw new PXException(Messages.PositionInUseForDelete, p.AcctCD);
}
}
}
public void Prefetch()
{
pagesAnlytics = new Dictionary <Guid, List <Guid> >();
pagesAnlyticstext = new Dictionary <Guid, string>();
foreach (WikiDescriptor _wikiDescriptor in PXSelect <WikiDescriptor> .Select(new PXGraph()))
{
foreach (PXResult <WikiPageAnalytic, WikiPage> rec in PXSelectJoin <WikiPageAnalytic,
InnerJoin <WikiPage, On <WikiPage.pageID, Equal <WikiPageAnalytic.pageID> > >,
Where <WikiPage.pageID, Equal <Required <WikiPage.wikiID> > > >
.Select(new PXGraph(), _wikiDescriptor.PageID, _wikiDescriptor.PageID))
{
WikiPageAnalytic wra = rec[typeof(WikiPageAnalytic)] as WikiPageAnalytic;
WikiPage wp = rec[typeof(WikiPage)] as WikiPage;
List <Guid> list;
if (!pagesAnlytics.TryGetValue(wra.PageID.Value, out list))
{
list = new List <Guid>();
pagesAnlytics.Add(wra.PageID.Value, list);
}
if (!(list.IndexOf(wra.NPageID.Value) > -1))
{
list.Add(wra.NPageID.Value);
}
}
if (pagesAnlytics.ContainsKey((Guid)_wikiDescriptor.PageID))
{
foreach (Guid scriptid in pagesAnlytics[(Guid)_wikiDescriptor.PageID])
{
foreach (PXResult <WikiRevision> rec1 in PXSelect <WikiRevision,
Where <WikiRevision.pageID, Equal <Required <WikiRevision.pageID> > >,
OrderBy <Desc <WikiRevision.pageRevisionID> > > .SelectWindowed(new PXGraph(), 0, 1, scriptid, scriptid))
{
WikiRevision wrp = rec1[typeof(WikiRevision)] as WikiRevision;
if (!pagesAnlyticstext.ContainsKey((Guid)_wikiDescriptor.PageID))
{
pagesAnlyticstext.Add((Guid)_wikiDescriptor.PageID, wrp.Content);
}
else
{
pagesAnlyticstext[(Guid)_wikiDescriptor.PageID] = pagesAnlyticstext[(Guid)_wikiDescriptor.PageID] + wrp.Content;
}
}
}
}
}
}
protected virtual IEnumerable spdocs()
{
List <ARSPCommnDocResult> res = new List <ARSPCommnDocResult>();
SPDocFilter filter = Filter.Current;
if (filter?.CommnPeriod != null)
{
PXSelectBase <ARSalesPerTran> sel = new PXSelectJoin <ARSalesPerTran,
InnerJoin <ARRegister, On <ARSalesPerTran.docType, Equal <ARRegister.docType>,
And <ARSalesPerTran.refNbr, Equal <ARRegister.refNbr> > >,
InnerJoinSingleTable <Customer, On <Customer.bAccountID, Equal <ARRegister.customerID>,
And <Match <Customer, Current <AccessInfo.userName> > > > > >,
Where <ARSalesPerTran.actuallyUsed, Equal <BQLConstants.BitOn> > >(this);
if (filter.SalesPersonID != null)
{
sel.WhereAnd <Where <ARSalesPerTran.salespersonID, Equal <Current <SPDocFilter.salesPersonID> > > >();
}
if (filter.CommnPeriod != null)
{
sel.WhereAnd <Where <ARSalesPerTran.commnPaymntPeriod, Equal <Current <SPDocFilter.commnPeriod> > > >();
}
if (filter.CustomerID != null)
{
sel.WhereAnd <Where <ARRegister.customerID, Equal <Current <SPDocFilter.customerID> > > >();
}
if (filter.LocationID != null)
{
sel.WhereAnd <Where <ARRegister.customerLocationID, Equal <Current <SPDocFilter.locationID> > > >();
}
PXView view = sel.View;
int startRow = PXView.StartRow;
int totalRows = 0;
List <object> windowedSelection = view.Select(PXView.Currents, PXView.Parameters, PXView.Searches, PXView.SortColumns, PXView.Descendings, PXView.Filters, ref startRow, PXView.MaximumRows, ref totalRows);
PXView.StartRow = 0;
foreach (PXResult <ARSalesPerTran, ARRegister, Customer> it in windowedSelection)
{
ARSPCommnDocResult m = new ARSPCommnDocResult();
Copy(m, ((ARSalesPerTran)it));
Copy(m, ((ARRegister)it));
res.Add(m);
}
}
return(res);
}
public virtual IEnumerable routeDocuments()
{
var commandFilter = new PXSelectJoin <FSRouteDocument,
InnerJoin <FSRoute,
On <FSRoute.routeID, Equal <FSRouteDocument.routeID> > > >(this);
var filter = Filter.Current;
//Filters
if (filter.FromDate != null)
{
commandFilter.WhereAnd <Where <FSRouteDocument.date, GreaterEqual <CurrentValue <RouteDocumentFilter.fromDate> > > >();
}
if (filter.ToDate != null)
{
commandFilter.WhereAnd <Where <FSRouteDocument.date, LessEqual <CurrentValue <RouteDocumentFilter.toDate> > > >();
}
if (filter.RouteID != null)
{
commandFilter.WhereAnd <Where <FSRouteDocument.routeID, Equal <CurrentValue <RouteDocumentFilter.routeID> > > >();
}
if (filter.StatusOpen == true || filter.StatusInProcess == true || filter.StatusCanceled == true || filter.StatusCompleted == true || filter.StatusClosed == true)
{
SetWhereStatus(filter.StatusOpen, filter.StatusInProcess, filter.StatusCanceled, filter.StatusCompleted, filter.StatusClosed, commandFilter);
}
int startRow = PXView.StartRow;
int totalRows = 0;
var list = commandFilter.View.Select(
PXView.Currents,
PXView.Parameters,
PXView.Searches,
PXView.SortColumns,
PXView.Descendings,
PXView.Filters,
ref startRow,
PXView.MaximumRows,
ref totalRows);
PXView.StartRow = 0;
return(list);
}
protected virtual void _(Events.RowInserted <Document> e)
{
var row = e.Row as Document;
if (row == null)
{
return;
}
bool oldContactDirty = GetContactCache().IsDirty;
bool oldAddressDirty = GetAddressCache().IsDirty;
Contact oldContact = null;
Address oldAddress = null;
if (row.ContactID != null)
{
oldContact = PXSelect <Contact,
Where <Contact.contactID, Equal <Current <Document.contactID> > > > .Select(Base);
oldAddress = PXSelectJoin <Address,
LeftJoin <Contact, On <Contact.defAddressID, Equal <Address.addressID> > >,
Where <Contact.contactID, Equal <Current <Document.contactID> > > > .Select(Base);
}
else if (row.LocationID != null)
{
oldContact = PXSelectJoin <Contact,
LeftJoin <Location, On <Location.locationID, Equal <Current <Document.locationID> > > >,
Where <Contact.contactID, Equal <Location.defContactID> > > .Select(Base);
oldAddress = PXSelectJoin <Address,
LeftJoin <Contact, On <Contact.defAddressID, Equal <Address.addressID> >,
LeftJoin <Location, On <Location.locationID, Equal <Current <Document.locationID> > > > >,
Where <Address.addressID, Equal <Location.defAddressID> > > .Select(Base);
}
ChangedData forContactInfo = new ChangedData();
forContactInfo.OldContact = oldContact;
forContactInfo.OldAddress = oldAddress;
DefaultRecords(row, forContactInfo, new ChangedData(false));
GetContactCache().IsDirty = oldContactDirty;
GetAddressCache().IsDirty = oldAddressDirty;
}
public Func <decimal?, decimal> GetRoundDelegateForLedger(int?ledgerID)
{
var currency = (Currency)PXSelectJoin <Currency,
InnerJoin <Ledger,
On <Currency.curyID, Equal <Ledger.baseCuryID> > >,
Where
<Ledger.ledgerID, Equal <Required <Ledger.ledgerID> > > >
.Select(this, ledgerID);
if (currency == null)
{
throw new PXException(
PXMessages.LocalizeFormat(Messages.CurrencyForLedgerCannotBeFound, ledgerID));
}
return(value => Math.Round(value.Value, currency.DecimalPlaces.Value, MidpointRounding.AwayFromZero));
}
private PXResultset <CSAnswers, CSAttributeGroup, CSAttributeDetail2> GenerateAttributeList(int attributeNum)
{
PXResultset <CSAnswers, CSAttributeGroup, CSAttributeDetail2> list = new PXResultset <CSAnswers, CSAttributeGroup, CSAttributeDetail2>();
PXSelectBase <CSAttributeGroup> query = new PXSelectJoin <CSAttributeGroup,
InnerJoin <CSAttributeDetail2, On <CSAttributeGroupExt.usrCategory, Equal <CSAttributeDetail2.valueID>,
And <CSAttributeDetail2.attributeID, Equal <Required <INSetupExt.usrCategoryAttribute> >,
And <CSAttributeDetail2.sortOrder, Equal <Required <CSAttributeDetail2.sortOrder> >,
And <CSAttributeDetail2.disabled, Equal <False> > > > > >,
Where <CSAttributeGroup.entityClassID, Equal <Required <InventoryItem.itemClassID> >
, And <CSAttributeGroup.entityType, Equal <PCBConst.entityTypeIN> >
>,
OrderBy <Asc <CSAttributeGroup.sortOrder> > >(Base);
InventoryItem current = Base.Item.Current;
INSetupExt setupExt = Base.insetup.Current.GetExtension <INSetupExt>();
if (current != null && current.InventoryID != null && setupExt != null) //&& current.InventoryID > 0
{
foreach (PXResult <CSAttributeGroup, CSAttributeDetail2> item in query.Select(setupExt.UsrCategoryAttribute, attributeNum, current.ItemClassID))
{
CSAttributeGroup attribute = item;
CSAttributeDetail2 detail = item;
CSAnswers answerCheck = PXSelect <CSAnswers, Where <CSAnswers.refNoteID, Equal <Required <CSAnswers.refNoteID> >,
And <CSAnswers.attributeID, Equal <Required <CSAnswers.attributeID> > > > >
.Select(Base, current.NoteID, attribute.AttributeID);
if (answerCheck == null)
{
CSAnswers newAnswer = new CSAnswers();
newAnswer.AttributeID = attribute.AttributeID;
newAnswer.Value = string.Empty;
newAnswer.Order = attribute.SortOrder;
newAnswer.IsRequired = attribute.Required;
newAnswer.RefNoteID = current.NoteID;
list.Add(new PXResult <CSAnswers, CSAttributeGroup, CSAttributeDetail2>(newAnswer, attribute, detail));
}
else
{
list.Add(new PXResult <CSAnswers, CSAttributeGroup, CSAttributeDetail2>(answerCheck, attribute, detail));
}
}
}
return(list);
}
/// <summary>
/// Searches for a reference to <paramref name="numberingID"/> in segmented keys.
/// </summary>
/// <param name="numberingID">The identifier of the numbering sequence to search for.</param>
/// <param name="demensionID">The ID of the segmented key in which the reference has been found.</param>
/// <param name="segmentID">The ID of the segment in which the reference has been found.</param>
/// <returns>If a segmented key with the reference to the specified <paramref name="numberingID"/> has
/// been found, the method returns <tt>True</tt>; otherwise, the method returns <tt>False</tt>.</returns>
public bool IsInUseSegments(string numberingID, out string demensionID, out string segmentID)
{
foreach (PXResult <Dimension, Segment> r in PXSelectJoin <Dimension,
InnerJoin <Segment, On <Segment.dimensionID, Equal <Dimension.dimensionID> > >,
Where <Dimension.numberingID, Equal <Optional <Numbering.numberingID> >,
And <Segment.autoNumber, Equal <Optional <Segment.autoNumber> > > > > .Select(parentGraph, numberingID, true))
{
Dimension dim = r;
Segment segrow = r;
demensionID = segrow.DimensionID;
segmentID = segrow.SegmentID.ToString();
return(true);
}
demensionID = null;
segmentID = null;
return(false);
}
public bool CheckDoNotExistUnreleasedCAAdjsWithCASplitsWithBranchWithFinPeriodLessOrEqual(int?branchID, string finPeriod)
{
var childBranchIds = PXAccess.GetChildBranchIDs(GetBranchByID(branchID).BranchCD);
var query = new PXSelectJoin <CAAdj,
LeftJoin <CASplit,
On <CAAdj.adjTranType, Equal <CASplit.adjTranType>,
And <CAAdj.adjRefNbr, Equal <CASplit.adjRefNbr> > > >,
Where <CAAdj.released, Equal <False>,
And <CAAdj.finPeriodID, LessEqual <Required <CAAdj.finPeriodID> >,
And <Where <CAAdj.branchID, In <Required <CAAdj.branchID> >,
Or <CASplit.branchID, In <Required <CASplit.branchID> > > > > > > >(_graph);
var caAdj = query.SelectSingle(finPeriod, childBranchIds, childBranchIds);
return(caAdj == null);
}
public bool CheckDoNotExistUnreleasedARRegistersWithARTransWithBranchWithFinPeriodLessOrEqual(int?branchID, string finPeriod)
{
var childBranchIds = PXAccess.GetChildBranchIDs(GetBranchByID(branchID).BranchCD);
var query = new PXSelectJoin <ARRegister,
LeftJoin <ARTran,
On <ARRegister.docType, Equal <ARTran.tranType>,
And <ARRegister.refNbr, Equal <ARTran.refNbr> > > >,
Where <ARRegister.released, Equal <False>,
And <ARRegister.finPeriodID, LessEqual <Required <ARRegister.finPeriodID> >,
And <Where <ARRegister.branchID, In <Required <ARRegister.branchID> >,
Or <ARTran.branchID, In <Required <ARTran.branchID> > > > > > > >(_graph);
var arRegister = query.SelectSingle(finPeriod, childBranchIds, childBranchIds);
return(arRegister == null);
}
protected override void ClosePeriodProc(FinPeriod p)
{
PXSelectBase select = new PXSelectJoin<ARRegister,
LeftJoin<ARAdjust, On<ARAdjust.adjgDocType, Equal<ARRegister.docType>, And<ARAdjust.adjgRefNbr, Equal<ARRegister.refNbr>, And<ARAdjust.released, Equal<False>>>>>,
Where<ARRegister.voided, Equal<boolFalse>,
And<ARRegister.scheduled, Equal<boolFalse>,
And<Where<ARAdjust.adjgFinPeriodID, IsNull, And<ARRegister.released, Equal<False>, And<ARRegister.finPeriodID, Equal<Required<ARRegister.finPeriodID>>, Or<ARAdjust.adjgFinPeriodID, Equal<Required<ARAdjust.adjgFinPeriodID>>>>>>>>>>(this);
object doc = select.View.SelectSingle(p.FinPeriodID, p.FinPeriodID);
if (doc != null)
{
throw new PXException(AP.Messages.PeriodHasUnreleasedDocs);
}
p.ARClosed = true;
Caches[typeof(FinPeriod)].Update(p);
Actions.PressSave();
}
/// <summary>
/// Add the Billing Customer info as a recipient(s) in the Email template generated by Appointment.
/// </summary>
private static void AddBillingRecipient(AppointmentEntry graphAppointmentEntry, NotificationRecipient recSetup, RecipientList recipients)
{
NotificationRecipient recipient = null;
if (graphAppointmentEntry.ServiceOrderRelated.Current.BillCustomerID != null)
{
Customer customerRow = PXSelect <Customer,
Where <
Customer.bAccountID, Equal <Required <Customer.bAccountID> > > >
.Select(graphAppointmentEntry, graphAppointmentEntry.ServiceOrderRelated.Current.BillCustomerID);
if (customerRow == null)
{
return;
}
FSxCustomer fsxCustomerRow = PXCache <Customer> .GetExtension <FSxCustomer>(customerRow);
if (fsxCustomerRow.SendAppNotification == true)
{
Contact contactRow = PXSelectJoin <Contact,
InnerJoin <Customer,
On <Contact.bAccountID, Equal <Customer.bAccountID>,
And <Contact.contactID, Equal <Customer.defBillContactID> > > >,
Where <
Customer.bAccountID, Equal <Required <Customer.bAccountID> > > >
.Select(graphAppointmentEntry, graphAppointmentEntry.ServiceOrderRelated.Current.BillCustomerID);
if (contactRow != null && contactRow.EMail != null)
{
recipient = new NotificationRecipient()
{
Active = true,
Email = contactRow.EMail,
Hidden = recSetup.Hidden,
Format = recSetup.Format
};
}
}
if (recipient != null)
{
recipients.Add(recipient);
}
}
}
/// <summary>
/// Add the Employee info defined in the Notification tab defined in the <c>SrvOrdType</c> as a recipient(s) in the Email template generated by Appointment.
/// </summary>
private static void AddEmployeeRecipient(PXGraph graph, NotificationRecipient recSetup, RecipientList recipients)
{
NotificationRecipient recipient = null;
bool?appNotification = false;
PXResult <Contact, BAccount, EPEmployee> bqlResult =
(PXResult <Contact, BAccount, EPEmployee>) PXSelectJoin <Contact,
InnerJoin <BAccount,
On <Contact.bAccountID, Equal <BAccount.parentBAccountID>,
And <Contact.contactID, Equal <BAccount.defContactID> > >,
InnerJoin <EPEmployee,
On <EPEmployee.bAccountID, Equal <BAccount.bAccountID> > > >,
Where <
Contact.contactID, Equal <Required <Contact.contactID> >,
And <BAccount.type, Equal <Required <BAccount.type> > > > >
.Select(graph, recSetup.ContactID, BAccountType.EmployeeType);
Contact contactRow = (Contact)bqlResult;
BAccount baccountRow = (BAccount)bqlResult;
EPEmployee epEmployeeRow = (EPEmployee)bqlResult;
if (epEmployeeRow != null)
{
FSxEPEmployee fsxEpEmployeeRow = PXCache <EPEmployee> .GetExtension <FSxEPEmployee>(epEmployeeRow);
appNotification = fsxEpEmployeeRow.SendAppNotification;
if (appNotification == true)
{
if (contactRow != null && contactRow.EMail != null)
{
recipient = new NotificationRecipient()
{
Active = true,
Email = contactRow.EMail,
Hidden = recSetup.Hidden,
Format = recSetup.Format
};
if (recipient != null)
{
recipients.Add(recipient);
}
}
}
}
}
/// <summary><see cref="InventoryByClassFilter.InventoryID"/> Updated</summary>
protected virtual void InventoryByClassFilter_InventoryID_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e)
{
var row = (InventoryByClassFilter)e.Row;
if (row?.InventoryID != null)
{
INItemClass current = PXSelectJoin <INItemClass,
InnerJoin <InventoryItem, On <INItemClass.itemClassID, Equal <InventoryItem.itemClassID> > >,
Where <InventoryItem.inventoryID, Equal <Required <InventoryItem.inventoryID> > > >
.SelectWindowed(this, 0, 1, row.InventoryID);
_allowToSyncTreeCurrentWithPrimaryViewCurrent = true;
_forbidToSyncTreeCurrentWithPrimaryViewCurrent = false;
_keepInventoryFilter = true;
ItemClassFilter.Current = current;
}
}
protected virtual void EPCompanyTreeMember_Active_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e)
{
EPCompanyTreeMember row = (EPCompanyTreeMember)e.Row;
if (row == null)
{
return;
}
string res = "";
foreach (EPAssignmentMap map in PXSelectJoin <EPAssignmentMap,
InnerJoin <EPAssignmentRoute, On <EPAssignmentRoute.assignmentMapID, Equal <EPAssignmentMap.assignmentMapID> > >,
Where <EPAssignmentRoute.ownerID, Equal <Required <EPAssignmentRoute.ownerID> > > > .
Select(this, row.UserID))
{
if (map == null)
{
throw new PXException(Objects.EP.Messages.WorkgroupIsInUse);
}
string MapType = "";
if (map.MapType == EPMapType.Assignment)
{
MapType = Objects.EP.Messages.Assignment;
}
else
{
MapType = Objects.EP.Messages.Approval;
}
EPEmployee Employee = PXSelect <EPEmployee,
Where <EPEmployee.userID, Equal <Required <EPEmployee.userID> > > > .Select(this, row.UserID);
if (Employee != null)
{
res = res + string.Format(Objects.EP.Messages.EmployeeIsInUseAtAssignmentMapPart1, Employee.AcctName, MapType, map.Name) + "\n";
}
}
if (!String.IsNullOrEmpty(res))
{
sender.RaiseExceptionHandling <EPCompanyTreeMember.userID>(row, row.UserID, new PXSetPropertyException(res + "\n" + Objects.EP.Messages.EmployeeIsInUseAtAssignmentMapPart2, PXErrorLevel.RowWarning));
}
}
protected virtual void GenerateStatement(ARStatementCycle cycle, DateTime statementDate, bool clearExisting)
{
PXSelectBase <Customer> selectCustomer = new PXSelectJoin <Customer,
InnerJoin <CustomerMaster, On <CustomerMaster.bAccountID, Equal <Customer.statementCustomerID> > >,
Where <CustomerMaster.statementCycleId, Equal <Required <Customer.statementCycleId> > >,
OrderBy <Asc <Customer.statementCustomerID> > >(this);
var statementGraph = CreateInstance <StatementCreateBO>();
var family = new List <Customer> {
};
foreach (Customer customer in selectCustomer.Select(cycle.StatementCycleId))
{
if (family.Any() == false || family.First().StatementCustomerID == customer.StatementCustomerID)
{
family.Add(customer);
}
else
{
GenerateStatementForCustomerFamily(statementGraph, cycle, family, statementDate, clearExisting);
family = new List <Customer> {
customer
};
}
}
if (family.Any())
{
GenerateStatementForCustomerFamily(statementGraph, cycle, family, statementDate, clearExisting);
}
Customer leftToProcess = PXSelectReadonly2 <Customer,
InnerJoin <CustomerMaster, On <CustomerMaster.bAccountID, Equal <Customer.statementCustomerID> > >,
Where <CustomerMaster.statementCycleId, Equal <Required <Customer.statementCycleId> >,
And <Where <Customer.statementLastDate, IsNull,
Or <Customer.statementLastDate, Less <Required <Customer.statementLastDate> > > > > > > .SelectWindowed(this, 0, 1, cycle.StatementCycleId, statementDate);
if (leftToProcess == null)
{
cycle.LastStmtDate = statementDate;
this.CyclesList.Update(cycle);
this.Actions.PressSave();
}
}
public static ItemCost Fetch(PXGraph graph, int?vendorID, int?vendorLocationID, DateTime?docDate, string curyID, int?inventoryID, int?subItemID, int?siteID, string uom, bool onlyVendor)
{
PXSelectBase <InventoryItem> vendorCostSelect =
new PXSelectJoin <InventoryItem,
LeftJoin <INItemCost, On <INItemCost.inventoryID, Equal <InventoryItem.inventoryID> >,
LeftJoin <POVendorInventory, On <
POVendorInventory.inventoryID, Equal <InventoryItem.inventoryID>,
And <POVendorInventory.active, Equal <True>,
And <POVendorInventory.vendorID, Equal <Required <Vendor.bAccountID> >,
And <POVendorInventory.curyID, Equal <Required <POVendorInventory.curyID> >,
And2 <Where <POVendorInventory.subItemID, Equal <Required <POVendorInventory.subItemID> >,
Or <POVendorInventory.subItemID, Equal <InventoryItem.defaultSubItemID>,
Or <POVendorInventory.subItemID, IsNull,
Or <Where <Required <POVendorInventory.subItemID>, IsNull,
And <POVendorInventory.subItemID, Equal <True> > > > > > >,
And2 <Where <POVendorInventory.purchaseUnit, Equal <Required <POVendorInventory.purchaseUnit> > >,
And <Where <POVendorInventory.vendorLocationID, Equal <Required <POVendorInventory.vendorLocationID> >,
Or <POVendorInventory.vendorLocationID, IsNull> > > > > > > > > > >,
Where <InventoryItem.inventoryID, Equal <Required <InventoryItem.inventoryID> > >,
OrderBy <
Asc <Switch <Case <Where <POVendorInventory.purchaseUnit, Equal <InventoryItem.purchaseUnit> >, True>, False>,
Asc <Switch <Case <Where <POVendorInventory.subItemID, Equal <InventoryItem.defaultSubItemID> >, True>, False>,
Asc <Switch <Case <Where <POVendorInventory.vendorLocationID, IsNull>, True>, False>,
Asc <InventoryItem.inventoryCD> > > > > >(graph);
Func <string, PXResult <InventoryItem, INItemCost, POVendorInventory> > selectVendorCostByUOM =
uomParam => vendorCostSelect
.Select(vendorID, curyID, subItemID, subItemID, uomParam, vendorLocationID, inventoryID)
.FirstOrDefault(r => r.GetItem <POVendorInventory>() != null)
as PXResult <InventoryItem, INItemCost, POVendorInventory>;
var vendorCostRow = selectVendorCostByUOM(uom);
var item = vendorCostRow.GetItem <InventoryItem>();
Func <POVendorInventory, ItemCost> fetchVendorLastCost =
vendorPrice => vendorPrice.LastPrice != null && vendorPrice.LastPrice != 0m
? new ItemCost(item, vendorPrice.PurchaseUnit, curyID, vendorPrice.LastPrice.Value, false)
: null;
return(fetchVendorLastCost(vendorCostRow.GetItem <POVendorInventory>())
?? fetchVendorLastCost(selectVendorCostByUOM(item.BaseUnit).GetItem <POVendorInventory>())
?? (onlyVendor ? null : FetchStdCost(graph, item, docDate))
?? (onlyVendor ? null : FetchSiteLastCost(graph, item, siteID))
?? new ItemCost(item, vendorCostRow.GetItem <INItemCost>()?.LastCost ?? 0));
}
public virtual BqlCommand ComposeBQLCommandForRecords(SchedulesFilter filter)
{
if (filter == null)
{
return(null);
}
PXSelectBase <SchedulesInqResult> select = new PXSelectJoin <SchedulesInqResult,
InnerJoin <DRSchedule, On <DRSchedule.scheduleID, Equal <SchedulesInqResult.scheduleID> >,
InnerJoin <DRDeferredCode, On <DRDeferredCode.deferredCodeID, Equal <SchedulesInqResult.defCode> >,
LeftJoin <InventoryItem, On <InventoryItem.inventoryID, Equal <SchedulesInqResult.componentID> > > > >,
Where <DRDeferredCode.accountType, Equal <Current <SchedulesFilter.accountType> > > >(this);
if (!string.IsNullOrEmpty(filter.DeferredCode))
{
select.WhereAnd <Where <SchedulesInqResult.defCode, Equal <Current <SchedulesFilter.deferredCode> > > >();
}
if (filter.OrgBAccountID != null)
{
select.WhereAnd <Where <SchedulesInqResult.branchID, Inside <Current <SchedulesFilter.orgBAccountID> > > >(); //MatchWithOrg
}
if (filter.AccountID != null)
{
select.WhereAnd <Where <SchedulesInqResult.defAcctID, Equal <Current <SchedulesFilter.accountID> > > >();
}
if (filter.SubID != null)
{
select.WhereAnd <Where <SchedulesInqResult.defSubID, Equal <Current <SchedulesFilter.subID> > > >();
}
if (filter.BAccountID != null)
{
select.WhereAnd <Where <SchedulesInqResult.bAccountID, Equal <Current <SchedulesFilter.bAccountID> > > >();
}
if (filter.ComponentID != null)
{
select.WhereAnd <Where <SchedulesInqResult.componentID, Equal <Current <SchedulesFilter.componentID> > > >();
}
return(select.View.BqlSelect);
}
protected override void ClosePeriodProc(FinPeriod p)
{
PXSelectBase select = new PXSelect <INRegister,
Where <INRegister.finPeriodID, Equal <Required <INRegister.finPeriodID> >,
And <INRegister.released, Equal <boolFalse> > > >(this);
INRegister doc = (INRegister)select.View.SelectSingle(p.FinPeriodID);
if (doc != null)
{
throw new PXException(AP.Messages.PeriodHasUnreleasedDocs);
}
//MS Landed cost will not be able to create these transactions if the period is closed
LandedCostTran lcTranFromAP = PXSelectJoin <LandedCostTran,
InnerJoin <APRegister, On <LandedCostTran.aPDocType, Equal <APRegister.docType>,
And <LandedCostTran.aPRefNbr, Equal <APRegister.refNbr> > > >,
Where <LandedCostTran.invoiceDate, GreaterEqual <Required <LandedCostTran.invoiceDate> >,
And <LandedCostTran.invoiceDate, Less <Required <LandedCostTran.invoiceDate> >,
And <LandedCostTran.source, Equal <LandedCostTranSource.fromAP>,
And <APRegister.released, Equal <True>,
And <LandedCostTran.processed, Equal <False> > > > > > > .Select(this, p.StartDate, p.EndDate);
if (lcTranFromAP != null && lcTranFromAP.LCTranID.HasValue)
{
throw new PXException(Messages.PeriodHasINDocsFromAP_LCToBeCreated);
}
PO.LandedCostTran lcTranFromPO = PXSelectJoin <LandedCostTran,
InnerJoin <POReceipt, On <LandedCostTran.pOReceiptNbr, Equal <POReceipt.receiptNbr> > >,
Where <LandedCostTran.invoiceDate, GreaterEqual <Required <LandedCostTran.invoiceDate> >,
And <LandedCostTran.invoiceDate, Less <Required <LandedCostTran.invoiceDate> >,
And <LandedCostTran.source, Equal <LandedCostTranSource.fromPO>,
And <POReceipt.released, Equal <True>,
And <LandedCostTran.processed, Equal <False> > > > > > > .Select(this, p.StartDate, p.EndDate);
if (lcTranFromPO != null && lcTranFromPO.LCTranID.HasValue)
{
throw new PXException(Messages.PeriodHasINDocsFromPO_LCToBeCreated);
}
p.INClosed = true;
Caches[typeof(FinPeriod)].Update(p);
Actions.PressSave();
}
protected override void ClosePeriodProc(FinPeriod p)
{
APRegister prebookedDoc = PXSelect<APRegister, Where<APRegister.voided, Equal<boolFalse>,
And<APRegister.prebooked, Equal<boolTrue>,
And<APRegister.released, Equal<boolFalse>,
And<APRegister.finPeriodID, Equal<Required<APRegister.finPeriodID>>>>>>>.Select(this, p.FinPeriodID);
if (prebookedDoc != null)
{
throw new PXException(Messages.PeriodHasPrebookedDocs);
}
PXSelectBase select = new PXSelectJoin<APRegister,
LeftJoin<APAdjust, On<APAdjust.adjgDocType, Equal<APRegister.docType>, And<APAdjust.adjgRefNbr, Equal<APRegister.refNbr>, And<APAdjust.released, Equal<False>>>>>,
Where<APRegister.voided, Equal<boolFalse>,
And<APRegister.scheduled, Equal<boolFalse>,
And<Where<APAdjust.adjgFinPeriodID, IsNull, And<APRegister.released, Equal<False>, And<APRegister.finPeriodID, Equal<Required<APRegister.finPeriodID>>, Or<APAdjust.adjgFinPeriodID, Equal<Required<APAdjust.adjgFinPeriodID>>>>>>>>>>(this);
object doc = select.View.SelectSingle(p.FinPeriodID, p.FinPeriodID);
if (doc != null)
{
throw new PXException(Messages.PeriodHasUnreleasedDocs);
}
PO.LandedCostTran lcTran = PXSelectJoin<LandedCostTran,
InnerJoin<POReceipt, On<LandedCostTran.pOReceiptNbr, Equal<POReceipt.receiptNbr>>>,
Where<LandedCostTran.source, Equal<LandedCostTranSource.fromPO>,
And<POReceipt.released, Equal<True>,
And<LandedCostTran.postponeAP,Equal<False>,
And<LandedCostTran.processed, Equal<False>,
And<LandedCostTran.invoiceDate, GreaterEqual<Required<LandedCostTran.invoiceDate>>,
And<LandedCostTran.invoiceDate, Less<Required<LandedCostTran.invoiceDate>>>>>>>>>.Select(this, p.StartDate, p.EndDate);
if (lcTran != null && lcTran.LCTranID.HasValue)
{
throw new PXException(Messages.PeriodHasAPDocsFromPO_LCToBeCreated);
}
p.APClosed = true;
Caches[typeof(FinPeriod)].Update(p);
Actions.PressSave();
}
protected virtual IEnumerable GetRecords()
{
bool ar = true;
PXCache cache = this._Graph.Caches[BqlCommand.GetItemType(moduleField)];
string docType = ARDocType.Invoice;
if (cache.Current != null )
{
docType = (string)cache.GetValue(cache.Current, docTypeField.Name);
string module = (string)cache.GetValue(cache.Current, moduleField.Name);
if (module == BatchModule.AP)
ar = false;
}
if (ar)
{
PXSelectBase<ARInvoice> select = new
PXSelectJoin<ARInvoice,
InnerJoin<BAccount, On<BAccount.bAccountID, Equal<ARInvoice.customerID>>>,
Where<ARInvoice.docType, Equal<Required<ARInvoice.docType>>>>(this._Graph);
foreach (PXResult<ARInvoice, BAccount> res in select.Select(docType))
{
ARInvoice doc = (ARInvoice)res;
BAccount customer = (BAccount)res;
string status = null;
ARDocStatus.ListAttribute x = new ARDocStatus.ListAttribute();
if (x.ValueLabelDic.ContainsKey(doc.Status))
{
status = x.ValueLabelDic[doc.Status];
}
DRDocumentRecord record = new DRDocumentRecord();
record.BAccountCD = customer.AcctCD;
record.RefNbr = doc.RefNbr;
record.Status = status;
record.FinPeriodID = doc.FinPeriodID;
record.DocType = doc.DocType;
record.DocDate = doc.DocDate;
record.LocationID = doc.CustomerLocationID;
record.CuryOrigDocAmt = doc.CuryOrigDocAmt;
record.CuryID = doc.CuryID;
yield return record;
}
}
else
{
PXSelectBase<APInvoice> select = new
PXSelectJoin<APInvoice,
InnerJoin<BAccount, On<BAccount.bAccountID, Equal<APInvoice.vendorID>>>,
Where<APInvoice.docType, Equal<Required<APInvoice.docType>>>>(this._Graph);
foreach (PXResult<APInvoice, BAccount> res in select.Select(docType))
{
APInvoice doc = (APInvoice)res;
BAccount customer = (BAccount)res;
string status = null;
APDocStatus.ListAttribute x = new APDocStatus.ListAttribute();
if (x.ValueLabelDic.ContainsKey(doc.Status))
{
status = x.ValueLabelDic[doc.Status];
}
DRDocumentRecord record = new DRDocumentRecord();
record.BAccountCD = customer.AcctCD;
record.RefNbr = doc.RefNbr;
record.Status = status;
record.FinPeriodID = doc.FinPeriodID;
record.DocType = doc.DocType;
record.DocDate = doc.DocDate;
record.LocationID = doc.VendorLocationID;
record.CuryOrigDocAmt = doc.CuryOrigDocAmt;
record.CuryID = doc.CuryID;
yield return record;
}
}
}
protected override void ApplyAvalaraTax(ARInvoice invoice, GetTaxResult result)
{
TaxZone taxZone = (TaxZone)taxzone.View.SelectSingleBound(new object[] { invoice });
AP.Vendor vendor = PXSelect<AP.Vendor, Where<AP.Vendor.bAccountID, Equal<Required<AP.Vendor.bAccountID>>>>.Select(this, taxZone.TaxVendorID);
if (vendor == null)
throw new PXException("Tax Vendor is required but not found for the External TaxZone.");
Dictionary<string, ARTaxTran> existingRows = new Dictionary<string, ARTaxTran>();
foreach (PXResult<ARTaxTran, Tax> res in Taxes.View.SelectMultiBound(new object[] { invoice }))
{
ARTaxTran taxTran = (ARTaxTran)res;
existingRows.Add(taxTran.TaxID.Trim().ToUpperInvariant(), taxTran);
}
this.Views.Caches.Add(typeof(Tax));
bool requireControlTotal = ARSetup.Current.RequireControlTotal == true;
if (invoice.Hold != true)
ARSetup.Current.RequireControlTotal = false;
try
{
for (int i = 0; i < result.TaxSummary.Count; i++)
{
string taxID = result.TaxSummary[i].TaxName.ToUpperInvariant();
//Insert Tax if not exists - just for the selectors sake
Tax tx = PXSelect<Tax, Where<Tax.taxID, Equal<Required<Tax.taxID>>>>.Select(this, taxID);
if (tx == null)
{
tx = new Tax();
tx.TaxID = taxID;
//tx.Descr = string.Format("Avalara {0} {1}%", taxID, Convert.ToDecimal(result.TaxSummary[i].Rate)*100);
tx.Descr = string.Format("Avalara {0}", taxID);
tx.TaxType = CSTaxType.Sales;
tx.TaxCalcType = CSTaxCalcType.Doc;
tx.TaxCalcLevel = CSTaxCalcLevel.CalcOnItemAmt;
tx.TaxApplyTermsDisc = CSTaxTermsDiscount.ToTaxableAmount;
tx.SalesTaxAcctID = vendor.SalesTaxAcctID;
tx.SalesTaxSubID = vendor.SalesTaxSubID;
tx.ExpenseAccountID = vendor.TaxExpenseAcctID;
tx.ExpenseSubID = vendor.TaxExpenseSubID;
tx.TaxVendorID = taxZone.TaxVendorID;
this.Caches[typeof(Tax)].Insert(tx);
}
ARTaxTran existing = null;
existingRows.TryGetValue(taxID, out existing);
if (existing != null)
{
existing.TaxAmt = Math.Abs(result.TaxSummary[i].Tax);
existing.CuryTaxAmt = Math.Abs(result.TaxSummary[i].Tax);
existing.TaxableAmt = Math.Abs(result.TaxSummary[i].Taxable);
existing.CuryTaxableAmt = Math.Abs(result.TaxSummary[i].Taxable);
existing.TaxRate = Convert.ToDecimal(result.TaxSummary[i].Rate);
Taxes.Update(existing);
existingRows.Remove(existing.TaxID.Trim().ToUpperInvariant());
}
else
{
ARTaxTran tax = new ARTaxTran();
tax.Module = BatchModule.AR;
tax.TranType = invoice.DocType;
tax.RefNbr = invoice.RefNbr;
tax.TaxID = taxID;
tax.TaxAmt = Math.Abs(result.TaxSummary[i].Tax);
tax.CuryTaxAmt = Math.Abs(result.TaxSummary[i].Tax);
tax.TaxableAmt = Math.Abs(result.TaxSummary[i].Taxable);
tax.CuryTaxableAmt = Math.Abs(result.TaxSummary[i].Taxable);
tax.TaxRate = Convert.ToDecimal(result.TaxSummary[i].Rate);
tax.TaxType = "S";
tax.TaxBucketID = 0;
tax.AccountID = vendor.SalesTaxAcctID;
tax.SubID = vendor.SalesTaxSubID;
Taxes.Insert(tax);
}
}
foreach (ARTaxTran taxTran in existingRows.Values)
{
Taxes.Delete(taxTran);
}
SOInvoice soInvoice = PXSelect<SOInvoice, Where<SOInvoice.docType, Equal<Required<SOInvoice.docType>>, And<SOInvoice.refNbr, Equal<Required<SOInvoice.refNbr>>>>>.Select(this, invoice.DocType, invoice.RefNbr);
invoice.CuryTaxTotal = Math.Abs(result.TotalTax);
Document.Cache.SetValueExt<ARInvoice.isTaxSaved>(invoice, true);
}
finally
{
ARSetup.Current.RequireControlTotal = requireControlTotal;
}
if (invoice.ApplyPaymentWhenTaxAvailable == true)
{
PXSelectBase<ARAdjust> select = new PXSelectJoin<ARAdjust,
InnerJoin<ARPayment, On<ARAdjust.adjgDocType, Equal<ARPayment.docType>, And<ARAdjust.adjgRefNbr, Equal<ARPayment.refNbr>>>>,
Where<ARAdjust.adjdDocType, Equal<Required<ARInvoice.docType>>,
And<ARAdjust.adjdRefNbr, Equal<Required<ARInvoice.refNbr>>>>>(this);
foreach (PXResult<ARAdjust, ARPayment> res in select.Select(invoice.DocType, invoice.RefNbr))
{
ARAdjust row = (ARAdjust)res;
ARPayment payment = (ARPayment)res;
ARAdjust copy = PXCache<ARAdjust>.CreateCopy(row);
copy.CuryAdjdAmt = Math.Min(copy.CuryAdjdAmt.GetValueOrDefault(), invoice.CuryDocBal.GetValueOrDefault());
Adjustments.Update(copy);
}
}
}
public virtual List<CSBox> GetBoxesByCarrierID(string carrierID)
{
List<CSBox> list = new List<CSBox>();
if (string.IsNullOrEmpty(carrierID))
{
foreach (CSBox box in PXSelect<CSBox, Where<CSBox.maxWeight, Greater<decimal0>>>.Select(graph))
{
list.Add(box);
}
}
else
{
PXSelectBase<CSBox> select = new PXSelectJoin<CSBox,
InnerJoin<CarrierPackage, On<CSBox.boxID, Equal<CarrierPackage.boxID>>>,
Where<CarrierPackage.carrierID, Equal<Required<CarrierPackage.carrierID>>,
And<CSBox.maxWeight, Greater<decimal0>>>, OrderBy<Asc<CSBox.maxWeight>>>(graph);
foreach (CSBox box in select.Select(carrierID))
{
list.Add(box);
}
}
return list;
}
public virtual List<INItemBoxEx> GetBoxesByInventoryID(int inventoryID, string carrierID)
{
PXSelectBase<INItemBoxEx> select;
if (string.IsNullOrEmpty(carrierID))
{
select = new PXSelect<INItemBoxEx,
Where<INItemBoxEx.inventoryID, Equal<Required<INItemBoxEx.inventoryID>>>>(graph);
}
else
{
select = new PXSelectJoin<INItemBoxEx,
InnerJoin<CarrierPackage, On<INItemBoxEx.boxID, Equal<CarrierPackage.boxID>>>,
Where<INItemBoxEx.inventoryID, Equal<Required<INItemBox.inventoryID>>,
And<CarrierPackage.carrierID, Equal<Required<CarrierPackage.carrierID>>>>>(graph);
}
List<INItemBoxEx> list = new List<INItemBoxEx>();
foreach (INItemBoxEx box in select.Select(inventoryID, carrierID))
{
list.Add(box);
}
if (list.Count == 0 )
{
if (string.IsNullOrEmpty(carrierID))
{
//there are no explicit boxes setup on the InventoryItem. This means that all system boxes are applicable:
List<CSBox> allboxes = GetBoxesByCarrierID(carrierID);
foreach (CSBox csBox in allboxes)
{
INItemBoxEx box = new INItemBoxEx();
box.BoxID = csBox.BoxID;
box.BaseQty = null;
box.BoxWeight = csBox.BoxWeight;
box.CarrierBox = csBox.CarrierBox;
box.Description = csBox.Description;
box.InventoryID = inventoryID;
box.MaxQty = null;
box.MaxVolume = csBox.MaxVolume;
box.MaxWeight = csBox.MaxWeight;
box.Qty = null;
box.UOM = null;
list.Add(box);
}
}
else
{
//There is no common box between boxes defined for the item and boxess defined for the carrier.
throw new PXException(Messages.BoxesNotDefined);
}
}
return list;
}
protected virtual IEnumerable GetRecords()
{
bool useOnlyExisting = false;
PXCache cache = this._Graph.Caches[typeof(DRScheduleDetail)];
if (cache.Current != null && cache.GetStatus(cache.Current) != PXEntryStatus.Inserted)
{
useOnlyExisting = true;
}
if (useOnlyExisting)
{
PXSelectBase<DRScheduleDetail> select = new PXSelectJoin<DRScheduleDetail,
LeftJoin<InventoryItem, On<DRScheduleDetail.componentID, Equal<InventoryItem.inventoryID>>>, Where<DRScheduleDetail.scheduleID, Equal<Current<DRScheduleDetail.scheduleID>>>>(this._Graph);
foreach (PXResult<DRScheduleDetail, InventoryItem> res in select.Select())
{
InventoryItem item = (InventoryItem)res;
if (item.InventoryID != null)
yield return item;
}
}
else
{
foreach (InventoryItem item in PXSelect<InventoryItem>.Select(this._Graph))
{
yield return item;
}
}
}
