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);
}
private void ValidateNotMainRowLevelSources(PXCache cache, object oldRow, object newRow, bool externalCall, FinPeriod newMainOrgFinPeriod)
{
ValidationResult validationResult = ValidateRowLevelSources(
CalendarOrganizationIDProvider,
cache,
newRow,
organizationID => FinPeriodRepository
.GetFinPeriodByMasterPeriodID(organizationID, newMainOrgFinPeriod.MasterFinPeriodID).IsSuccess,
skipMain: true);
if (validationResult.HasErrors)
{
foreach (var branchValue in validationResult.BranchValuesWithErrors)
{
if (branchValue.SpecificationItem.BranchSourceType != null &&
(branchValue.SpecificationItem.BranchSourceFormulaType != null ||
PXAccess.FeatureInstalled <FeaturesSet.branch>()))
{
PXCache branchCache = cache.Graph.Caches[BqlCommand.GetItemType(branchValue.SpecificationItem.BranchSourceType)];
object newBranch = branchCache.GetItemType().IsAssignableFrom(newRow.GetType())
? newRow
: branchCache.Current;
object oldBranch = branchCache.GetItemType().IsAssignableFrom(oldRow.GetType())
? oldRow
: branchCache.Current;
string organizationCD =
PXAccess.GetOrganizationCD(
PXAccess.GetParentOrganizationID(branchValue.SourceBranchIDs.Single()));
var exception = new PXSetPropertyException(
Messages.RelatedFinPeriodForMasterDoesNotExistForCompany,
FormatForError(newMainOrgFinPeriod.MasterFinPeriodID),
organizationCD);
SetErrorAndResetToOldForField(
branchCache,
oldBranch,
newBranch,
branchValue.SpecificationItem.BranchSourceType.Name,
exception,
externalCall);
}
}
}
}
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 virtual OrganizationFinPeriod GetNearestOpenOrganizationFinPeriodInSubledgerByOrganization <TClosedInSubledgerField>(string orgFinPeriodID, int?organizationID, Func <bool> additionalCondition = null)
where TClosedInSubledgerField : IBqlField
{
OrganizationFinPeriod orgFinPeriod = PXSelect <
OrganizationFinPeriod,
Where <OrganizationFinPeriod.finPeriodID, GreaterEqual <Required <OrganizationFinPeriod.finPeriodID> >,
And <OrganizationFinPeriod.organizationID, Equal <Required <OrganizationFinPeriod.organizationID> >,
And <TClosedInSubledgerField, NotEqual <True>,
And <OrganizationFinPeriod.startDate, NotEqual <OrganizationFinPeriod.endDate> > > > >,
OrderBy <Asc <OrganizationFinPeriod.finPeriodID> > >
.SelectWindowed(Graph, 0, 1, orgFinPeriodID, organizationID);
if (orgFinPeriod == null && (additionalCondition == null || additionalCondition()))
{
throw new PXException(
Messages.NoOpenPeriodInOrganization,
PXAccess.GetOrganizationCD(organizationID));
}
return(orgFinPeriod);
}
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 virtual ProcessingResult <FinPeriod> GetFinPeriodByMasterPeriodID(int?organizationID, string masterFinPeriodID)
{
FinPeriod period = PXSelect <FinPeriod,
Where <FinPeriod.organizationID, Equal <Required <FinPeriod.organizationID> >,
And <FinPeriod.masterFinPeriodID, Equal <Required <FinPeriod.masterFinPeriodID> > > > >
.Select(Graph, organizationID, masterFinPeriodID);
var result = ProcessingResult <FinPeriod> .CreateSuccess(period);
if (period == null)
{
string errorMessage = PXMessages.LocalizeFormatNoPrefix(
Messages.RelatedFinPeriodsForMasterDoesNotExistForCompany,
PeriodIDAttribute.FormatForError(masterFinPeriodID),
PXAccess.GetOrganizationCD(organizationID));
result.AddErrorMessage(errorMessage);
}
return(result);
}
public virtual ProcessingResult <FABookPeriod> FindMappedFABookPeriodUsingFinPeriod(int?bookID, int?sourceOrganizationID, string sourcefinPeriodID, int?targetOrganizationID)
{
IFinPeriodRepository finPeriodRepository = Graph.GetService <IFinPeriodRepository>();
string targetFinPeriodID = finPeriodRepository.GetMappedPeriod(sourceOrganizationID, sourcefinPeriodID, targetOrganizationID)?.FinPeriodID;
FABookPeriod targetFABookPeriod = FindByKey(bookID, targetOrganizationID, targetFinPeriodID);
ProcessingResult <FABookPeriod> result = ProcessingResult <FABookPeriod> .CreateSuccess(targetFABookPeriod);
if (targetFABookPeriod == null)
{
string errorMessage = PXMessages.LocalizeFormat(
Messages.PeriodDoesNotExistForBookAndCompany,
PeriodIDAttribute.FormatForError(sourcefinPeriodID),
FindFABook(bookID).BookCode,
PXAccess.GetOrganizationCD(sourceOrganizationID));
result.AddErrorMessage(errorMessage);
}
return(result);
}
public virtual ProcessingResult <FABookPeriod> FindMappedFABookPeriod(int?bookID, int?sourceOrganizationID, string sourcefinPeriodID, int?targetOrganizationID)
{
FABookPeriod sourceFABookPeriod = FindByKey(bookID, sourceOrganizationID, sourcefinPeriodID);
ProcessingResult <FABookPeriod> result = ProcessingResult <FABookPeriod> .CreateSuccess(sourceFABookPeriod);
if (sourceFABookPeriod == null)
{
string errorMessage = PXMessages.LocalizeFormat(
Messages.PeriodDoesNotExistForBookAndCompany,
PeriodIDAttribute.FormatForError(sourcefinPeriodID),
FindFABook(bookID).BookCode,
PXAccess.GetOrganizationCD(sourceOrganizationID));
result.AddErrorMessage(errorMessage);
}
else if (IsPostingFABook(bookID) && sourceOrganizationID != targetOrganizationID)
{
result = GetFABookPeriodByMasterPeriodID(bookID, targetOrganizationID, sourceFABookPeriod?.MasterFinPeriodID);
}
return(result);
}
public virtual ProcessingResult <FABookPeriod> GetFABookPeriodByMasterPeriodID(int?bookID, int?organizationID, string masterFinPeriodID)
{
FABookPeriod period = SelectFrom <FABookPeriod>
.Where <FABookPeriod.bookID.IsEqual <@P.AsInt>
.And <FABookPeriod.organizationID.IsEqual <@P.AsInt> >
.And <FABookPeriod.masterFinPeriodID.IsEqual <@P.AsString> > >
.View
.ReadOnly
.Select(Graph, bookID, organizationID, masterFinPeriodID);
ProcessingResult <FABookPeriod> result = ProcessingResult <FABookPeriod> .CreateSuccess(period);
if (period == null)
{
string errorMessage = PXMessages.LocalizeFormatNoPrefix(
GL.Messages.RelatedFinPeriodsForMasterDoesNotExistForCompany,
PeriodIDAttribute.FormatForError(masterFinPeriodID),
PXAccess.GetOrganizationCD(organizationID));
result.AddErrorMessage(errorMessage);
}
return(result);
}
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 object GetOrganizationCDByID(object organizationID)
{
return(PXAccess.GetOrganizationCD((int?)organizationID));
}
protected override void ValidatePeriodAndSourcesImpl(PXCache cache, object oldRow, object newRow, bool externalCall)
{
PeriodKeyProviderBase.KeyWithSourceValuesCollection <
FABookPeriodKeyProvider.FAKeyWithSourceValues,
FABookPeriodKeyProvider.FASourceSpecificationItem,
FABookPeriod.Key> newKeyWithSourceValues =
FABookPeriodKeyProvider.GetKeys(cache.Graph, cache, newRow);
PeriodKeyProviderBase.KeyWithSourceValuesCollection <
FABookPeriodKeyProvider.FAKeyWithSourceValues,
FABookPeriodKeyProvider.FASourceSpecificationItem,
FABookPeriod.Key> oldKeyWithSourceValues =
FABookPeriodKeyProvider.GetKeys(cache.Graph, cache, oldRow);
FABookPeriod.Key newPeriodKey = newKeyWithSourceValues.ConsolidatedKey;
newPeriodKey.PeriodID = (string)cache.GetValue(newRow, _FieldName);
if (!newPeriodKey.Defined)
{
return;
}
IFABookPeriodRepository periodRepository = cache.Graph.GetService <IFABookPeriodRepository>();
FABookPeriod period = periodRepository.FindByKey(newPeriodKey.BookID, newPeriodKey.OrganizationID,
newPeriodKey.PeriodID);
if (period == null)
{
PXSetPropertyException exception = null;
FABook book = BookMaint.FindByID(cache.Graph, newPeriodKey.BookID);
if (book.UpdateGL == true)
{
exception = new PXSetPropertyException(PXMessages.LocalizeFormatNoPrefix(
Messages.PeriodDoesNotExistForBookAndCompany,
FormatForError(newPeriodKey.PeriodID),
book.BookCode,
PXAccess.GetOrganizationCD(newPeriodKey.OrganizationID)));
if (FAMainSpecificationItem.OrganizationSourceType != null &&
newKeyWithSourceValues.MainItem.SourceOrganizationIDs.First() != null &&
newKeyWithSourceValues.MainItem.SourceOrganizationIDs.First() != oldKeyWithSourceValues.MainItem.SourceOrganizationIDs.First())
{
SetErrorAndResetToOldForField(
cache,
oldRow,
newRow,
FAMainSpecificationItem.OrganizationSourceType.Name,
exception,
externalCall);
}
if (FAMainSpecificationItem.BranchSourceType != null &&
newKeyWithSourceValues.MainItem.SourceBranchIDs.First() != null &&
newKeyWithSourceValues.MainItem.SourceBranchIDs.First() != oldKeyWithSourceValues.MainItem.SourceBranchIDs.First())
{
SetErrorAndResetToOldForField(
cache,
oldRow,
newRow,
FAMainSpecificationItem.BranchSourceType.Name,
exception,
externalCall);
}
if (FAMainSpecificationItem.AssetSourceType != null &&
newKeyWithSourceValues.MainItem.SourceAssetIDs.First() != null &&
newKeyWithSourceValues.MainItem.SourceAssetIDs.First() != oldKeyWithSourceValues.MainItem.SourceAssetIDs.First())
{
SetErrorAndResetToOldForField(
cache,
oldRow,
newRow,
FAMainSpecificationItem.AssetSourceType.Name,
exception,
externalCall);
}
}
else
{
exception = new PXSetPropertyException(PXMessages.LocalizeFormatNoPrefix(
Messages.PeriodDoesNotExistForBook,
FormatForError(newPeriodKey.PeriodID)));
}
cache.RaiseExceptionHandling(
_FieldName,
newRow,
FormatForDisplay(newPeriodKey.PeriodID),
exception);
cache.SetValue(
newRow,
_FieldName,
cache.GetValue(oldRow, _FieldName));
if (FAMainSpecificationItem.BookSourceType != null &&
newKeyWithSourceValues.MainItem.SourceBookIDs.First() != null &&
newKeyWithSourceValues.MainItem.SourceBookIDs.First() != oldKeyWithSourceValues.MainItem.SourceBookIDs.First())
{
SetErrorAndResetToOldForField(
cache,
oldRow,
newRow,
FAMainSpecificationItem.BookSourceType.Name,
exception,
externalCall);
}
}
}
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);
}
}