public override void IsValidPeriod(PXCache sender, object row, object newValue)
{
string oldValue = (string)sender.GetValue(row, _FieldName);
base.IsValidPeriod(sender, row, newValue);
if (newValue != null && _ValidatePeriod != PeriodValidation.Nothing)
{
FinPeriod p = (FinPeriod)PXSelect <FinPeriod, Where <FinPeriod.finPeriodID, Equal <Required <FinPeriod.finPeriodID> > > > .Select(sender.Graph, (string)newValue);
if (p.CAClosed == true)
{
if (PostClosedPeriods(sender.Graph))
{
sender.RaiseExceptionHandling(_FieldName, row, null, new FiscalPeriodClosedException(p.FinPeriodID, PXErrorLevel.Warning));
return;
}
else
{
throw new FiscalPeriodClosedException(p.FinPeriodID);
}
}
}
return;
}
private void SetPeriods(UpdateMCAssignmentSettings settings)
{
INSetup insetup = INSetup.Current;
PXCache cache = UpdateSettings.Cache;
if (insetup != null && insetup.TurnoverPeriodsPerYear != null && insetup.TurnoverPeriodsPerYear != 0m && settings.PeriodNbr != null && settings.Year != null)
{
String periodString = (12 / insetup.TurnoverPeriodsPerYear * (settings.PeriodNbr - 1) + 1).ToString();
periodString = periodString.Length == 1 ? "0" + periodString : periodString;
periodString = settings.Year + periodString;
FinPeriod startPeriod = FinPeriodRepository.FindByID(FinPeriod.organizationID.MasterValue, periodString);
if (startPeriod != null)
{
//cache.SetValueExt<UpdateMCAssignmentSettings.startFinPeriodID>(settings, startPeriod.FinPeriodID);
settings.StartFinPeriodID = startPeriod.FinPeriodID;
cache.SetValueExt <UpdateMCAssignmentSettings.startDate>(settings, startPeriod.StartDate);
}
periodString = (12 / insetup.TurnoverPeriodsPerYear * settings.PeriodNbr).ToString();
periodString = periodString.Length == 1 ? "0" + periodString : periodString;
periodString = settings.Year + periodString;
FinPeriod endPeriod = FinPeriodRepository.FindByID(FinPeriod.organizationID.MasterValue, periodString);
if (endPeriod != null)
{
//cache.SetValueExt<UpdateMCAssignmentSettings.endFinPeriodID>(settings, endPeriod.FinPeriodID);
settings.EndFinPeriodID = endPeriod.FinPeriodID;
cache.SetValueExt <UpdateMCAssignmentSettings.endDate>(settings, endPeriod.EndDate);
}
}
}
private void SetPeriods(UpdateMCAssignmentSettings settings)
{
INSetup insetup = INSetup.Current;
PXCache cache = UpdateSettings.Cache;
if (insetup != null && insetup.TurnoverPeriodsPerYear != null && insetup.TurnoverPeriodsPerYear != 0m && settings.PeriodNbr != null && settings.Year != null)
{
String periodString = (12 / insetup.TurnoverPeriodsPerYear * (settings.PeriodNbr - 1) + 1).ToString();
periodString = periodString.Length == 1 ? "0" + periodString : periodString;
periodString = settings.Year + periodString;
FinPeriod startPeriod = (FinPeriod)PXSelect <FinPeriod, Where <FinPeriod.finPeriodID, Equal <Required <FinPeriod.finPeriodID> > > > .Select(this, periodString);
if (startPeriod != null)
{
//cache.SetValueExt<UpdateMCAssignmentSettings.startFinPeriodID>(settings, startPeriod.FinPeriodID);
settings.StartFinPeriodID = startPeriod.FinPeriodID;
cache.SetValueExt <UpdateMCAssignmentSettings.startDate>(settings, startPeriod.StartDate);
}
periodString = (12 / insetup.TurnoverPeriodsPerYear * settings.PeriodNbr).ToString();
periodString = periodString.Length == 1 ? "0" + periodString : periodString;
periodString = settings.Year + periodString;
FinPeriod endPeriod = (FinPeriod)PXSelect <FinPeriod, Where <FinPeriod.finPeriodID, Equal <Required <FinPeriod.finPeriodID> > > > .Select(this, periodString);
if (endPeriod != null)
{
//cache.SetValueExt<UpdateMCAssignmentSettings.endFinPeriodID>(settings, endPeriod.FinPeriodID);
settings.EndFinPeriodID = endPeriod.FinPeriodID;
cache.SetValueExt <UpdateMCAssignmentSettings.endDate>(settings, endPeriod.EndDate);
}
}
}
public override void IsValidPeriod(PXCache sender, object Row, object NewValue)
{
if (NewValue != null && _ValidatePeriod != PeriodValidation.Nothing)
{
FinPeriod period = (FinPeriod)PXSelect<FinPeriod, Where<FinPeriod.finPeriodID, Equal<Required<FinPeriod.finPeriodID>>>>.Select(sender.Graph, (string)NewValue);
if (period == null)
{
throw new PXSetPropertyException(Messages.NoPeriodsDefined);
}
FASetup setup = PXSetupOptional<FASetup>.Select(sender.Graph);
if (setup == null || setup.UpdateGL == true)
{
if (period.Active != true)
{
sender.RaiseExceptionHandling(_FieldName, Row, null, new FiscalPeriodInactiveException(period.FinPeriodID, PXErrorLevel.Warning));
return;
}
if (period.FAClosed == true)
{
if (PostClosedPeriods(sender.Graph))
{
sender.RaiseExceptionHandling(_FieldName, Row, null, new FiscalPeriodClosedException(period.FinPeriodID, PXErrorLevel.Warning));
return;
}
else
{
throw new FiscalPeriodClosedException(period.FinPeriodID);
}
}
}
}
}
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))
{
FinPeriod finPeriod = PXSelect <FinPeriod, Where <FinPeriod.finPeriodID, Equal <Current <UsageFilter.invFinPeriodID> > > > .Select(this);
if (finPeriod != null)
{
select.WhereAnd <Where <PMTran.billedDate, Between <Required <FinPeriod.startDate>, Required <FinPeriod.endDate> > > >();
}
}
return(select.Select());
}
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 override void ClosePeriodProc(FinPeriod financialPeriod)
{
PXSelectBase <APRegister> prebookedDocuments = new PXSelect <
APRegister,
Where <
APRegister.voided, Equal <False>,
And <APRegister.prebooked, Equal <True>,
And <APRegister.released, Equal <False>,
And <APRegister.finPeriodID, Equal <Required <APRegister.finPeriodID> > > > > > >(this);
if (prebookedDocuments.Any(financialPeriod.FinPeriodID))
{
throw new PXException(Messages.PeriodHasPrebookedDocs);
}
PXSelectBase <APRegister> unreleasedDocuments = new PXSelectJoin <
APRegister,
LeftJoin <APAdjust,
On <APAdjust.adjgDocType, Equal <APRegister.docType>,
And <APAdjust.adjgRefNbr, Equal <APRegister.refNbr>,
And <APAdjust.released, Equal <False> > > > >,
Where <
APRegister.voided, Equal <False>,
And <APRegister.scheduled, Equal <False>,
And <APRegister.rejected, Equal <False>,
And <Where <
APAdjust.adjgFinPeriodID, IsNull,
And <APRegister.released, Equal <False>,
And <APRegister.finPeriodID, Equal <Required <APRegister.finPeriodID> >,
Or <APAdjust.adjgFinPeriodID, Equal <Required <APAdjust.adjgFinPeriodID> > > > > > > > > > >(this);
if (unreleasedDocuments.Any(financialPeriod.FinPeriodID, financialPeriod.FinPeriodID))
{
throw new PXException(Messages.PeriodHasUnreleasedDocs);
}
LandedCostTran landedCostTransactions = PXSelectJoin <
LandedCostTran,
InnerJoin <POReceipt,
On <LandedCostTran.pOReceiptNbr, Equal <POReceipt.receiptNbr> > >,
Where <
LandedCostTran.source, Equal <LandedCostTranSource.fromPO>,
And <POReceipt.released, Equal <True>,
And <LandedCostTran.postponeAP, Equal <False>,
And <LandedCostTran.processed, Equal <False>,
And <LandedCostTran.invoiceDate, GreaterEqual <Required <LandedCostTran.invoiceDate> >,
And <LandedCostTran.invoiceDate, Less <Required <LandedCostTran.invoiceDate> > > > > > > > >
.SelectWindowed(this, 0, 1, financialPeriod.StartDate, financialPeriod.EndDate);
if (landedCostTransactions?.LCTranID != null)
{
throw new PXException(Messages.PeriodHasAPDocsFromPO_LCToBeCreated);
}
financialPeriod.APClosed = true;
Caches[typeof(FinPeriod)].Update(financialPeriod);
Actions.PressSave();
}
public virtual IEnumerable nextperiod(PXAdapter adapter)
{
InventoryTranSumEnqFilter filter = Filter.Current as InventoryTranSumEnqFilter;
FinPeriod nextperiod = FinPeriodRepository.FindNextPeriod(FinPeriod.organizationID.MasterValue, filter.FinPeriodID, looped: true);
filter.FinPeriodID = nextperiod?.FinPeriodID;
return(adapter.Get());
}
private decimal PeriodProportionByDays(DateTime date, int shift = 0)
{
FinPeriod finPeriod = _financialPeriodProvider.FindFinPeriodByDate(_graph, date);
var start = _financialPeriodProvider.PeriodStartDate(_graph, finPeriod.FinPeriodID);
var end = _financialPeriodProvider.PeriodEndDate(_graph, finPeriod.FinPeriodID);
int days = (int)end.Subtract(start).TotalDays + 1;
return((decimal)(date.Subtract(start).TotalDays + 1 + shift) / days);
}
protected virtual void InventoryTranByAcctEnqFilter_PeriodEndDate_FieldDefaulting(PXCache cache, PXFieldDefaultingEventArgs e)
{
var row = e.Row as InventoryTranByAcctEnqFilter;
if (row != null)
{
FinPeriod period = FinPeriodRepository.FindByID(FinPeriod.organizationID.MasterValue, row.FinPeriodID);
e.NewValue = period?.EndDate;
}
}
public virtual IEnumerable previousperiod(PXAdapter adapter)
{
InventoryTranByAcctEnqFilter filter = Filter.Current as InventoryTranByAcctEnqFilter;
FinPeriod prevPeriod = FinPeriodRepository.FindPrevPeriod(FinPeriod.organizationID.MasterValue, filter.FinPeriodID, looped: true);
filter.FinPeriodID = prevPeriod?.FinPeriodID;
ResetFilterDates(filter);
return(adapter.Get());
}
public virtual IEnumerable NextPeriod(PXAdapter adapter)
{
ScheduleTransFilter filter = Filter.Current as ScheduleTransFilter;
int? calendarOrganizationID = FinPeriodRepository.GetCalendarOrganizationID(filter.OrganizationID, filter.BranchID, filter.UseMasterCalendar);
FinPeriod nextPeriod = FinPeriodRepository.FindNextPeriod(calendarOrganizationID, filter.FinPeriodID, looped: true);
filter.FinPeriodID = nextPeriod != null ? nextPeriod.FinPeriodID : null;
return(adapter.Get());
}
public FinPeriod GetOffsetPeriod(string finPeriodID, int offset, int?organizationID)
{
FinPeriod offsetPeriod = FindOffsetPeriod(finPeriodID, offset, organizationID);
if (offsetPeriod == null)
{
throw new FinancialPeriodOffsetNotFoundException(finPeriodID, offset);
}
return(offsetPeriod);
}
public FinPeriod GetFinPeriodByDate(DateTime?date, int?organizationID)
{
FinPeriod finPeriod = FindFinPeriodByDate(date, organizationID);
if (finPeriod == null)
{
throw new FinancialPeriodNotDefinedForDateException(date);
}
return(finPeriod);
}
public static new void ClosePeriod(List <FinPeriod> list)
{
CAClosing pg = PXGraph.CreateInstance <CAClosing>();
for (int i = 0; i < list.Count; i++)
{
pg.Clear();
FinPeriod per = list[i];
pg.ClosePeriodProc(per);
}
}
public virtual IEnumerable NextPeriod(PXAdapter adapter)
{
ScheduleTransFilter filter = Filter.Current as ScheduleTransFilter;
FinPeriod nextperiod = FiscalPeriodUtils.FindNextPeriod(this, filter.FinPeriodID, true);
if (nextperiod != null)
{
filter.FinPeriodID = nextperiod.FinPeriodID;
}
return(adapter.Get());
}
public static IEnumerable <string> GetPeriodAgingBucketDescriptions(
IFinPeriodRepository finPeriodRepository,
DateTime currentDate,
AgingDirection agingDirection,
int numberOfBuckets,
int calendarOrganizationID,
bool usePeriodDescription)
{
if (finPeriodRepository == null)
{
throw new ArgumentNullException(nameof(finPeriodRepository));
}
if (numberOfBuckets <= 0)
{
throw new ArgumentOutOfRangeException(nameof(numberOfBuckets));
}
short periodStep = (short)(agingDirection == AgingDirection.Backwards ? -1 : 1);
FinPeriod currentPeriod = finPeriodRepository.GetByID(
finPeriodRepository.GetPeriodIDFromDate(currentDate, calendarOrganizationID),
calendarOrganizationID);
yield return(usePeriodDescription
? currentPeriod.Descr
: FinPeriodUtils.FormatForError(currentPeriod.FinPeriodID));
--numberOfBuckets;
while (numberOfBuckets > 1)
{
currentPeriod = finPeriodRepository.GetByID(
finPeriodRepository.GetOffsetPeriodId(currentPeriod.FinPeriodID, periodStep, calendarOrganizationID),
calendarOrganizationID);
yield return(usePeriodDescription
? currentPeriod.Descr
: FinPeriodUtils.FormatForError(currentPeriod.FinPeriodID));
--numberOfBuckets;
}
if (numberOfBuckets > 0)
{
yield return(PXMessages.LocalizeFormatNoPrefix(
agingDirection == AgingDirection.Backwards
? Messages.BeforeMonth
: Messages.AfterMonth,
usePeriodDescription
? currentPeriod.Descr
: FinPeriodUtils.FormatForError(currentPeriod.FinPeriodID)));
}
}
protected virtual void ResetFilterDates(InventoryTranByAcctEnqFilter aRow)
{
FinPeriod period = PXSelectReadonly <FinPeriod, Where <FinPeriod.finPeriodID, Equal <Required <FinPeriod.finPeriodID> > > > .Select(this, aRow.FinPeriodID);
if (period != null)
{
aRow.PeriodStartDate = period.StartDate;
aRow.PeriodEndDate = period.EndDate;
aRow.EndDate = null;
aRow.StartDate = null;
}
}
protected virtual void ResetFilterDates(InventoryTranByAcctEnqFilter aRow)
{
FinPeriod period = FinPeriodRepository.FindByID(FinPeriod.organizationID.MasterValue, aRow.FinPeriodID);
if (period != null)
{
aRow.PeriodStartDate = period.StartDate;
aRow.PeriodEndDate = period.EndDate;
aRow.EndDate = null;
aRow.StartDate = null;
}
}
public FinPeriod GetByID(string finPeriodID, int?organizationID)
{
FinPeriod finPeriod = FindByID(organizationID, finPeriodID);
if (finPeriod == null)
{
throw new PXException(Common.Messages.EntityWithIDDoesNotExist,
EntityHelper.GetFriendlyEntityName(typeof(FinPeriod)),
finPeriodID);
}
return(finPeriod);
}
public override void FieldDefaulting(PXCache sender, PXFieldDefaultingEventArgs e)
{
base.FieldDefaulting(sender, e);
PXSelectBase <FinPeriod> select = new PXSelect <FinPeriod, Where <FinPeriod.finYear, Equal <Required <FinPeriod.finYear> > >, OrderBy <Asc <FinPeriod.periodNbr> > >(sender.Graph);
FinPeriod fp = select.SelectWindowed(0, 1, DateTime.Now.Year);
if (fp != null)
{
e.NewValue = FinPeriodIDFormattingAttribute.FormatForDisplay(fp.FinPeriodID);
}
}
private DRScheduleDetail InsertScheduleDetail(
int?componentID,
DRDeferredCode defCode,
decimal amount,
AccountSubaccountPair deferralAccountSubaccount,
AccountSubaccountPair salesOrExpenseAccountSubaccount,
int?overridenSubID = null)
{
FinPeriod detailFinPeriod = FinPeriodRepository
.GetFinPeriodByMasterPeriodID(PXAccess.GetParentOrganizationID(_branchID),
_schedule.FinPeriodID).GetValueOrRaiseError();
DRScheduleDetail scheduleDetail = new DRScheduleDetail
{
ScheduleID = _schedule.ScheduleID,
BranchID = _branchID,
ComponentID = componentID,
CuryTotalAmt = amount,
CuryDefAmt = amount,
DefCode = defCode.DeferredCodeID,
Status = _isDraft ? DRScheduleStatus.Draft : DRScheduleStatus.Open,
IsCustom = false,
IsOpen = true,
Module = _schedule.Module,
DocType = _schedule.DocType,
RefNbr = _schedule.RefNbr,
LineNbr = _schedule.LineNbr,
FinPeriodID = detailFinPeriod.FinPeriodID,
TranPeriodID = detailFinPeriod.MasterFinPeriodID,
BAccountID = _schedule.BAccountID,
AccountID = salesOrExpenseAccountSubaccount.AccountID,
SubID = overridenSubID ?? salesOrExpenseAccountSubaccount.SubID,
DefAcctID = deferralAccountSubaccount.AccountID,
DefSubID = deferralAccountSubaccount.SubID,
CreditLineNbr = 0,
DocDate = _schedule.DocDate,
BAccountType =
_schedule.Module == BatchModule.AP
? BAccountType.VendorType
: BAccountType.CustomerType,
};
scheduleDetail = _drEntityStorage.Insert(scheduleDetail);
if (!_isDraft)
{
_drEntityStorage.CreateCreditLineTransaction(scheduleDetail, defCode, _branchID);
}
return(scheduleDetail);
}
public static IEnumerable <string> GetPeriodAgingBucketDescriptions(
IFinPeriodRepository finPeriodRepository,
DateTime currentDate,
AgingDirection agingDirection,
int numberOfBuckets)
{
if (finPeriodRepository == null)
{
throw new ArgumentNullException(nameof(finPeriodRepository));
}
if (numberOfBuckets <= 0)
{
throw new ArgumentOutOfRangeException(nameof(numberOfBuckets));
}
short periodStep = (short)(agingDirection == AgingDirection.Backwards ? -1 : 1);
// Must not re-use any existing graphs due to possible query
// caching of financial periods, which can impact localization
// of their descriptions, see AC-84505.
// -
PXGraph graph = new PXGraph();
FinPeriod currentPeriod = finPeriodRepository.GetByID(
finPeriodRepository.GetPeriodIDFromDate(currentDate, FinPeriod.organizationID.MasterValue),
FinPeriod.organizationID.MasterValue);
yield return(currentPeriod.Descr);
--numberOfBuckets;
while (numberOfBuckets > 1)
{
currentPeriod = finPeriodRepository.GetByID(
finPeriodRepository.GetOffsetPeriodId(currentPeriod.FinPeriodID, periodStep, FinPeriod.organizationID.MasterValue),
FinPeriod.organizationID.MasterValue);
yield return(currentPeriod.Descr);
--numberOfBuckets;
}
if (numberOfBuckets > 0)
{
yield return(PXMessages.LocalizeFormatNoPrefix(
agingDirection == AgingDirection.Backwards
? Messages.BeforeMonth
: Messages.AfterMonth,
currentPeriod.Descr));
}
}
protected override void FinPeriod_RowSelected(PXCache sender, PXRowSelectedEventArgs e)
{
base.FinPeriod_RowSelected(sender, e);
FinPeriod per = (FinPeriod)e.Row;
if (per == null)
{
return;
}
FinPeriod p = PeriodList.Select();
ShowAssets.SetEnabled(p.Selected == true);
}
private decimal PeriodProportionByDays(DateTime date, int?organizationID, int shift = 0)
{
FinPeriod finPeriod = _finPeriodRepository.FindFinPeriodByDate(date, organizationID);
if (finPeriod == null)
{
throw new PXException(Messages.TermStartDateOrTermEndDatedoNotExist, _code.DeferredCodeID);
}
var start = _finPeriodRepository.PeriodStartDate(finPeriod.FinPeriodID, organizationID);
var end = _finPeriodRepository.PeriodEndDate(finPeriod.FinPeriodID, organizationID);
int days = (int)end.Subtract(start).TotalDays + 1;
return((decimal)(date.Subtract(start).TotalDays + 1 + shift) / days);
}
/// <summary>
/// Returns End date for the given period
/// </summary>
public DateTime PeriodEndDate(string finPeriodID, int?organizationID)
{
FinPeriod financialPeriod = PXSelect <
FinPeriod,
Where <FinPeriod.finPeriodID, Equal <Required <FinPeriod.finPeriodID> >,
And <FinPeriod.organizationID, Equal <Required <FinPeriod.organizationID> > > > >
.Select(Graph, finPeriodID, organizationID);
if (financialPeriod == null)
{
throw new FinancialPeriodWithIdNotFoundException(finPeriodID);
}
return(financialPeriod.EndDate.Value.AddDays(-1));
}
protected override void FinPeriod_Selected_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e)
{
FinPeriod row = (FinPeriod)e.Row;
if (row != null && row.Selected == true)
{
if (PXSelect <PendingPPDDebitAdjApp, Where <APAdjust.adjgFinPeriodID, Equal <Required <APAdjust.adjgFinPeriodID> > > >
.SelectSingleBound(this, null, row.FinPeriodID).Count > 0)
{
sender.RaiseExceptionHandling <FinPeriod.selected>(row, true, new PXSetPropertyException(Messages.UnprocessedPPDExistsClosing, PXErrorLevel.RowWarning));
}
}
base.FinPeriod_Selected_FieldUpdated(sender, e);
}
public virtual IEnumerable nextperiod(PXAdapter adapter)
{
InventoryTranSumEnqFilter filter = Filter.Current as InventoryTranSumEnqFilter;
FinPeriod nextperiod = PXSelect <FinPeriod,
Where <FinPeriod.finPeriodID,
Greater <Current <InventoryTranSumEnqFilter.finPeriodID> > >,
OrderBy <Asc <FinPeriod.finPeriodID> >
> .SelectWindowed(this, 0, 1);
if (nextperiod == null)
{
nextperiod = PXSelectOrderBy <FinPeriod,
OrderBy <Asc <FinPeriod.finPeriodID> > > .SelectWindowed(this, 0, 1);
}
filter.FinPeriodID = nextperiod.FinPeriodID;
return(adapter.Get());
}
public virtual IEnumerable NextPeriod(PXAdapter adapter)
{
DiscrepancyEnqFilter filter = Filter.Current as DiscrepancyEnqFilter;
filter.UseMasterCalendar = filter.OrganizationID == null && filter.BranchID == null;
int?calendarOrganizationID = FinPeriodRepository.GetCalendarOrganizationID(filter.OrganizationID, filter.BranchID, filter.UseMasterCalendar);
FinPeriod nextPeriodFrom = FinPeriodRepository.FindNextPeriod(calendarOrganizationID, filter.PeriodFrom, looped: true);
filter.PeriodFrom = nextPeriodFrom != null ? nextPeriodFrom.FinPeriodID : null;
FinPeriod nextPeriodTo = FinPeriodRepository.FindNextPeriod(calendarOrganizationID, filter.PeriodTo, looped: true);
filter.PeriodTo = nextPeriodTo != null ? nextPeriodTo.FinPeriodID : null;
filter.FilterDetails = null;
return(adapter.Get());
}
protected override void ClosePeriodProc(FinPeriod p)
{
PXSelectBase select = new PXSelect <INRegister,
Where <INRegister.finPeriodID, Equal <Required <INRegister.finPeriodID> >,
And <INRegister.released, Equal <boolFalse> > > >(this);
INRegister doc = (INRegister)select.View.SelectSingle(p.FinPeriodID);
if (doc != null)
{
throw new PXException(AP.Messages.PeriodHasUnreleasedDocs);
}
//MS Landed cost will not be able to create these transactions if the period is closed
LandedCostTran lcTranFromAP = PXSelectJoin <LandedCostTran,
InnerJoin <APRegister, On <LandedCostTran.aPDocType, Equal <APRegister.docType>,
And <LandedCostTran.aPRefNbr, Equal <APRegister.refNbr> > > >,
Where <LandedCostTran.invoiceDate, GreaterEqual <Required <LandedCostTran.invoiceDate> >,
And <LandedCostTran.invoiceDate, Less <Required <LandedCostTran.invoiceDate> >,
And <LandedCostTran.source, Equal <LandedCostTranSource.fromAP>,
And <APRegister.released, Equal <True>,
And <LandedCostTran.processed, Equal <False> > > > > > > .Select(this, p.StartDate, p.EndDate);
if (lcTranFromAP != null && lcTranFromAP.LCTranID.HasValue)
{
throw new PXException(Messages.PeriodHasINDocsFromAP_LCToBeCreated);
}
PO.LandedCostTran lcTranFromPO = PXSelectJoin <LandedCostTran,
InnerJoin <POReceipt, On <LandedCostTran.pOReceiptNbr, Equal <POReceipt.receiptNbr> > >,
Where <LandedCostTran.invoiceDate, GreaterEqual <Required <LandedCostTran.invoiceDate> >,
And <LandedCostTran.invoiceDate, Less <Required <LandedCostTran.invoiceDate> >,
And <LandedCostTran.source, Equal <LandedCostTranSource.fromPO>,
And <POReceipt.released, Equal <True>,
And <LandedCostTran.processed, Equal <False> > > > > > > .Select(this, p.StartDate, p.EndDate);
if (lcTranFromPO != null && lcTranFromPO.LCTranID.HasValue)
{
throw new PXException(Messages.PeriodHasINDocsFromPO_LCToBeCreated);
}
p.INClosed = true;
Caches[typeof(FinPeriod)].Update(p);
Actions.PressSave();
}
