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);
}
public virtual void GLAllocation_StartFinPeriodID_FieldDefaulting(PXCache cache, PXFieldDefaultingEventArgs e)
{
FinPeriod finPeriod = FinPeriodRepository.FindFinPeriodByDate(Accessinfo.BusinessDate, FinPeriod.organizationID.MasterValue);
if (finPeriod != null)
{
e.NewValue = FinPeriodIDFormattingAttribute.FormatForDisplay(finPeriod.FinPeriodID);
}
}
public virtual void GLAllocation_StartFinPeriodID_FieldDefaulting(PXCache cache, PXFieldDefaultingEventArgs e)
{
PXSelectBase selectdate = new PXSelect <FinPeriod, Where <FinPeriod.startDate, LessEqual <Required <FinPeriod.startDate> >, And <FinPeriod.endDate, Greater <Required <FinPeriod.endDate> > > > >(this);
FinPeriod res = selectdate.View.SelectSingle(Accessinfo.BusinessDate, Accessinfo.BusinessDate) as FinPeriod;
if (res != null)
{
e.NewValue = FinPeriodIDFormattingAttribute.FormatForDisplay(res.FinPeriodID);
}
}
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);
}
public override void FieldDefaulting(PXCache sender, PXFieldDefaultingEventArgs e)
{
base.FieldDefaulting(sender, e);
FABookPeriod period = PXSelectJoin <FABookPeriod, LeftJoin <FABook, On <FABookPeriod.bookID, Equal <FABook.bookID> > >,
Where <FABookPeriod.startDate, LessEqual <Current <AccessInfo.businessDate> >, And <FABookPeriod.endDate, Greater <Current <AccessInfo.businessDate> >, And <FABook.updateGL, Equal <boolTrue> > > > > .SelectSingleBound(sender.Graph, new object[0]);
if (period != null)
{
e.NewValue = FinPeriodIDFormattingAttribute.FormatForDisplay(period.FinPeriodID);
}
}
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 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);
}
}
public virtual void GLAllocation_EndFinPeriodID_FieldDefaulting(PXCache cache, PXFieldDefaultingEventArgs e)
{
FinPeriod finPeriod = FinPeriodRepository.FindFinPeriodByDate(Accessinfo.BusinessDate, FinPeriod.organizationID.MasterValue);
if (finPeriod != null)
{
FinPeriod lastPeriodOfYear = FinPeriodRepository.FindLastYearNotAdjustmentPeriod(finPeriod.FinYear, FinPeriod.organizationID.MasterValue);
if (lastPeriodOfYear != null)
{
e.NewValue = FinPeriodIDFormattingAttribute.FormatForDisplay(lastPeriodOfYear.FinPeriodID);
}
}
}
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 ShowOpenShipments(IEnumerable <FinPeriod> periods)
{
ParallelQuery <string> periodIDs = periods.Select(fp => fp.FinPeriodID).AsParallel();
Dictionary <string, string> parameters = new Dictionary <string, string>();
parameters["FromPeriodID"] = FinPeriodIDFormattingAttribute.FormatForDisplay(periodIDs.Min());
parameters["ToPeriodID"] = FinPeriodIDFormattingAttribute.FormatForDisplay(periodIDs.Max());
Organization org = OrganizationMaint.FindOrganizationByID(this, Filter.Current.OrganizationID);
parameters["OrgID"] = org?.OrganizationCD;
throw new PXReportRequiredException(parameters, "IN656500", PXBaseRedirectException.WindowMode.NewWindow, "Documents Not Posted to Inventory");
}
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_FieldUpdating(PXCache sender, PXFieldUpdatingEventArgs e)
{
try
{
if (e.Row != null && IsDefaulting)
{
object newValue = FinPeriodIDFormattingAttribute.FormatForStoring((string)e.NewValue);
sender.RaiseFieldVerifying <FATran.finPeriodID>(e.Row, ref newValue);
}
}
finally
{
IsDefaulting = false;
}
}
/// <summary>
/// Retrieves the first financial period of the year corresponding
/// to the financial period specified.
/// If no such period exists, returns <c>null</c>.
/// </summary>
public string GetFirstPeriodOfYear(string financialPeriodID)
{
if (financialPeriodID == null)
{
return(null);
}
PXGraph graph = PXGraph.CreateInstance <FiscalPeriodMaint>();
string firstPeriodOfYear = FinPeriodIDAttribute.GetFirstFinPeriodIDOfYear(financialPeriodID);
if (!FinPeriodIDAttribute.PeriodExists(graph, financialPeriodID))
{
return(null);
}
return(FinPeriodIDFormattingAttribute.FormatForDisplay(firstPeriodOfYear));
}
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;
}
}
/// <summary>
/// Retrieves the first financial period of the year corresponding
/// to the financial period specified.
/// If no such period exists, returns <c>null</c>.
/// </summary>
public string GetFirstPeriodOfYear(string financialPeriodID)
{
if (financialPeriodID == null)
{
return(null);
}
PXGraph graph = PXGraph.CreateInstance <MasterFinPeriodMaint>();
string firstPeriodOfYear = FinPeriodUtils.GetFirstFinPeriodIDOfYear(financialPeriodID);
IFinPeriodRepository finPeriodRepository = graph.GetService <IFinPeriodRepository>();
if (!finPeriodRepository.PeriodExists(financialPeriodID, FinPeriod.organizationID.MasterValue))
{
return(null);
}
return(FinPeriodIDFormattingAttribute.FormatForDisplay(firstPeriodOfYear));
}
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);
}
}
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);
}
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);
}
/// <summary>
/// Retrieves the financial period with the same <see cref="MasterFinPeriod.PeriodNbr"/>
/// as the one specified, but residing in the previous financial year.
/// If no such period exists, returns <c>null</c>.
/// </summary>
public string GetSamePeriodInPreviousYear(string financialPeriodID)
{
if (financialPeriodID == null)
{
return(null);
}
PXGraph graph = PXGraph.CreateInstance <MasterFinPeriodMaint>();
try
{
IFinPeriodRepository finPeriodRepository = graph.GetService <IFinPeriodRepository>();
string resultingPeriodID = finPeriodRepository.GetSamePeriodInPreviousYear(financialPeriodID, FinPeriod.organizationID.MasterValue);
return(FinPeriodIDFormattingAttribute.FormatForDisplay(resultingPeriodID));
}
catch (PXFinPeriodException)
{
return(null);
}
}
/// <summary>
/// Retrieves the financial period with the same <see cref="FinPeriod.PeriodNbr"/>
/// as the one specified, but residing in the previous financial year.
/// If no such period exists, returns <c>null</c>.
/// </summary>
public string GetSamePeriodInPreviousYear(string financialPeriodID)
{
if (financialPeriodID == null)
{
return(null);
}
PXGraph graph = PXGraph.CreateInstance <FiscalPeriodMaint>();
try
{
string resultingPeriodID = FinPeriodIDAttribute.GetSamePeriodInPreviousYear(
graph,
financialPeriodID);
return(FinPeriodIDFormattingAttribute.FormatForDisplay(resultingPeriodID));
}
catch (PXFinPeriodException)
{
return(null);
}
}
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;
}
// 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);
}
public static string UnFormatPeriod(string period)
{
return(FinPeriodIDFormattingAttribute.FormatForStoring(period));
}
public static string FormatPeriod(string period)
{
return(FinPeriodIDFormattingAttribute.FormatForDisplay(period));
}
public static string FormatForError(string period)
{
return(FinPeriodIDFormattingAttribute.FormatForError(period));
}
protected virtual void DoTransfer(TransferFilter filter, List <FixedAsset> list)
{
DocumentList <FARegister> created = new DocumentList <FARegister>(this);
foreach (FixedAsset asset in list)
{
FADetails det = PXSelect <FADetails, Where <FADetails.assetID, Equal <Current <FixedAsset.assetID> > > > .SelectSingleBound(this, new object[] { asset });
FALocationHistory location = PXSelect <FALocationHistory, Where <FALocationHistory.assetID, Equal <Current <FADetails.assetID> >, And <FALocationHistory.revisionID, Equal <Current <FADetails.locationRevID> > > > > .SelectSingleBound(this, new object[] { det });
int? destClassID = filter.ClassTo ?? asset.ClassID;
int? destBranchID = filter.BranchTo ?? location.LocationID;
string destDeptID = string.IsNullOrEmpty(filter.DepartmentTo) ? location.Department : filter.DepartmentTo;
if (location.LocationID != destBranchID || location.Department != destDeptID || asset.ClassID != destClassID)
{
FADetails copy_det = (FADetails)Details.Cache.CreateCopy(det);
FALocationHistory copy_loc = (FALocationHistory)Lochist.Cache.CreateCopy(location);
copy_loc.RevisionID = ++copy_det.LocationRevID;
copy_loc.LocationID = destBranchID;
copy_loc.Department = destDeptID;
copy_loc.PeriodID = filter.PeriodID;
copy_loc.TransactionDate = filter.TransferDate;
copy_loc.Reason = filter.Reason;
TransactionEntry.SegregateRegister(this, (int)destBranchID, FARegister.origin.Transfer, null, filter.TransferDate, "", created);
Details.Update(copy_det);
location = Lochist.Insert(copy_loc);
if (asset.ClassID != destClassID)
{
asset.ClassID = destClassID;
AssetSelect.Cache.Update(asset);
}
FARegister reg = Register.Current;
AssetProcess.TransferAsset(this, asset, location, ref reg);
}
}
if (Register.Current != null && created.Find(Register.Current) == null)
{
created.Add(Register.Current);
}
Actions.PressSave();
if (fasetup.Current.AutoReleaseTransfer == true)
{
SelectTimeStamp();
PXLongOperation.StartOperation(this, delegate { AssetTranRelease.ReleaseDoc(created, false); });
}
else if (created.Count > 0)
{
AssetTranRelease graph = CreateInstance <AssetTranRelease>();
AssetTranRelease.ReleaseFilter fltr = (AssetTranRelease.ReleaseFilter)graph.Filter.Cache.CreateCopy(graph.Filter.Current);
fltr.Origin = FARegister.origin.Transfer;
graph.Filter.Update(fltr);
graph.SelectTimeStamp();
Dictionary <string, string> parameters = new Dictionary <string, string>();
for (int i = 0; i < created.Count; ++i)
{
FARegister reg = created[i];
reg.Selected = true;
graph.FADocumentList.Update(reg);
graph.FADocumentList.Cache.SetStatus(reg, PXEntryStatus.Updated);
graph.FADocumentList.Cache.IsDirty = false;
parameters["FARegister.RefNbr" + i] = reg.RefNbr;
}
parameters["PeriodFrom"] = FinPeriodIDFormattingAttribute.FormatForDisplay(filter.PeriodID);
parameters["PeriodTo"] = FinPeriodIDFormattingAttribute.FormatForDisplay(filter.PeriodID);
parameters["Mode"] = "U";
PXReportRequiredException reportex = new PXReportRequiredException(parameters, "FA642000", "Preview");
throw new PXRedirectWithReportException(graph, reportex, "Release FA Transaction");
}
}
