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"); } }