private TaxPeriod GetTaxPeriodForTaxAdjustment(TaxAdjustment taxAdjustment)
{
if (taxAdjustment?.BranchID == null || taxAdjustment.VendorID == null || taxAdjustment.DocDate == null)
{
return(null);
}
TaxPeriod taxPeriod =
PXSelectJoin <TaxPeriod,
InnerJoin <GL.Branch,
On <GL.Branch.organizationID, Equal <TaxPeriod.organizationID> > >,
Where <GL.Branch.branchID, Equal <Required <GL.Branch.branchID> >,
And <TaxPeriod.vendorID, Equal <Required <TaxPeriod.vendorID> >,
And <TaxPeriod.startDate, LessEqual <Required <TaxPeriod.startDate> >,
And <TaxPeriod.endDate, Greater <Required <TaxPeriod.endDate> > > > > > >
.SelectSingleBound(this, currents : null, pars : new object[]
{
taxAdjustment.BranchID,
taxAdjustment.VendorID,
taxAdjustment.DocDate,
taxAdjustment.DocDate
});
return(taxPeriod);
}
protected virtual void TaxAdjustment_DocDate_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e)
{
CurrencyInfoAttribute.SetEffectiveDate <TaxAdjustment.docDate>(sender, e);
foreach (TaxTran taxTran in Transactions.Select())
{
SetTaxTranTranDate(taxTran);
_TaxRev = SalesTaxRev_Select.Select(taxTran.TaxID, taxTran.TaxType, taxTran.TranDate);
Transactions.Cache.SetDefaultExt <TaxTran.taxBucketID>(taxTran);
Transactions.Cache.SetDefaultExt <TaxTran.taxRate>(taxTran);
}
_TaxRev = null;
if (!(e.Row is TaxAdjustment taxAdjustment) || taxAdjustment.TaxPeriod != null || taxAdjustment.DocDate == null)
{
return;
}
TaxPeriod taxPeriod = GetTaxPeriodForTaxAdjustment(taxAdjustment);
if (taxPeriod == null)
{
return;
}
if (taxPeriod.Status == TaxPeriodStatus.Prepared)
{
sender.SetValue <TaxAdjustment.taxPeriod>(taxAdjustment, taxPeriod.TaxPeriodID);
}
}
public static void UpdateTaxHistorySums(PXGraph graph, RoundingManager rmanager, string taxPeriodId, int?revisionId, int?organizationID, int?branchID, Func <TaxReportLine, bool> ShowTaxReportLine = null)
{
if (!rmanager.IsRequireRounding)
{
return;
}
PXCache cache = graph.Caches[typeof(TaxHistory)];
using (new PXReadBranchRestrictedScope(organizationID.SingleToArray(), branchID.SingleToArrayOrNull(), requireAccessForAllSpecified: true))
{
PXResultset <TaxHistory> lines = GetTaxHistoryLines(graph, rmanager.CurrentVendor.BAccountID, taxPeriodId, revisionId);
if (lines.Count == 0)
{
return;
}
if (organizationID == null)
{
Branch branch = PXSelect <Branch, Where <Branch.branchID, Equal <Required <Branch.branchID> > > > .SelectSingleBound(graph, null, branchID);
organizationID = branch?.OrganizationID;
}
TaxPeriod period = TaxYearMaint.GetTaxPeriodByKey(graph, organizationID, rmanager.CurrentVendor.BAccountID,
taxPeriodId);
Company company = PXSelect <Company> .Select(graph);
PXResult <Currency, CurrencyRateByDate> curyWithRateSet = GetCurrencyAndRateByDate(graph, rmanager.CurrentVendor, company, period);
Currency currency = curyWithRateSet;
CurrencyRateByDate rateByDate = currency.CuryID != company.BaseCuryID ? curyWithRateSet : null;
TaxBucketsCalculation taxBucketsAggregatesCalc =
new TaxBucketsCalculation(TaxReportLineType.TaxAmount, graph, rmanager, currency, rateByDate, ShowTaxReportLine);
TaxBucketsCalculation taxableBucketsAggregatesCalc =
new TaxBucketsCalculation(TaxReportLineType.TaxableAmount, graph, rmanager, currency, rateByDate, ShowTaxReportLine);
taxBucketsAggregatesCalc.CalculateTaxBuckets(lines);
taxableBucketsAggregatesCalc.CalculateTaxBuckets(lines);
}
cache.Persist(PXDBOperation.Insert);
cache.Persisted(isAborted: false);
}
public static void UpdateTaxHistorySums(PXGraph graph, RoundingManager rmanager, string taxPeriodId, int?revisionId, int?branchID, Func <TaxReportLine, bool> ShowTaxReportLine = null)
{
if (!rmanager.IsRequireRounding)
{
return;
}
PXCache cache = graph.Caches[typeof(TaxHistory)];
using (new PXReadBranchRestrictedScope(branchID))
{
PXResultset <TaxHistory> lines = GetTaxHistoryLines(graph, rmanager.CurrentVendor.BAccountID, taxPeriodId, revisionId);
if (lines.Count == 0)
{
return;
}
Branch branch = BranchMaint.FindBranchByID(graph, branchID);
TaxPeriod period = TaxYearMaint.GetTaxPeriodByKey(graph, branch.ParentBranchID, rmanager.CurrentVendor.BAccountID,
taxPeriodId);
Company company = PXSelect <Company> .Select(graph);
PXResult <Currency, CurrencyRateByDate> curyWithRateSet = GetCurrencyAndRateByDate(graph, rmanager.CurrentVendor, company, period);
Currency currency = curyWithRateSet;
CurrencyRateByDate rateByDate = currency.CuryID != company.BaseCuryID ? curyWithRateSet : null;
TaxBucketsCalculation taxBucketsAggregatesCalc =
new TaxBucketsCalculation(TaxReportLineType.TaxAmount, graph, rmanager, currency, rateByDate, ShowTaxReportLine);
TaxBucketsCalculation taxableBucketsAggregatesCalc =
new TaxBucketsCalculation(TaxReportLineType.TaxableAmount, graph, rmanager, currency, rateByDate, ShowTaxReportLine);
taxBucketsAggregatesCalc.CalculateTaxBuckets(lines);
taxableBucketsAggregatesCalc.CalculateTaxBuckets(lines);
}
cache.Persist(PXDBOperation.Insert);
cache.Persisted(isAborted: false);
}
private static PXResult <Currency, CurrencyRateByDate> GetCurrencyAndRateByDate(PXGraph graph, Vendor curVendor, Company company, TaxPeriod period)
{
var curyWithRateSet = (PXResult <Currency, CurrencyRateByDate>)
PXSelectJoin <Currency,
LeftJoin <
CurrencyRateByDate,
On <CurrencyRateByDate.fromCuryID, Equal <Currency.curyID>,
And <CurrencyRateByDate.toCuryID, Equal <Required <Company.baseCuryID> >,
And <CurrencyRateByDate.curyRateType, Equal <Required <CurrencyRateByDate.curyRateType> >,
And <CurrencyRateByDate.curyEffDate, LessEqual <Required <CurrencyRateByDate.curyEffDate> >,
And <
Where <
CurrencyRateByDate.nextEffDate, Greater <Required <CurrencyRateByDate.curyEffDate> >,
Or <CurrencyRateByDate.nextEffDate, IsNull> > > > > > > >,
Where <Currency.curyID, Equal <Required <Currency.curyID> > > >
.SelectWindowed(graph, StartRow, TotalRows, company.BaseCuryID, curVendor.CuryRateTypeID,
period.EndDate, period.EndDate, curVendor.CuryID ?? company.BaseCuryID);
return(curyWithRateSet);
}
protected virtual void TaxAdjustment_RowSelected(PXCache cache, PXRowSelectedEventArgs e)
{
TaxAdjustment doc = e.Row as TaxAdjustment;
if (doc == null)
{
return;
}
bool isAdjustmentReleased = doc.Released == true;
cache.AllowDelete = !isAdjustmentReleased;
cache.AllowUpdate = !isAdjustmentReleased;
Transactions.Cache.SetAllEditPermissions(!isAdjustmentReleased);
PXUIFieldAttribute.SetEnabled(cache, doc, !isAdjustmentReleased);
reverseAdjustment.SetEnabled(isAdjustmentReleased);
if (isAdjustmentReleased)
{
release.SetEnabled(false);
}
else
{
PXDBCurrencyAttribute.SetBaseCalc <TaxAdjustment.curyDocBal>(cache, null, true);
PXUIFieldAttribute.SetEnabled <TaxAdjustment.status>(cache, doc, false);
PXUIFieldAttribute.SetEnabled <TaxAdjustment.curyDocBal>(cache, doc, false);
PXUIFieldAttribute.SetEnabled <TaxAdjustment.batchNbr>(cache, doc, false);
release.SetEnabled(doc.Hold == false);
ValidateDocDate(cache, doc);
}
PXUIFieldAttribute.SetEnabled <TaxAdjustment.docType>(cache, doc);
PXUIFieldAttribute.SetEnabled <TaxAdjustment.refNbr>(cache, doc);
PXUIFieldAttribute.SetEnabled <TaxAdjustment.curyID>(cache, doc, false);
PXUIFieldAttribute.SetVisible <TaxAdjustment.curyID>(cache, doc, PXAccess.FeatureInstalled <FeaturesSet.multicurrency>());
editVendor.SetEnabled(vendor.Current != null);
bool tranExist = (TaxTran)this.Transactions.SelectWindowed(0, 1) != null;
PXUIFieldAttribute.SetEnabled <TaxAdjustment.vendorID>(cache, doc, !tranExist);
cache.RaiseExceptionHandling <TaxAdjustment.docDate>(doc, doc.DocDate, null);
if (doc?.BranchID == null || doc.VendorID == null || doc.DocDate == null)
{
return;
}
TaxPeriod taxPeriod = GetTaxPeriodForTaxAdjustment(doc);
if (taxPeriod == null)
{
cache.RaiseExceptionHandling <TaxAdjustment.docDate>(doc, doc.DocDate,
new PXSetPropertyException(Messages.DateBelongsToNonExistingPeriod, PXErrorLevel.Warning));
}
else if (taxPeriod.Status == TaxPeriodStatus.Closed)
{
cache.RaiseExceptionHandling <TaxAdjustment.docDate>(doc, doc.DocDate,
new PXSetPropertyException(Messages.DateBelongsToClosedPeriod, PXErrorLevel.Warning));
}
}
protected virtual void baseTaxPeriodFilterRowUpdated(PXCache sender, PXRowUpdatedEventArgs e)
{
VATPeriodFilter filter = (VATPeriodFilter)e.Row;
if (filter == null)
{
return;
}
if (!sender.ObjectsEqual <VATPeriodFilter.organizationID, VATPeriodFilter.branchID>(e.Row, e.OldRow))
{
List <PXView> views = this.Views.Select(view => view.Value).ToList();
foreach (var view in views)
{
view.Clear();
}
}
if (!sender.ObjectsEqual <VATPeriodFilter.organizationID>(e.Row, e.OldRow) ||
!sender.ObjectsEqual <VATPeriodFilter.branchID>(e.Row, e.OldRow) ||
!sender.ObjectsEqual <VATPeriodFilter.vendorID>(e.Row, e.OldRow))
{
if (filter.OrganizationID != null && filter.VendorID != null)
{
PX.Objects.TX.TaxPeriod taxper = TaxYearMaint.FindPreparedPeriod(this, filter.OrganizationID, filter.VendorID);
if (taxper != null)
{
filter.TaxPeriodID = taxper.TaxPeriodID;
}
else
{
taxper = TaxYearMaint.FindLastClosedPeriod(this, filter.OrganizationID, filter.VendorID);
filter.TaxPeriodID = taxper != null ? taxper.TaxPeriodID : null;
}
}
else
{
filter.TaxPeriodID = null;
}
}
Organization organization = OrganizationMaint.FindOrganizationByID(this, filter.OrganizationID);
if (!sender.ObjectsEqual <VATPeriodFilter.organizationID>(e.Row, e.OldRow) ||
!sender.ObjectsEqual <VATPeriodFilter.branchID>(e.Row, e.OldRow) ||
!sender.ObjectsEqual <VATPeriodFilter.vendorID>(e.Row, e.OldRow) ||
!sender.ObjectsEqual <VATPeriodFilter.taxPeriodID>(e.Row, e.OldRow) ||
filter.RevisionId == null)
{
if (filter.OrganizationID != null &&
(filter.BranchID != null && organization.FileTaxesByBranches == true || organization.FileTaxesByBranches != true) &&
filter.VendorID != null && filter.TaxPeriodID != null)
{
filter.RevisionId = ReportTaxProcess.CurrentRevisionId(this, filter.OrganizationID, filter.BranchID, filter.VendorID, filter.TaxPeriodID);
}
else
{
filter.RevisionId = null;
}
}
}
