protected virtual void _(Events.FieldUpdated <FeaturesSet, FeaturesSet.centralizedPeriodsManagement> e)
{
if (e.Row == null)
{
return;
}
if ((bool?)e.OldValue != true &&
e.Row.CentralizedPeriodsManagement == true &&
EtalonOrganization != null)
{
foreach (PXResult <MasterFinPeriod, OrganizationFinPeriod> res in MasterFinPeriods.Select(EtalonOrganization.OrganizationID))
{
MasterFinPeriod masterFinPeriod = res;
OrganizationFinPeriod organizationFinPeriod = res;
masterFinPeriod.DateLocked = organizationFinPeriod.DateLocked;
masterFinPeriod.Status = organizationFinPeriod.Status;
masterFinPeriod.APClosed = organizationFinPeriod.APClosed;
masterFinPeriod.ARClosed = organizationFinPeriod.ARClosed;
masterFinPeriod.INClosed = organizationFinPeriod.INClosed;
masterFinPeriod.CAClosed = organizationFinPeriod.CAClosed;
masterFinPeriod.FAClosed = organizationFinPeriod.FAClosed;
MasterFinPeriods.Cache.Update(masterFinPeriod);
}
}
}
private static void Validate(CATranEntryLight graph, CashAccount cashAccount, CABalanceValidationPeriodFilter filter)
{
if (string.IsNullOrEmpty(filter.FinPeriodID))
{
throw new PXException(GL.Messages.Prefix + ": " + GL.Messages.ProcessingRequireFinPeriodID);
}
MasterFinPeriod period = PXSelect <MasterFinPeriod, Where <MasterFinPeriod.finPeriodID, Equal <Required <MasterFinPeriod.finPeriodID> > > > .Select(graph, filter.FinPeriodID);
if (period == null)
{
throw new PXException(GL.Messages.ProcessingRequireFinPeriodID);
}
ValidateAccount(graph, cashAccount);
graph.Clear();
ValidateCleared(graph, cashAccount, period);
graph.Clear();
ValidateCAAdjustments(graph, cashAccount, period);
graph.Clear();
ValidateCATransfers(graph, cashAccount, period);
graph.Clear();
ValidateCATrans(graph, cashAccount, period);
graph.Clear();
ValidateCADailySummary(graph, cashAccount, period);
}
protected virtual FinPeriod BuildFinPeriod(int?organizationID, object record)
{
if (organizationID == FinPeriod.organizationID.MasterValue &&
MasterPeriodBasedOnOrganizationPeriods)
{
MasterFinPeriod baseFinPeriod = (record as PXResult).GetItem <MasterFinPeriod>();
return(new FinPeriod()
{
FinPeriodID = baseFinPeriod.FinPeriodID,
StartDateUI = baseFinPeriod.StartDateUI,
EndDateUI = baseFinPeriod.EndDateUI,
Descr = baseFinPeriod.Descr,
NoteID = baseFinPeriod.NoteID
});
}
else
{
PXResult resultRecord = record as PXResult;
FinPeriod orgFinPeriod = resultRecord != null
? resultRecord.GetItem <FinPeriod>()
: (FinPeriod)record;
return(new FinPeriod
{
FinPeriodID = orgFinPeriod.FinPeriodID,
StartDateUI = orgFinPeriod.StartDateUI,
EndDateUI = orgFinPeriod.EndDateUI,
Descr = orgFinPeriod.Descr,
NoteID = orgFinPeriod.NoteID
});
}
}
protected virtual OrganizationFinYear GenerateSingleOrganizationFinYear(int organizationID, string startYearNumber, string startMasterFinPeriodID)
{
MasterFinYear startYear = FinPeriodRepository.FindMasterFinYearByID(startYearNumber);
MasterFinPeriod startMasterFinPeriod = FinPeriodRepository.FindMasterFinPeriodByID(startMasterFinPeriodID);
return(GenerateSingleOrganizationFinYear(organizationID, startYear, startMasterFinPeriod));
}
protected virtual IEnumerable billed()
{
UsageFilter filter = Filter.Current;
if (filter == null)
{
return(new List <PMTran>());
}
PXSelectBase <PMTran> select = new PXSelectJoin <
PMTran,
LeftJoin <CRCase,
On <CRCase.noteID, Equal <PMTran.origRefID>,
Or <CRCase.caseID, Equal <PMTran.caseID> > > >,
Where <
PMTran.billed, Equal <True>,
And <PMTran.projectID, Equal <Current <UsageFilter.contractID> > > > >
(this);
if (!string.IsNullOrEmpty(filter.InvFinPeriodID))
{
MasterFinPeriod finPeriod = PXSelect <MasterFinPeriod, Where <MasterFinPeriod.finPeriodID, Equal <Current <UsageFilter.invFinPeriodID> > > > .Select(this);
if (finPeriod != null)
{
select.WhereAnd <Where <PMTran.billedDate, Between <Required <MasterFinPeriod.startDate>, Required <MasterFinPeriod.endDate> > > >();
}
}
return(select.Select());
}
protected virtual OrganizationFinYear GenerateNextOrganizationFinYear(OrganizationFinYear year)
{
string generatedYearNumber = $"{int.Parse(year.Year) + 1:0000}";
MasterFinYear masterFinYear;
while ((masterFinYear = FinPeriodRepository.FindMasterFinYearByID(generatedYearNumber, clearQueryCache: true)) == null)
{
MasterCalendarGraph.Clear();
MasterCalendarGraph.GenerateCalendar(
FinPeriod.organizationID.MasterValue,
int.Parse(FinPeriodRepository.FindLastYear(FinPeriod.organizationID.MasterValue, clearQueryCache: true).Year),
int.Parse(generatedYearNumber));
}
short generatedFinPeriodsCount = (short)masterFinYear.FinPeriods;
if (YearSetup.Current.HasAdjustmentPeriod == true)
{
generatedFinPeriodsCount--;
}
OrganizationFinPeriod lastNonAdjustmentOrgFinPeriod = this.FinPeriodRepository.FindLastNonAdjustmentOrganizationFinPeriodOfYear(year.OrganizationID, year.Year, clearQueryCache: true);
int generatedMasterYearNumber = int.Parse(lastNonAdjustmentOrgFinPeriod.FinYear);
List <MasterFinPeriod> masterFinPeriods;
PXSelectBase <MasterFinPeriod> select = new PXSelectReadonly <
MasterFinPeriod,
Where <MasterFinPeriod.finPeriodID, Greater <Required <MasterFinPeriod.finPeriodID> >,
And <MasterFinPeriod.startDate, NotEqual <MasterFinPeriod.endDate> > >,
OrderBy <
Asc <MasterFinPeriod.finPeriodID> > >(this);
select.View.Clear();
while ((masterFinPeriods = select
.SelectWindowed(0, generatedFinPeriodsCount, lastNonAdjustmentOrgFinPeriod.MasterFinPeriodID)
.RowCast <MasterFinPeriod>()
.ToList()).Count < generatedFinPeriodsCount)
{
generatedMasterYearNumber++;
MasterCalendarGraph.Clear();
MasterCalendarGraph.GenerateCalendar(
FinPeriod.organizationID.MasterValue,
int.Parse(FinPeriodRepository.FindLastYear(FinPeriod.organizationID.MasterValue, clearQueryCache: true).Year),
generatedMasterYearNumber);
select.View.Clear();
}
MasterFinPeriod startMasterFinPeriod = masterFinPeriods.First();
return(GenerateSingleOrganizationFinYear((int)year.OrganizationID, masterFinYear, startMasterFinPeriod));
}
protected virtual OrganizationFinPeriod GenerateAdjustmentOrganizationFinPeriod(int organizationID, OrganizationFinPeriod prevFinPeriod)
{
(string masterYearNumber, string masterPeriodNumber) = FinPeriodUtils.ParseFinPeriodID(prevFinPeriod.FinPeriodID);
MasterFinYear masterFinYear = FinPeriodRepository.FindMasterFinYearByID(masterYearNumber, clearQueryCache: true);
string adjustmentMasterFinPeriodID = $"{masterYearNumber:0000}{masterFinYear.FinPeriods:00}";
(string yearNumber, string periodNumber) = FinPeriodUtils.ParseFinPeriodID(prevFinPeriod.FinPeriodID);
periodNumber = $"{int.Parse(periodNumber) + 1:00}";
OrganizationFinPeriod orgFinPeriod = new OrganizationFinPeriod
{
OrganizationID = organizationID,
FinPeriodID = FinPeriodUtils.ComposeFinPeriodID(yearNumber, periodNumber),
MasterFinPeriodID = adjustmentMasterFinPeriodID,
FinYear = yearNumber,
PeriodNbr = periodNumber,
Custom = prevFinPeriod.Custom,
DateLocked = prevFinPeriod.DateLocked,
StartDate = prevFinPeriod.EndDate,
EndDate = prevFinPeriod.EndDate,
Status = prevFinPeriod.Status,
ARClosed = prevFinPeriod.ARClosed,
APClosed = prevFinPeriod.APClosed,
FAClosed = prevFinPeriod.FAClosed,
CAClosed = prevFinPeriod.CAClosed,
INClosed = prevFinPeriod.INClosed,
Descr = Messages.AdjustmentPeriod,
};
MasterFinPeriod masterFinPeriod = FinPeriodRepository.FindMasterFinPeriodByID(adjustmentMasterFinPeriodID);
PXDBLocalizableStringAttribute.CopyTranslations <MasterFinPeriod.descr, OrganizationFinPeriod.descr>(this, masterFinPeriod, orgFinPeriod);
return(orgFinPeriod);
}
/// <summary>
/// TODO: Share function in <see cref="OrganizationMaint.CreateOrganizationCalendar"/> function
/// </summary>
/// <param name="organizationID"></param>
/// <param name="masterFinPeriod"></param>
/// <returns></returns>
protected virtual OrganizationFinPeriod CopyOrganizationFinPeriodFromMaster(
int organizationID,
MasterFinPeriod masterFinPeriod,
FinPeriod orgFinPeriodStatusSource,
string yearNumber = null,
string periodNumber = null)
{
bool isCentralizedManagement = PXAccess.FeatureInstalled <FeaturesSet.centralizedPeriodsManagement>();
string organizationFinPeriodID = FinPeriodUtils.ComposeFinPeriodID(yearNumber, periodNumber) ?? masterFinPeriod.FinPeriodID;
OrganizationFinPeriod orgFinPeriod = new OrganizationFinPeriod
{
OrganizationID = organizationID,
FinPeriodID = organizationFinPeriodID,
MasterFinPeriodID = masterFinPeriod.FinPeriodID,
FinYear = yearNumber ?? masterFinPeriod.FinYear,
PeriodNbr = periodNumber ?? masterFinPeriod.PeriodNbr,
Custom = masterFinPeriod.Custom,
DateLocked = masterFinPeriod.DateLocked,
StartDate = masterFinPeriod.StartDate,
EndDate = masterFinPeriod.EndDate,
Status = isCentralizedManagement ? masterFinPeriod.Status : orgFinPeriodStatusSource != null ? orgFinPeriodStatusSource.Status : FinPeriod.status.Inactive,
ARClosed = isCentralizedManagement ? masterFinPeriod.ARClosed : orgFinPeriodStatusSource != null ? orgFinPeriodStatusSource.ARClosed : false,
APClosed = isCentralizedManagement ? masterFinPeriod.APClosed : orgFinPeriodStatusSource != null ? orgFinPeriodStatusSource.APClosed : false,
FAClosed = isCentralizedManagement ? masterFinPeriod.FAClosed : orgFinPeriodStatusSource != null ? orgFinPeriodStatusSource.FAClosed : false,
CAClosed = isCentralizedManagement ? masterFinPeriod.CAClosed : orgFinPeriodStatusSource != null ? orgFinPeriodStatusSource.CAClosed : false,
INClosed = isCentralizedManagement ? masterFinPeriod.INClosed : orgFinPeriodStatusSource != null ? orgFinPeriodStatusSource.INClosed : false,
Descr = masterFinPeriod.Descr,
};
PXDBLocalizableStringAttribute.CopyTranslations <MasterFinPeriod.descr, OrganizationFinPeriod.descr>(this, masterFinPeriod, orgFinPeriod);
return(orgFinPeriod);
}
protected virtual void _(Events.FieldUpdating <FeaturesSet.centralizedPeriodsManagement> e)
{
e.NewValue = PXBoolAttribute.ConvertValue(e.NewValue);
FeaturesSet row = (FeaturesSet)e.Row;
if (row == null)
{
return;
}
int messageCount = 0;
bool isError = false;
if (row.CentralizedPeriodsManagement != null && row.CentralizedPeriodsManagement != (bool)e.NewValue && (bool)e.NewValue == true)
{
foreach (Organization organization in PXSelect <Organization> .Select(this))
{
foreach (MasterFinPeriod problemPeriod in PXSelectJoin <
MasterFinPeriod,
LeftJoin <OrganizationFinPeriod,
On <MasterFinPeriod.finPeriodID, Equal <OrganizationFinPeriod.masterFinPeriodID>,
And <OrganizationFinPeriod.organizationID, Equal <Required <OrganizationFinPeriod.organizationID> > > > >,
Where <OrganizationFinPeriod.finPeriodID, IsNull> >
.Select(this, organization.OrganizationID))
{
isError = true;
if (messageCount <= MAX_FINPERIOD_DISCREPANCY_MESSAGE_COUNT)
{
PXTrace.WriteError(GL.Messages.DiscrepancyPeriod, organization.OrganizationCD, problemPeriod.FinPeriodID);
messageCount++;
}
else
{
break;
}
}
}
if (isError)
{
e.Cancel = true;
throw new PXSetPropertyException(GL.Messages.DiscrepancyPeriodError);
}
Organization etalonOrganization = PXSelect <Organization> .Select(this).First();
if (etalonOrganization != null)
{
foreach (Organization organization in PXSelect <Organization> .Select(this))
{
if (organization.OrganizationID == etalonOrganization.OrganizationID)
{
continue;
}
foreach (OrganizationFinPeriod problemPeriod in PXSelectJoin <
OrganizationFinPeriod,
LeftJoin <OrganizationFinPeriodStatus,
On <OrganizationFinPeriodStatus.organizationID, Equal <Required <OrganizationFinPeriodStatus.organizationID> >,
And <OrganizationFinPeriod.finPeriodID, Equal <OrganizationFinPeriodStatus.finPeriodID>,
And <OrganizationFinPeriod.dateLocked, Equal <OrganizationFinPeriodStatus.dateLocked>,
And <OrganizationFinPeriod.status, Equal <OrganizationFinPeriodStatus.status>,
And <OrganizationFinPeriod.aPClosed, Equal <OrganizationFinPeriodStatus.aPClosed>,
And <OrganizationFinPeriod.aRClosed, Equal <OrganizationFinPeriodStatus.aRClosed>,
And <OrganizationFinPeriod.iNClosed, Equal <OrganizationFinPeriodStatus.iNClosed>,
And <OrganizationFinPeriod.cAClosed, Equal <OrganizationFinPeriodStatus.cAClosed>,
And <OrganizationFinPeriod.fAClosed, Equal <OrganizationFinPeriodStatus.fAClosed> > > > > > > > > > >,
Where <OrganizationFinPeriodStatus.finPeriodID, IsNull,
And <OrganizationFinPeriod.organizationID, Equal <Required <OrganizationFinPeriod.organizationID> > > > >
.Select(this, organization.OrganizationID, etalonOrganization.OrganizationID))
{
isError = true;
if (messageCount <= MAX_FINPERIOD_DISCREPANCY_MESSAGE_COUNT)
{
string problemFields = GetProblemFields(organization, problemPeriod);
PXTrace.WriteError(GL.Messages.DiscrepancyField,
etalonOrganization.OrganizationCD,
organization.OrganizationCD,
problemFields,
problemPeriod.FinPeriodID);
messageCount++;
}
else
{
break;
}
}
}
if (isError)
{
e.Cancel = true;
throw new PXSetPropertyException(GL.Messages.DiscrepancyFieldError);
}
}
foreach (PXResult <MasterFinPeriod, OrganizationFinPeriod> res in MasterFinPeriods.Select(etalonOrganization.OrganizationID))
{
MasterFinPeriod masterFinPeriod = res;
OrganizationFinPeriod organizationFinPeriod = res;
masterFinPeriod.DateLocked = organizationFinPeriod.DateLocked;
masterFinPeriod.Status = organizationFinPeriod.Status;
masterFinPeriod.APClosed = organizationFinPeriod.APClosed;
masterFinPeriod.ARClosed = organizationFinPeriod.ARClosed;
masterFinPeriod.INClosed = organizationFinPeriod.INClosed;
masterFinPeriod.CAClosed = organizationFinPeriod.CAClosed;
masterFinPeriod.FAClosed = organizationFinPeriod.FAClosed;
this.MasterFinPeriods.Cache.Update(masterFinPeriod);
}
}
}
protected virtual OrganizationFinYear GenerateSingleOrganizationFinYear(int organizationID, MasterFinYear startMasterYear, MasterFinPeriod startMasterFinPeriod)
{
if (startMasterYear == null)
{
throw new ArgumentNullException(nameof(startMasterYear));
}
if (startMasterFinPeriod == null)
{
throw new ArgumentNullException(nameof(startMasterFinPeriod));
}
OrganizationFinYear newOrganizationFinYear = (OrganizationFinYear)this.Caches <OrganizationFinYear>().Insert(
new OrganizationFinYear
{
OrganizationID = organizationID,
Year = startMasterYear.Year,
FinPeriods = startMasterYear.FinPeriods,
StartMasterFinPeriodID = startMasterFinPeriod.FinPeriodID,
StartDate = startMasterFinPeriod.StartDate,
});
short periodNumber = 1;
MasterFinPeriod sourceMasterFinPeriod = startMasterFinPeriod;
int periodsCountForCopy = (int)newOrganizationFinYear.FinPeriods;
if (YearSetup.Current.HasAdjustmentPeriod == true)
{
periodsCountForCopy--;
}
OrganizationFinPeriod newOrganizationFinPeriod = null;
FinPeriod firstOrgFinPeriod = FinPeriodRepository.FindFirstPeriod(organizationID, clearQueryCache: true);
while (periodNumber <= periodsCountForCopy)
{
newOrganizationFinPeriod = (OrganizationFinPeriod)this.Caches <OrganizationFinPeriod>().Insert(
CopyOrganizationFinPeriodFromMaster(
organizationID,
sourceMasterFinPeriod,
firstOrgFinPeriod != null && Convert.ToInt32(firstOrgFinPeriod.FinYear) > Convert.ToInt32(newOrganizationFinYear.Year) ? firstOrgFinPeriod : null,
newOrganizationFinYear.Year,
$"{periodNumber:00}"));
if (periodNumber < periodsCountForCopy) // no need to search for the next master period if last organization period is generated
{
string sourceMasterFinPeriodID = sourceMasterFinPeriod.FinPeriodID;
while ((sourceMasterFinPeriod = FinPeriodRepository.FindNextNonAdjustmentMasterFinPeriod(sourceMasterFinPeriodID, clearQueryCache: true)) == null)
{
MasterCalendarGraph.Clear();
MasterCalendarGraph.GenerateNextMasterFinYear();
}
}
periodNumber++;
}
newOrganizationFinYear.EndDate = newOrganizationFinPeriod.EndDate;
if (YearSetup.Current.HasAdjustmentPeriod == true)
{
this.Caches <OrganizationFinPeriod>().Insert(GenerateAdjustmentOrganizationFinPeriod(organizationID, newOrganizationFinPeriod));
}
return(newOrganizationFinYear);
}
