public ProcessingResult FinPeriodsForMasterExist(string masterFinPeriodID, int?[] organizationIDs)
{
List <FinPeriod> finPeriods =
PXSelect <FinPeriod,
Where <FinPeriod.masterFinPeriodID, Equal <Required <FinPeriod.masterFinPeriodID> >,
And <FinPeriod.organizationID, In <Required <FinPeriod.organizationID> > > > >
.Select(Graph, masterFinPeriodID, organizationIDs)
.RowCast <FinPeriod>()
.ToList();
ProcessingResult validationResult = new ProcessingResult();
if (finPeriods.Count != organizationIDs.Length)
{
IEnumerable <int?> unexistingForOrganizationIDs =
organizationIDs.Except(finPeriods.Select(period => period.OrganizationID));
validationResult.AddMessage(
PXErrorLevel.Error,
Messages.RelatedFinPeriodsForMasterDoesNotExistForCompanies,
FinPeriodIDFormattingAttribute.FormatForError(masterFinPeriodID),
unexistingForOrganizationIDs.Select(PXAccess.GetOrganizationCD).OrderBy(v => v).ToArray().JoinIntoStringForMessageNoQuotes(20));
}
return(validationResult);
}
private static ProcessingResult ValidateFinPeriods(GLBudgetEntry graph, IEnumerable <GLBudgetLineDetail> records)
{
ProcessingResult generalResult = new ProcessingResult();
var recordsByPeriod = records.GroupBy(record => record.FinPeriodID);
foreach (var recordsByPeriodGroup in recordsByPeriod)
{
string finPeriodID = recordsByPeriodGroup.Key;
int?[] orgnizationIDs = recordsByPeriodGroup.GroupBy(t => PXAccess.GetParentOrganizationID(t.BranchID))
.Select(g => g.Key)
.ToArray();
ICollection <OrganizationFinPeriod> finPeriods =
PXSelect <OrganizationFinPeriod,
Where <OrganizationFinPeriod.organizationID, In <Required <OrganizationFinPeriod.organizationID> >,
And <OrganizationFinPeriod.finPeriodID, Equal <Required <OrganizationFinPeriod.finPeriodID> > > > >
.Select(graph, orgnizationIDs, finPeriodID)
.RowCast <OrganizationFinPeriod>()
.ToArray();
if (finPeriods.Count != orgnizationIDs.Length)
{
string[] organizationCDs = orgnizationIDs.Except(finPeriods.Select(period => period.OrganizationID))
.Select(PXAccess.GetOrganizationCD)
.ToArray();
generalResult.AddErrorMessage(Messages.FinPeriodDoesNotExistForCompanies,
FinPeriodIDFormattingAttribute.FormatForError(finPeriodID),
organizationCDs.JoinIntoStringForMessageNoQuotes(20));
}
foreach (OrganizationFinPeriod finPeriod in finPeriods)
{
ProcessingResult result = new ProcessingResult();
if (finPeriod.Status == FinPeriod.status.Locked)
{
result.AddErrorMessage(Messages.FinPeriodIsLockedInCompany,
FinPeriodIDFormattingAttribute.FormatForError(finPeriod.FinPeriodID),
PXAccess.GetOrganizationCD(finPeriod.OrganizationID));
}
generalResult.Aggregate(result);
if (generalResult.Messages.Count > 20)
{
return(generalResult);
}
}
}
return(generalResult);
}
protected virtual ProcessingResult HandleErrorThatPeriodIsClosed(IFinPeriod finPeriod)
{
ProcessingResult result = new ProcessingResult();
if (!CanPostToClosedPeriod())
{
result.AddErrorMessage(Messages.FinPeriodIsClosedInCompany,
FinPeriodIDFormattingAttribute.FormatForError(finPeriod.FinPeriodID),
PXAccess.GetOrganizationCD(finPeriod.OrganizationID));
}
return(result);
}
public virtual ProcessingResult CanPostToPeriod(IFinPeriod finPeriod, Type fieldModuleClosed = null)
{
ProcessingResult result = new ProcessingResult();
if (finPeriod.Status == FinPeriod.status.Locked)
{
result.AddErrorMessage(Messages.FinPeriodIsLockedInCompany,
FinPeriodIDFormattingAttribute.FormatForError(finPeriod.FinPeriodID),
PXAccess.GetOrganizationCD(finPeriod.OrganizationID));
return(result);
}
if (AllowPostToUnlockedPeriodAnyway)
{
return(result);
}
if (finPeriod.Status == FinPeriod.status.Inactive)
{
result.AddErrorMessage(Messages.FinPeriodIsInactiveInCompany,
FinPeriodIDFormattingAttribute.FormatForError(finPeriod.FinPeriodID),
PXAccess.GetOrganizationCD(finPeriod.OrganizationID));
return(result);
}
if (finPeriod.Status == FinPeriod.status.Closed)
{
result = HandleErrorThatPeriodIsClosed(finPeriod);
if (result.HasWarningOrError)
{
return(result);
}
}
if (fieldModuleClosed != null)
{
PXCache cache = Graph.Caches[BqlCommand.GetItemType(fieldModuleClosed)];
bool?isClosedInModule = (bool)cache.GetValue(finPeriod, fieldModuleClosed.Name);
if (isClosedInModule == true)
{
result = HandleErrorThatPeriodIsClosed(finPeriod);
}
}
return(result);
}
protected virtual void FATran_FinPeriodID_FieldVerifying(PXCache sender, PXFieldVerifyingEventArgs e)
{
FATran tran = (FATran)e.Row;
if (tran?.AssetID == null || tran.BookID == null || tran.TranDate == null)
{
return;
}
try
{
// TODO: AC-106141
// Use BranchID of the fixed asset referenced by local FATran
FABookPeriod period = PXSelect <
FABookPeriod,
Where <FABookPeriod.bookID, Equal <Required <FABookPeriod.bookID> >,
And <FABookPeriod.finPeriodID, Equal <Required <FABookPeriod.finPeriodID> > > > >
.Select(this, tran.BookID, (string)e.NewValue);
if (period == null)
{
throw new PXSetPropertyException(Messages.NoPeriodsDefined);
}
FABookBalance bal = bookbalances.SelectSingle(tran.AssetID, tran.BookID);
if ((tran.TranType == FATran.tranType.DepreciationPlus || tran.TranType == FATran.tranType.DepreciationMinus) && tran.Origin == FARegister.origin.Adjustment)
{
if (!string.IsNullOrEmpty(bal.CurrDeprPeriod) && string.CompareOrdinal((string)e.NewValue, bal.CurrDeprPeriod) >= 0)
{
throw new PXSetPropertyException(CS.Messages.Entry_LT, FinPeriodIDFormattingAttribute.FormatForError(bal.CurrDeprPeriod));
}
if (!string.IsNullOrEmpty(bal.LastDeprPeriod) && string.CompareOrdinal((string)e.NewValue, bal.LastDeprPeriod) > 0)
{
throw new PXSetPropertyException(CS.Messages.Entry_LE, FinPeriodIDFormattingAttribute.FormatForError(bal.LastDeprPeriod));
}
if (!string.IsNullOrEmpty(bal.DeprFromPeriod) && string.CompareOrdinal((string)e.NewValue, bal.DeprFromPeriod) < 0)
{
throw new PXSetPropertyException(CS.Messages.Entry_GE, FinPeriodIDFormattingAttribute.FormatForError(bal.DeprFromPeriod));
}
}
}
catch (PXSetPropertyException)
{
e.NewValue = FinPeriodIDAttribute.FormatForDisplay((string)e.NewValue);
throw;
}
}
protected virtual void FATran_FinPeriodID_FieldVerifying(PXCache sender, PXFieldVerifyingEventArgs e)
{
FATran tran = (FATran)e.Row;
if (tran == null || tran.AssetID == null || tran.BookID == null)
{
return;
}
try
{
FABookPeriod p = PXSelect <FABookPeriod,
Where <FABookPeriod.bookID, Equal <Required <FABookPeriod.bookID> >,
And <FABookPeriod.finPeriodID, Equal <Required <FABookPeriod.finPeriodID> > > > > .Select(this, tran.BookID, (string)e.NewValue);
if (p == null)
{
throw new PXSetPropertyException(Messages.NoPeriodsDefined);
}
FABookBalance bal = PXSelect <FABookBalance,
Where <FABookBalance.assetID, Equal <Required <FABookBalance.assetID> >,
And <FABookBalance.bookID, Equal <Required <FABookBalance.bookID> > > > > .Select(this, tran.AssetID, tran.BookID);
if ((tran.TranType == FATran.tranType.DepreciationPlus || tran.TranType == FATran.tranType.DepreciationMinus) && tran.Origin == FARegister.origin.Adjustment)
{
if (!string.IsNullOrEmpty(bal.CurrDeprPeriod) && String.Compare((string)e.NewValue, bal.CurrDeprPeriod) >= 0)
{
throw new PXSetPropertyException(CS.Messages.Entry_LT, FinPeriodIDFormattingAttribute.FormatForError(bal.CurrDeprPeriod));
}
if (!string.IsNullOrEmpty(bal.LastDeprPeriod) && String.Compare((string)e.NewValue, bal.LastDeprPeriod) > 0)
{
throw new PXSetPropertyException(CS.Messages.Entry_LE, FinPeriodIDFormattingAttribute.FormatForError(bal.LastDeprPeriod));
}
}
}
catch (PXSetPropertyException)
{
e.NewValue = FinPeriodSelectorAttribute.FormatForDisplay((string)e.NewValue);
throw;
}
}
public virtual OrganizationFinPeriod GetOpenOrganizationFinPeriodInSubledger <TClosedInSubledgerField>(string orgFinPeriodID, int?branchID)
where TClosedInSubledgerField : IBqlField
{
int?organizationID = PXAccess.GetParentOrganizationID(branchID);
OrganizationFinPeriod orgFinPeriod = PXSelect <
OrganizationFinPeriod,
Where <OrganizationFinPeriod.finPeriodID, Equal <Required <OrganizationFinPeriod.finPeriodID> >,
And <OrganizationFinPeriod.organizationID, Equal <Required <OrganizationFinPeriod.organizationID> >,
And <TClosedInSubledgerField, NotEqual <True> > > > >
.SelectWindowed(Graph, 0, 1, orgFinPeriodID, organizationID);
if (orgFinPeriod == null)
{
throw new PXException(
Messages.FiscalPeriodClosedInOrganization,
FinPeriodIDFormattingAttribute.FormatForError(orgFinPeriodID),
PXAccess.GetOrganizationCD(organizationID));
}
return(orgFinPeriod);
}
public override object Evaluate(PXCache cache, object item, Dictionary <Type, object> parameters)
{
string direction = (string)parameters[typeof(Direction)];
string periodID = (string)parameters[typeof(PeriodID)];
switch (direction)
{
case FormatDirection.Display:
return(FinPeriodIDFormattingAttribute.FormatForDisplay(periodID));
case FormatDirection.Store:
return(FinPeriodIDFormattingAttribute.FormatForStoring(periodID));
case FormatDirection.Error:
return(FinPeriodIDFormattingAttribute.FormatForError(periodID));
default:
return(null);
}
}
protected virtual void ValidateFinPeriod(string finPeriodID,
int?[] orgnizationIDs,
Type fieldModuleClosed = null,
ProcessingResult generalResult = null)
{
if (generalResult == null)
{
generalResult = new ProcessingResult();
}
ICollection <OrganizationFinPeriod> finPeriods =
PXSelect <OrganizationFinPeriod,
Where <OrganizationFinPeriod.organizationID, In <Required <OrganizationFinPeriod.organizationID> >,
And <OrganizationFinPeriod.finPeriodID, Equal <Required <OrganizationFinPeriod.finPeriodID> > > > >
.Select(Graph, orgnizationIDs, finPeriodID)
.RowCast <OrganizationFinPeriod>()
.ToArray();
if (finPeriods.Count != orgnizationIDs.Length)
{
string[] organizationCDs = orgnizationIDs.Except(finPeriods.Select(period => period.OrganizationID))
.Select(PXAccess.GetOrganizationCD)
.ToArray();
generalResult.AddErrorMessage(Messages.FinPeriodDoesNotExistForCompanies,
FinPeriodIDFormattingAttribute.FormatForError(finPeriodID),
organizationCDs.JoinIntoStringForMessageNoQuotes(20));
}
foreach (OrganizationFinPeriod finPeriod in finPeriods)
{
ProcessingResult result = CanPostToPeriod(finPeriod, fieldModuleClosed);
generalResult.Aggregate(result);
if (generalResult.Messages.Count > 20)
{
generalResult.RaiseIfHasError();
}
}
}
public virtual OrganizationFinPeriod GetOpenOrganizationFinPeriodInFA(string orgFinPeriodID, int?assetID)
{
OrganizationFinPeriod orgFinPeriod = PXSelectJoin <
OrganizationFinPeriod,
InnerJoin <Branch,
On <Branch.organizationID, Equal <OrganizationFinPeriod.organizationID> >,
InnerJoin <FixedAsset,
On <FixedAsset.assetID, Equal <Required <FixedAsset.assetID> >,
And <FixedAsset.branchID, Equal <Branch.branchID> > > > >,
Where <OrganizationFinPeriod.finPeriodID, Equal <Required <OrganizationFinPeriod.finPeriodID> >,
And <OrganizationFinPeriod.fAClosed, NotEqual <True> > > >
.SelectWindowed(Graph, 0, 1, assetID, orgFinPeriodID);
if (orgFinPeriod == null)
{
throw new PXException(
Messages.FiscalPeriodClosed,
FinPeriodIDFormattingAttribute.FormatForError(orgFinPeriodID));
}
return(orgFinPeriod);
}
public virtual ProcessingResult CheckFinPeriod(string finPeriodID, int? branchID)
{
ProcessingResult result = new ProcessingResult();
int? organizationID = PXAccess.GetParentOrganizationID(branchID);
FinPeriod period = FinPeriodRepository.FindByID(organizationID, finPeriodID);
if (period == null)
{
result.AddErrorMessage(GL.Messages.FinPeriodDoesNotExistForCompany,
FinPeriodIDFormattingAttribute.FormatForError(finPeriodID),
PXAccess.GetOrganizationCD(PXAccess.GetParentOrganizationID(branchID)));
}
else
{
result = FinPeriodUtils.CanPostToPeriod(period);
}
if (!result.IsSuccess)
{
PXProcessing<THistory>.SetError(new PXException(result.GetGeneralMessage()));
}
return result;
}
public static string FormatForError(string period)
{
return(FinPeriodIDFormattingAttribute.FormatForError(period));
}
// TODO: Must be removed in scope of AC-156072
private DateTime CalculateAdditionDate(string periodID, DateTime?deprFromDate)
{
DateTime additionDate = MaxDate(
RepositoryHelper.FindOrganizationFABookPeriodByID(periodID, BookID, AssetID).StartDate.Value,
deprFromDate.Value);
if (RepositoryHelper.GetFABookPeriodIDOfDate(additionDate, BookID, AssetID) != periodID)
{
throw new PXException(Messages.DeprFromDateNotMatchPeriod, additionDate, FinPeriodIDFormattingAttribute.FormatForError(periodID), FixedAsset.AssetCD);
}
return(additionDate);
}
