protected virtual void FAOrganizationBook_RowSelected(PXCache sender, PXRowSelectedEventArgs e)
{
FAOrganizationBook book = (FAOrganizationBook)e.Row;
if (book == null)
{
return;
}
PXSetPropertyException disableRowException = null;
FABookYearSetup setup = PXSelect <FABookYearSetup, Where <FABookYearSetup.bookID, Equal <Current <FAOrganizationBook.bookID> > > > .SelectSingleBound(this, new object[] { book });
if (setup == null && book.UpdateGL != true)
{
disableRowException = new PXSetPropertyException(Messages.CalendarSetupNotFound, PXErrorLevel.RowWarning, book.BookCode);
}
OrganizationFinYear nearestFinYear = FinPeriodRepository.FindNearestOrganizationFinYear(book.OrganizationID, "1900");
if (disableRowException == null &&
book.OrganizationID != FinPeriod.organizationID.MasterValue &&
book.UpdateGL == true &&
nearestFinYear == null)
{
disableRowException = new PXSetPropertyException(GL.Messages.OrganizationCalendarDoesNotExist, PXErrorLevel.RowWarning, PXAccess.GetOrganizationCD(book.OrganizationID));
}
if (disableRowException != null)
{
PXUIFieldAttribute.SetEnabled <FAOrganizationBook.selected>(sender, book, false);
sender.RaiseExceptionHandling <FAOrganizationBook.selected>(book, null, disableRowException);
}
}
private bool IsFirstOrLastOrganizationFinYear(OrganizationFinYear organizationFinYear)
{
FinYear firstFinYear = FinPeriodRepository.FindFirstYear(organizationFinYear.OrganizationID, clearQueryCache: true);
FinYear lastFinYear = FinPeriodRepository.FindLastYear(organizationFinYear.OrganizationID, clearQueryCache: true);
return(organizationFinYear.Year == firstFinYear.Year ||
organizationFinYear.Year == lastFinYear.Year);
}
protected bool IsOrganizationFinYearUsed(OrganizationFinYear organizationFinYear)
{
return(OrgFinPeriods
.Select(organizationFinYear.OrganizationID, organizationFinYear.Year)
.RowCast <OrganizationFinPeriod>()
.Any(period => period.Status == FinPeriod.status.Closed ||
period.Status == FinPeriod.status.Locked ||
period.DateLocked == true) ||
IsOrganizationFinYearReferenced(organizationFinYear));
}
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 void VerifyOrganizationFinYearForDelete(OrganizationFinYear organizationFinYear)
{
if (!IsFirstOrLastOrganizationFinYear(organizationFinYear))
{
throw new PXException(Messages.OnlyFirstOrLastYearCanBeDeleted);
}
if (IsOrganizationFinYearUsed(organizationFinYear))
{
throw new PXException(Messages.PeriodAlreadyUsed);
}
}
private bool IsOrganizationFinYearReferenced(OrganizationFinYear organizationFinYear)
{
using (new PXConnectionScope())
{
GLTran tran = ReferencingByTranQuery
.WhereNew <Where <OrganizationFinPeriod.organizationID, Equal <Required <OrganizationFinYear.organizationID> >,
And <OrganizationFinPeriod.finYear, Equal <Required <OrganizationFinYear.year> > > > >()
.SelectSingleReadonly <GLTran>(this, organizationFinYear.OrganizationID, organizationFinYear.Year);
Batch batch = ReferencingByBatchQuery
.WhereNew <Where <OrganizationFinPeriod.organizationID, Equal <Required <OrganizationFinYear.organizationID> >,
And <OrganizationFinPeriod.finYear, Equal <Required <OrganizationFinYear.year> > > > >()
.SelectSingleReadonly <Batch>(this, organizationFinYear.OrganizationID, organizationFinYear.Year);
return(batch != null || tran != null);
}
}
public virtual void GenerateCalendar(int?organizationID, int fromYear, int toYear)
{
(int firstYearNumber, int lastYearNumber) = FinPeriodUtils.GetFirstLastYearForGeneration(organizationID, fromYear, toYear,
clearQueryCache: true);
OrganizationFinYear firstFinYear = FinPeriodRepository.FindOrganizationFinYearByID(organizationID, $"{firstYearNumber:0000}",
clearQueryCache: true);
OrganizationFinYear lastFinYear = FinPeriodRepository.FindOrganizationFinYearByID(organizationID, $"{lastYearNumber:0000}",
clearQueryCache: true);
OrganizationFinYear baseFinYear = firstFinYear;
using (PXTransactionScope ts = new PXTransactionScope())
{
if (fromYear < firstYearNumber)
{
do
{
baseFinYear = GeneratePreviousOrganizationFinYear(baseFinYear);
Actions.PressSave();
}while (baseFinYear != null &&
string.CompareOrdinal(baseFinYear.Year, $"{fromYear:0000}") > 0);
}
baseFinYear = lastFinYear;
if (toYear > lastYearNumber)
{
do
{
baseFinYear = GenerateNextOrganizationFinYear(baseFinYear);
Actions.PressSave();
}while (baseFinYear != null &&
string.CompareOrdinal(baseFinYear.Year, $"{toYear:0000}") < 0);
}
ts.Complete();
}
}
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);
}
protected virtual IEnumerable Cancel(PXAdapter a)
{
string organizationCD;
string yearNumber;
if (NewCalendarParams.View.Answer == WebDialogResult.None) // First outer call
{
FinYearKey storedYearKey = new FinYearKey
{
OrganizationID = OrgFinYear.Current?.OrganizationID,
Year = OrgFinYear.Current?.Year
};
#region Deliberate Technomagic. Copy-pasted fron base PXCancel instead invocation
Clear();
SelectTimeStamp();
#endregion
StoredYearKey.Cache.Clear();
StoredYearKey.Insert(storedYearKey);
StoredYearKey.Cache.IsDirty = false;
organizationCD = (string)a.Searches.GetSearchValueByPosition(0);
if (organizationCD == null)
{
yield break;
}
yearNumber = (string)a.Searches.GetSearchValueByPosition(1);
}
else // Second call after SmartPanel closing
{
object extValue = NewCalendarParams.Cache.GetValueExt <NewOrganizationCalendarParameters.organizationID>(NewCalendarParams.Current);
PXFieldState state = extValue as PXFieldState;
organizationCD = state != null ? (string)state.Value : (string)extValue;
yearNumber = NewCalendarParams.Current.StartYear;
}
OrganizationFinYear targetYear = PXSelectJoin <
OrganizationFinYear,
InnerJoin <Organization,
On <OrganizationFinYear.organizationID, Equal <Organization.organizationID> > >,
Where <Organization.organizationCD, Equal <Required <Organization.organizationCD> >,
And <OrganizationFinYear.year, Equal <Required <OrganizationFinYear.year> > > > >
.SelectSingleBound(this, new object[] { }, organizationCD, yearNumber);
OrganizationFinYear returnYear = null;
if (targetYear == null)
{
OrganizationFinYear lastYear = LastOrganizationYear.SelectSingle(organizationCD);
if (lastYear == null)
{
if (NewCalendarParams.AskExtFullyValid((graph, viewName) =>
{
NewCalendarParams.Current.OrganizationID = PXAccess.GetOrganizationID(organizationCD);
},
DialogAnswerType.Positive))
{
OrganizationFinYear generatedFinYear;
using (PXTransactionScope ts = new PXTransactionScope())
{
generatedFinYear = GenerateSingleOrganizationFinYear(
(int)NewCalendarParams.Current.OrganizationID,
NewCalendarParams.Current.StartYear,
NewCalendarParams.Current.StartMasterFinPeriodID);
Actions.PressSave();
ts.Complete();
}
returnYear = generatedFinYear;
}
else
{
OrganizationFinYear storedYear = FinPeriodRepository.FindOrganizationFinYearByID(StoredYearKey.Current?.OrganizationID, StoredYearKey.Current?.Year);
returnYear = storedYear;
}
}
else
{
returnYear = lastYear;
}
}
else
{
returnYear = targetYear;
}
if (returnYear != null)
{
yield return(returnYear);
}
yield break;
}
