protected override string GetMappedPeriodID(PXCache cache, OrganizationDependedPeriodKey newPeriodKey,
                                                    OrganizationDependedPeriodKey oldPeriodKey)
        {
            FinPeriod mappedFinPeriod = FinPeriodRepository.GetMappedPeriod(oldPeriodKey.OrganizationID, oldPeriodKey.PeriodID, newPeriodKey.OrganizationID);

            return(mappedFinPeriod?.FinPeriodID);
        }
        public virtual OrganizationDependedPeriodKey GetFullKey(PXCache cache, object row)
        {
            OrganizationDependedPeriodKey key = PeriodKeyProvider.GetKey(cache.Graph, cache, row);

            key.PeriodID = (string)cache.GetValue(row, _FieldName);

            return(key);
        }
예제 #3
0
        protected override string GetMappedPeriodID(PXCache cache, OrganizationDependedPeriodKey newPeriodKey,
                                                    OrganizationDependedPeriodKey oldPeriodKey)
        {
            IFABookPeriodRepository periodRepository = cache.Graph.GetService <IFABookPeriodRepository>();

            FABookPeriod mappedPeriod = periodRepository.FindMappedPeriod((FABookPeriod.Key)oldPeriodKey, (FABookPeriod.Key)newPeriodKey);

            return(mappedPeriod?.FinPeriodID);
        }
        protected override bool ShouldExecuteRedefaultFinPeriodIDonRowUpdated(object errorValue, bool hasError,
                                                                              OrganizationDependedPeriodKey newPeriodKey, OrganizationDependedPeriodKey oldPeriodKey)
        {
            var newKey = (FinPeriod.Key)newPeriodKey;
            var oldKey = (FinPeriod.Key)oldPeriodKey;

            return(base.ShouldExecuteRedefaultFinPeriodIDonRowUpdated(errorValue, hasError, newKey, oldKey) ||
                   HeaderMasterFinPeriodIDType != null && oldKey.OrganizationID != newKey.OrganizationID);
        }
 protected virtual bool ShouldExecuteRedefaultFinPeriodIDonRowUpdated(object errorValue,
                                                                      bool hasError,
                                                                      OrganizationDependedPeriodKey newPeriodKey,
                                                                      OrganizationDependedPeriodKey oldPeriodKey)
 {
     return(errorValue == null && hasError ||
            newPeriodKey.PeriodID == null && oldPeriodKey.PeriodID == null ||
            newPeriodKey.IsMasterCalendar && !oldPeriodKey.IsMasterCalendar ||
            !newPeriodKey.IsMasterCalendar && oldPeriodKey.IsMasterCalendar);
 }
 protected abstract string GetMappedPeriodID(PXCache cache, OrganizationDependedPeriodKey newPeriodKey,
                                             OrganizationDependedPeriodKey oldPeriodKey);
        protected virtual void RowUpdatedImpl(PXCache cache, PXRowUpdatedEventArgs e)
        {
            if (RedefaultOrRevalidateOnOrganizationSourceUpdated)
            {
                object value      = null;
                object errorValue = null;
                bool   hasError   = false;

                foreach (PXEventSubscriberAttribute attribute in cache.GetAttributesReadonly(e.Row, _FieldName))
                {
                    IPXInterfaceField uiFieldAttribute = attribute as IPXInterfaceField;

                    if (uiFieldAttribute != null)
                    {
                        hasError = uiFieldAttribute.ErrorLevel == PXErrorLevel.Error || uiFieldAttribute.ErrorLevel == PXErrorLevel.RowError;

                        if (hasError ||
                            uiFieldAttribute.ErrorLevel == PXErrorLevel.Warning ||
                            uiFieldAttribute.ErrorLevel == PXErrorLevel.RowWarning)
                        {
                            errorValue = uiFieldAttribute.ErrorValue;

                            value = hasError
                                ? errorValue
                                : FormatForDisplay((string)cache.GetValue(e.Row, _FieldName));

                            cache.RaiseExceptionHandling(_FieldName, e.Row, value, null);
                        }
                    }
                }

                OrganizationDependedPeriodKey newPeriodKey = GetFullKey(cache, e.Row);

                OrganizationDependedPeriodKey oldPeriodKey = GetFullKey(cache, e.OldRow);

                if (ShouldExecuteRedefaultFinPeriodIDonRowUpdated(errorValue, hasError, newPeriodKey, oldPeriodKey))
                {
                    RedefaultPeriodID(cache, e.Row);
                }
                else if (!newPeriodKey.IsNotPeriodPartsEqual(oldPeriodKey) &&
                         oldPeriodKey.PeriodID != null &&
                         !cache.Graph.IsContractBasedAPI &&
                         !cache.Graph.UnattendedMode &&
                         !cache.Graph.IsImport &&
                         !cache.Graph.IsExport)
                {
                    OrganizationDependedPeriodKey basePeriodForMapping = GetFullKey(cache, e.OldRow);

                    if (hasError)
                    {
                        basePeriodForMapping.PeriodID = UnFormatPeriod((string)errorValue);
                    }
                    else if (oldPeriodKey.PeriodID != newPeriodKey.PeriodID)
                    {
                        basePeriodForMapping.PeriodID = newPeriodKey.PeriodID;
                    }

                    string mappedPeriod = GetMappedPeriodID(cache, newPeriodKey, basePeriodForMapping);

                    cache.SetValueExt(e.Row, _FieldName, FormatForDisplay(mappedPeriod));
                }
                else
                {
                    cache.SetValueExt(e.Row, _FieldName, FormatForDisplay(newPeriodKey.PeriodID));
                }
            }
        }