/// <summary>
/// Check All Organizations & Set Error to FinPeriod Field
/// </summary>
private void ValidateRelatedToMainFinPeriods(PXCache cache, object oldRow, object newRow, bool externalCall,
int?newMainCalendarOrgID, int?oldMainCalendarOrgID, FinPeriod newMainOrgFinPeriod)
{
string oldMainOrgFinPeriodID = (string)cache.GetValue(oldRow, _FieldName);
FinPeriod oldMainOrgFinPeriod = FinPeriodRepository.FindByID(oldMainCalendarOrgID, oldMainOrgFinPeriodID);
if (newMainOrgFinPeriod.MasterFinPeriodID != oldMainOrgFinPeriod?.MasterFinPeriodID)
{
HashSet <int?> usedOrgIDs = new HashSet <int?>();
if (IsHeader)
{
usedOrgIDs.AddRange(CalendarOrganizationIDProvider.GetDetailOrganizationIDs(cache.Graph));
}
if (!usedOrgIDs.Any())
{
return;
}
ProcessingResult existenceValidationResult =
FinPeriodRepository.FinPeriodsForMasterExist(newMainOrgFinPeriod.MasterFinPeriodID, usedOrgIDs.ToArray());
if (!existenceValidationResult.IsSuccess)
{
SetErrorAndResetForMainFields(cache, oldRow, newRow, oldMainCalendarOrgID, newMainCalendarOrgID,
externalCall,
new PXSetPropertyException(existenceValidationResult.GeneralMessage));
}
}
}
public virtual string CalcFinPeriodIDForMaster(PXCache cache, object row, string masterFinPeriodID)
{
return(FinPeriodRepository
.GetFinPeriodByMasterPeriodID(
CalendarOrganizationIDProvider.GetCalendarOrganizationID(cache.Graph, cache, row),
masterFinPeriodID)
.Result
?.FinPeriodID);
}
public FinPeriodIDAttribute(
Type sourceType = null,
Type branchSourceType = null,
Type branchSourceFormulaType = null,
Type organizationSourceType = null,
Type useMasterCalendarSourceType = null,
Type defaultType = null,
bool redefaultOrRevalidateOnOrganizationSourceUpdated = true,
bool useMasterOrganizationIDByDefault = false,
Type[] sourceSpecificationTypes = null,
Type masterFinPeriodIDType = null,
Type headerMasterFinPeriodIDType = null,
bool filterByOrganizationID = true,
bool redefaultOnDateChanged = true)
: base(
dateType: sourceType,
searchByDateType: typeof(Search <FinPeriod.finPeriodID,
Where <FinPeriod.startDate, LessEqual <Current2 <QueryParams.sourceDate> >,
And <FinPeriod.endDate, Greater <Current2 <QueryParams.sourceDate> > > > >),
defaultType: defaultType,
redefaultOrRevalidateOnOrganizationSourceUpdated: redefaultOrRevalidateOnOrganizationSourceUpdated,
filterByOrganizationID: true,
useMasterOrganizationIDByDefault: useMasterOrganizationIDByDefault,
redefaultOnDateChanged: redefaultOnDateChanged)
{
HeaderFindingMode = HeaderFindingModes.Current;
CalculatePeriodByHeader = true;
AutoCalculateMasterPeriod = true;
MasterFinPeriodIDType = masterFinPeriodIDType;
HeaderMasterFinPeriodIDType = headerMasterFinPeriodIDType;
FilterByOrganizationID = filterByOrganizationID;
UseMasterOrganizationIDByDefault = useMasterOrganizationIDByDefault;
UseMasterCalendarSourceType = useMasterCalendarSourceType;
RedefaultOrRevalidateOnOrganizationSourceUpdated = redefaultOrRevalidateOnOrganizationSourceUpdated;
PeriodKeyProvider =
CalendarOrganizationIDProvider = new CalendarOrganizationIDProvider(
new PeriodKeyProviderBase.SourcesSpecificationCollection()
{
SpecificationItems = new PeriodKeyProviderBase.SourceSpecificationItem()
{
BranchSourceType = branchSourceType,
BranchSourceFormulaType = branchSourceFormulaType,
OrganizationSourceType = organizationSourceType,
}.SingleToList()
},
sourceSpecificationTypes: sourceSpecificationTypes,
useMasterCalendarSourceType: useMasterCalendarSourceType,
useMasterOrganizationIDByDefault: useMasterOrganizationIDByDefault);
}
protected virtual void SetUseMasterCalendarValue(PXCache sender, object row)
{
if (UseMasterCalendarSourceType == null)
{
return;
}
bool useMasterCalendarValue =
CalendarOrganizationIDProvider.GetBranchIDsValueFromField(sender.Graph, sender, row,
CalendarOrganizationIDProvider.GetSourcesSpecification(sender, row).MainSpecificationItem)
.SourceBranchIDs.FirstOrDefault() == null &&
CalendarOrganizationIDProvider.GetOrganizationIDsValueFromField(sender.Graph, sender, row,
CalendarOrganizationIDProvider.GetSourcesSpecification(sender, row).MainSpecificationItem)
.SourceOrganizationIDs.FirstOrDefault() == null;
sender.SetValueExt(row,
UseMasterCalendarSourceType.Name,
useMasterCalendarValue);
}
protected override void ValidatePeriodAndSourcesImpl(PXCache cache, object oldRow, object newRow,
bool externalCall)
{
int?newMainCalendarOrgID = CalendarOrganizationIDProvider.GetCalendarOrganizationID(cache.Graph, cache, newRow);
int?oldMainCalendarOrgID = CalendarOrganizationIDProvider.GetCalendarOrganizationID(cache.Graph, cache, oldRow);
if (HeaderMasterFinPeriodIDType != null && CalculatePeriodByHeader)
{
if (newMainCalendarOrgID != oldMainCalendarOrgID)
{
string headerMasterPeriodID = GetHeaderMasterFinPeriodID(cache, newRow);
if (headerMasterPeriodID != null)
{
ProcessingResult <FinPeriod> procResult = FinPeriodRepository.GetFinPeriodByMasterPeriodID(newMainCalendarOrgID, headerMasterPeriodID);
if (!procResult.IsSuccess)
{
SetErrorAndResetToOldForField(
cache,
oldRow,
newRow,
CalendarOrganizationIDProvider.GetSourcesSpecification(cache, newRow).MainSpecificationItem.BranchSourceType.Name,
new PXSetPropertyException(procResult.GetGeneralMessage()),
externalCall);
}
}
}
}
else
{
FinPeriod newMainOrgFinPeriod = GetAndValidateMainFinPeriod(cache, oldRow, newRow, externalCall);
if (newMainOrgFinPeriod == null)
{
return;
}
ValidateRelatedToMainFinPeriods(cache, oldRow, newRow, externalCall, newMainCalendarOrgID, oldMainCalendarOrgID, newMainOrgFinPeriod);
ValidateNotMainRowLevelSources(cache, oldRow, newRow, externalCall, newMainOrgFinPeriod);
}
}
protected virtual FinPeriod GetAndValidateMainFinPeriod(PXCache cache, object oldRow, object newRow, bool externalCall)
{
int?newMainCalendarOrgID = CalendarOrganizationIDProvider.GetCalendarOrganizationID(cache.Graph, cache, newRow);
int?oldMainCalendarOrgID = CalendarOrganizationIDProvider.GetCalendarOrganizationID(cache.Graph, cache, oldRow);
string newMainOrgFinPeriodID = null;
FinPeriod newMainOrgFinPeriod = null;
newMainOrgFinPeriodID = (string)cache.GetValue(newRow, _FieldName);
if (newMainOrgFinPeriodID == null)
{
return(null);
}
newMainOrgFinPeriod = FinPeriodRepository.FindByID(newMainCalendarOrgID, newMainOrgFinPeriodID);
if (newMainOrgFinPeriod == null)
{
string errorMessage = null;
if (newMainCalendarOrgID == FinPeriod.organizationID.MasterValue)
{
errorMessage = PXMessages.LocalizeFormatNoPrefix(Messages.MasterFinPeriodDoesNotExist,
FormatForError(newMainOrgFinPeriodID));
}
else
{
errorMessage = PXMessages.LocalizeFormatNoPrefix(
Messages.FinPeriodDoesNotExistForCompany,
FormatForError(newMainOrgFinPeriodID),
PXAccess.GetOrganizationCD(newMainCalendarOrgID));
}
SetErrorAndResetForMainFields(cache, oldRow, newRow, oldMainCalendarOrgID, newMainCalendarOrgID, externalCall,
new PXSetPropertyException(errorMessage));
return(null);
}
return(newMainOrgFinPeriod);
}
protected override void RedefaultPeriodID(PXCache cache, object row)
{
if (HeaderMasterFinPeriodIDType != null)
{
if (CalculatePeriodByHeader)
{
string newFinPeriodID = null;
int?calendarOrgID = CalendarOrganizationIDProvider.GetCalendarOrganizationID(cache.Graph, cache, row);
if (calendarOrgID != null)
{
FinPeriod orgFinPeriod =
FinPeriodRepository.GetFinPeriodByMasterPeriodID(
calendarOrgID,
GetHeaderMasterFinPeriodID(cache, row))
.Result;
if (orgFinPeriod != null)
{
newFinPeriodID = FormatForDisplay(orgFinPeriod.FinPeriodID);
}
}
cache.SetValueExt(row, _FieldName, newFinPeriodID);
}
}
else
{
base.RedefaultPeriodID(cache, row);
if (AutoCalculateMasterPeriod)
{
SetMasterPeriodID(cache, row);
}
}
}
public virtual string CalcMasterPeriodID(PXCache cache, object row)
{
string finPeriodID;
finPeriodID = (string)cache.GetValue(row, _FieldName);
int?calendarOrgID = CalendarOrganizationIDProvider.GetCalendarOrganizationID(cache.Graph, cache, row);
if (calendarOrgID == FinPeriod.organizationID.MasterValue)
{
return(finPeriodID);
}
string masterFinPeriodID = null;
if (finPeriodID != null)
{
FinPeriod orgFinPeriod = FinPeriodRepository.FindByID(calendarOrgID, finPeriodID);
masterFinPeriodID = orgFinPeriod?.MasterFinPeriodID;
}
return(masterFinPeriodID);
}
public override void FieldDefaulting(PXCache sender, PXFieldDefaultingEventArgs e)
{
SetUseMasterCalendarValue(sender, e.Row);
if (HeaderMasterFinPeriodIDType != null && CalculatePeriodByHeader)
{
int?calendarOrgID = CalendarOrganizationIDProvider.GetCalendarOrganizationID(sender.Graph, sender, e.Row);
FinPeriod orgFinPeriod =
FinPeriodRepository.GetFinPeriodByMasterPeriodID(
calendarOrgID,
GetHeaderMasterFinPeriodID(sender, e.Row))
.Result;
if (orgFinPeriod != null)
{
e.NewValue = FormatForDisplay(orgFinPeriod.FinPeriodID);
}
}
else
{
base.FieldDefaulting(sender, e);
}
}
