protected virtual void CRServiceCase_CustomerID_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e) { if (cmSetup.Current.MCActivated == true && (e.ExternalCall || sender.GetValuePending <CRServiceCase.curyID>(e.Row) == null)) { var info = CurrencyInfoAttribute.SetDefaults <CRServiceCase.curyInfoID>(sender, e.Row); var row = (CRServiceCase)e.Row; var message = PXUIFieldAttribute.GetError <CurrencyInfo.curyEffDate>(dummyCuryInfo.Cache, info); if (!string.IsNullOrEmpty(message)) { sender.RaiseExceptionHandling <CRServiceCase.createdDateTime>(e.Row, row.CreatedDateTime, new PXSetPropertyException(message, PXErrorLevel.Warning)); } if (info != null) { row.CuryID = info.CuryID; } } SharedRecordAttribute.DefaultRecord <CRServiceCase.destinationAddressID>(sender, e.Row); SharedRecordAttribute.DefaultRecord <CRServiceCase.billAddressID>(sender, e.Row); sender.SetDefaultExt <CRServiceCase.locationID>(e.Row); }
protected virtual void TaxAdjustment_VendorID_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e) { TaxAdjustment doc = (TaxAdjustment)e.Row; if (doc == null) { return; } if (PXAccess.FeatureInstalled <FeaturesSet.multicurrency>()) { if (e.ExternalCall || sender.GetValuePending <TaxAdjustment.curyID>(doc) == null) { CurrencyInfo info = CurrencyInfoAttribute.SetDefaults <TaxAdjustment.curyInfoID>(sender, doc); string message = PXUIFieldAttribute.GetError <CurrencyInfo.curyEffDate>(currencyinfo.Cache, info); if (string.IsNullOrEmpty(message) == false) { sender.RaiseExceptionHandling <TaxAdjustment.docDate>(doc, doc.DocDate, new PXSetPropertyException(message, PXErrorLevel.Warning)); } if (info != null) { doc.CuryID = info.CuryID; } } } sender.SetDefaultExt <TaxAdjustment.vendorLocationID>(e.Row); sender.SetDefaultExt <TaxAdjustment.taxPeriod>(e.Row); sender.SetDefaultExt <TaxAdjustment.adjAccountID>(e.Row); sender.SetDefaultExt <TaxAdjustment.adjSubID>(e.Row); }
protected virtual void PTInstStatement_CashAccountID_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e) { if (this.cashAccount.Current == null || this.cashAccount.Current.AccountID != ((PTInstStatement)e.Row).CashAccountID) { this.cashAccount.Current = (CashAccount)PXSelectorAttribute.Select <CashAccount.cashAccountID>(sender, e.Row); } //if ((bool)CMSetup.Current.MCActivated) { if (e.ExternalCall || sender.GetValuePending <PTInstStatement.curyID>(e.Row) == null) { CurrencyInfo info = CurrencyInfoAttribute.SetDefaults <PTInstStatement.curyInfoID>(sender, e.Row); string message = PXUIFieldAttribute.GetError <CurrencyInfo.curyEffDate>(currencyinfo.Cache, info); if (string.IsNullOrEmpty(message) == false) { sender.RaiseExceptionHandling <PTInstStatement.statementDate>(e.Row, ((PTInstStatement)e.Row).StatementDate, new PXSetPropertyException(message, PXErrorLevel.Warning)); } if (info != null) { ((PTInstStatement)e.Row).CuryID = info.CuryID; } } } }
protected virtual void TXImportZipFileData_ZipCode_FieldUpdating(PXCache sender, PXFieldUpdatingEventArgs e) { if (e.Row != null) { _importing = sender.GetValuePending(e.Row, PXImportAttribute.ImportFlag) != null; } }
public static object GetNewValueByIncoming(PXCache cache, object row, string fieldName, bool externalCall) { object incoming = null; if (externalCall) { incoming = cache.GetValuePending(row, fieldName); if (incoming != null) { return(incoming); } } try { incoming = cache.GetValueExt(row, fieldName); return(PXFieldState.UnwrapValue(incoming)); } catch { } return(cache.GetValue(row, fieldName)); }
public static object GetValuePendingOrCurrent(PXCache cache, Type sourceType, object row) { object value = cache.GetValuePending(row, sourceType.Name); if (value != PXCache.NotSetValue) { return(value); } return(BqlHelper.GetOperandValue(cache, row ?? cache.Current, sourceType)); }
public static object GetValuePendingOrRow <TField>(PXCache cache, object row) where TField : IBqlField { object value = cache.GetValuePending(row, typeof(TField).Name); if (value != PXCache.NotSetValue) { cache.RaiseFieldUpdating <TField>(row, ref value); return(value); } return(BqlHelper.GetOperandValue(cache, row, typeof(TField))); }
protected virtual void INTran_LocationID_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e) { INTran row = e.Row as INTran; if (row == null) { return; } sender.SetDefaultExt <INTran.projectID>(e.Row); //will set pending value for TaskID to null if project is changed. This is the desired behavior for all other screens. if (sender.GetValuePending <INTran.taskID>(e.Row) == null) //To redefault the TaskID in currecnt screen - set the Pending value from NULL to NOTSET { sender.SetValuePending <INTran.taskID>(e.Row, PXCache.NotSetValue); } sender.SetDefaultExt <INTran.taskID>(e.Row); }
private void SourceFieldUpdated(PXCache cache, PXFieldUpdatedEventArgs e) { object sourcedate = cache.GetValue(e.Row, _sourceField); if (sourcedate != null) { PeriodResult result = GetPeriod(cache, _searchType, (DateTime)sourcedate, new object[] { e.Row }, true); string newValue = result; bool haspending = false; try { object pendingValue = cache.GetValuePending(e.Row, _FieldName); if (pendingValue != null && pendingValue != PXCache.NotSetValue) { pendingValue = UnFormatPeriod((string)pendingValue); cache.RaiseFieldVerifying(_FieldName, e.Row, ref pendingValue); haspending = true; } } catch (PXSetPropertyException) { cache.SetValuePending(e.Row, _FieldName, newValue); } finally { if (cache.HasAttributes(e.Row)) { cache.RaiseExceptionHandling(_FieldName, e.Row, null, null); } //this will happen only if FirstOpenPeriod is set from OpenPeriod if (!haspending && result.StartDate > (DateTime?)sourcedate) { cache.SetValueExt(e.Row, _sourceField, result.StartDate); } else { cache.SetValueExt(e.Row, _FieldName, newValue); } } } else { cache.SetValue(e.Row, _FieldName, null); } }
protected virtual void EPActivity_RowPersisted(PXCache cache, PXRowPersistedEventArgs e) { var row = e.Row as EPActivity; if (row == null || e.TranStatus != PXTranStatus.Open || cache.GetValuePending(row, PXImportAttribute.ImportFlag) != null) { return; } var operation = e.Operation & PXDBOperation.Command; if (operation == PXDBOperation.Insert || operation == PXDBOperation.Update) { EPViewStatusAttribute.MarkAsViewed(this, row, true); } }
public void FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e) { var valuePending = sender.GetValuePending(e.Row, _FieldName); if (_FromAttribute == false || PXCache.NotSetValue == valuePending) { return; } _FromAttribute = false; DateTime?dateTimeValue = (DateTime?)valuePending; if (dateTimeValue != null) { sender.SetValue(e.Row, _FieldName, dateTimeValue); } }
protected virtual void CuryFieldUpdating(PXCache sender, PXFieldUpdatingEventArgs e, string curyField, string baseField) { if (!FormatValue(e, sender.Graph.Culture)) { return; } if (Base.Accessinfo.CuryViewState && e.Row != null && e.NewValue != null && object.ReferenceEquals(sender.GetValuePending(e.Row, curyField), e.NewValue)) { e.NewValue = sender.GetValue(e.Row, curyField); } else { CurrencyInfo info = GetCurrencyInfo(Documents.Current); if (info != null) { PopulatePrecision(currencyinfo.Cache, info); var value = Convert.ToDecimal(e.NewValue); e.NewValue = Math.Round(value, info.CuryPrecision ?? 2, MidpointRounding.AwayFromZero); } } }
protected object GetNewValueByIncomig(PXCache cache, object row, string fieldName, bool externalCall) { object incoming = null; if (externalCall) { incoming = cache.GetValuePending(row, fieldName); if (incoming != null) { return(incoming); } } try { incoming = cache.GetValueExt(row, fieldName); var state = incoming as PXFieldState; if (state != null) { return(state.Value); } if (incoming != null) { return(incoming); } } catch { } return(cache.GetValue(row, fieldName)); }
protected virtual void GetRecords() { PXCache cache = this._Graph.Caches[BqlCommand.GetItemType(this.BatchModule)]; object current = null; foreach (object item in PXView.Currents) { if (item != null && (item.GetType() == BqlCommand.GetItemType(this.BatchModule) || item.GetType().IsSubclassOf(BqlCommand.GetItemType(this.BatchModule)))) { current = item; break; } } if (current == null) { current = cache.Current; } PXView view = PXView.View; if (view != null) { if (_CuryID != null) { object curyID = cache.GetValue(current, this._CuryID.Name) ?? cache.GetValuePending(current, _CuryID.Name); PX.Common.PXContext.SetSlot(this._CuryID.FullName, curyID); } switch ((string)(cache.GetValue(current, this.BatchModule.Name) ?? cache.GetValuePending(current, this.BatchModule.Name))) { case GL.BatchModule.AP: view.WhereNew <Where2 <Match <VendorR, Current <AccessInfo.userName> >, And <Where <BAccountR.type, Equal <BAccountType.vendorType>, Or <BAccountR.type, Equal <BAccountType.employeeType>, Or <BAccountR.type, Equal <BAccountType.combinedType>, Or <BAccountR.type, Equal <BAccountType.empCombinedType> > > > > > > >(); if (_CuryID != null) { Type join = BqlCommand.Compose( typeof(InnerJoin <,>), typeof(VendorR), typeof(On <, ,>), typeof(VendorR.bAccountID), typeof(Equal <>), typeof(BAccountR.bAccountID), typeof(And <>), typeof(Where <, ,>), typeof(VendorR.curyID), typeof(Equal <>), typeof(SavedStringValue <>), _CuryID, typeof(Or <, ,>), typeof(VendorR.allowOverrideCury), typeof(Equal <>), typeof(True), typeof(Or <,>), typeof(VendorR.curyID), typeof(IsNull)); view.JoinNew(join); } else { Type join = BqlCommand.Compose( typeof(InnerJoin <,>), typeof(VendorR), typeof(On <,>), typeof(VendorR.bAccountID), typeof(Equal <>), typeof(BAccountR.bAccountID)); view.JoinNew(join); } break; case GL.BatchModule.AR: view.WhereNew <Where2 <Match <CustomerR, Current <AccessInfo.userName> >, And <Where <BAccountR.type, Equal <BAccountType.customerType>, Or <BAccountR.type, Equal <BAccountType.combinedType>, Or <BAccountR.type, Equal <BAccountType.empCombinedType> > > > > > >(); if (_CuryID != null) { Type join = BqlCommand.Compose( typeof(InnerJoin <,>), typeof(CustomerR), typeof(On <, ,>), typeof(CustomerR.bAccountID), typeof(Equal <>), typeof(BAccountR.bAccountID), typeof(And <>), typeof(Where <, ,>), typeof(CustomerR.curyID), typeof(Equal <>), typeof(SavedStringValue <>), _CuryID, typeof(Or <, ,>), typeof(CustomerR.allowOverrideCury), typeof(Equal <>), typeof(True), typeof(Or <,>), typeof(CustomerR.curyID), typeof(IsNull)); view.JoinNew(join); } else { Type join = BqlCommand.Compose( typeof(InnerJoin <,>), typeof(CustomerR), typeof(On <,>), typeof(CustomerR.bAccountID), typeof(Equal <>), typeof(BAccountR.bAccountID)); view.JoinNew(join); } break; } } //return null; }
protected virtual void CurrencyRate_RowInserting(PXCache cache, PXRowInsertingEventArgs e) { CurrencyRate cr = e.Row as CurrencyRate; CuryRateFilter crf = Filter.Current as CuryRateFilter; if (cr.FromCuryID != null && crf.ToCurrency != null && String.Compare(cr.FromCuryID, crf.ToCurrency, true) == 0) { throw new PXException(Messages.DestShouldDifferFromOrig); } bool importing = e.Row != null && cache.GetValuePending(e.Row, PXImportAttribute.ImportFlag) != null; if (e.ExternalCall && !importing) { if (cr.CuryEffDate == null) { if (crf.EffDate == null) { cr.CuryEffDate = DateTime.Now; } else { cr.CuryEffDate = crf.EffDate; } } if (cr.CuryRate != null) { cr.RateReciprocal = Math.Round((decimal)(1 / cr.CuryRate), 8); if (((CurrencyInfo)cr).CheckRateVariance(cache)) { cache.RaiseExceptionHandling <CurrencyRate.curyRate>(cr, cr.CuryRate, new PXSetPropertyException(Messages.RateVarianceExceeded, PXErrorLevel.Warning)); } } if (cr.CuryMultDiv == " " && cr.FromCuryID != null && cr.ToCuryID != null && cr.CuryRateType != null && cr.CuryEffDate != null) { CurrencyRate existRateMultDiv = PXSelectReadonly <CurrencyRate, Where <CurrencyRate.fromCuryID, Equal <Required <CurrencyRate.fromCuryID> >, And <CurrencyRate.toCuryID, Equal <Required <CurrencyRate.toCuryID> >, And <CurrencyRate.curyRateType, Equal <Required <CurrencyRate.curyRateType> >, And <CurrencyRate.curyEffDate, LessEqual <Required <CurrencyRate.curyEffDate> > > > > >, OrderBy <Desc <CurrencyRate.curyEffDate> > > .Select(cache.Graph, cr.FromCuryID, cr.ToCuryID, cr.CuryRateType, cr.CuryEffDate); if (existRateMultDiv != null) { cr.CuryMultDiv = existRateMultDiv.CuryMultDiv; } } } if (cr.FromCuryID != null && cr.CuryRateType != null && cr.CuryRateType != null && cr.CuryEffDate != null && cr.CuryRate != null) { CurrencyRate existRate = PXSelectReadonly <CurrencyRate, Where <CurrencyRate.toCuryID, Equal <Required <CurrencyRate.toCuryID> >, And <CurrencyRate.fromCuryID, Equal <Required <CurrencyRate.fromCuryID> >, And <CurrencyRate.curyRateType, Equal <Required <CurrencyRate.curyRateType> >, And <CurrencyRate.curyEffDate, Equal <Required <CurrencyRate.curyEffDate> > > > > > > .Select(cache.Graph, cr.ToCuryID, cr.FromCuryID, cr.CuryRateType, cr.CuryEffDate); if (existRate != null) { e.Cancel = true; CurrencyRate newExistRate = (CurrencyRate)CuryRateRecordsEntry.Cache.CreateCopy(existRate); newExistRate.CuryRate = cr.CuryRate; newExistRate.CuryMultDiv = cr.CuryMultDiv; newExistRate.RateReciprocal = cr.RateReciprocal; CuryRateRecordsEntry.Update(newExistRate); cache.RaiseExceptionHandling <CurrencyRate.curyRate>(cr, cr.CuryRate, new PXSetPropertyException(Messages.SuchRateTypeAlreadyExist, PXErrorLevel.Warning)); } } }
public override object Evaluate(PXCache cache, object item, Dictionary <Type, object> pars) { return(cache.GetValuePending <Field>(item)); }