452 lines
18 KiB
C#
452 lines
18 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using Swarmops.Basic.Types;
|
|
using Swarmops.Database;
|
|
using Swarmops.Logic.Structure;
|
|
using Swarmops.Logic.Support;
|
|
using Swarmops.Logic.Swarm;
|
|
|
|
namespace Swarmops.Logic.Financial
|
|
{
|
|
public class Payouts: PluralBase<Payouts,Payout,BasicPayout>
|
|
{
|
|
public static Payouts ForOrganization (Organization organization)
|
|
{
|
|
return ForOrganization(organization, false);
|
|
}
|
|
|
|
public static Payouts ForOrganization (Organization organization, bool includeClosed)
|
|
{
|
|
if (includeClosed)
|
|
{
|
|
return FromArray(SwarmDb.GetDatabaseForReading().GetPayouts(organization));
|
|
}
|
|
else
|
|
{
|
|
return FromArray(SwarmDb.GetDatabaseForReading().GetPayouts(organization, DatabaseCondition.OpenTrue));
|
|
}
|
|
}
|
|
|
|
public static Payouts Construct (Organization organization)
|
|
{
|
|
// Construct a list of not-yet-created payouts. Basically, these are the things that
|
|
// Economy hasn't yet filed with the bank.
|
|
|
|
Payouts result = new Payouts();
|
|
|
|
AddUnpaidExpenseClaims(result, organization);
|
|
AddUnpaidInboundInvoices(result, organization);
|
|
AddUnpaidSalaries(result, organization);
|
|
AddUnpaidCashAdvances(result, organization);
|
|
|
|
return result;
|
|
}
|
|
|
|
private static void AddUnpaidExpenseClaims(Payouts payoutList, Organization organization)
|
|
{
|
|
ExpenseClaims claims = ExpenseClaims.FromOrganization(organization);
|
|
|
|
Dictionary<int, Payout> payoutLookup = new Dictionary<int, Payout>();
|
|
|
|
foreach (ExpenseClaim claim in claims)
|
|
{
|
|
// If ready for payout, add to list.
|
|
|
|
if (claim.Open)
|
|
{
|
|
if (claim.Attested && claim.Validated && !claim.Repaid && !claim.KeepSeparate)
|
|
{
|
|
// this should be added to the list. Check if we already have pending payouts
|
|
// for this person:
|
|
|
|
if (payoutLookup.ContainsKey(claim.ClaimingPersonId))
|
|
{
|
|
// Yes. Add claim to list.
|
|
|
|
payoutLookup[claim.ClaimingPersonId].DependentExpenseClaims.Add(claim);
|
|
}
|
|
else
|
|
{
|
|
// No. Create a new payout for this person.
|
|
|
|
BasicPayout basicPayout = new BasicPayout(0, organization.Identity, claim.Claimer.BankName,
|
|
claim.Claimer.BankClearing + " / " + claim.Claimer.BankAccount, string.Empty, 0,
|
|
DateTime.MinValue, false, DateTime.Now, 0);
|
|
Payout payout = Payout.FromBasic(basicPayout);
|
|
|
|
payout.DependentExpenseClaims.Add(claim);
|
|
|
|
payoutLookup[claim.ClaimingPersonId] = payout;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// At this point, all the expense claims have been added - but we need to add the open
|
|
// cash advances and deduct them.
|
|
|
|
CashAdvances cashAdvances = CashAdvances.ForOrganization(organization);
|
|
cashAdvances = cashAdvances.WherePaid;
|
|
|
|
// At this point, only open and paid cash advances are in the list: they're debts to the org
|
|
|
|
foreach (CashAdvance cashAdvance in cashAdvances)
|
|
{
|
|
if (payoutLookup.ContainsKey(cashAdvance.PersonId))
|
|
{
|
|
// there's a payout prepared to this person - we need to deduct the cash advance from it.
|
|
|
|
payoutLookup[cashAdvance.PersonId].DependentCashAdvancesPayback.Add(cashAdvance);
|
|
}
|
|
}
|
|
|
|
// We now have the list of payouts and the associated claims, but the amounts aren't set on the
|
|
// payouts. This will be the next step, as we assemble the list.
|
|
|
|
foreach (Payout payout in payoutLookup.Values)
|
|
{
|
|
Int64 newAmountCents = 0;
|
|
List<int> claimIds = new List<int>();
|
|
|
|
foreach (ExpenseClaim claim in payout.DependentExpenseClaims)
|
|
{
|
|
newAmountCents += claim.AmountCents;
|
|
claimIds.Add(claim.Identity);
|
|
}
|
|
|
|
foreach (CashAdvance previousAdvance in payout.DependentCashAdvancesPayback)
|
|
{
|
|
newAmountCents -= previousAdvance.AmountCents;
|
|
}
|
|
|
|
string lessAdvancesIndicator = payout.DependentCashAdvancesPayback.Count > 0
|
|
? "LessAdvances"
|
|
: string.Empty;
|
|
|
|
payout.AmountCents = newAmountCents;
|
|
|
|
if (claimIds.Count == 1)
|
|
{
|
|
payout.Reference = "[Loc]Financial_ExpenseClaimSpecification" + lessAdvancesIndicator + "|" + claimIds[0].ToString(CultureInfo.InvariantCulture);
|
|
}
|
|
else
|
|
{
|
|
claimIds.Sort();
|
|
payout.Reference = "[Loc]Financial_ExpenseClaimsSpecification" + lessAdvancesIndicator + "|" + Formatting.GenerateRangeString(claimIds);
|
|
}
|
|
|
|
if (newAmountCents > 0)
|
|
{
|
|
payoutList.Add(payout);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private static void AddUnpaidCashAdvances(Payouts payoutList, Organization organization)
|
|
{
|
|
CashAdvances advances = CashAdvances.ForOrganization(organization);
|
|
advances = advances.WhereAttested;
|
|
advances = advances.WhereUnpaid;
|
|
|
|
Dictionary<int, Payout> payoutLookup = new Dictionary<int, Payout>();
|
|
|
|
foreach (CashAdvance advance in advances)
|
|
{
|
|
// If ready for payout, add to list.
|
|
|
|
if (!advance.Open || !advance.Attested || advance.PaidOut)
|
|
{
|
|
throw new InvalidOperationException("Got into loop with closed/unattested/paid-out cash advances - this is not a possible state");
|
|
}
|
|
|
|
if (payoutLookup.ContainsKey(advance.PersonId))
|
|
{
|
|
// Yes. Add claim to list.
|
|
|
|
payoutLookup[advance.PersonId].DependentCashAdvancesPayout.Add(advance);
|
|
}
|
|
else
|
|
{
|
|
// No. Create a new payout for this person.
|
|
|
|
BasicPayout basicPayout = new BasicPayout(0, organization.Identity, advance.Person.BankName,
|
|
advance.Person.BankClearing + " / " + advance.Person.BankAccount, string.Empty, 0,
|
|
DateTime.MinValue, false, DateTime.Now, 0);
|
|
Payout payout = Payout.FromBasic(basicPayout);
|
|
|
|
payout.DependentCashAdvancesPayout.Add(advance);
|
|
|
|
payoutLookup[advance.PersonId] = payout;
|
|
}
|
|
}
|
|
|
|
// We now have the list of payouts and the associated claims, but the amounts aren't set on the
|
|
// payouts. This will be the next step, as we assemble the list.
|
|
|
|
foreach (Payout payout in payoutLookup.Values)
|
|
{
|
|
Int64 newAmountCents = 0;
|
|
List<int> advanceIds = new List<int>();
|
|
|
|
foreach (CashAdvance advance in payout.DependentCashAdvancesPayout)
|
|
{
|
|
newAmountCents += advance.AmountCents;
|
|
advanceIds.Add(advance.Identity);
|
|
}
|
|
|
|
payout.AmountCents = newAmountCents;
|
|
|
|
if (advanceIds.Count == 1)
|
|
{
|
|
payout.Reference = "[Loc]Financial_CashAdvanceSpecification|" + advanceIds[0].ToString(CultureInfo.InvariantCulture);
|
|
}
|
|
else
|
|
{
|
|
advanceIds.Sort();
|
|
payout.Reference = "[Loc]Financial_CashAdvancesSpecification|" + Formatting.GenerateRangeString(advanceIds);
|
|
}
|
|
|
|
if (newAmountCents > 0)
|
|
{
|
|
payoutList.Add(payout);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
private static void AddUnpaidInboundInvoices(Payouts payoutList, Organization organization)
|
|
{
|
|
InboundInvoices invoices = InboundInvoices.ForOrganization(organization);
|
|
|
|
foreach (InboundInvoice invoice in invoices)
|
|
{
|
|
if (invoice.Attested)
|
|
{
|
|
BasicPayout basicPayout = new BasicPayout(0, organization.Identity, string.Empty,
|
|
invoice.PayToAccount, invoice.Ocr.Length > 0? "OCR " + invoice.Ocr : "Ref# " + invoice.InvoiceReference, (Int64) (invoice.Amount * 100),
|
|
invoice.DueDate, false, DateTime.Now, 0);
|
|
Payout payout = Payout.FromBasic(basicPayout);
|
|
|
|
payout.DependentInvoices.Add(invoice);
|
|
|
|
payoutList.Add(payout);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void AddUnpaidSalaries (Payouts payoutList, Organization organization)
|
|
{
|
|
Int64 taxTotalCents = 0;
|
|
|
|
Salaries salaries = Salaries.ForOrganization(organization);
|
|
List<int> identityList = new List<int>();
|
|
DateTime payDay = DateTime.MaxValue;
|
|
|
|
foreach (Salary salary in salaries)
|
|
{
|
|
if (!salary.Attested)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!salary.NetPaid)
|
|
{
|
|
PayrollItem payrollItem = salary.PayrollItem;
|
|
Person employee = payrollItem.Person;
|
|
|
|
BasicPayout basicPayout = new BasicPayout(0, organization.Identity, employee.BankName,
|
|
employee.BankClearing+" / "+employee.BankAccount, "[Loc]Financial_SalarySpecification|[Date]" + salary.PayoutDate.ToString(CultureInfo.InvariantCulture),
|
|
salary.NetSalaryCents, salary.PayoutDate, false, DateTime.Now, 0);
|
|
Payout payout = Payout.FromBasic(basicPayout);
|
|
|
|
payout.DependentSalariesNet.Add(salary);
|
|
|
|
payoutList.Add(payout);
|
|
|
|
if (payDay > salary.PayoutDate)
|
|
{
|
|
payDay = salary.PayoutDate;
|
|
}
|
|
}
|
|
|
|
if (!salary.TaxPaid)
|
|
{
|
|
taxTotalCents += salary.TaxTotalCents;
|
|
identityList.Add(salary.Identity);
|
|
|
|
if (payDay > salary.PayoutDate)
|
|
{
|
|
payDay = salary.PayoutDate;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (taxTotalCents > 0)
|
|
{
|
|
// Add the summarized tax line, too
|
|
|
|
string referenceString = string.Empty;
|
|
|
|
if (identityList.Count == 1)
|
|
{
|
|
referenceString = "[Loc]Financial_TaxSpecification|" + identityList[0].ToString();
|
|
}
|
|
else
|
|
{
|
|
identityList.Sort();
|
|
referenceString = "[Loc]Financial_TaxesSpecification|" + Formatting.GenerateRangeString(identityList);
|
|
}
|
|
|
|
|
|
BasicPayout basicPayout = new BasicPayout(0, organization.Identity, "[Loc]Financial_TheTaxMan",
|
|
string.Empty, referenceString,
|
|
taxTotalCents, payDay, false, DateTime.Now, 0);
|
|
Payout payout = Payout.FromBasic(basicPayout);
|
|
|
|
foreach (int salaryId in identityList)
|
|
{
|
|
payout.DependentSalariesTax.Add(Salary.FromIdentity(salaryId));
|
|
}
|
|
|
|
payoutList.Add(payout);
|
|
}
|
|
}
|
|
|
|
|
|
public static void AutomatchAgainstUnbalancedTransactions(Organization organization)
|
|
{
|
|
// Matches unbalanced financial transactions against unclosed payouts
|
|
|
|
// Should this be in bot?
|
|
|
|
Payouts payouts = Payouts.ForOrganization(organization);
|
|
|
|
FinancialTransactions transactions = FinancialTransactions.GetUnbalanced(organization);
|
|
|
|
foreach (FinancialTransaction transaction in transactions)
|
|
{
|
|
// Console.WriteLine("Looking at transaction #{0} ({1:yyyy-MM-dd}, {2:N2}).", transaction.Identity, transaction.DateTime, transaction.Rows.AmountTotal);
|
|
|
|
// First, establish that there are no similar transactions within 7 days. N^2 search.
|
|
|
|
DateTime timeLow = transaction.DateTime.AddDays(-7);
|
|
DateTime timeHigh = transaction.DateTime.AddDays(7);
|
|
|
|
bool foundCompeting = false;
|
|
|
|
foreach (FinancialTransaction possiblyCompetingTransaction in transactions)
|
|
{
|
|
if (possiblyCompetingTransaction.Rows.AmountCentsTotal == transaction.Rows.AmountCentsTotal &&
|
|
possiblyCompetingTransaction.DateTime >= timeLow &&
|
|
possiblyCompetingTransaction.DateTime <= timeHigh &&
|
|
possiblyCompetingTransaction.Identity != transaction.Identity)
|
|
{
|
|
foundCompeting = true;
|
|
// Console.WriteLine(" - Transaction #{0} ({1:yyyy-MM-dd} is competing, aborting", possiblyCompetingTransaction.Identity, possiblyCompetingTransaction.DateTime);
|
|
}
|
|
}
|
|
|
|
if (foundCompeting)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Console.WriteLine(" - no competing transactions...\r\n - transaction description is \"{0}\".", transaction.Description);
|
|
|
|
// Console.WriteLine(" - looking for matching payouts");
|
|
|
|
int foundCount = 0;
|
|
int payoutIdFound = 0;
|
|
|
|
// As the amount of payouts grow, this becomes less efficient exponentially.
|
|
|
|
foreach (Payout payout in payouts)
|
|
{
|
|
// Ugly hack to fix cash advance payouts
|
|
|
|
DateTime payoutLowerTimeLimit = timeLow;
|
|
DateTime payoutUpperTimeLimit = timeHigh;
|
|
|
|
if (payout.AmountCents == -transaction.Rows.AmountCentsTotal && (payout.DependentCashAdvancesPayout.Count > 0 || payout.DependentCashAdvancesPayback.Count > 0))
|
|
{
|
|
// HACK: While PW5 doesn't have a manual-debug interface, special case for cash advances
|
|
|
|
payoutLowerTimeLimit = transaction.DateTime.AddDays(-60);
|
|
payoutUpperTimeLimit = transaction.DateTime.AddDays(60);
|
|
}
|
|
|
|
if (payout.ExpectedTransactionDate >= payoutLowerTimeLimit && payout.ExpectedTransactionDate <= payoutUpperTimeLimit && payout.AmountCents == -transaction.Rows.AmountCentsTotal)
|
|
{
|
|
// Console.WriteLine(" - - payout #{0} matches ({1}, {2:yyyy-MM-dd})", payout.Identity, payout.Recipient, payout.ExpectedTransactionDate);
|
|
|
|
try
|
|
{
|
|
FinancialTransaction tiedTransaction = FinancialTransaction.FromDependency(payout);
|
|
|
|
// Console.WriteLine(" - - - but is tied to transaction #{0} already", tiedTransaction.Identity);
|
|
break;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
// There isn't such a transaction, which is what we want
|
|
}
|
|
|
|
foundCount++;
|
|
payoutIdFound = payout.Identity;
|
|
}
|
|
}
|
|
|
|
if (foundCount == 0)
|
|
{
|
|
// Console.WriteLine(" - none found");
|
|
}
|
|
else if (foundCount > 1)
|
|
{
|
|
// Console.WriteLine(" - multiple found, not autoprocessing");
|
|
}
|
|
else
|
|
{
|
|
Payout payout = Payout.FromIdentity(payoutIdFound);
|
|
payout.BindToTransactionAndClose(transaction, null);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
public decimal TotalAmount
|
|
{
|
|
get
|
|
{
|
|
decimal result = 0.0m;
|
|
|
|
foreach (Payout payout in this)
|
|
{
|
|
result += payout.Amount;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public Int64 TotalAmountCents
|
|
{
|
|
get
|
|
{
|
|
Int64 result = 0;
|
|
|
|
foreach (Payout payout in this)
|
|
{
|
|
result += payout.AmountCents;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
}
|