540 lines
20 KiB
C#
540 lines
20 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using Swarmops.Basic.Types.Common;
|
|
using Swarmops.Basic.Types.Financial;
|
|
using Swarmops.Common.Enums;
|
|
using Swarmops.Common.Interfaces;
|
|
using Swarmops.Database;
|
|
using Swarmops.Logic.Structure;
|
|
|
|
namespace Swarmops.Logic.Financial
|
|
{
|
|
public class VatReport: BasicVatReport
|
|
{
|
|
#region Creation and Construction
|
|
|
|
private VatReport(BasicVatReport basic): base (basic)
|
|
{
|
|
// private ctor prevents random instantiation
|
|
}
|
|
|
|
public static VatReport FromBasic(BasicVatReport basic)
|
|
{
|
|
// Interface to private ctor
|
|
return new VatReport(basic);
|
|
}
|
|
|
|
public static VatReport FromIdentity(int vatReportId)
|
|
{
|
|
return FromBasic(SwarmDb.GetDatabaseForReading().GetVatReport(vatReportId));
|
|
}
|
|
|
|
protected static VatReport FromIdentityAggressive(int vatReportId)
|
|
{
|
|
// "Open For Writing" is intentional - it bypasses the lag of replication-to-readonly
|
|
// instances of large-deployment databases and reads at the write source
|
|
|
|
return FromBasic(SwarmDb.GetDatabaseForWriting().GetVatReport(vatReportId));
|
|
}
|
|
|
|
public static VatReport FromGuid(string guid)
|
|
{
|
|
int vatReportId = SwarmDb.GetDatabaseForReading().GetVatReportIdFromGuid(guid);
|
|
|
|
if (vatReportId == 0)
|
|
{
|
|
throw new ArgumentException("No such report");
|
|
}
|
|
|
|
return FromIdentity(vatReportId);
|
|
}
|
|
|
|
private static VatReport CreateDbRecord (Organization organization, int year, int startMonth, int monthCount)
|
|
{
|
|
System.Guid guid = System.Guid.NewGuid();
|
|
|
|
int vatReportId = SwarmDb.GetDatabaseForWriting()
|
|
.CreateVatReport(organization.Identity, guid.ToString(), year*100 + startMonth, monthCount);
|
|
return FromIdentityAggressive(vatReportId);
|
|
}
|
|
|
|
public static void CreateNext(Organization organization)
|
|
{
|
|
// Creates all VAT reports that are required up until today.
|
|
// Normally this is just one, but in the case of a missed report slot, this function will
|
|
// catch up with all the missed ones, too.
|
|
|
|
DateTime nowUtc = DateTime.UtcNow;
|
|
DateTime nextReportDue = NextReportDue(organization);
|
|
int reportMonthInterval = organization.VatReportFrequencyMonths;
|
|
|
|
if (nextReportDue > nowUtc)
|
|
{
|
|
throw new InvalidOperationException("VAT report is not yet due or has already been generated");
|
|
}
|
|
|
|
DateTime thisReportDate = new DateTime(organization.FirstFiscalYear, 1, 1); // default to first report
|
|
VatReports reports = VatReports.ForOrganization(organization, true);
|
|
|
|
if (reports.Count > 0)
|
|
{
|
|
reports.Sort(VatReports.VatReportSorterByDate);
|
|
|
|
VatReport lastReport = reports.Last();
|
|
DateTime lastReportDate = new DateTime(lastReport.YearMonthStart / 100, reports.Last().YearMonthStart % 100,
|
|
1);
|
|
|
|
thisReportDate = lastReportDate.AddMonths(lastReport.MonthCount);
|
|
}
|
|
|
|
while (thisReportDate.AddMonths(reportMonthInterval) < nowUtc)
|
|
{
|
|
VatReport.Create(organization, thisReportDate.Year, thisReportDate.Month, reportMonthInterval);
|
|
thisReportDate = thisReportDate.AddMonths(reportMonthInterval);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public static ReportRequirement IsRequired(Organization organization)
|
|
{
|
|
// If org isn't VAT enabled, the report is never required
|
|
|
|
if (!organization.VatEnabled)
|
|
{
|
|
return ReportRequirement.NotRequired;
|
|
}
|
|
|
|
DateTime nowUtc = DateTime.UtcNow;
|
|
int reportMonthInterval = organization.VatReportFrequencyMonths;
|
|
|
|
// Check when next report is due
|
|
|
|
DateTime nextReportDue = NextReportDue(organization);
|
|
|
|
// if the next report is due (reportMonthInterval) months from now,
|
|
// then the report for this month has already been completed
|
|
|
|
DateTime lastReportDate = nextReportDue.AddMonths(-reportMonthInterval);
|
|
if (lastReportDate.Year == nowUtc.Year && lastReportDate.Month == nowUtc.Month)
|
|
{
|
|
// Already completed
|
|
return ReportRequirement.Completed;
|
|
}
|
|
|
|
// If the next report is due this month, it's required
|
|
|
|
if (nextReportDue.Year == nowUtc.Year && nextReportDue.Month == nowUtc.Month)
|
|
{
|
|
return ReportRequirement.Required;
|
|
}
|
|
|
|
// If the next report was due earlier this year, it's definitely required
|
|
|
|
if (nextReportDue.Year == nowUtc.Year && nextReportDue.Month < nowUtc.Month)
|
|
{
|
|
return ReportRequirement.Required; // if there was a "VeryRequired" option it would be appropriate here
|
|
}
|
|
|
|
// If the next report was due last year, it's even more required
|
|
|
|
if (nextReportDue.Year < nowUtc.Year)
|
|
{
|
|
return ReportRequirement.Required;
|
|
}
|
|
|
|
// Otherwise not required
|
|
|
|
return ReportRequirement.NotRequired;
|
|
|
|
}
|
|
|
|
|
|
public static DateTime NextReportDue(Organization organization)
|
|
{
|
|
int reportMonthInterval = organization.VatReportFrequencyMonths;
|
|
|
|
// Get the list of previous VAT reports
|
|
|
|
VatReports reports = VatReports.ForOrganization(organization, true);
|
|
|
|
if (reports.Count == 0)
|
|
{
|
|
DateTime firstReportGenerationTime =
|
|
new DateTime(organization.FirstFiscalYear, 1, 1).AddMonths(reportMonthInterval);
|
|
// construct VAT report on the first day of the new month
|
|
|
|
return firstReportGenerationTime;
|
|
}
|
|
else // if reports.Count > 0
|
|
{
|
|
reports.Sort(VatReports.VatReportSorterByDate);
|
|
|
|
VatReport lastReport = reports.Last();
|
|
DateTime lastReportDate = new DateTime(lastReport.YearMonthStart/100, reports.Last().YearMonthStart%100,
|
|
1);
|
|
|
|
DateTime nextReportDate = lastReportDate.AddMonths(lastReport.MonthCount);
|
|
DateTime nextReportGenerationTime = nextReportDate.AddMonths(reportMonthInterval);
|
|
|
|
return nextReportGenerationTime;
|
|
}
|
|
}
|
|
|
|
|
|
public static VatReport Create(Organization organization, int year, int startMonth, int monthCount)
|
|
{
|
|
VatReport newReport = CreateDbRecord(organization, year, startMonth, monthCount);
|
|
DateTime endDate = new DateTime(year, startMonth, 1).AddMonths(monthCount);
|
|
|
|
FinancialAccount vatInbound = organization.FinancialAccounts.AssetsVatInboundUnreported;
|
|
FinancialAccount vatOutbound = organization.FinancialAccounts.DebtsVatOutboundUnreported;
|
|
FinancialAccount sales = organization.FinancialAccounts.IncomeSales;
|
|
FinancialAccounts salesTree = sales.ThisAndBelow();
|
|
|
|
FinancialAccountRows inboundRows = RowsNotInVatReport(vatInbound, endDate);
|
|
FinancialAccountRows outboundRows = RowsNotInVatReport(vatOutbound, endDate);
|
|
FinancialAccountRows turnoverRows = RowsNotInVatReport(salesTree, endDate);
|
|
|
|
Dictionary<int, bool> transactionsIncludedLookup = new Dictionary<int, bool>();
|
|
|
|
newReport.AddVatReportItemsFromAccountRows(inboundRows, transactionsIncludedLookup);
|
|
newReport.AddVatReportItemsFromAccountRows(outboundRows, transactionsIncludedLookup);
|
|
newReport.AddVatReportItemsFromAccountRows(turnoverRows, transactionsIncludedLookup);
|
|
|
|
newReport.Release();
|
|
|
|
// Create financial TX that moves this VAT from unreported to reported
|
|
|
|
Int64 differenceCents = newReport.VatInboundCents - newReport.VatOutboundCents;
|
|
|
|
if (differenceCents != 0 && newReport.VatInboundCents > 0)
|
|
{
|
|
// if there's anything to report
|
|
|
|
FinancialTransaction vatReportTransaction = FinancialTransaction.Create(organization, endDate.AddDays(4).AddHours(9),
|
|
newReport.Description);
|
|
|
|
if (newReport.VatInboundCents > 0)
|
|
{
|
|
vatReportTransaction.AddRow(organization.FinancialAccounts.AssetsVatInboundUnreported,
|
|
-newReport.VatInboundCents, null);
|
|
}
|
|
if (newReport.VatOutboundCents > 0)
|
|
{
|
|
vatReportTransaction.AddRow(organization.FinancialAccounts.DebtsVatOutboundUnreported,
|
|
newReport.VatOutboundCents, null);
|
|
// not negative, because our number is sign-different from the bookkeeping's
|
|
}
|
|
|
|
if (differenceCents < 0) // outbound > inbound
|
|
{
|
|
vatReportTransaction.AddRow(organization.FinancialAccounts.DebtsVatOutboundReported,
|
|
differenceCents, null); // debt, so negative as in our variable
|
|
}
|
|
else // inbound > outbound
|
|
{
|
|
vatReportTransaction.AddRow(organization.FinancialAccounts.AssetsVatInboundReported,
|
|
differenceCents, null); // asset, so positive as in our variable
|
|
}
|
|
|
|
vatReportTransaction.Dependency = newReport;
|
|
newReport.OpenTransaction = vatReportTransaction;
|
|
}
|
|
else
|
|
{
|
|
newReport.Open = false; // nothing to close, no tx created
|
|
}
|
|
|
|
return newReport;
|
|
}
|
|
|
|
private void AddVatReportItemsFromAccountRows(FinancialAccountRows rows,
|
|
Dictionary<int, bool> transactionsIncludedLookup)
|
|
{
|
|
if (rows.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Organization organization = rows[0].Transaction.Organization; // there is always a rows[0] because check above
|
|
int vatInboundAccountId = organization.FinancialAccounts.AssetsVatInboundUnreported.Identity;
|
|
int vatOutboundAccountId = organization.FinancialAccounts.DebtsVatOutboundUnreported.Identity;
|
|
|
|
Dictionary<int, bool> turnoverAccountLookup = new Dictionary<int, bool>();
|
|
|
|
FinancialAccounts turnoverAccounts = FinancialAccounts.ForOrganization(organization,
|
|
FinancialAccountType.Income);
|
|
|
|
foreach (FinancialAccount turnoverAccount in turnoverAccounts)
|
|
{
|
|
turnoverAccountLookup[turnoverAccount.Identity] = true;
|
|
}
|
|
|
|
foreach (FinancialAccountRow accountRow in rows)
|
|
{
|
|
FinancialTransaction tx = accountRow.Transaction;
|
|
|
|
if (tx.Dependency is VatReport)
|
|
{
|
|
continue; // Never include previous VAT reports in new VAT reports
|
|
}
|
|
|
|
if (!transactionsIncludedLookup.ContainsKey(tx.Identity))
|
|
{
|
|
Int64 vatInbound = 0;
|
|
Int64 vatOutbound = 0;
|
|
Int64 turnOver = 0;
|
|
|
|
transactionsIncludedLookup[accountRow.FinancialTransactionId] = true;
|
|
|
|
FinancialTransactionRows txRows = accountRow.Transaction.Rows;
|
|
|
|
foreach (FinancialTransactionRow txRow in txRows)
|
|
{
|
|
if (txRow.FinancialAccountId == vatInboundAccountId)
|
|
{
|
|
vatInbound += txRow.AmountCents;
|
|
}
|
|
else if (txRow.FinancialAccountId == vatOutboundAccountId)
|
|
{
|
|
vatOutbound += -txRow.AmountCents; // this is a negative, so converting to positive
|
|
}
|
|
else if (turnoverAccountLookup.ContainsKey(txRow.FinancialAccountId))
|
|
{
|
|
turnOver -= txRow.AmountCents; // turnover accounts are sign reversed, so convert to positive
|
|
}
|
|
}
|
|
|
|
// Add new row to the VAT report
|
|
|
|
AddItem(tx, turnOver, vatInbound, vatOutbound);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
public void AddItem(FinancialTransaction transaction, Int64 turnoverCents,
|
|
Int64 vatInboundCents, Int64 vatOutboundCents)
|
|
{
|
|
if (!UnderConstruction)
|
|
{
|
|
throw new InvalidOperationException("Cannot add items once the report is released");
|
|
}
|
|
|
|
VatReportItem.Create(this, transaction, turnoverCents, vatInboundCents, vatOutboundCents);
|
|
}
|
|
|
|
public void Release()
|
|
{
|
|
// if we're not under construction, throw exception
|
|
|
|
if (!this.UnderConstruction)
|
|
{
|
|
throw new InvalidOperationException("VAT report is already released");
|
|
}
|
|
|
|
// Releasing calculates sums of turnover, VAT inbound, outbound across items into report record
|
|
|
|
SwarmDb.GetDatabaseForWriting().SetVatReportReleased(this.Identity);
|
|
|
|
base.UnderConstruction = false;
|
|
base.TurnoverCents = Items.TurnoverCents;
|
|
base.VatInboundCents = Items.VatInboundCents;
|
|
base.VatOutboundCents = Items.VatOutboundCents;
|
|
}
|
|
|
|
public VatReportItems Items
|
|
{
|
|
get { return VatReportItems.ForReport(this); }
|
|
}
|
|
|
|
|
|
private static FinancialAccountRows RowsNotInVatReport(FinancialAccounts accounts, DateTime endTime)
|
|
{
|
|
FinancialAccountRows result = new FinancialAccountRows();
|
|
|
|
result.AddRange(accounts.SelectMany(account => RowsNotInVatReport(account, endTime)));
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
private static FinancialAccountRows RowsNotInVatReport(FinancialAccount account, DateTime endDateTime)
|
|
{
|
|
Organization organization = account.Organization;
|
|
SwarmDb dbRead = SwarmDb.GetDatabaseForReading();
|
|
|
|
FinancialAccountRows rowsIntermediate =
|
|
FinancialAccountRows.FromArray(
|
|
SwarmDb.GetDatabaseForReading().GetAccountRowsNotInVatReport(account.Identity, endDateTime));
|
|
|
|
FinancialAccountRows rowsFinal = new FinancialAccountRows();
|
|
foreach (FinancialAccountRow row in rowsIntermediate)
|
|
{
|
|
// Check if this row _closes_ an _existing_ VAT report, in which case it should _not_ be included
|
|
|
|
int vatReportOpenId = dbRead.GetVatReportIdFromCloseTransaction(row.FinancialTransactionId);
|
|
int vatReportCloseId = dbRead.GetVatReportIdFromOpenTransaction(row.FinancialTransactionId);
|
|
if (vatReportOpenId == 0 && vatReportCloseId == 0)
|
|
{
|
|
// This particular transaction doesn't close an existing VAT report
|
|
rowsFinal.Add(row);
|
|
}
|
|
}
|
|
|
|
return rowsFinal;
|
|
}
|
|
|
|
public string Description
|
|
{
|
|
get
|
|
{
|
|
switch (MonthCount)
|
|
{
|
|
case 1:
|
|
return String.Format(Resources.Logic_Financial_VatReport.Description_SingleMonth,
|
|
new DateTime(YearMonthStart/100, YearMonthStart%100, 2));
|
|
case 12:
|
|
return String.Format(Resources.Logic_Financial_VatReport.Description_FullYear,
|
|
YearMonthStart/100);
|
|
default:
|
|
DateTime start = new DateTime(YearMonthStart/100, YearMonthStart%100, 2);
|
|
|
|
return String.Format(Resources.Logic_Financial_VatReport.Description_Months,
|
|
start, start.AddMonths(MonthCount - 1));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public static string NextReportDescription(Organization organization)
|
|
{
|
|
DateTime nextReportDue = NextReportDue(organization);
|
|
int monthInterval = organization.VatReportFrequencyMonths;
|
|
DateTime nextReportConcerns = nextReportDue.AddMonths(-monthInterval);
|
|
|
|
switch (monthInterval)
|
|
{
|
|
case 1:
|
|
return String.Format(Resources.Logic_Financial_VatReport.Description_SingleMonth,
|
|
new DateTime(nextReportConcerns.Year, nextReportConcerns.Month, 2)); // the 2 is to prevent timezone errors
|
|
|
|
case 12:
|
|
return String.Format(Resources.Logic_Financial_VatReport.Description_FullYear,
|
|
nextReportConcerns.Year);
|
|
|
|
default:
|
|
return String.Format(Resources.Logic_Financial_VatReport.Description_Months,
|
|
nextReportConcerns, nextReportConcerns.AddMonths(monthInterval - 1));
|
|
|
|
}
|
|
}
|
|
|
|
public static string LastReportDescription(Organization organization)
|
|
{
|
|
VatReports reports = VatReports.ForOrganization(organization, true);
|
|
if (reports.Count == 0)
|
|
{
|
|
throw new InvalidOperationException("Cannot look up last description of nonexistent VAT report collection");
|
|
}
|
|
|
|
reports.Sort(VatReports.VatReportSorterByDate);
|
|
return reports.Last().Description;
|
|
}
|
|
|
|
|
|
public string DescriptionShort
|
|
{
|
|
get
|
|
{
|
|
switch (MonthCount)
|
|
{
|
|
case 1:
|
|
return String.Format("{0:MMM yyyy}",
|
|
new DateTime(YearMonthStart / 100, YearMonthStart % 100, 2));
|
|
case 12:
|
|
return String.Format("{0}",
|
|
YearMonthStart / 100);
|
|
default:
|
|
DateTime start = new DateTime(YearMonthStart / 100, YearMonthStart % 100, 2);
|
|
|
|
return String.Format("{0:MMM}-{1:MMM yyyy}",
|
|
start, start.AddMonths(MonthCount - 1));
|
|
}
|
|
}
|
|
}
|
|
|
|
private new int OpenTransactionId
|
|
{
|
|
get
|
|
{
|
|
return base.OpenTransactionId;
|
|
}
|
|
set
|
|
{
|
|
SwarmDb.GetDatabaseForWriting().SetVatReportOpenTransaction(this.Identity, value);
|
|
base.OpenTransactionId = value;
|
|
}
|
|
}
|
|
|
|
public FinancialTransaction OpenTransaction
|
|
{
|
|
get
|
|
{
|
|
if (base.OpenTransactionId == 0) return null;
|
|
return FinancialTransaction.FromIdentity(OpenTransactionId);
|
|
}
|
|
set { this.OpenTransactionId = value.Identity; }
|
|
}
|
|
|
|
private new int CloseTransactionId
|
|
{
|
|
get { return base.CloseTransactionId; }
|
|
set
|
|
{
|
|
SwarmDb.GetDatabaseForWriting().SetVatReportCloseTransaction(this.Identity, value);
|
|
base.CloseTransactionId = value;
|
|
}
|
|
}
|
|
|
|
public FinancialTransaction CloseTransaction
|
|
{
|
|
get
|
|
{
|
|
if (base.CloseTransactionId == 0) return null;
|
|
return FinancialTransaction.FromIdentity(CloseTransactionId);
|
|
}
|
|
set
|
|
{
|
|
if (value != null)
|
|
{
|
|
this.CloseTransactionId = value.Identity;
|
|
value.Dependency = this;
|
|
this.Open = false;
|
|
}
|
|
else
|
|
{
|
|
throw new ArgumentNullException(); // is this a valid case?
|
|
}
|
|
}
|
|
}
|
|
|
|
public new bool Open
|
|
{
|
|
get { return base.Open; }
|
|
set
|
|
{
|
|
SwarmDb.GetDatabaseForWriting().SetVatReportOpen(this.Identity, value);
|
|
base.Open = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|