public bool IsValidEntity(Appointment entity, ProcessingResult processResult)
{
if (entity.HostId == Guid.Empty)
{
processResult.AddErrorMessage("Appointment Validation Error: host id is invalid");
return(false);
}
if (entity.StartTime < _dateTimeProvider.UtcNow)
{
processResult.AddErrorMessage("Appointment Validation Error: start time is past date");
return(false);
}
if (entity.StartTime >= entity.EndTime)
{
processResult.AddErrorMessage("Appointment Validation Error: start time later than end time");
return(false);
}
if (entity.Contact == null)
{
processResult.AddErrorMessage("Appointment Validation Error: contact is null");
return(false);
}
return(true);
}
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 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 ProcessingResult ValidateTaxYearStructure(TaxPeriod taxPeriod)
{
var finPeriodWithSameStartDate = _gafRepository.FindFinPeriodWithStartDate(taxPeriod.StartDate);
var finPeriodWithSameEndDate = _gafRepository.FindFinPeriodWithEndDate(taxPeriod.EndDate);
if (finPeriodWithSameStartDate == null || finPeriodWithSameEndDate == null)
{
var result = new ProcessingResult();
result.AddErrorMessage(Messages.TheGAFFileCannotBePrepared);
return(result);
}
return(ProcessingResult.Success);
}
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;
}
