using System; using System.Collections.Generic; using Activizr.Logic.Pirates; using Activizr.Logic.Structure; using Activizr.Logic.Support; using Activizr.Basic.Enums; using Activizr.Basic.Types; using Activizr.Database; namespace Activizr.Logic.Financial { public class ExpenseClaim : BasicExpenseClaim, IValidatable, IAttestable { #region Construction and Creation private ExpenseClaim() : base (null) { } // Private constructor prevents wanton creation private ExpenseClaim (BasicExpenseClaim basic) : base (basic) { } // Used by FromBasic() internal static ExpenseClaim FromBasic (BasicExpenseClaim basic) { return new ExpenseClaim (basic); } public static ExpenseClaim FromIdentity (int expenseId) { return FromBasic (PirateDb.GetDatabase().GetExpenseClaim (expenseId)); } public static ExpenseClaim Create (Person claimer, Organization organization, FinancialAccount budget, DateTime expenseDate, string description, Int64 amountCents) { ExpenseClaim newClaim = FromIdentity (PirateDb.GetDatabase().CreateExpenseClaim (claimer.Identity, organization.Identity, budget.Identity, expenseDate, description, amountCents)); // Create the financial transaction with rows string transactionDescription = "Expense #" + newClaim.Identity + ": " + description; if (transactionDescription.Length > 64) { transactionDescription = transactionDescription.Substring(0, 61) + "..."; } FinancialTransaction transaction = FinancialTransaction.Create(organization.Identity, DateTime.Now, transactionDescription); transaction.AddRow(organization.FinancialAccounts.DebtsExpenseClaims, -amountCents, claimer); transaction.AddRow(budget, amountCents, claimer); // Make the transaction dependent on the expense claim transaction.Dependency = newClaim; return newClaim; } #endregion public Person Claimer { get { return Person.FromIdentity (base.ClaimingPersonId); } } public void CreateEvent (ExpenseEventType eventType, Person person) { // OBSOLETE // CreateEvent (eventType, person.Identity); } public void CreateEvent (ExpenseEventType eventType, int personId) { // OBSOLETE // PirateDb.GetDatabase().CreateExpenseEvent (Identity, eventType, personId); // TODO: Repopulate Events property, when created } public bool Approved { get { return Validated && Attested; } } public void Close() { this.Open = false; } public string ClaimerCanonical { get { try { return Claimer.Canonical; } catch (ArgumentException) { return "NOT-IN-DATABASE"; // For development purposes only! } } } public Organization Organization { get { return Organization.FromIdentity(this.OrganizationId); } } public FinancialTransaction FinancialTransaction { get { FinancialTransactions transactions = FinancialTransactions.ForDependentObject(this); if (transactions.Count == 0) { return null; // not possible from July 26 onwards, but some grandfather work } else if (transactions.Count == 1) { return transactions[0]; } throw new InvalidOperationException("It appears expense claim #" + this.Identity + " has multiple dependent financial transactions. This is an invalid state."); } } public new bool Attested { get { return base.Attested; } set { if (base.Attested != value) { PirateDb.GetDatabase().SetExpenseClaimAttested(this.Identity, value); base.Attested = value; } } } public new bool Validated { get { return base.Validated; } set { if (base.Validated != value) { PirateDb.GetDatabase().SetExpenseClaimValidated(this.Identity, value); base.Validated = value; } } } public new bool Open { get { return base.Open; } set { if (base.Open != value) { base.Open = value; PirateDb.GetDatabase().SetExpenseClaimOpen(this.Identity, value); } } } public new bool Claimed { get { return base.Claimed; } set { if (base.Claimed != value) { base.Claimed = value; PirateDb.GetDatabase().SetExpenseClaimClaimed(this.Identity, value); UpdateFinancialTransaction(this.Claimer); } } } public new bool Repaid { get { return base.Repaid; } set { if (base.Repaid != value) { base.Repaid = value; PirateDb.GetDatabase().SetExpenseClaimRepaid(this.Identity, value); } } } public new bool KeepSeparate { get { return base.KeepSeparate; } set { if (base.KeepSeparate != value) { base.KeepSeparate = value; PirateDb.GetDatabase().SetExpenseClaimKeepSeparate(this.Identity, value); } } } public new string Description { get { return base.Description; } set { PirateDb.GetDatabase().SetExpenseClaimDescription(this.Identity, value); base.Description = value; } } public FinancialAccount Budget { get { return FinancialAccount.FromIdentity(base.BudgetId); } } public int BudgetYear { get { return this.CreatedDateTime.Year; } set { // ignore } } public decimal Amount { get { return base.AmountCents / 100.0m; } } public new Int64 AmountCents { get { return base.AmountCents; } } public void SetAmountCents (Int64 amountCents, Person settingPerson) { if (base.AmountCents == amountCents) { return; } base.AmountCents = amountCents; PirateDb.GetDatabase().SetExpenseClaimAmount(this.Identity, amountCents); UpdateFinancialTransaction(settingPerson); } public void SetBudget (FinancialAccount budget, Person settingPerson) { PirateDb.GetDatabase().SetExpenseClaimBudget (this.Identity, budget.Identity); base.BudgetId = budget.Identity; UpdateFinancialTransaction(settingPerson); } public void Kill (Person killingPerson) { // Set the state to Closed, Unvalidated, Unattested Attested = false; Validated = false; Open = false; UpdateFinancialTransaction(killingPerson); // will zero out transaction since both Validated and Open are false // Mark transaction as invalid in description FinancialTransaction.Description = "Expense Claim #" + this.Identity.ToString() + " (killed/zeroed)"; } public new DateTime ExpenseDate { get { return base.ExpenseDate; } set { // TODO } } public Documents Documents { get { return Documents.ForObject(this); } } public FinancialValidations Validations { get { return FinancialValidations.ForObject(this); } } public void Recalibrate() { UpdateFinancialTransaction(null); // only to be used for fix-bookkeeping scripts } private void UpdateFinancialTransaction(Person updatingPerson) { Dictionary nominalTransaction = new Dictionary(); int debtAccountId = this.Organization.FinancialAccounts.DebtsExpenseClaims.Identity; if (!this.Claimed) { debtAccountId = this.Organization.FinancialAccounts.CostsAllocatedFunds.Identity; } if (this.Validated || this.Open) { // ...only holds values if not closed as invalid... nominalTransaction[debtAccountId] = -AmountCents; nominalTransaction[BudgetId] = AmountCents; } this.FinancialTransaction.RecalculateTransaction(nominalTransaction, updatingPerson); } #region IValidatable Members public void Validate(Person validator) { PirateDb.GetDatabase().SetExpenseClaimValidated(this.Identity, true); PirateDb.GetDatabase().CreateFinancialValidation(FinancialValidationType.Validation, FinancialDependencyType.ExpenseClaim, this.Identity, DateTime.Now, validator.Identity, (double) this.Amount); base.Validated = true; } public void Devalidate (Person devalidator) { PirateDb.GetDatabase().SetExpenseClaimValidated(this.Identity, false); PirateDb.GetDatabase().CreateFinancialValidation(FinancialValidationType.Devalidation, FinancialDependencyType.ExpenseClaim, this.Identity, DateTime.Now, devalidator.Identity, (double) this.Amount); base.Validated = false; } #endregion #region IAttestable Members public void Attest(Person attester) { PirateDb.GetDatabase().SetExpenseClaimAttested(this.Identity, true); PirateDb.GetDatabase().CreateFinancialValidation(FinancialValidationType.Attestation, FinancialDependencyType.ExpenseClaim, this.Identity, DateTime.Now, attester.Identity, (double) this.Amount); base.Attested = true; } public void Deattest(Person deattester) { PirateDb.GetDatabase().SetExpenseClaimAttested(this.Identity, false); PirateDb.GetDatabase().CreateFinancialValidation(FinancialValidationType.Deattestation, FinancialDependencyType.ExpenseClaim, this.Identity, DateTime.Now, deattester.Identity, (double) this.Amount); base.Attested = false; } #endregion } }