private void PopulateGrid()
{
string personIdString = Request.QueryString["PersonId"];
string organizationIdString = Request.QueryString["OrganizationId"];
Person person = Person.FromIdentity(Int32.Parse(personIdString));
Organization organization = Organization.FromIdentity(Int32.Parse(organizationIdString));
this.LabelOrganization.Text = organization.Name;
this.LabelDebtor.Text = person.Canonical;
ExpenseClaims allClaims = ExpenseClaims.FromClaimingPersonAndOrganization(person, organization); // again, this needs a "get open only"
ExpenseClaims gridClaims = new ExpenseClaims();
foreach (ExpenseClaim claim in allClaims)
{
// If ready for payout, add to list.
if (claim.Open)
{
if (claim.Attested && claim.Validated && !claim.Repaid)
{
gridClaims.Add(claim);
}
}
}
// Now, we have grouped all ready but unsettled expenses per person. Let's add only those with a positive debt to the final list.
gridClaims.Sort(SortGridItems);
this.GridDebts.DataSource = gridClaims;
}
private void AddReceiptValidation(Person person)
{
TaskGroup group = new TaskGroup(TaskGroupType.ValidateExpenseClaims);
// TODO: Loop over roles, get all open claims for roles where person can attest
if (!person.GetAuthority().HasPermission(Permission.CanDoEconomyTransactions, Organization.PPSEid, Geography.RootIdentity, Authorization.Flag.AnyGeographyExactOrganization))
{
// no permission, no tasks
return;
}
ExpenseClaims claims = ExpenseClaims.ForOrganization(Organization.PPSE);
foreach (ExpenseClaim claim in claims)
{
if (!claim.Validated)
{
group.Tasks.Add(new TaskReceiptValidation(claim));
}
}
if (group.Tasks.Count > 0)
{
this.Add(group);
}
}
private void PopulateExpenses()
{
ExpenseClaims expenses = ExpenseClaims.ForOrganization(CurrentOrganization);
foreach (ExpenseClaim expenseClaim in expenses)
{
if (this._attestationRights.ContainsKey(expenseClaim.BudgetId) ||
expenseClaim.Budget.OwnerPersonId == Person.NobodyId)
{
Documents dox = expenseClaim.Documents;
bool hasDox = (dox.Count > 0 ? true : false);
AttestableItem item = new AttestableItem(
"E" + expenseClaim.Identity.ToString(CultureInfo.InvariantCulture),
expenseClaim.ClaimerCanonical, expenseClaim.AmountCents, expenseClaim.Budget,
expenseClaim.Description, "Financial_ExpenseClaim", hasDox, expenseClaim);
if (expenseClaim.Attested)
{
this._attestedItems.Add(item);
}
else
{
this._items.Add(item);
}
}
}
}
private void AddExpenseClaims(Person person, Organization organization)
{
TaskGroup group = new TaskGroup(TaskGroupType.AttestExpenseClaims);
// TODO: Loop over roles, get all open claims for roles where person can attest
ExpenseClaims claims = ExpenseClaims.ForOrganization(organization);
foreach (ExpenseClaim claim in claims)
{
try
{
if (claim.Budget.OwnerPersonId == person.Identity && !claim.Attested)
{
group.Tasks.Add(new TaskExpenseClaim(claim));
}
}
catch (Exception)
{
// ignore fn
}
}
if (group.Tasks.Count > 0)
{
Add(group);
}
}
private void PopulateClaims(AttestableItems items)
{
ExpenseClaims allClaims = ExpenseClaims.FromOrganization(Organization.PPSE);
ExpenseClaims unattestedClaims = new ExpenseClaims();
// LINQ would be nice here. "Where Attested=0".
foreach (ExpenseClaim claim in allClaims)
{
if (!claim.Attested && claim.Open)
{
if (attestationRights.ContainsKey(claim.BudgetId))
{
unattestedClaims.Add(claim);
}
}
}
unattestedClaims.Sort(SortGridClaims);
foreach (ExpenseClaim claim in unattestedClaims)
{
AddAttestableItem(items, claim);
}
}
private void AddReceiptValidations(Person person, Organization organization)
{
if (!person.HasAccess(new Access(organization, AccessAspect.Financials, AccessType.Write)))
{
return;
}
ExpenseClaims claims = ExpenseClaims.ForOrganization(organization);
claims = claims.WhereUnvalidated;
if (claims.Count == 0)
{
// nothing to add
return;
}
DashboardTodo todo = new DashboardTodo();
if (claims.Count > 1)
{
todo.Description = String.Format(App_GlobalResources.Logic_Swarm_DashboardTodos.Validate_Receipts_Many, Formatting.GenerateRangeString(claims.Identities));
}
else
{
todo.Description = String.Format(App_GlobalResources.Logic_Swarm_DashboardTodos.Validate_Receipts_One, claims[0].Identity);
}
todo.Icon = "/Images/PageIcons/iconshock-invoice-greentick-16px.png";
todo.Url = "/Pages/v5/Financial/ValidateReceipts.aspx";
this.Add(todo);
}
private void PopulateGrid()
{
ExpenseClaims allClaims = ExpenseClaims.FromOrganization(Organization.PPSE);
allClaims.Sort(SortGridItems);
this.GridExpenseClaims.DataSource = allClaims;
}
private void PopulateGrid()
{
Dictionary <int, AdvanceDebt> debtLookup = new Dictionary <int, AdvanceDebt>();
ExpenseClaims claims = ExpenseClaims.ForOrganization(Organization.PPSE);
foreach (ExpenseClaim claim in claims)
{
// If ready for payout, add to list.
if (claim.Open)
{
if (claim.Attested && claim.Validated && !claim.Repaid)
{
// this should be added to the list. Check if we already have some open claims
// for this person:
if (debtLookup.ContainsKey(claim.ClaimingPersonId))
{
// Yes. Add claim to list.
debtLookup[claim.ClaimingPersonId].DebtCents -= claim.AmountCents;
debtLookup[claim.ClaimingPersonId].ClaimIds.Add(claim.Identity);
}
else
{
// No. Create a new debt for this person.
AdvanceDebt debt = new AdvanceDebt(claim.Claimer, -claim.AmountCents);
debt.ClaimIds.Add(claim.Identity);
debtLookup[claim.ClaimingPersonId] = debt;
}
if (debtLookup[claim.ClaimingPersonId].EarliestDate > claim.CreatedDateTime)
{
debtLookup[claim.ClaimingPersonId].EarliestDate = claim.CreatedDateTime;
}
}
}
}
// Now, we have grouped all ready but unsettled expenses per person. Let's add only those with a positive debt to the final list.
List <AdvanceDebt> debtList = new List <AdvanceDebt>();
foreach (int personId in debtLookup.Keys)
{
if (debtLookup[personId].DebtCents > 0)
{
debtList.Add(debtLookup[personId]);
}
}
debtList.Sort(SortGridItems);
this.GridDebts.DataSource = debtList;
}
// TODO: Refactor the attest-X functions into one function with minimal differences
private void AddExpenseClaimAttestations(Person person, Organization organization)
{
ExpenseClaims claims = ExpenseClaims.ForOrganization(organization);
List <int> expenseClaimIds = new List <int>();
bool isPersonOrgAdmin = false;
if (person.Identity == 1)
{
isPersonOrgAdmin = true; // TODO: Make more advanced, obviously
}
foreach (ExpenseClaim claim in claims)
{
if (claim.Attested)
{
continue;
}
bool attestable = false;
if (claim.Budget.OwnerPersonId == 0 && isPersonOrgAdmin)
{
attestable = true;
}
else if (claim.Budget.OwnerPersonId == person.Identity)
{
attestable = true;
}
if (attestable)
{
expenseClaimIds.Add(claim.Identity);
}
}
if (expenseClaimIds.Count > 0)
{
DashboardTodo todo = new DashboardTodo();
if (expenseClaimIds.Count > 1)
{
todo.Description = String.Format(Logic_Swarm_DashboardTodos.Attest_ExpenseClaim_Many,
Formatting.GenerateRangeString(expenseClaimIds));
}
else
{
todo.Description = String.Format(Logic_Swarm_DashboardTodos.Attest_ExpenseClaim_One,
expenseClaimIds[0]);
}
todo.Icon = "/Images/PageIcons/iconshock-stamped-paper-16px.png";
todo.Url = "/Pages/v5/Financial/AttestCosts.aspx";
Add(todo);
}
}
private void PopulateExpenses()
{
ExpenseClaims expenses = ExpenseClaims.ForOrganization(this.CurrentOrganization).WhereUnvalidated;
foreach (var expenseClaim in expenses)
{
AddDocuments(expenseClaim.Documents, "E" + expenseClaim.Identity.ToString(CultureInfo.InvariantCulture), String.Format(Resources.Global.Financial_ExpenseClaimSpecification + " - ", expenseClaim.Identity) + Resources.Global.Financial_ReceiptSpecification);
}
}
private void PopulateExpenses()
{
ExpenseClaims expenses = ExpenseClaims.ForOrganization(this.CurrentOrganization).WhereUnattested;
foreach (var expenseClaim in expenses)
{
if (_attestationRights.ContainsKey(expenseClaim.BudgetId) || expenseClaim.Budget.OwnerPersonId == Person.NobodyId)
{
AddDocuments(expenseClaim.Documents, "E" + expenseClaim.Identity.ToString(CultureInfo.InvariantCulture), String.Format(Resources.Global.Financial_ExpenseClaimSpecificationWithClaimer + " - ", expenseClaim.Identity, expenseClaim.ClaimerCanonical) + Resources.Global.Financial_ReceiptSpecification);
}
}
}
public SampleData()
{
var designService = new DesignExpenseClaimService();
foreach (var item in designService.GetExpenseClaimsForStatus("Open").Result)
{
ExpenseClaims.Add(item);
}
foreach (var item in designService.GetMostRecentExpenseClaimsByStatus().Result)
{
GroupedExpenseClaims.Add(item);
}
}
private string FormatAsJson(ExpenseClaims claims)
{
StringBuilder result = new StringBuilder(16384);
string hasDoxString =
"<img baseid='E{5}' class='LocalIconDox action-icon' />";
result.Append("{\"rows\":[");
FinancialTransactionTagSets tagSets = FinancialTransactionTagSets.ForOrganization(CurrentOrganization);
foreach (ExpenseClaim claim in claims)
{
StringBuilder extraTags = new StringBuilder();
FinancialTransaction transaction = claim.FinancialTransaction;
if (transaction != null)
{
foreach (FinancialTransactionTagSet tagSet in tagSets)
{
FinancialTransactionTagType tagType = transaction.GetTag(tagSet);
extraTags.AppendFormat("\"tagSet{0}\":\"{1}\",",
tagSet.Identity, tagType != null ? JsonSanitize(tagType.Name) : string.Empty);
}
}
result.Append("{");
result.AppendFormat(
"\"description\":\"{2}\",\"budgetName\":\"{3}\",{6}\"amountRequested\":\"{4:N2}\",\"itemId\":\"E{5}\"," +
"\"dox\":\"" + (claim.Documents.Count > 0 ? hasDoxString : " ") + "\"," +
"\"actions\":\"" +
"<img id='IconApprovalE{5}' class='LocalIconApproval action-icon' baseid='E{5}' />" +
"<img id='IconApprovedE{5}' class='LocalIconApproved status-icon' baseid='E{5}' />" +
"<img id='IconWaitE{5}' class='LocalIconWait status-icon' baseid='E{5}' />" +
"<img id='IconUndoE{5}' class='LocalIconUndo action-icon' baseid='E{5}' />" +
"<img id='IconDenialE{5}' class='LocalIconDenial action-icon' baseid='E{5}' />" +
"<img id='IconDeniedE{5}' class='LocalIconDenied status-icon' baseid='E{5}' />\"",
"olditem", JsonSanitize(claim.ClaimerCanonical), JsonSanitize(claim.Description),
JsonSanitize(claim.Budget.Name),
claim.AmountCents / 100.0, claim.Identity, extraTags);
result.Append("},");
}
result.Remove(result.Length - 1, 1); // remove last comma
result.Append("]}");
return(result.ToString());
}
internal ExpensePayout(Person person, ExpenseClaims expenseClaims)
{
this.person = person;
this.expenseClaims = expenseClaims;
decimal total = 0.0m;
foreach (ExpenseClaim expense in expenseClaims)
{
total += expense.Amount;
}
this.amount = total;
}
internal ExpensePayout(Person person, ExpenseClaims expenseClaims)
{
this.person = person;
this.expenseClaims = expenseClaims;
decimal total = 0.0m;
foreach (ExpenseClaim expense in expenseClaims)
{
total += expense.Amount;
}
this.amount = total;
}
private string FormatAsJson(ExpenseClaims claims)
{
StringBuilder result = new StringBuilder(16384);
string hasDoxString =
"<img src=\\\"/Images/Icons/iconshock-glass-16px.png\\\" onmouseover=\\\"this.src='/Images/Icons/iconshock-glass-16px-hot.png';\\\" onmouseout=\\\"this.src='/Images/Icons/iconshock-glass-16px.png';\\\" baseid=\\\"E{5}\\\" class=\\\"LocalViewDox\\\" style=\\\"cursor:pointer\\\" />";
result.Append("{\"rows\":[");
FinancialTransactionTagSets tagSets = FinancialTransactionTagSets.ForOrganization(CurrentOrganization);
foreach (ExpenseClaim claim in claims)
{
StringBuilder extraTags = new StringBuilder();
FinancialTransaction transaction = claim.FinancialTransaction;
if (transaction != null)
{
foreach (FinancialTransactionTagSet tagSet in tagSets)
{
FinancialTransactionTagType tagType = transaction.GetTag(tagSet);
extraTags.AppendFormat("\"tagSet{0}\":\"{1}\",",
tagSet.Identity, tagType != null ? JsonSanitize(tagType.Name) : string.Empty);
}
}
result.Append("{");
result.AppendFormat(
"\"description\":\"{2}\",\"budgetName\":\"{3}\",{6}\"amountRequested\":\"{4:N2}\",\"itemId\":\"E{5}\"," +
"\"dox\":\"" + (claim.Documents.Count > 0? hasDoxString: " ") + "\"," +
"\"actions\":\"<span style=\\\"position:relative;top:3px\\\">" +
"<img id=\\\"IconApprovalE{5}\\\" class=\\\"LocalIconApproval\\\" baseid=\\\"E{5}\\\" height=\\\"16\\\" width=\\\"16\\\" />" +
"<img id=\\\"IconApprovedE{5}\\\" class=\\\"LocalIconApproved\\\" baseid=\\\"E{5}\\\" height=\\\"16\\\" width=\\\"16\\\" /> " +
"<img id=\\\"IconDenialE{5}\\\" class=\\\"LocalIconDenial\\\" baseid=\\\"E{5}\\\" height=\\\"16\\\" width=\\\"16\\\" />" +
"<img id=\\\"IconDeniedE{5}\\\" class=\\\"LocalIconDenied\\\" baseid=\\\"E{5}\\\" height=\\\"16\\\" width=\\\"16\\\" /></span>\"",
"olditem", JsonSanitize(claim.ClaimerCanonical), JsonSanitize(claim.Description), JsonSanitize(claim.Budget.Name),
claim.AmountCents / 100.0, claim.Identity, extraTags.ToString());
result.Append("},");
}
result.Remove(result.Length - 1, 1); // remove last comma
result.Append("]}");
return result.ToString();
}
private string FormatAsJson(ExpenseClaims claims)
{
StringBuilder result = new StringBuilder(16384);
string hasDoxString =
"<img src='/Images/Icons/iconshock-search-256px.png' onmouseover=\\\"this.src='/Images/Icons/iconshock-search-hot-256px.png';\\\" onmouseout=\\\"this.src='/Images/Icons/iconshock-search-256px.png';\\\" baseid=\\\"E{5}\\\" class=\\\"LocalViewDox\\\" height=\\\"20\\\" width=\\\"20\\\" style=\\\"cursor:pointer\\\" />";
result.Append("{\"rows\":[");
FinancialTransactionTagSets tagSets = FinancialTransactionTagSets.ForOrganization(CurrentOrganization);
foreach (ExpenseClaim claim in claims)
{
StringBuilder extraTags = new StringBuilder();
FinancialTransaction transaction = claim.FinancialTransaction;
if (transaction != null)
{
foreach (FinancialTransactionTagSet tagSet in tagSets)
{
FinancialTransactionTagType tagType = transaction.GetTag(tagSet);
extraTags.AppendFormat("\"tagSet{0}\":\"{1}\",",
tagSet.Identity, tagType != null ? JsonSanitize(tagType.Name) : string.Empty);
}
}
result.Append("{");
result.AppendFormat(
"\"description\":\"{2}\",\"budgetName\":\"{3}\",{6}\"amountRequested\":\"{4:N2}\",\"itemId\":\"E{5}\"," +
"\"dox\":\"" + (claim.Documents.Count > 0 ? hasDoxString : " ") + "\"," +
"\"actions\":\"" +
"<img id=\\\"IconApprovalE{5}\\\" class=\\\"LocalIconApproval\\\" baseid=\\\"E{5}\\\" height=\\\"18\\\" width=\\\"24\\\" />" +
"<img id=\\\"IconApprovedE{5}\\\" class=\\\"LocalIconApproved\\\" baseid=\\\"E{5}\\\" height=\\\"18\\\" width=\\\"24\\\" />" +
"<img id=\\\"IconDenialE{5}\\\" class=\\\"LocalIconDenial\\\" baseid=\\\"E{5}\\\" height=\\\"18\\\" width=\\\"24\\\" />" +
"<img id=\\\"IconDeniedE{5}\\\" class=\\\"LocalIconDenied\\\" baseid=\\\"E{5}\\\" height=\\\"18\\\" width=\\\"24\\\" />\"",
"olditem", JsonSanitize(claim.ClaimerCanonical), JsonSanitize(claim.Description),
JsonSanitize(claim.Budget.Name),
claim.AmountCents / 100.0, claim.Identity, extraTags);
result.Append("},");
}
result.Remove(result.Length - 1, 1); // remove last comma
result.Append("]}");
return(result.ToString());
}
private void LoadDependencies()
{
DependentExpenseClaims = new ExpenseClaims();
DependentInvoices = new InboundInvoices();
DependentSalariesNet = new Salaries();
DependentSalariesTax = new Salaries();
DependentCashAdvancesPayout = new CashAdvances();
DependentCashAdvancesPayback = new CashAdvances();
BasicFinancialDependency[] dependencies = SwarmDb.GetDatabaseForReading().GetPayoutDependencies(this.Identity);
foreach (BasicFinancialDependency dependency in dependencies)
{
switch (dependency.DependencyType)
{
case FinancialDependencyType.ExpenseClaim:
DependentExpenseClaims.Add(ExpenseClaim.FromIdentity(dependency.ForeignId));
break;
case FinancialDependencyType.InboundInvoice:
DependentInvoices.Add(InboundInvoice.FromIdentity(dependency.ForeignId));
break;
case FinancialDependencyType.Salary:
Salary salary = Salary.FromIdentity(dependency.ForeignId);
if (salary.NetSalaryCents == this.AmountCents) // HACK: Assumes that tax total is not identical
{
DependentSalariesNet.Add(salary);
}
else
{
DependentSalariesTax.Add(salary);
}
break;
case FinancialDependencyType.CashAdvance:
DependentCashAdvancesPayout.Add(CashAdvance.FromIdentity(dependency.ForeignId));
break;
case FinancialDependencyType.CashAdvancePayback:
DependentCashAdvancesPayback.Add(CashAdvance.FromIdentity(dependency.ForeignId));
break;
default:
throw new NotImplementedException("Unknown financial dependency type in Payout.LoadDependencies(): " + dependency.ToString());
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!CurrentUser.HasAccess(new Access(CurrentOrganization, AccessAspect.Financials, AccessType.Read)))
{
throw new UnauthorizedAccessException();
}
ExpenseClaims claims = ExpenseClaims.ForOrganization(CurrentOrganization);
claims = claims.WhereUnvalidated;
// Format as JSON and return
Response.ContentType = "application/json";
string json = FormatAsJson(claims);
Response.Output.WriteLine(json);
Response.End();
}
private void PopulateGrid()
{
ExpenseClaims allClaims = ExpenseClaims.ForOrganization(Organization.PPSE);
ExpenseClaims unvalidatedClaims = new ExpenseClaims();
// LINQ would be nice here. "Where Validated=0".
foreach (ExpenseClaim claim in allClaims)
{
if (!claim.Validated)
{
unvalidatedClaims.Add(claim);
}
}
unvalidatedClaims.Sort(SortGridItems);
this.GridExpenseClaims.DataSource = unvalidatedClaims;
}
private void PopulateGrid()
{
ExpenseClaims allClaims = ExpenseClaims.ForOrganization(Organization.PPSE);
ExpenseClaims unvalidatedClaims = new ExpenseClaims();
// LINQ would be nice here. "Where Validated=0".
foreach (ExpenseClaim claim in allClaims)
{
if (!claim.Validated)
{
unvalidatedClaims.Add(claim);
}
}
unvalidatedClaims.Sort(SortGridItems);
this.GridExpenseClaims.DataSource = unvalidatedClaims;
}
private void PopulateExpenses()
{
ExpenseClaims expenses = ExpenseClaims.ForOrganization(CurrentOrganization);
bool vatEnabled = CurrentOrganization.VatEnabled;
foreach (ExpenseClaim expenseClaim in expenses)
{
if (this._approvalRights.ContainsKey(expenseClaim.BudgetId) ||
expenseClaim.Budget.OwnerPersonId == Person.NobodyId)
{
Documents dox = expenseClaim.Documents;
bool hasDox = (dox.Count > 0 ? true : false);
ApprovableCost cost = null;
if (vatEnabled)
{
cost = new ApprovableCost(
"E" + expenseClaim.Identity.ToString(CultureInfo.InvariantCulture),
expenseClaim.ClaimerCanonical, expenseClaim.AmountCents - expenseClaim.VatCents, expenseClaim.Budget,
expenseClaim.Description, "Financial_ExpenseClaim", hasDox, expenseClaim);
}
else
{
cost = new ApprovableCost(
"E" + expenseClaim.Identity.ToString(CultureInfo.InvariantCulture),
expenseClaim.ClaimerCanonical, expenseClaim.AmountCents, expenseClaim.Budget,
expenseClaim.Description, "Financial_ExpenseClaim", hasDox, expenseClaim);
}
if (expenseClaim.Attested)
{
this._approvedCosts.Add(cost);
}
else
{
this._approvableCosts.Add(cost);
}
}
}
}
private void PopulateGrid()
{
ExpenseClaims allClaims = ExpenseClaims.FromClaimingPerson(_currentUser);
ExpenseClaims gridData = new ExpenseClaims();
DateTime oneYearAgo = DateTime.Today.AddYears(-1);
foreach (ExpenseClaim claim in allClaims)
{
// Add those that are less than a year old AND/OR not repaid yet.
if (claim.ExpenseDate > oneYearAgo || claim.Open)
{
gridData.Add(claim);
}
}
gridData.Sort(SortGridItems);
this.GridExpenseClaims.DataSource = gridData;
this.GridExpenseClaims.Rebind();
}
public static ExpensePayouts FromOrganization(int organizationId)
{
// This aggregates a list of all pending expense payouts per person,
// and returns an ExpensePayouts object.
// It uses a Dictionary<int, List<ExpenseClaim>> to build the data, iterating over
// all expenses, where the int key is the person identity.
ExpenseClaims allExpenseClaims = ExpenseClaims.FromOrganization(Organization.FromIdentity(organizationId));
Dictionary <int, ExpenseClaims> aggregation = new Dictionary <int, ExpenseClaims>();
ExpensePayouts result = new ExpensePayouts();
// Aggregate per person
foreach (ExpenseClaim expense in allExpenseClaims)
{
if (expense.Approved && expense.Open)
{
// Ready for payout
if (!aggregation.ContainsKey(expense.ClaimingPersonId))
{
aggregation[expense.ClaimingPersonId] = new ExpenseClaims();
}
aggregation[expense.ClaimingPersonId].Add(expense);
}
}
// Create ExpensePayout objects
foreach (int personId in aggregation.Keys)
{
result.Add(new ExpensePayout(Person.FromIdentity(personId), aggregation[personId]));
}
return(result);
}
private void PopulatePreattested()
{
ExpenseClaims allClaims = ExpenseClaims.FromClaimingPersonAndOrganization(_currentUser, Organization.PPSE);
ExpenseClaims preAttested = new ExpenseClaims();
foreach (ExpenseClaim claim in allClaims)
{
if (claim.Open && claim.Attested && !claim.Claimed)
{
preAttested.Add(claim);
}
}
if (preAttested.Count > 0)
{
this.RadioPreattested.Checked = true;
this.RadioNewClaim.Checked = false;
this.DropPreattested.Items.Clear();
this.DropPreattested.Items.Add(new ListItem("-- Select One --", "0"));
foreach (ExpenseClaim claim in preAttested)
{
this.DropPreattested.Items.Add(new ListItem(string.Format("Up to {0:N2}: {1} ({2})", claim.Amount, claim.Description, claim.Budget.Name), claim.Identity.ToString()));
}
this.DropPreattested.SelectedIndex = 0;
}
else
{
this.RadioNewClaim.Checked = true;
this.RadioPreattested.Checked = false;
this.RadioPreattested.Enabled = false;
this.DropPreattested.Items.Clear();
this.DropPreattested.Items.Add(new ListItem("-- None --", "0"));
this.DropPreattested.Enabled = false;
}
}
public static ExpensePayout FromOrganizationAndPerson (int organizationId, int personId)
{
ExpenseClaims allExpenseClaims = ExpenseClaims.FromOrganization(Organization.FromIdentity(organizationId));
ExpenseClaims expenseClaims = new ExpenseClaims();
// Aggregate per person
foreach (ExpenseClaim expense in allExpenseClaims)
{
if (expense.ClaimingPersonId == personId)
{
if (expense.Approved && expense.Open)
{
// Ready for payout
expenseClaims.Add(expense);
}
}
}
// Create ExpensePayout object
return new ExpensePayout(Person.FromIdentity(personId), expenseClaims);
}
public static ExpensePayout FromOrganizationAndPerson(int organizationId, int personId)
{
ExpenseClaims allExpenseClaims = ExpenseClaims.FromOrganization(Organization.FromIdentity(organizationId));
ExpenseClaims expenseClaims = new ExpenseClaims();
// Aggregate per person
foreach (ExpenseClaim expense in allExpenseClaims)
{
if (expense.ClaimingPersonId == personId)
{
if (expense.Approved && expense.Open)
{
// Ready for payout
expenseClaims.Add(expense);
}
}
}
// Create ExpensePayout object
return(new ExpensePayout(Person.FromIdentity(personId), expenseClaims));
}
private void AddAdvanceDebts(Person person, Organization organization)
{
TaskGroup group = new TaskGroup(TaskGroupType.DeclareAdvanceDebts);
// TODO: One task group for each organization, actually
ExpenseClaims claims = ExpenseClaims.FromClaimingPersonAndOrganization(person, organization);
decimal debt = 0.0m;
foreach (ExpenseClaim claim in claims)
{
if (claim.Open && claim.Attested && claim.Validated && claim.Claimed)
{
debt += -claim.Amount;
}
}
if (debt > 0.0m)
{
group.Tasks.Add(new TaskAdvanceDebt(debt));
Add(group);
}
}
public ExpenseClaim Update(ExpenseClaim item)
{
return(ExpenseClaims.Update(item));
}
public ExpenseClaim Create(ExpenseClaim item)
{
return(ExpenseClaims.Create(item));
}
public IEnumerable <ExpenseClaim> Update(IEnumerable <ExpenseClaim> items)
{
return(ExpenseClaims.Update(items));
}
public List <PaymentHistoryLineItem> GetAmountsOwed()
{
List <PaymentHistoryLineItem> items = new List <PaymentHistoryLineItem>();
// Expense claims
ExpenseClaims expenses = ExpenseClaims.FromClaimingPersonAndOrganization(_person,
_authenticationData.CurrentOrganization);
foreach (ExpenseClaim claim in expenses)
{
if (claim.Open || claim.PaidOut) // if both these are false, the claim was denied and shouldn't be listed
{
PaymentHistoryLineItem newItem = new PaymentHistoryLineItem();
newItem.Id = "E" + claim.Identity.ToString(CultureInfo.InvariantCulture);
newItem.Name = String.Format(Resources.Global.Financial_ExpenseClaimLongSpecification, claim.Identity);
newItem.Description = claim.Description;
newItem.OpenedDate = claim.CreatedDateTime;
newItem.OwedToPerson = claim.AmountCents;
Payout payout = claim.Payout;
if (payout != null && payout.Open == false)
{
_payoutLookup[payout.Identity] = payout;
newItem.ClosedDate = payout.FinancialTransaction.DateTime;
}
items.Add(newItem);
}
}
// Salaries
Salaries salaries = Salaries.ForPersonAndOrganization(_person, _authenticationData.CurrentOrganization, true);
foreach (Salary salary in salaries)
{
if (salary.Open || salary.NetPaid) // either of these must be open for the salary to be valid
{
PaymentHistoryLineItem newItem = new PaymentHistoryLineItem();
newItem.Id = "S" + salary.Identity.ToString(CultureInfo.InvariantCulture);
newItem.Name = Resources.Global.Financial_Salary;
newItem.Description = String.Format(Resources.Global.Financial_SalaryDualSpecification, salary.Identity, salary.PayoutDate);
newItem.OwedToPerson = salary.NetSalaryCents;
FinancialTransaction openTx = FinancialTransaction.FromDependency(salary);
if (openTx != null)
{
newItem.OpenedDate = openTx.DateTime;
}
Payout payout = Payout.FromDependency(salary, FinancialDependencyType.Salary);
if (payout != null && payout.Open == false)
{
_payoutLookup[payout.Identity] = payout;
newItem.ClosedDate = payout.FinancialTransaction.DateTime;
}
items.Add(newItem);
}
}
// Cash advances
CashAdvances advances = CashAdvances.ForPersonAndOrganization(_person,
_authenticationData.CurrentOrganization, true);
foreach (CashAdvance advance in advances)
{
if (advance.Open || advance.PaidOut)
{
Payout payout = advance.PayoutOut;
if (payout != null)
{
_payoutLookup[payout.Identity] = payout;
_payoutDescriptionOverride[payout.Identity] =
String.Format(Resources.Global.Financial_CashAdvanceSpecification, advance.Identity.ToString("N0"));
}
}
}
return(items);
}
public static ExpenseClaim[] SelectStatic(ExpenseClaims expenseClaims)
{
return(expenseClaims.ToArray());
}
public static ExpenseClaim[] SelectUnapprovedByOrganization(int organizationId)
{
return(ExpenseClaims.FromOrganization(Organization.FromIdentity(organizationId)).WhereUnapproved.ToArray());
}
public static ExpenseClaim[] SelectOpenByClaimer(int personId)
{
return(ExpenseClaims.FromClaimingPerson(Person.FromIdentity(personId)).WhereOpen.ToArray());
}
private void PopulateGrid()
{
ExpenseClaims allClaims = ExpenseClaims.FromClaimingPerson(_currentUser);
ExpenseClaims gridData = new ExpenseClaims();
DateTime oneYearAgo = DateTime.Today.AddYears(-1);
foreach (ExpenseClaim claim in allClaims)
{
// Add those that are less than a year old AND/OR not repaid yet.
if (claim.ExpenseDate > oneYearAgo || claim.Open)
{
gridData.Add(claim);
}
}
gridData.Sort(SortGridItems);
this.GridExpenseClaims.DataSource = gridData;
this.GridExpenseClaims.Rebind();
}
public static void ProcessExpensesRepaidClosed (BasicPWEvent newPwEvent)
{
Person expenser = Person.FromIdentity(newPwEvent.AffectedPersonId);
Person payer = Person.FromIdentity(newPwEvent.ActingPersonId);
// The ParameterText field is like a,b,c,d where a..d are expense IDs
string[] idStrings = newPwEvent.ParameterText.Split(',');
ExpenseClaims expenseClaims = new ExpenseClaims();
decimal totalAmount = 0.0m;
foreach (string idString in idStrings)
{
ExpenseClaim newExpenseClaim = ExpenseClaim.FromIdentity(Int32.Parse(idString));
totalAmount += newExpenseClaim.Amount;
expenseClaims.Add(newExpenseClaim);
}
string body = "The following expenses, totaling " + totalAmount.ToString("#,##0.00") +
", have been repaid to your registered account, " + expenser.BankName + " " +
expenser.BankAccount + ".\r\n\r\n";
body += FormatExpenseLine("#", "Description", "Amount");
body += FormatExpenseLine("===", "========================================", "=========");
foreach (ExpenseClaim expense in expenseClaims)
{
body += FormatExpenseLine(expense.Identity.ToString(), expense.Description,
expense.Amount.ToString("#,##0.00"));
}
body += FormatExpenseLine("---", "----------------------------------------", "---------");
body += FormatExpenseLine(string.Empty, "TOTAL", totalAmount.ToString("#,##0.00"));
body += "\r\nIf you see any problems with this, please contact the treasurer, " + payer.Name + ", at " +
payer.PartyEmail + ". Thank you for helping the pirate movement succeed.\r\n";
new MailTransmitter(Strings.MailSenderNameFinancial, Strings.MailSenderAddress,
"Expenses Repaid: " + totalAmount.ToString("#,##0.00"), body,
expenser, true).Send();
}
private void PopulatePreattested()
{
ExpenseClaims allClaims = ExpenseClaims.FromClaimingPersonAndOrganization(_currentUser, Organization.PPSE);
ExpenseClaims preAttested = new ExpenseClaims();
foreach (ExpenseClaim claim in allClaims)
{
if (claim.Open && claim.Attested && !claim.Claimed)
{
preAttested.Add(claim);
}
}
if (preAttested.Count > 0)
{
this.RadioPreattested.Checked = true;
this.RadioNewClaim.Checked = false;
this.DropPreattested.Items.Clear();
this.DropPreattested.Items.Add(new ListItem("-- Select One --", "0"));
foreach (ExpenseClaim claim in preAttested)
{
this.DropPreattested.Items.Add(new ListItem(string.Format("Up to {0:N2}: {1} ({2})", claim.Amount, claim.Description, claim.Budget.Name), claim.Identity.ToString()));
}
this.DropPreattested.SelectedIndex = 0;
}
else
{
this.RadioNewClaim.Checked = true;
this.RadioPreattested.Checked = false;
this.RadioPreattested.Enabled = false;
this.DropPreattested.Items.Clear();
this.DropPreattested.Items.Add(new ListItem("-- None --", "0"));
this.DropPreattested.Enabled = false;
}
}
public static ExpenseClaim[] SelectStatic (ExpenseClaims expenseClaims)
{
return expenseClaims.ToArray();
}
