public override object Evaluate(PXCache cache, object item, Dictionary <Type, object> pars) { decimal?curyAmount = (decimal?)pars[typeof(CuryAmount)]; long? curyInfoID = (long?)pars[typeof(CuryInfoID)]; long? toCuryInfoID = (long?)pars[typeof(ToCuryInfoID)]; CurrencyInfo orig_info = PXSelect <CurrencyInfo, Where <CurrencyInfo.curyInfoID, Equal <Required <CurrencyInfo.curyInfoID> > > > .Select(cache.Graph, curyInfoID); CurrencyInfo info = PXSelect <CurrencyInfo, Where <CurrencyInfo.curyInfoID, Equal <Required <CurrencyInfo.curyInfoID> > > > .Select(cache.Graph, toCuryInfoID); if (curyAmount == null || info == null || orig_info == null) { return(0m); } if (string.Equals(info.CuryID, orig_info.CuryID)) { return(curyAmount); } decimal val; decimal curyval; PXCurrencyAttribute.CuryConvBase(cache, orig_info, (decimal)curyAmount, out val); PXCurrencyAttribute.CuryConvCury(cache, info, val, out curyval); return(curyval); }
protected virtual void _(Events.RowUpdated <CurrencyInfo> e) { if (e.Row == null) { return; } foreach (ARTran tran in Base.Transactions.Select()) { decimal newTranAmt = 0; if (e.Row.CuryRate != null) { PXCurrencyAttribute.CuryConvBase(e.Cache, e.Row, tran.CuryTranAmt.GetValueOrDefault(), out newTranAmt); } var newTran = Base.Transactions.Cache.CreateCopy(tran) as ARTran; newTran.TranAmt = newTranAmt; decimal oldTranAmt = 0; if (e.OldRow.CuryRate != null) { PXCurrencyAttribute.CuryConvBase(e.Cache, e.OldRow, tran.CuryTranAmt.GetValueOrDefault(), out oldTranAmt); } var oldTran = Base.Transactions.Cache.CreateCopy(tran) as ARTran; oldTran.TranAmt = oldTranAmt; SyncBudgets(newTran, oldTran); } }
protected virtual void SetPOAdjustAdjdAmt(POAdjust row) { if (row == null) { return; } var order = POOrder.PK.Find(Base, row.AdjdOrderType, row.AdjdOrderNbr); if (order != null) { if (order.CuryID == Base.Document.Current.CuryID) { POAdjustments.Cache.SetValueExt <POAdjust.curyAdjdAmt>(row, row.CuryAdjgAmt); } else { PXCurrencyAttribute.CuryConvBase <POAdjust.adjgCuryInfoID>(POAdjustments.Cache, row, row.CuryAdjgAmt ?? 0, out decimal baseCuryAmt); PXCurrencyAttribute.CuryConvCury(Base.Caches <POOrder>(), order, baseCuryAmt, out decimal orderCuryAmt); POAdjustments.Cache.SetValueExt <POAdjust.curyAdjdAmt>(row, orderCuryAmt); } } POAdjustments.Cache.SetValueExt <POAdjust.adjdAmt>(row, row.AdjgAmt); }
protected virtual void _(Events.FieldVerifying <POAdjust, POAdjust.curyAdjgAmt> eventArgs) { if (eventArgs.Row == null || eventArgs.Row.IsRequest == true) { return; } var order = POOrder.PK.Find(Base, eventArgs.Row.AdjdOrderType, eventArgs.Row.AdjdOrderNbr); if (order != null) { bool exceed; decimal newValue = (decimal?)eventArgs.NewValue ?? 0; if (order.CuryID == Base.Document.Current.CuryID) { exceed = order.CuryPrepaidTotal + newValue > order.CuryUnbilledOrderTotal; } else { PXCurrencyAttribute.CuryConvBase <POAdjust.adjgCuryInfoID>(POAdjustments.Cache, eventArgs.Row, newValue, out decimal baseCuryValue); exceed = order.PrepaidTotal + baseCuryValue > order.UnbilledOrderTotal; } if (exceed) { throw new PXSetPropertyException(Messages.PrepaidTotalGreaterUnbilledOrderTotal, order.OrderNbr); } } }
public override void Verify(PXCache cache, object item, List <object> pars, ref bool?result, ref object value) { decimal?curyAmount = (decimal?)Calculate <CuryAmount>(cache, item); long? curyInfoID = (long?)Calculate <CuryInfoID>(cache, item); long? toCuryInfoID = (long?)Calculate <ToCuryInfoID>(cache, item); CurrencyInfo orig_info = PXSelect <CurrencyInfo, Where <CurrencyInfo.curyInfoID, Equal <Required <CurrencyInfo.curyInfoID> > > > .Select(cache.Graph, curyInfoID); CurrencyInfo info = PXSelect <CurrencyInfo, Where <CurrencyInfo.curyInfoID, Equal <Required <CurrencyInfo.curyInfoID> > > > .Select(cache.Graph, toCuryInfoID); decimal val; decimal curyval; if (curyAmount == null || info == null || orig_info == null) { value = 0m; return; } if (string.Equals(info.CuryID, orig_info.CuryID)) { value = curyAmount; } else { PXCurrencyAttribute.CuryConvBase(cache, orig_info, (decimal)curyAmount, out val); PXCurrencyAttribute.CuryConvCury(cache, info, val, out curyval); value = curyval; } }
public static Decimal ConventCury(PXGraph graph, string curyRateTypeID, string curyID, decimal curyCost, string destinationCuryID) { if (curyID == destinationCuryID) { return(curyCost); } Decimal baseCost = curyCost; string BaseCuryID = new PXSetup <Company>(graph).Current.BaseCuryID; if (curyID != BaseCuryID) { PXCurrencyAttribute.CuryConvBase(graph.Caches[typeof(CurrencyInfo)], GetCurrencyInfo(graph, curyRateTypeID, curyID), curyCost, out baseCost, true); } Decimal cost = baseCost; if (destinationCuryID != BaseCuryID) { PXCurrencyAttribute.CuryConvCury(graph.Caches[typeof(CurrencyInfo)], GetCurrencyInfo(graph, curyRateTypeID, destinationCuryID), baseCost, out cost, true); } return(cost); }
public virtual IEnumerable glaccountlist() { foreach (PXResult <GLHistoryByPeriod, RevaluedGLHistory, Account, Branch, FinPeriod, GLHistoryLastRevaluation> res in PXSelectJoin <GLHistoryByPeriod, InnerJoin <RevaluedGLHistory, On <RevaluedGLHistory.ledgerID, Equal <GLHistoryByPeriod.ledgerID>, And <RevaluedGLHistory.branchID, Equal <GLHistoryByPeriod.branchID>, And <RevaluedGLHistory.accountID, Equal <GLHistoryByPeriod.accountID>, And <RevaluedGLHistory.subID, Equal <GLHistoryByPeriod.subID>, And <RevaluedGLHistory.finPeriodID, Equal <GLHistoryByPeriod.lastActivityPeriod> > > > > >, InnerJoin <Account, On <Account.accountID, Equal <GLHistoryByPeriod.accountID> >, InnerJoin <Branch, On <Branch.branchID, Equal <GLHistoryByPeriod.branchID>, And <Branch.ledgerID, Equal <GLHistoryByPeriod.ledgerID> > >, InnerJoin <FinPeriod, On <GLHistoryByPeriod.finPeriodID, Equal <FinPeriod.finPeriodID>, And <Branch.organizationID, Equal <FinPeriod.organizationID> > >, LeftJoin <GLHistoryLastRevaluation, On <GLHistoryByPeriod.ledgerID, Equal <GLHistoryLastRevaluation.ledgerID>, And <GLHistoryByPeriod.branchID, Equal <GLHistoryLastRevaluation.branchID>, And <GLHistoryByPeriod.accountID, Equal <GLHistoryLastRevaluation.accountID>, And <GLHistoryByPeriod.subID, Equal <GLHistoryLastRevaluation.subID> > > > > > > > > >, Where <Account.curyID, Equal <Current <RevalueFilter.curyID> >, And <FinPeriod.masterFinPeriodID, Equal <Current <RevalueFilter.finPeriodID> >, And <Where <RevaluedGLHistory.curyFinYtdBalance, NotEqual <decimal0>, Or <RevaluedGLHistory.finYtdBalance, NotEqual <decimal0> > > > > > > .Select(this)) { GLHistoryByPeriod histbyper = res; GLHistoryLastRevaluation lastRevaluationPeriod = res; RevaluedGLHistory hist = PXCache <RevaluedGLHistory> .CreateCopy(res); RevaluedGLHistory existing; if ((existing = GLAccountList.Locate(hist)) != null) { yield return(existing); continue; } else { GLAccountList.Cache.SetStatus(hist, PXEntryStatus.Held); } if (string.IsNullOrEmpty(hist.CuryRateTypeID = ((Account)res).RevalCuryRateTypeId)) { hist.CuryRateTypeID = cmsetup.Current.GLRateTypeReval; } if (string.IsNullOrEmpty(hist.CuryRateTypeID)) { GLAccountList.Cache.RaiseExceptionHandling <RevaluedGLHistory.curyRateTypeID>(hist, null, new PXSetPropertyException(Messages.RateTypeNotFound)); } else { CurrencyRate curyrate = PXSelect <CurrencyRate, Where <CurrencyRate.fromCuryID, Equal <Current <RevalueFilter.curyID> >, And <CurrencyRate.toCuryID, Equal <Current <Company.baseCuryID> >, And <CurrencyRate.curyRateType, Equal <Required <Account.revalCuryRateTypeId> >, And <CurrencyRate.curyEffDate, LessEqual <Current <RevalueFilter.curyEffDate> > > > > >, OrderBy <Desc <CurrencyRate.curyEffDate> > > .Select(this, hist.CuryRateTypeID); if (curyrate == null || curyrate.CuryMultDiv == null) { hist.CuryMultDiv = "M"; hist.CuryRate = 1m; hist.RateReciprocal = 1m; hist.CuryEffDate = Filter.Current.CuryEffDate; GLAccountList.Cache.RaiseExceptionHandling <RevaluedGLHistory.curyRate>(hist, 1m, new PXSetPropertyException(Messages.RateNotFound, PXErrorLevel.RowWarning)); } else { hist.CuryRate = curyrate.CuryRate; hist.RateReciprocal = curyrate.RateReciprocal; hist.CuryEffDate = curyrate.CuryEffDate; hist.CuryMultDiv = curyrate.CuryMultDiv; } CurrencyInfo info = new CurrencyInfo(); info.BaseCuryID = company.Current.BaseCuryID; info.CuryID = hist.CuryID; info.CuryMultDiv = hist.CuryMultDiv; info.CuryRate = hist.CuryRate; decimal baseval; PXCurrencyAttribute.CuryConvBase(currencyinfo.Cache, info, (decimal)hist.CuryFinYtdBalance, out baseval); hist.FinYtdRevalued = baseval; hist.FinPtdRevalued = hist.FinYtdRevalued - hist.FinYtdBalance; hist.LastRevaluedFinPeriodID = lastRevaluationPeriod?.LastActivityPeriod; } yield return(hist); } }
public virtual IEnumerable araccountlist() { foreach (PXResult <ARHistoryByPeriod, RevaluedARHistory, Account, Customer> res in PXSelectJoin <ARHistoryByPeriod, InnerJoin <RevaluedARHistory, On <RevaluedARHistory.customerID, Equal <ARHistoryByPeriod.customerID>, And <RevaluedARHistory.branchID, Equal <ARHistoryByPeriod.branchID>, And <RevaluedARHistory.accountID, Equal <ARHistoryByPeriod.accountID>, And <RevaluedARHistory.subID, Equal <ARHistoryByPeriod.subID>, And <RevaluedARHistory.curyID, Equal <ARHistoryByPeriod.curyID>, And <RevaluedARHistory.finPeriodID, Equal <ARHistoryByPeriod.lastActivityPeriod> > > > > > >, LeftJoin <Account, On <Account.accountID, Equal <ARHistoryByPeriod.accountID>, And <Account.curyID, IsNotNull> >, InnerJoin <Customer, On <Customer.bAccountID, Equal <ARHistoryByPeriod.customerID> > > > >, Where <ARHistoryByPeriod.curyID, Equal <Current <RevalueFilter.curyID> >, And <ARHistoryByPeriod.finPeriodID, Equal <Current <RevalueFilter.finPeriodID> >, And <Account.accountID, IsNull, And <RevaluedARHistory.curyFinYtdBalance, NotEqual <decimal0> > > > > > .Select(this)) { ARHistoryByPeriod histbyper = res; RevaluedARHistory hist = PXCache <RevaluedARHistory> .CreateCopy(res); RevaluedARHistory existing; Customer cust = res; if ((existing = ARAccountList.Locate(hist)) != null) { yield return(existing); continue; } else { ARAccountList.Cache.SetStatus(hist, PXEntryStatus.Held); } hist.CustomerClassID = cust.CustomerClassID; hist.CuryRateTypeID = cmsetup.Current.ARRateTypeReval ?? cust.CuryRateTypeID; if (string.IsNullOrEmpty(hist.CuryRateTypeID)) { ARAccountList.Cache.RaiseExceptionHandling <RevaluedGLHistory.curyRateTypeID>(hist, null, new PXSetPropertyException(Messages.RateTypeNotFound)); } else { CurrencyRateByDate curyrate = PXSelect <CurrencyRateByDate, Where <CurrencyRateByDate.fromCuryID, Equal <Current <RevalueFilter.curyID> >, And <CurrencyRateByDate.toCuryID, Equal <Current <Company.baseCuryID> >, And <CurrencyRateByDate.curyRateType, Equal <Required <Customer.curyRateTypeID> >, And2 <Where <CurrencyRateByDate.curyEffDate, LessEqual <Current <RevalueFilter.curyEffDate> >, Or <CurrencyRateByDate.curyEffDate, IsNull> >, And <Where <CurrencyRateByDate.nextEffDate, Greater <Current <RevalueFilter.curyEffDate> >, Or <CurrencyRateByDate.nextEffDate, IsNull> > > > > > > > .Select(this, hist.CuryRateTypeID); if (curyrate == null || curyrate.CuryMultDiv == null) { hist.CuryMultDiv = "M"; hist.CuryRate = 1m; ARAccountList.Cache.RaiseExceptionHandling <RevaluedARHistory.curyRate>(hist, 1m, new PXSetPropertyException(Messages.RateNotFound, PXErrorLevel.RowWarning)); } else { hist.CuryRate = curyrate.CuryRate; hist.CuryMultDiv = curyrate.CuryMultDiv; } CurrencyInfo info = new CurrencyInfo(); info.BaseCuryID = company.Current.BaseCuryID; info.CuryID = hist.CuryID; info.CuryMultDiv = hist.CuryMultDiv; info.CuryRate = hist.CuryRate; //hist.CuryFinYtdBalance -= hist.CuryFinYtdDeposits; //hist.FinYtdBalance -= hist.FinYtdDeposits; decimal baseval; PXCurrencyAttribute.CuryConvBase(currencyinfo.Cache, info, (decimal)hist.CuryFinYtdBalance, out baseval); hist.FinYtdRevalued = baseval; hist.FinPrevRevalued = string.Equals(histbyper.FinPeriodID, histbyper.LastActivityPeriod) ? hist.FinPtdRevalued : 0m; hist.FinPtdRevalued = hist.FinYtdRevalued - hist.FinPrevRevalued - hist.FinYtdBalance; } yield return(hist); } }
protected virtual decimal ConvertAmt(string from, string to, string rateType, DateTime effectiveDate, decimal amount) { if (from == to) { return(amount); } decimal result = amount; PXCache curyCache = CarrierRatesDummyCuryInfo.Cache; using (var rs = new ReadOnlyScope(curyCache)) { if (from == Base.Accessinfo.BaseCuryID) { CurrencyInfo ci = new CurrencyInfo(); ci.CuryRateTypeID = rateType; ci.CuryID = to; ci = (CurrencyInfo)curyCache.Insert(ci); ci.SetCuryEffDate(curyCache, effectiveDate); curyCache.Update(ci); PXCurrencyAttribute.CuryConvCury(curyCache, ci, amount, out result); curyCache.Delete(ci); } else if (to == Base.Accessinfo.BaseCuryID) { CurrencyInfo ci = new CurrencyInfo(); ci.CuryRateTypeID = rateType; ci.CuryID = from; ci = (CurrencyInfo)curyCache.Insert(ci); ci.SetCuryEffDate(curyCache, effectiveDate); curyCache.Update(ci); PXCurrencyAttribute.CuryConvBase(curyCache, ci, amount, out result); curyCache.Delete(ci); } else { CurrencyInfo ciFrom = new CurrencyInfo(); ciFrom.CuryRateTypeID = rateType; ciFrom.CuryID = from; ciFrom = (CurrencyInfo)curyCache.Insert(ciFrom); ciFrom.SetCuryEffDate(curyCache, effectiveDate); curyCache.Update(ciFrom); decimal inBase; PXCurrencyAttribute.CuryConvBase(curyCache, ciFrom, amount, out inBase, true); CurrencyInfo ciTo = new CurrencyInfo(); ciTo.CuryRateTypeID = rateType; ciTo.CuryID = to; ciTo = (CurrencyInfo)curyCache.Insert(ciTo); ciTo.SetCuryEffDate(curyCache, effectiveDate); curyCache.Update(ciFrom); PXCurrencyAttribute.CuryConvCury(curyCache, ciTo, inBase, out result, true); curyCache.Delete(ciFrom); curyCache.Delete(ciTo); } } return(result); }
public virtual IEnumerable apaccountlist() { foreach (PXResult <APHistoryByPeriod, RevaluedAPHistory, Vendor, APHistoryLastRevaluation> res in PXSelectJoin <APHistoryByPeriod, InnerJoin <RevaluedAPHistory, On <RevaluedAPHistory.vendorID, Equal <APHistoryByPeriod.vendorID>, And <RevaluedAPHistory.branchID, Equal <APHistoryByPeriod.branchID>, And <RevaluedAPHistory.accountID, Equal <APHistoryByPeriod.accountID>, And <RevaluedAPHistory.subID, Equal <APHistoryByPeriod.subID>, And <RevaluedAPHistory.curyID, Equal <APHistoryByPeriod.curyID>, And <RevaluedAPHistory.finPeriodID, Equal <APHistoryByPeriod.lastActivityPeriod> > > > > > >, InnerJoin <Vendor, On <Vendor.bAccountID, Equal <APHistoryByPeriod.vendorID> >, LeftJoin <APHistoryLastRevaluation, On <APHistoryByPeriod.vendorID, Equal <APHistoryLastRevaluation.vendorID>, And <APHistoryByPeriod.branchID, Equal <APHistoryLastRevaluation.branchID>, And <APHistoryByPeriod.accountID, Equal <APHistoryLastRevaluation.accountID>, And <APHistoryByPeriod.subID, Equal <APHistoryLastRevaluation.subID>, And <APHistoryByPeriod.curyID, Equal <APHistoryLastRevaluation.curyID> > > > > > > > >, Where <APHistoryByPeriod.curyID, Equal <Current <RevalueFilter.curyID> >, And <APHistoryByPeriod.finPeriodID, Equal <Current <RevalueFilter.finPeriodID> >, And <Where <RevaluedAPHistory.curyFinYtdBalance, NotEqual <decimal0>, Or <RevaluedAPHistory.finPtdRevalued, NotEqual <decimal0>, Or <RevaluedAPHistory.curyFinYtdDeposits, NotEqual <decimal0> > > > > > > > .Select(this)) { APHistoryByPeriod histbyper = res; APHistoryLastRevaluation lastRevaluationPeriod = res; RevaluedAPHistory hist = PXCache <RevaluedAPHistory> .CreateCopy(res); RevaluedAPHistory existing; Vendor vendor = res; if ((existing = APAccountList.Locate(hist)) != null) { yield return(existing); continue; } else { APAccountList.Cache.SetStatus(hist, PXEntryStatus.Held); } hist.VendorClassID = vendor.VendorClassID; hist.CuryRateTypeID = cmsetup.Current.APRateTypeReval ?? ((Vendor)res).CuryRateTypeID; if (string.IsNullOrEmpty(hist.CuryRateTypeID)) { APAccountList.Cache.RaiseExceptionHandling <RevaluedGLHistory.curyRateTypeID>(hist, null, new PXSetPropertyException(Messages.RateTypeNotFound)); } else { CurrencyRate curyrate = PXSelect <CurrencyRate, Where <CurrencyRate.fromCuryID, Equal <Current <RevalueFilter.curyID> >, And <CurrencyRate.toCuryID, Equal <Current <Company.baseCuryID> >, And <CurrencyRate.curyRateType, Equal <Required <Vendor.curyRateTypeID> >, And <CurrencyRate.curyEffDate, LessEqual <Current <RevalueFilter.curyEffDate> > > > > >, OrderBy <Desc <CurrencyRate.curyEffDate> > > .Select(this, hist.CuryRateTypeID); if (curyrate == null || curyrate.CuryMultDiv == null) { hist.CuryMultDiv = "M"; hist.CuryRate = 1m; hist.RateReciprocal = 1m; hist.CuryEffDate = Filter.Current.CuryEffDate; APAccountList.Cache.RaiseExceptionHandling <RevaluedAPHistory.curyRate>(hist, 1m, new PXSetPropertyException(Messages.RateNotFound, PXErrorLevel.RowWarning)); } else { hist.CuryRate = curyrate.CuryRate; hist.RateReciprocal = curyrate.RateReciprocal; hist.CuryEffDate = curyrate.CuryEffDate; hist.CuryMultDiv = curyrate.CuryMultDiv; } CurrencyInfo info = new CurrencyInfo(); info.BaseCuryID = company.Current.BaseCuryID; info.CuryID = hist.CuryID; info.CuryMultDiv = hist.CuryMultDiv; info.CuryRate = hist.CuryRate; info.RecipRate = hist.RateReciprocal; hist.CuryFinYtdBalance -= hist.CuryFinYtdDeposits; hist.FinYtdBalance -= hist.FinYtdDeposits; decimal baseval; PXCurrencyAttribute.CuryConvBase(currencyinfo.Cache, info, (decimal)hist.CuryFinYtdBalance, out baseval); hist.FinYtdRevalued = baseval; hist.FinPrevRevalued = string.Equals(histbyper.FinPeriodID, histbyper.LastActivityPeriod) ? hist.FinPtdRevalued : 0m; hist.FinPtdRevalued = hist.FinYtdRevalued - hist.FinPrevRevalued - hist.FinYtdBalance; hist.LastRevaluedFinPeriodID = lastRevaluationPeriod?.LastActivityPeriod; } yield return(hist); } }
public static ItemCost Fetch(PXGraph graph, int?vendorID, int?vendorLocationID, DateTime?docDate, string curyID, int?inventoryID, int?subItemID, int?siteID, string uom, bool onlyVendor) { InventoryItem item = null; INItemCost cost = null; Vendor vendor = null; POVendorInventory vendorPrice = null; foreach (PXResult <InventoryItem, INItemCost, Vendor, POVendorInventory> r in PXSelectJoin <InventoryItem, LeftJoin <INItemCost, On <INItemCost.inventoryID, Equal <InventoryItem.inventoryID> >, LeftJoin <Vendor, On <Vendor.bAccountID, Equal <Required <Vendor.bAccountID> > >, LeftJoin <POVendorInventory, On <POVendorInventory.inventoryID, Equal <InventoryItem.inventoryID>, And <POVendorInventory.active, Equal <boolTrue>, And <POVendorInventory.vendorID, Equal <Vendor.bAccountID>, 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> >, Or <POVendorInventory.purchaseUnit, Equal <InventoryItem.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> >, boolTrue>, boolFalse>, Asc <Switch <Case <Where <POVendorInventory.subItemID, Equal <InventoryItem.defaultSubItemID> >, boolTrue>, boolFalse>, Asc <Switch <Case <Where <POVendorInventory.vendorLocationID, IsNull>, boolTrue>, boolFalse>, Asc <InventoryItem.inventoryCD> > > > > > .Select(graph, vendorID, subItemID, subItemID, uom, vendorLocationID, inventoryID)) { item = r; cost = r; vendor = r; vendorPrice = r; if (vendorPrice != null) { break; } } if (vendorPrice != null && vendorPrice.VendorID != null) { Decimal?price = (docDate != null && docDate >= vendorPrice.EffDate && vendorPrice.EffPrice > 0) ? vendorPrice.EffPrice : vendorPrice.LastPrice; string purchaseUnit = vendorPrice.PurchaseUnit ?? item.PurchaseUnit; if (price == 0) { price = null; } if (price != null) { Company company = new PXSetup <Company>(graph).Current; if (vendorPrice.CuryID == company.BaseCuryID || vendorPrice.CuryID == null) { return(new ItemCost(item, purchaseUnit, price.Value)); } try { Decimal basePrice; PXCurrencyAttribute.CuryConvBase(graph.Caches[typeof(CurrencyInfo)], GetCurrencyInfo(graph, vendor.CuryRateTypeID, vendorPrice.CuryID), price.Value, out basePrice, true); return(new ItemCost(item, purchaseUnit, vendorPrice.CuryID, price.Value, basePrice)); } catch { return(new ItemCost(item, purchaseUnit, 0)); } } } return (FetchHistoryLastCost(graph, vendorID, vendorLocationID, inventoryID, subItemID) ?? (onlyVendor ? null : FetchLastCost(graph, item, docDate)) ?? (onlyVendor ? null : FetchSiteLastCost(graph, item, cost, siteID)) ?? new ItemCost(item, 0)); }
public virtual List <PMTask> CreateProjectTrans() { var autoAllocateTasks = new List <PMTask>(); if (Base.BatchModule.Current != null && Base.BatchModule.Current.Module != BatchModule.GL) { PXResultset <GLTran> trans = new PXSelect <GLTran, Where <GLTran.module, Equal <Current <Batch.module> >, And <GLTran.batchNbr, Equal <Current <Batch.batchNbr> >, And <GLTran.pMTranID, IsNull, And <GLTran.isNonPM, NotEqual <True> > > > > >(Base).Select(); if (trans.Count > 0) { ProjectBalance pb = CreateProjectBalance(); var tasksToAutoAllocate = new Dictionary <string, PMTask>(); var sourceForAllocation = new List <PMTran>(); var doc = new PMRegister(); doc.Module = Base.BatchModule.Current.Module; doc.Date = Base.BatchModule.Current.DateEntered; doc.Description = Base.BatchModule.Current.Description; doc.Released = true; doc.Status = PMRegister.status.Released; bool docInserted = false; //to prevent creating empty batch JournalEntryTranRef entryRefGraph = PXGraph.CreateInstance <JournalEntryTranRef>(); foreach (GLTran tran in trans) { var acc = (Account)PXSelect <Account, Where <Account.accountID, Equal <Required <GLTran.accountID> >, And <Account.accountGroupID, IsNotNull> > > .Select(Base, tran.AccountID); if (acc == null) { continue; } var ag = (PMAccountGroup)PXSelect <PMAccountGroup, Where <PMAccountGroup.groupID, Equal <Required <Account.accountGroupID> >, And <PMAccountGroup.type, NotEqual <PMAccountType.offBalance> > > > .Select(Base, acc.AccountGroupID); if (ag == null) { continue; } var project = (PMProject)PXSelect <PMProject, Where <PMProject.contractID, Equal <Required <GLTran.projectID> >, And <PMProject.nonProject, Equal <False> > > > .Select(Base, tran.ProjectID); if (project == null) { continue; } var task = (PMTask)PXSelect <PMTask, Where <PMTask.projectID, Equal <Required <GLTran.projectID> >, And <PMTask.taskID, Equal <Required <GLTran.taskID> > > > > .Select(Base, tran.ProjectID, tran.TaskID); if (task == null) { continue; } APTran apTran = null; if (Base.BatchModule.Current.Module == BatchModule.AP) { apTran = (APTran)PXSelect <APTran, Where <APTran.refNbr, Equal <Required <GLTran.refNbr> >, And <APTran.lineNbr, Equal <Required <GLTran.tranLineNbr> >, And <APTran.tranType, Equal <Required <GLTran.tranType> > > > > > .Select(Base, tran.RefNbr, tran.TranLineNbr, tran.TranType); } ARTran arTran = null; if (Base.BatchModule.Current.Module == BatchModule.AR) { arTran = (ARTran)PXSelect <ARTran, Where <ARTran.refNbr, Equal <Required <GLTran.refNbr> >, And <ARTran.lineNbr, Equal <Required <GLTran.tranLineNbr> >, And <ARTran.tranType, Equal <Required <GLTran.tranType> > > > > > .Select(Base, tran.RefNbr, tran.TranLineNbr, tran.TranType); } if (!docInserted) { doc = ProjectDocs.Insert(doc); docInserted = true; } doc.OrigDocType = entryRefGraph.GetDocType(apTran, arTran, tran); doc.OrigNoteID = entryRefGraph.GetNoteID(apTran, arTran, tran); PMTran pmt = (PMTran)ProjectTrans.Cache.Insert(); pmt.BranchID = tran.BranchID; pmt.AccountGroupID = acc.AccountGroupID; pmt.AccountID = tran.AccountID; pmt.SubID = tran.SubID; entryRefGraph.AssignCustomerVendorEmployee(tran, pmt); //CustomerLocation is lost. //pmt.BatchNbr = tran.BatchNbr; pmt.Date = tran.TranDate; pmt.TranDate = tran.TranDate; pmt.Description = tran.TranDesc; pmt.FinPeriodID = tran.FinPeriodID; pmt.TranPeriodID = tran.TranPeriodID; pmt.InventoryID = tran.InventoryID ?? PMInventorySelectorAttribute.EmptyInventoryID; pmt.OrigLineNbr = tran.LineNbr; pmt.OrigModule = tran.Module; pmt.OrigRefNbr = tran.RefNbr; pmt.OrigTranType = tran.TranType; pmt.ProjectID = tran.ProjectID; pmt.TaskID = tran.TaskID; pmt.CostCodeID = tran.CostCodeID; if (arTran != null) { pmt.Billable = false; pmt.ExcludedFromBilling = true; pmt.ExcludedFromBillingReason = arTran.TranType == ARDocType.CreditMemo ? PXMessages.LocalizeFormatNoPrefix(Messages.ExcludedFromBillingAsCreditMemoResult, arTran.RefNbr) : PXMessages.LocalizeFormatNoPrefix(Messages.ExcludedFromBillingAsARInvoiceResult, arTran.RefNbr); } else { pmt.Billable = tran.NonBillable != true; } pmt.Released = true; if (apTran != null && apTran.Date != null) { pmt.Date = apTran.Date; } pmt.UseBillableQty = true; pmt.UOM = tran.UOM; pmt.Amount = tran.DebitAmt - tran.CreditAmt; CurrencyInfo projectCuryInfo = null; if (PXAccess.FeatureInstalled <FeaturesSet.projectMultiCurrency>()) { pmt.TranCuryID = Base.BatchModule.Current.CuryID; pmt.ProjectCuryID = project.CuryID; pmt.BaseCuryInfoID = tran.CuryInfoID; pmt.TranCuryAmount = tran.CuryDebitAmt - tran.CuryCreditAmt; if (project.CuryID == Base.ledger.Current.BaseCuryID) { pmt.ProjectCuryInfoID = tran.CuryInfoID; pmt.ProjectCuryAmount = pmt.Amount; } else if (project.CuryID == Base.BatchModule.Current.CuryID) { projectCuryInfo = new CurrencyInfo(); projectCuryInfo.ModuleCode = GL.BatchModule.PM; projectCuryInfo.BaseCuryID = project.CuryID; projectCuryInfo.CuryID = project.CuryID; projectCuryInfo.CuryRateTypeID = project.RateTypeID ?? Base.CMSetup.Current.PMRateTypeDflt; projectCuryInfo.CuryEffDate = tran.TranDate; projectCuryInfo.CuryRate = 1; projectCuryInfo.RecipRate = 1; projectCuryInfo = Base.currencyinfo.Insert(projectCuryInfo); pmt.ProjectCuryInfoID = projectCuryInfo.CuryInfoID; pmt.ProjectCuryAmount = pmt.TranCuryAmount; } else { CM.Extensions.IPXCurrencyService currencyService = ServiceLocator.Current.GetInstance <Func <PXGraph, CM.Extensions.IPXCurrencyService> >()(Base); projectCuryInfo = new CurrencyInfo(); projectCuryInfo.ModuleCode = GL.BatchModule.PM; projectCuryInfo.BaseCuryID = project.CuryID; projectCuryInfo.CuryID = Base.BatchModule.Current.CuryID; projectCuryInfo.CuryRateTypeID = project.RateTypeID ?? currencyService.DefaultRateTypeID(BatchModule.PM); projectCuryInfo.CuryEffDate = tran.TranDate; var rate = currencyService.GetRate(projectCuryInfo.CuryID, projectCuryInfo.BaseCuryID, projectCuryInfo.CuryRateTypeID, projectCuryInfo.CuryEffDate); if (rate == null) { throw new PXException(PM.Messages.FxTranToProjectNotFound, projectCuryInfo.CuryID, projectCuryInfo.BaseCuryID, projectCuryInfo.CuryRateTypeID, tran.TranDate); } projectCuryInfo = Base.currencyinfo.Insert(projectCuryInfo); pmt.ProjectCuryInfoID = projectCuryInfo.CuryInfoID; decimal val; PXCurrencyAttribute.CuryConvBase(Base.BatchModule.Cache, projectCuryInfo, pmt.TranCuryAmount.GetValueOrDefault(), out val); pmt.ProjectCuryAmount = val; } } else { pmt.TranCuryAmount = pmt.Amount; pmt.ProjectCuryAmount = pmt.Amount; pmt.TranCuryID = Base.ledger.Current.BaseCuryID; pmt.ProjectCuryID = Base.ledger.Current.BaseCuryID; if (Base.BatchModule.Current.CuryID != Base.ledger.Current.BaseCuryID) { CurrencyInfo baseCuryInfo = new CurrencyInfo(); baseCuryInfo.ModuleCode = GL.BatchModule.PM; baseCuryInfo.BaseCuryID = Base.ledger.Current.BaseCuryID; baseCuryInfo.CuryID = Base.ledger.Current.BaseCuryID; baseCuryInfo.CuryRateTypeID = null; baseCuryInfo.CuryEffDate = tran.TranDate; baseCuryInfo.CuryRate = 1; baseCuryInfo.RecipRate = 1; baseCuryInfo = Base.currencyinfo.Insert(baseCuryInfo); pmt.ProjectCuryInfoID = baseCuryInfo.CuryInfoID; pmt.BaseCuryInfoID = baseCuryInfo.CuryInfoID; } else { pmt.ProjectCuryInfoID = tran.CuryInfoID; pmt.BaseCuryInfoID = tran.CuryInfoID; } } pmt.Qty = tran.Qty; //pmt.Amount >= 0 ? tran.Qty : (tran.Qty * -1); int sign = 1; if (acc.Type == AccountType.Income || acc.Type == AccountType.Liability) { sign = -1; } if (ProjectBalance.IsFlipRequired(acc.Type, ag.Type)) { pmt.ProjectCuryAmount = -pmt.ProjectCuryAmount; pmt.TranCuryAmount = -pmt.TranCuryAmount; pmt.Amount = -pmt.Amount; pmt.Qty = -pmt.Qty; } pmt.BillableQty = pmt.Qty; Base.GLTranModuleBatNbr.SetValueExt <GLTran.pMTranID>(tran, pmt.TranID); if (apTran != null && apTran.NoteID != null) { PXNoteAttribute.CopyNoteAndFiles(Base.Caches[typeof(AP.APTran)], apTran, ProjectTrans.Cache, pmt); } else if (arTran != null && arTran.NoteID != null) { PXNoteAttribute.CopyNoteAndFiles(Base.Caches[typeof(AR.ARTran)], arTran, ProjectTrans.Cache, pmt); } ProjectBalance.Result balance = pb.Calculate(project, pmt, ag, acc.Type, sign, 1); if (balance.Status != null) { PMBudgetAccum ps = new PMBudgetAccum(); ps.ProjectID = balance.Status.ProjectID; ps.ProjectTaskID = balance.Status.ProjectTaskID; ps.AccountGroupID = balance.Status.AccountGroupID; ps.InventoryID = balance.Status.InventoryID; ps.CostCodeID = balance.Status.CostCodeID; ps.UOM = balance.Status.UOM; ps.IsProduction = balance.Status.IsProduction; ps.Type = balance.Status.Type; ps.Description = balance.Status.Description; ps.CuryInfoID = balance.Status.CuryInfoID; ps = ProjectBudget.Insert(ps); ps.ActualQty += balance.Status.ActualQty.GetValueOrDefault(); ps.CuryActualAmount += balance.Status.CuryActualAmount.GetValueOrDefault(); ps.ActualAmount += balance.Status.ActualAmount.GetValueOrDefault(); if (arTran != null && arTran.LineNbr != null && ag.Type == GL.AccountType.Income) { ps.CuryInvoicedAmount -= balance.Status.CuryActualAmount.GetValueOrDefault(); ps.InvoicedAmount -= balance.Status.ActualAmount.GetValueOrDefault(); } } if (balance.ForecastHistory != null) { PMForecastHistoryAccum forecast = new PMForecastHistoryAccum(); forecast.ProjectID = balance.ForecastHistory.ProjectID; forecast.ProjectTaskID = balance.ForecastHistory.ProjectTaskID; forecast.AccountGroupID = balance.ForecastHistory.AccountGroupID; forecast.InventoryID = balance.ForecastHistory.InventoryID; forecast.CostCodeID = balance.ForecastHistory.CostCodeID; forecast.PeriodID = balance.ForecastHistory.PeriodID; forecast = ForecastHistory.Insert(forecast); forecast.ActualQty += balance.ForecastHistory.ActualQty.GetValueOrDefault(); forecast.CuryActualAmount += balance.ForecastHistory.CuryActualAmount.GetValueOrDefault(); forecast.ActualAmount += balance.ForecastHistory.ActualAmount.GetValueOrDefault(); } if (balance.TaskTotal != null) { PMTaskTotal ta = new PMTaskTotal(); ta.ProjectID = balance.TaskTotal.ProjectID; ta.TaskID = balance.TaskTotal.TaskID; ta = ProjectTaskTotals.Insert(ta); ta.CuryAsset += balance.TaskTotal.CuryAsset.GetValueOrDefault(); ta.Asset += balance.TaskTotal.Asset.GetValueOrDefault(); ta.CuryLiability += balance.TaskTotal.CuryLiability.GetValueOrDefault(); ta.Liability += balance.TaskTotal.Liability.GetValueOrDefault(); ta.CuryIncome += balance.TaskTotal.CuryIncome.GetValueOrDefault(); ta.Income += balance.TaskTotal.Income.GetValueOrDefault(); ta.CuryExpense += balance.TaskTotal.CuryExpense.GetValueOrDefault(); ta.Expense += balance.TaskTotal.Expense.GetValueOrDefault(); } RegisterReleaseProcess.AddToUnbilledSummary(Base, pmt); sourceForAllocation.Add(pmt); if (pmt.Allocated != true && pmt.ExcludedFromAllocation != true && project.AutoAllocate == true) { if (!tasksToAutoAllocate.ContainsKey(string.Format("{0}.{1}", task.ProjectID, task.TaskID))) { tasksToAutoAllocate.Add(string.Format("{0}.{1}", task.ProjectID, task.TaskID), task); } } entryRefGraph.AssignAdditionalFields(tran, pmt); } autoAllocateTasks.AddRange(tasksToAutoAllocate.Values); } } return(autoAllocateTasks); }