public IActionResult DepositsPerYear(Guid id)
{
Claim user = User.Claims.FirstOrDefault(c => c.Type == MyClaimTypes.UserName);
Account account = _AccountsDbContext.Accounts.Single(a => a.Id == id && a.Owner == user.Value);
var lines = _AccountsDbContext.Deposits.Where(d => d.Account.Id == id && d.Account.Owner == user.Value).Select(d =>
new SummaryLine()
{
Year = d.Year,
Amount = d.Amount
}
).OrderBy(x => x.Year).ToArray();
AccountSummary accountSummary = new AccountSummary()
{
Currency = account.Currency,
Name = account.Name,
Id = account.Id,
Total = lines.Sum(d => d.Amount),
Lines = lines
};
return(Ok(accountSummary));
}
public void InsertAccount(Guid tenantId, Guid accountId, string accountCode, string accountStatus, Guid personId)
{
using (var db = new QueryDbContext(DatabaseConnectionString))
{
var account = new AccountSummary
{
TenantIdentifier = tenantId,
AccountIdentifier = accountId,
AccountCode = accountCode,
AccountStatus = accountStatus,
OwnerIdentifier = personId
};
db.AccountSummaries.Add(account);
db.SaveChanges();
if (accountStatus == "Open")
{
var person = db.PersonSummaries.Single(x => x.PersonIdentifier == personId);
person.OpenAccountCount++;
db.SaveChanges();
}
Denormalize();
}
}
private List <AccountSummary> GetAccountSummaryAll(DataTable dt)
{
var accountList = new List <AccountSummary>();
if (dt != null && dt.Rows.Count > 0)
{
for (int i = 0; i < dt.Rows.Count; i++)
{
var dr = dt.Rows[i];
var account = new AccountSummary
{
AccountId = Convert.ToInt32(dr["AccountId"]),
CustomerId = Convert.ToInt32(dr["CustomerId"]),
AccountName = dr["AccountName"].ToString(),
AccountNumber = dr["AccountNumber"].ToString(),
AccountType = GetAccountType(Convert.ToInt32(dr["AccountType"])),
Balance = Convert.ToDouble(dr["Balance"])
};
accountList.Add(account);
}
}
return(accountList);
}
private void CalculateAccountStatistics(AccountSummary summary)
{
this.BeginInvoke((MethodInvoker) delegate()
{
this.Buy_Volume_Label.Text = string.Format("{0} TL", summary.BuyVolume.ToString());
this.Sell_Volume_Label.Text = string.Format("{0} TL", summary.SellVolume.ToString());
this.Loan_Label.Text = string.Format("{0} TL", summary.LoanTotal.ToString());
this.Debt_Label.Text = string.Format("{0} TL", summary.DebtTotal.ToString());
this.Charged_Label.Text = string.Format("{0} TL", summary.Charged.ToString());
this.Paid_Label.Text = string.Format("{0} TL", summary.Paid.ToString());
this.Net_Loan_Label.Text = string.Format("{0} TL", summary.LoanNet.ToString());
this.Net_Debt_Label.Text = string.Format("{0} TL", summary.DebtNet.ToString());
this.Net_Value_Label.Text = string.Format("{0} TL", Math.Abs(summary.Net));
if (summary.Net < 0)
{
this.Net_State_Label.Text = "Alacağınız var.";
}
else if (summary.Net > 0)
{
this.Net_State_Label.Text = "Borcunuz var.";
}
else
{
this.Net_State_Label.Text = "Nötr";
}
});
}
public AccountSummary CreateOrUpdateEntry(AccountSummary accountSummary)
{
if (accountSummary is null)
{
throw new Exception("Null entry rejected");
}
var existing = _repo.FirstOrDefault(a => a.AccountName == accountSummary.AccountName);
if (existing != null)
{
existing.Balance += accountSummary.Balance;
}
else
{
existing = new AccountSummary()
{
Id = SequentialGuidGenerator.Instance.Create(),
IsDeleted = false,
CreatorUserId = _serviceHelper.GetCurrentUserId(),
AccountName = accountSummary.AccountName,
Balance = accountSummary.Balance,
};
_repo.Insert(existing);
}
return(existing);
}
private static void PrintChallengeResults(AccountSummary accountInfo)
{
Console.WriteLine($"==== Account Information ====");
Console.WriteLine();
Console.WriteLine(JsonConvert.SerializeObject(accountInfo, Formatting.Indented));
Console.WriteLine();
Console.WriteLine($"==== End of Account Information ====");
}
public void ShouldFailValidationWhenViolatingBank1Ruleset()
{
using (Banking1ServiceHost host = new Banking1ServiceHost())
{
CustomerInfo customer = GetInvalidBank1Customer();
AccountSummary summary = host.Proxy.GetAccountSummary(customer);
}
}
public AccountSummary GetAccountSummary(int accountId, int period)
{
var result = new AccountSummary();
if (accountId > 0)
{
result = base.Table <BankAccount>()
.Where(q => q.AccountId == accountId)
.Select(s => new
{
AccountId = s.AccountId,
Description = s.Description,
}).ProjectTo <AccountSummary>().FirstOrDefault();
}
else
{
result.AccountId = 0;
result.Description = "All Accounts";
}
var transactions = GetTransactionView(accountId).Where(q => q.TransactionDate >= DateTimeHelper.StartPriod(period));
//var result1 = (from item in transactionsLst
// where item.TransactionDate >= DateTimeHelper.StartPriod(period)
// group item by item into grp
// select new
// {
// DebitAmount = grp.Sum(o => o.DebitAmount),
// TransferOutAmount = grp.Sum(o => o.TransferOutAmount),
// CreditAmount = grp.Sum(o => o.CreditAmount),
// TransferInAmount = grp.Sum(o => o.TransferInAmount),
// }).FirstOrDefault();
result.CreditAmount = (decimal?)transactions.Sum(sum => sum.CreditAmount) ?? 0;
result.TransferInAmount = (decimal?)transactions.Sum(sum => sum.TransferInAmount) ?? 0;
result.DebitAmount = (decimal?)transactions.Sum(sum => sum.DebitAmount) ?? 0;
result.TransferOutAmount = (decimal?)transactions.Sum(sum => sum.TransferOutAmount) ?? 0;
// //result.Balance = GetBalance(accountId);
result.Balance = (result.CreditAmount + result.TransferInAmount) - (result.DebitAmount + result.TransferOutAmount);
result.FirstTransactionDate = (DateTime?)transactions.Min(m => m.TransactionDate) ?? DateTime.MinValue;
result.LastTransactionDate = (DateTime?)transactions.Max(m => m.TransactionDate) ?? DateTime.MinValue;
//var transactions = base.Table<BankTransaction>().Where(q => q.AccountId == (accountId > 0 ? accountId : q.AccountId));
// result.CreditAmount = (decimal?)transactions.Where(q => q.TransactionDate >= DateTimeHelper.StartPriod(period) && q.IsTransfer == false).Sum(sum => sum.CreditAmount) ?? 0;
// result.TransferInAmount = (decimal?)transactions.Where(q => q.TransactionDate >= DateTimeHelper.StartPriod(period) && q.IsTransfer == true).Sum(sum => sum.CreditAmount) ?? 0;
// result.DebitAmount = (decimal?)transactions.Where(q => q.TransactionDate >= DateTimeHelper.StartPriod(period) && q.IsTransfer == false).Sum(sum => sum.DebitAmount) ?? 0;
// result.TransferOutAmount = (decimal?)transactions.Where(q => q.TransactionDate >= DateTimeHelper.StartPriod(period) && q.IsTransfer == true).Sum(sum => sum.DebitAmount) ?? 0;
// //result.Balance = GetBalance(accountId);
// result.Balance = (result.CreditAmount + result.TransferInAmount) - (result.DebitAmount + result.TransferOutAmount);
// result.FirstTransactionDate = (DateTime?)transactions.Min(m => m.TransactionDate) ?? DateTime.MinValue;
// result.LastTransactionDate = (DateTime?)transactions.Max(m => m.TransactionDate) ?? DateTime.MinValue;
return(result);
}
private static string GetAccountSummaryCacheKey(IHasRequestId o)
{
return(o switch
{
AccountSummary a => $"{a.Account}+{a.Currency}+{a.Tag}",
AccountSummaryEnd => "AccountSummaryEnd",
Alert _ => "",
_ => throw new ArgumentException($"Unhandled type: {o.GetType()}.")
});
public static async Task Validate(this AccountSummary accountSummary, long accountNumber)
{
if (accountSummary == null)
{
throw new InvalidAccountNumberException(accountNumber);
}
await Task.CompletedTask;
}
public AccountSummary[] ProvideAccountSummaries()
{
List <AccountSummary> accountSummaries = new List <AccountSummary>();
AccountPortfolio[] portfolios = m_positionMonitor.GetAllAccountPortfolios();
if (portfolios != null)
{
foreach (AccountPortfolio positionMonitorPortfolio in portfolios)
{
Portfolio portfolio = BuildPortfolio(positionMonitorPortfolio, false);
AccountSummary accountSummary = new AccountSummary()
{
AccountName = portfolio.AccountName,
MinDelta = portfolio.AccountData.MinDelta,
MaxDelta = portfolio.AccountData.MaxDelta,
TargetDelta = portfolio.AccountData.TargetDelta,
NextTradeTime = portfolio.AccountData.NextTradeTime,
OptionPandL = portfolio.AccountData.OptionPandL,
StockPandL = portfolio.AccountData.StockPandL,
FuturesPandL = portfolio.AccountData.FuturesPandL,
TotalPandL = portfolio.AccountData.TotalPandL,
Benchmark = portfolio.AccountData.Benchmark,
PutsOutOfBounds = portfolio.AccountData.PutsOutOfBounds,
TradingComplete = portfolio.AccountData.TradingComplete,
};
if (portfolio.AccountData.StartOfDayEquity > 0)
{
accountSummary.ReturnOnEquity = accountSummary.TotalPandL / portfolio.AccountData.StartOfDayEquity;
accountSummary.GrossReturnMTD = Math.Exp(positionMonitorPortfolio.Data.LogGrossReturn_MTD + Math.Log(accountSummary.ReturnOnEquity + 1)) - 1;
accountSummary.NetReturnMTD = Math.Exp(positionMonitorPortfolio.Data.LogNetReturn_MTD + Math.Log(accountSummary.ReturnOnEquity + 1)) - 1;
}
if (portfolio.Benchmark != null)
{
if (portfolio.Benchmark.PrevClose != 0)
{
accountSummary.BenchmarkReturn = portfolio.Benchmark.LastPrice / portfolio.Benchmark.PrevClose - 1;
accountSummary.BenchmarkReturnMTD = Math.Exp(positionMonitorPortfolio.Data.BenchmarkLogReturn_MTD + Math.Log(accountSummary.BenchmarkReturn.Value + 1)) - 1;
}
}
if (portfolio.Indices.Length > 0)
{
Index totalRow = portfolio.Indices[portfolio.Indices.Length - 1];
accountSummary.TotalDeltaPct = totalRow.TotalDeltaPct;
accountSummary.PutsToTrade = totalRow.PutsToTrade;
if (totalRow.PrevClose != 0)
{
accountSummary.TargetReturn = totalRow.LastPrice / totalRow.PrevClose - 1;
}
}
accountSummaries.Add(accountSummary);
}
}
return(accountSummaries.ToArray());
}
public AccountSummary[] GetAccountSummary(string userName)
{
try
{
IBUser user = _userManager.GetUser(userName);
if (user != null)
{
Messages.AccountSummaryMessage[] accountSummarys = user.GetAccountSummary();
if (accountSummarys != null)
{
Dictionary <string, Messages.AccountSummaryMessage[]> dictMessages = (from p in accountSummarys
group p by p.Account into g
select g).ToDictionary(k => k.Key, v => v.ToArray());
List <AccountSummary> accountSummaryList = new List <AccountSummary>();
foreach (string account in dictMessages.Keys)
{
Messages.AccountSummaryMessage[] messages = dictMessages[account];
AccountSummary accountSummary = new AccountSummary();
Dictionary <string, System.Reflection.PropertyInfo> dictProperties = typeof(AccountSummary).GetProperties().ToDictionary(k => k.Name, v => v);
accountSummary.UserName = userName;
foreach (Messages.AccountSummaryMessage message in messages)
{
System.Reflection.PropertyInfo property = null;
if (dictProperties.TryGetValue(message.Tag, out property))
{
if (property.PropertyType == typeof(string))
{
property.SetValue(accountSummary, message.Value);
}
else if (property.PropertyType == typeof(double))
{
double val;
if (double.TryParse(message.Value, out val))
{
property.SetValue(accountSummary, val);
}
}
}
}
accountSummaryList.Add(accountSummary);
}
return(accountSummaryList.ToArray());
}
}
return(null);
}
catch (Exception ex)
{
_Logger.Error(ex);
throw ex;
}
}
/// <summary>
/// Get Account Summary Grouped By Currency .. Used to fill summary table at page top
/// </summary>
/// <param name="parentAccId"></param>
/// <param name="isCreditAccount"></param>
/// <param name="fromDate"></param>
/// <param name="toDate"></param>
/// <returns>AccountSummary object</returns>
public static AccountSummary GetAccountSummaryGrouped(string parentAccId, bool isCreditAccount = false,
DateTime?fromDate = null, DateTime?toDate = null, int bId = 0)
{
AccountSummary accountSummary = new AccountSummary();
var accSummaryList = GetAccSummaryByParentAccId(parentAccId, isCreditAccount, fromDate, toDate);
AccountingEntities db = new AccountingEntities();
accountSummary.AccountNameEn = db.AccountingCharts.Where(x => x.AccountId == parentAccId).FirstOrDefault().AccountNameEn;
//Cash in Bank .. get for specific bank ID
if (parentAccId == "193" && bId != 0)
{
var accIdsForBank = db.BankAccounts.Where(x => x.BankId == bId).Select(x => x.AccountId).ToList();
accSummaryList = accSummaryList.Where(x => accIdsForBank.Contains(x.AccountId)).ToList();
}
if (accSummaryList.Count > 0)
{
var grouped = accSummaryList.GroupBy(x => x.CurrencySign)
.Select(x => new
{
Currency = x.Key,
DebitSum = x.Sum(y => y.DebitAmout),
CreditSum = x.Sum(y => y.CreditAmount)
}).ToList();
List <AccountSummaryTotal> sumByCurrency = new List <AccountSummaryTotal>();
AccountSummaryTotal accountSummaryTotal;
decimal diffAmount;
foreach (var item in grouped)
{
accountSummaryTotal = new AccountSummaryTotal();
accountSummaryTotal.CurrencySign = item.Currency;
diffAmount = item.DebitSum - item.CreditSum;
if (diffAmount > 0)
{
accountSummaryTotal.DebitAmout = diffAmount;
}
else
{
accountSummaryTotal.CreditAmount = diffAmount * -1;
}
sumByCurrency.Add(accountSummaryTotal);
}
accountSummary.TotalByCurrency = sumByCurrency;
}
return(accountSummary);
}
public void DeriveAccountSummaryPlanDescriptionTest_PaymentPlanAmountZero()
{
AccountSummary account = new AccountSummary()
{
PaymentPlanAmount = 0
};
string result = _helper.DerivePlanDescription(account);
Assert.IsNull(result);
}
private AccountSummary AddAccountSummary(int customerId)
{
var accountSummary = new AccountSummary
{
CustomerId = customerId
};
_context.AccountSummaries.Add(accountSummary);
_context.SaveChanges();
accountSummary.Customer = GetCustomer(customerId);
return(accountSummary);
}
public string DeriveDiscountDescription(AccountSummary account)
{
if (AccountHasDiscountOffer(account))
{
string saveAmount = account.DiscountOfferAmount.Value.ToString("C", CultureInfo.CurrentCulture);
string untilDate = account.DiscountOfferExpiry.Value.ToString("d", CultureInfo.CurrentCulture);
return($"Save {saveAmount} until {untilDate}");
}
return(null);
}
public void DeriveDiscountDescription_AccountHasNoDiscountOffer()
{
AccountSummary account = new AccountSummary()
{
DiscountOfferAmount = null,
DiscountOfferExpiry = null
};
string expected = null;
string result = _helper.DeriveDiscountDescription(account);
Assert.AreEqual(expected, result);
}
public void DeriveDiscountDescription_AccountHasDiscountOffer()
{
AccountSummary account = new AccountSummary()
{
DiscountOfferAmount = 123.45M,
DiscountOfferExpiry = DateTime.Now
};
string expected = $"Save £123.45 until {DateTime.Now.ToString("d", CultureInfo.CurrentCulture)}";
string result = _helper.DeriveDiscountDescription(account);
Assert.AreEqual(expected, result);
}
public void AccountHasDiscountOfferTest()
{
AccountSummary account = new AccountSummary()
{
DiscountOfferAmount = 123.45M,
DiscountOfferExpiry = DateTime.Now
};
bool expected = true;
bool result = _helper.AccountHasDiscountOffer(account);
Assert.AreEqual(expected, result);
}
public ActionResult Index()
{
int accountId = Convert.ToInt32(Session["AccountID"]);
AccountManager oAccountManager = new AccountManager();
AccountSummary oAccountSummary = oAccountManager.GetAccountSummary(accountId);
ViewBag.ClientCount = oAccountSummary.ClientCount;
ViewBag.EmployeeCount = oAccountSummary.EmployeeCount;
ViewBag.ProjectCount = oAccountSummary.ProjectCount;
ViewBag.TotalHourIncurrentMonth = oAccountSummary.TotalHourIncurrentMonth;
ViewBag.CurrentMonth = DateTime.Now.Month.ToString() + "/" + DateTime.Now.Year.ToString();
return(View());
}
public void AccountHasDiscountOfferTest_DiscountOfferExpiryNull()
{
AccountSummary account = new AccountSummary()
{
DiscountOfferAmount = 123.45M,
DiscountOfferExpiry = null
};
bool expected = false;
bool result = _helper.AccountHasDiscountOffer(account);
Assert.AreEqual(expected, result);
}
/// <summary>
/// Get the Account summary
/// </summary>
/// <returns></returns>
public async Task <AccountSummary> GetAccountSummary()
{
AccountSummary accountSummary = new AccountSummary();
var accountList = await _accountClient.GetAccountList();
var numSensorByAccs = await _accountClient.GetNumSensorByAccount();
accountSummary.Status = await CalculateCustomerStatusSummary(accountList, numSensorByAccs);
accountSummary.Customers = await PrepareCuctomersSummary(accountList, numSensorByAccs);
return(accountSummary);
}
public void DeriveAccountSummaryPlanDescriptionTest()
{
AccountSummary account = new AccountSummary()
{
PaymentPlanAmount = 123.45M,
PaymentPlanFrequency = "monthly",
PaymentPlanMethod = "direct debit"
};
string expected = ": £123.45 monthly";
string result = _helper.DerivePlanDescription(account);
Assert.AreEqual(expected, result);
}
public AccountSummary[] GetAccountSummary()
{
AccountSummary[] accounts = new AccountSummary[AccountDataGridView.Rows.Count - 1];
for (int index = 1; index < AccountDataGridView.Rows.Count; index++)
{
DataGridViewRow accountRow = AccountDataGridView.Rows[index];
accounts[index - 1] = new AccountSummary();
accounts[index - 1].AccountType = accountRow.Cells[0].GetValue();
accounts[index - 1].AccountNumber = accountRow.Cells[1].GetValue();
accounts[index - 1].Balance = Convert.ToDouble(accountRow.Cells[2].GetValue());
}
return(accounts);
}
public AccountSummary GetSummary(List <AccountMovement> m_Movements)
{
AccountSummary m_Summary = new AccountSummary();
m_Summary.BuyVolume = m_Movements.Where(q => q.MovementTypeID == 3).Sum(q => q.Value);
m_Summary.SellVolume = m_Movements.Where(q => q.MovementTypeID == 1).Sum(q => q.Value);
m_Summary.LoanTotal = m_Movements.Where(q => q.MovementTypeID == 1 && q.PaymentTypeID == 3).Sum(q => q.Value); // Yapılan vadeli satışlardan alacak geçmişimiz
m_Summary.Charged = m_Movements.Where(q => q.MovementTypeID == 2).Sum(q => q.Value); // Yapılan vade tahsilatları
m_Summary.DebtTotal = m_Movements.Where(q => q.MovementTypeID == 3 && q.PaymentTypeID == 3).Sum(q => q.Value); // Yapılan vadeli ürün alımlarımıza ait borcumuz
m_Summary.Paid = m_Movements.Where(q => q.MovementTypeID == 4).Sum(q => q.Value); // Yaptığımız borç ödemeleri
return(m_Summary);
}
public async Task <AccountSummary> GetSummaryByYear(Guid id)
{
HttpResponseMessage response = await _Client.GetAsync($"/accounts/deposits/summary/year/{id}");
if (response.IsSuccessStatusCode)
{
string result = await response.Content.ReadAsStringAsync();
AccountSummary accounts = JsonConvert.DeserializeObject <AccountSummary>(result);
return(accounts);
}
_Logger.LogError($"Error retrieving accounts -> {response.StatusCode}: {response.ReasonPhrase}");
throw new Exception($"Error retrieving accounts -> {response.StatusCode}: {response.ReasonPhrase}");
}
public void ConfigureAccount()
{
string newAlias = "NewAlias";
string oldAlias = "OldAlias";
string aliasTouse = newAlias;
AccountSummary accountSummary = _api.GetAccountSummary(this.AccountId).Account;
if (accountSummary.Alias == newAlias)
{
aliasTouse = oldAlias;
}
ConfigureAccountResponse response = _api.ConfigureAccount(this.AccountId, aliasTouse, 0.1M);
Assert.IsTrue(response.ClientConfigureTransaction.Alias == aliasTouse);
}
public async Task <IHttpActionResult> GetAccountSummary(int accountId)
{
AccountSummary asummary = null;
try
{
AccountBLL bll = new AccountBLL(_unit);
asummary = bll.GetAccountSummary(accountId);
}
catch (Exception ex)
{
LogHelper.Error(_log, ex.ToString());
return(InternalServerError(ex));
}
return(Ok(asummary));
}
public static void SaveChange(AccountSummary account, List <BasicSetCollectionInfo> change)
{
if (account == null || change?.Count == 0)
{
return;
}
var path = Path.Combine(Path.GetDirectoryName(account.FileStoragePath), string.Format("Changes_{0}", account.AccountName));
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
path = Path.Combine(path, Path.ChangeExtension(Path.GetRandomFileName(), ".xml"));
XmlManager <List <BasicSetCollectionInfo> > .Save(path, change);
}
/// <summary>
/// Get Account Summary contains totals grouped by currency for specific account number
/// Used to fill summary table at page top
/// </summary>
/// <param name="accId"></param>
/// <param name="fromDate"></param>
/// <param name="toDate"></param>
/// <returns></returns>
public static AccountSummary GetAccSummaryByAccId(string accId, string fromDate = null, string toDate = null)
{
ReportsAccountingEntities db = new ReportsAccountingEntities();
AccountSummary accSummary = new AccountSummary();
var spResult = db.GetAccountDetailsByAccId(accId, fromDate == "" ? null : fromDate, toDate == "" ? null : toDate).ToList();
if (spResult.Count > 0)
{
accSummary.AccountNameEn = spResult.FirstOrDefault().AccountNameEn;
accSummary.AccountNameAr = spResult.FirstOrDefault().AccountNameAr;
accSummary.DiffAmount = accSummary.DebitAmout - accSummary.CreditAmount;
var grouped = spResult.GroupBy(x => x.CurrencySign)
.Select(x => new
{
Currency = x.Key,
DebitSum = x.Sum(y => y.DebitAmount),
CreditSum = x.Sum(y => y.CreditAmount)
}).ToList();
List <AccountSummaryTotal> sumByCurrency = new List <AccountSummaryTotal>();
AccountSummaryTotal accountSummaryTotal;
decimal diffAmount;
foreach (var item in grouped)
{
accountSummaryTotal = new AccountSummaryTotal();
accountSummaryTotal.CurrencySign = item.Currency;
diffAmount = item.DebitSum - item.CreditSum;
if (diffAmount > 0)
{
accountSummaryTotal.DebitAmout = diffAmount;
}
else
{
accountSummaryTotal.CreditAmount = diffAmount * -1;
}
sumByCurrency.Add(accountSummaryTotal);
}
accSummary.TotalByCurrency = sumByCurrency;
}
return(accSummary);
}
