public AccountListViewModel(IAccountRepository accountRepository,
IPaymentRepository paymentRepository,
IDialogService dialogService,
INavigationService navigationService)
{
this.accountRepository = accountRepository;
this.dialogService = dialogService;
this.navigationService = navigationService;
BalanceViewModel = new BalanceViewModel(accountRepository, paymentRepository);
}
public void GetTotalBalance_Zero()
{
var balanceCalculationService = new Mock <IBalanceCalculationService>();
balanceCalculationService.Setup(x => x.GetEndOfMonthBalanceForAccount(It.IsAny <AccountViewModel>())).Returns(() => 0);
balanceCalculationService.Setup(x => x.GetTotalEndOfMonthBalance()).ReturnsAsync(() => 0);
var vm = new BalanceViewModel(balanceCalculationService.Object,
new Mock <IMvxLogProvider>().Object,
new Mock <IMvxNavigationService>().Object);
vm.UpdateBalanceCommand.Execute();
vm.TotalBalance.ShouldEqual(0);
vm.EndOfMonthBalance.ShouldEqual(0);
}
public BalancePage()
{
InitializeComponent();
BindingContext = new BalanceViewModel(this);
if (DeviceInfo.Platform == DevicePlatform.UWP)
{
btnRefresh.IsVisible = true;
}
else
{
btnRefresh.IsVisible = false;
}
lvBalance.ItemTapped += LvBalance_ItemTapped;
}
public ActionResult SetBalance(string userId, string iban)
{
BalanceViewModel model = new BalanceViewModel();
var user = db.Users.Where(m => m.Id.Equals(userId)).FirstOrDefault();
if (user != null)
{
var account = db.Accounts.Where(m => m.Iban.Equals(iban)).FirstOrDefault();
model.Balance = 0;
model.UserName = user.NameIdentifier;
model.Iban = account.Iban;
model.UserId = user.Id;
return(View(model));
}
return(RedirectToAction("Index"));
}
/// <summary>
/// Fixing balance
/// </summary>
/// <param name="balance">Instance with info ablout fixing.</param>
/// <returns>Added data</returns>
public BalanceViewModel AddNewBalance(BalanceViewModel balance)
{
if (IsFinOpsInBalanceDay(balance))
{
throw new BusinessLogicException(ErrorMessages.AddNewBalanceMessageReject);
}
decimal amount = _unitOfWork.OrganizationAccountRepository.Read(balance.OrgAccountId).CurrentBalance;
balance.Amount = amount;
var addedBalanceEntity = _unitOfWork.BalanceRepository.Add(balance);
_unitOfWork.SaveChanges();
BalanceViewModel addedBalanceViewModel = ConvertToBalanceViewModel(addedBalanceEntity);
return(addedBalanceViewModel);
}
public AccountListViewModel(IMediator mediator,
IMapper mapper,
IBalanceCalculationService balanceCalculationService,
IDialogService dialogService,
ISettingsFacade settingsFacade,
NavigationService navigationService)
{
this.mediator = mediator;
this.mapper = mapper;
this.dialogService = dialogService;
this.navigationService = navigationService;
this.settingsFacade = settingsFacade;
BalanceViewModel = new BalanceViewModel(balanceCalculationService);
ViewActionViewModel = new AccountListViewActionViewModel(this.navigationService);
}
public IEnumerable <BalanceViewModel> GetBalanceViewModel(Guid jobOrderId, DateTime dateFrom, DateTime dateTo, BalanceViewModel.Scale scale)
{
var model = new List <BalanceViewModel>();
var step = scale == BalanceViewModel.Scale.Weekly ? 7 : 1;
foreach (DateTime day in EachDay(dateFrom, dateTo, step))
{
var jobOrder = Repository.GetById <Merp.Accountancy.CommandStack.Model.JobOrder, All_JobOrders>(jobOrderId);
var balance = new BalanceViewModel()
{
Date = day,
Balance = jobOrder.CalculateBalance(EventStore, day)
};
model.Add(balance);
}
return(model);
}
public async Task <IActionResult> Index()
{
var user = await GetUser(required : true);
//TODO: move this to a ViaRpcProvider in /Services (like IWalletProvider)
var via = new ViaJsonRpc(_settings.AccessHttpUrl);
var balances = Utils.GetUsedBalances(_settings, via, user.Exchange);
var model = new BalanceViewModel
{
User = user,
AssetSettings = _settings.Assets,
Balances = balances
};
return(View(model));
}
public async Task <IActionResult> Create(BalanceViewModel balanceViewModel)
{
if (ModelState.IsValid)
{
var accessToken = await HttpContext.GetTokenAsync("access_token");
BalanceJsonModel balanceJsonModel = _mapper.Map <BalanceViewModel,
BalanceJsonModel>(balanceViewModel);
var result = await _balanceRepository.CreateBalance
("https://localhost:44382/Balance/Create", accessToken, balanceJsonModel);
if (result.IsSuccessStatusCode)
{
return(RedirectToAction("Index", "Balance"));
}
}
return(View(balanceViewModel));
}
public ActionResult Index()
{
var loggedUser = IsValidUser();
if (loggedUser != null)
{
var account = _accountService.Balance(loggedUser.Accounts.FirstOrDefault().Id);
var balanceViewModel = new BalanceViewModel
{
CardNumber = loggedUser.AtmCard.Number,
Date = DateTime.Now,
Amount = account.Amount
};
return(View(balanceViewModel));
}
return(View("Error"));
}
public ExchangeViewModel(MainViewModel mainViewModel, ExchangeBase exchangeBase)
: base(exchangeBase)
{
Pairs = new PairManageViewModel(exchangeBase);
this.MainViewModel = mainViewModel;
this.Header = Exchange.Name;
//this.Foreground = Brushes.DodgerBlue;
MainViewModel.TimerSeconds.Tick += TimerSecondsOnTick;
Orders = new UserOrdersViewModel(Exchange);
Ticker = new TickerViewModel(Exchange);
OrderBook = new OrderBookViewModel(Exchange);
Trades = new TradesViewModel(MainViewModel, this, Exchange);
Balance = new BalanceViewModel(Exchange);
NewBuyOrder = new NewOrderViewModel(Exchange)
{
Side = OrderSide.Buy
};
NewSellOrder = new NewOrderViewModel(Exchange)
{
Side = OrderSide.Sell
};
if (!DesignerProperties.GetIsInDesignMode(new DependencyObject()))
{
UpdatePair();
//Exchange.ExchangeManager.Settings.
MainViewModel.SettingsService.SettingsLoaded += SettingsServiceOnSettingsLoaded;
Pairs.PairChanged += PairsOnPairChanged;
OrderBook.Ticker.LastTradeClickEvent += TickerOnLastTradeClickEvent;
OrderBook.SelectedAskChanged += OrderBookOnSelectedAskChanged;
OrderBook.SelectedBidChanged += OrderBookOnSelectedBidChanged;
Balance.SelectedBalanceChanged += BalanceOnSelectedBalanceChanged;
CreateTimer();
UpdateViewModels();
RegisterUpdates();
Ticker.Dispatched += TickerOnDispatched;
}
}
public IEnumerable <BalanceViewModel> GetBalanceViewModel(Guid jobOrderId, DateTime dateFrom, DateTime dateTo, BalanceViewModel.Scale scale)
{
DateTime[] dates = null;
switch (scale)
{
case BalanceViewModel.Scale.Daily:
case BalanceViewModel.Scale.Weekly:
var step = scale == BalanceViewModel.Scale.Weekly ? 7 : 1;
dates = EachDay(dateFrom, dateTo, step).ToArray();
break;
case BalanceViewModel.Scale.Monthly:
dates = EachMonth(dateFrom, dateTo).ToArray();
break;
case BalanceViewModel.Scale.Quarterly:
dates = EachQuarter(dateFrom, dateTo).ToArray();
break;
case BalanceViewModel.Scale.Yearly:
dates = EachYear(dateFrom, dateTo).ToArray();
break;
}
var isTimeAndMaterial = (from jo in Database.JobOrders
where jo.OriginalId == jobOrderId
select jo.IsTimeAndMaterial).Single();
Merp.Accountancy.CommandStack.Model.JobOrder[] jobOrders = null;
jobOrders = Repository.GetSeriesById <Merp.Accountancy.CommandStack.Model.JobOrder>(jobOrderId, dates);
var model = new List <BalanceViewModel>();
for (int i = 0; i < dates.Count(); i++)
{
var balance = new BalanceViewModel()
{
Date = dates[i],
Balance = jobOrders[i].Balance
};
model.Add(balance);
}
return(model);
}
public void GetTotalBalance_TwoAccounts_SumOfAccounts()
{
var accountMockSetup = new Mock <IAccountRepository>();
accountMockSetup.Setup(x => x.GetList(null)).Returns(() => new List <AccountViewModel>
{
new AccountViewModel {
CurrentBalance = 500
},
new AccountViewModel {
CurrentBalance = 200
}
});
var vm = new BalanceViewModel(accountMockSetup.Object, new Mock <IEndOfMonthManager>().Object);
vm.UpdateBalanceCommand.Execute();
vm.TotalBalance.ShouldBe(700);
}
public ActionResult AddBalance(BalanceViewModel model)
{
_logger.Information("Action: AddBalance; Controller: Account; Call method: POST;");
try
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Balance"));
}
_accountService.AddSumToBalance(model.AddSum, User.Identity.Name);
return(RedirectToAction("Balance"));
}
catch (Exception e)
{
LogException(e);
return(RedirectToAction("Index", "Error", new { exceptionType = e.GetType().Name }));
}
}
public void GetTotalBalance_TwoAccounts_SumOfAccounts()
{
var accountMockSetup = new Mock <IAccountRepository>();
accountMockSetup.Setup(x => x.GetList(It.IsAny <Expression <Func <AccountViewModel, bool> > >()))
.Returns(() => new List <AccountViewModel>
{
new AccountViewModel {
CurrentBalance = 500, IsExcluded = false
},
new AccountViewModel {
CurrentBalance = 200, IsExcluded = false
}
});
var vm = new BalanceViewModel(accountMockSetup.Object, new Mock <IEndOfMonthManager>().Object);
vm.UpdateBalanceCommand.Execute();
vm.TotalBalance.ShouldBe(700);
}
public void GetTotalBalance_TwoPayments_SumOfPayments()
{
var paymentMockSetup = new Mock <IPaymentRepository>();
paymentMockSetup.Setup(x => x.GetUnclearedPayments(It.IsAny <DateTime>()))
.Returns(() => new List <Payment> {
new Payment {
Amount = 20, Type = (int)PaymentType.Expense
},
new Payment {
Amount = 60, Type = (int)PaymentType.Income
}
});
var vm = new BalanceViewModel(new Mock <IAccountRepository>().Object,
paymentMockSetup.Object);
vm.UpdateBalanceCommand.Execute();
vm.TotalBalance.ShouldBe(0);
vm.EndOfMonthBalance.ShouldBe(40);
}
public void GetTotalBalance_TwoExpense_SumOfPayments()
{
var paymentMockSetup = new Mock <IPaymentRepository>();
paymentMockSetup.Setup(x => x.GetList(It.IsAny <Expression <Func <Payment, bool> > >()))
.Returns(() => new List <Payment>
{
new Payment {
Amount = 20, Type = (int)PaymentType.Expense
},
new Payment {
Amount = 60, Type = (int)PaymentType.Expense
}
});
var vm = new BalanceViewModel(new Mock <IAccountRepository>().Object, paymentMockSetup.Object);
vm.UpdateBalanceCommand.Execute();
vm.TotalBalance.ShouldBe(0);
vm.EndOfMonthBalance.ShouldBe(-80);
}
public async Task <BalanceViewModel> SyncBankAccountBalanceAsync(Guid userId, Guid id)
{
BalanceViewModel balanceViewModel;
Balance balance = await _balanceRepository.GetByIdAsync(userId, id);
BankAccountBalance bankAccountBalance = await _bankAccountService.GetBankAccountBalanceAsync(userId, balance.AssetId);
if (bankAccountBalance != null)
{
Balance updatedBalance = await _balanceRepository.UpdateAsync(userId, id, balance.AssetId, bankAccountBalance.Balance);
balanceViewModel = new BalanceViewModel(updatedBalance);
}
else
{
balanceViewModel = new BalanceViewModel(balance);
}
await _unitOfWork.SaveChangesAsync();
return(balanceViewModel);
}
internal Task AddCost(CostViewModel newCost)
{
return(Task.Factory.StartNew(() =>
{
App.RunUIAsync(() =>
{
Costs.Insert(0, newCost);
});
BalanceViewModel currentBalance = Accounts.Balances.FirstOrDefault(b => b.Id == newCost.BalanceId);
if (currentBalance != null)
{
currentBalance.AddCost(newCost.Cost);
DbWorker.UpdateBalance(currentBalance.Model);
}
DbWorker.AddCost(newCost.Model);
Accounts.RaiseBalance();
}));
}
private async Task <List <BalanceViewModel> > AddAssetsBalancesAsync(Guid userId, DateTime effectiveDate)
{
List <BalanceViewModel> result = new List <BalanceViewModel>();
IEnumerable <Asset> activeAssets = await _assetRepository.GetByUserIdAsync(userId, false);
if (!activeAssets.Any())
{
throw new UserHasNoAssetsException();
}
foreach (Asset asset in activeAssets)
{
Balance newBalance = await _balanceRepository.CreateAsync(userId, asset.Id, effectiveDate, 0.0M);
var assetModel = new AssetViewModel(asset);
var balanceModel = new BalanceViewModel(newBalance, assetModel);
result.Add(balanceModel);
}
await _unitOfWork.SaveChangesAsync();
return(result);
}
internal Task UpdateCost(CostViewModel updateCost)
{
return(Task.Factory.StartNew(() =>
{
updateCost.Update();
if (updateCost.HavePrevCost)
{
//TODO: o(n) - bad
BalanceViewModel currentBalance = Accounts.Balances.FirstOrDefault(b => b.Id == updateCost.BalanceId);
if (currentBalance != null)
{
currentBalance.ChanngeBalance(DbWorker.GetCost(updateCost.Id).Cost);
currentBalance.AddCost(updateCost.Cost);
DbWorker.UpdateBalance(currentBalance.Model);
}
updateCost.HavePrevCost = false;
}
DbWorker.UpdateCost(updateCost.Model);
}));
}
public async Task WhenIAddNewBalance()
{
_createdBalance = await _balanceFeatureContext.BalanceService
.AddBalanceAsync(_userContext.UserId, _balanceCreateModel);
}
private static BalanceViewModel GetBalancesResponse(string exchangeId, string formObject)
{
JObject jsonResult = JObject.Parse(formObject);
BalanceViewModel balances = null;
var balanceDetailsList = new List <BalanceDetailViewModel>();
if (exchangeId == "0")
{
var balancesJson = jsonResult["result"];
balanceDetailsList = JsonConvert.DeserializeObject <List <BalanceDetailViewModel> >(balancesJson.ToString());
}
else if (exchangeId == "1")
{
var balancesJson = jsonResult["balances"];
foreach (var detail in balancesJson)
{
var totalBalance = Double.Parse(detail["free"].ToString()) + Double.Parse(detail["locked"].ToString());
if (totalBalance == 0)
{
continue;
}
balanceDetailsList.Add(
new BalanceDetailViewModel
{
currency = detail["asset"].ToString(),
balance = String.Format("{0:F8}", totalBalance),
available = detail["free"].ToString(),
pending = detail["locked"].ToString()
}
);
}
}
else if (exchangeId == "2")
{
var balancesJson = jsonResult["result"];
var obj = JObject.Parse(balancesJson.ToString());
foreach (var asset in obj)
{
balanceDetailsList.Add(
new BalanceDetailViewModel
{
currency = asset.Key.Substring(1),
balance = String.Format("{0:F8}", asset.Value.ToString()),
/*available = detail["free"].ToString(),
* pending = detail["locked"].ToString()*/
}
);
}
}
else if (exchangeId == "3")
{
var balancesJson = jsonResult;
foreach (var detail in balancesJson)
{
if (Double.Parse(detail.Value.ToString()) == 0)
{
continue;
}
if (detail.Key.Contains("available", StringComparison.InvariantCulture))
{
var key = detail.Key.Substring(0, 3);
var asset = balanceDetailsList.Where(c => c.currency == key).SingleOrDefault();
if (asset == null)
{
balanceDetailsList.Add(new BalanceDetailViewModel
{
currency = key,
balance = "0",
available = detail.Value.ToString(),
pending = "0"
});
}
else
{
asset.available = detail.Value.ToString();
}
}
else if (detail.Key.Contains("balance", StringComparison.InvariantCulture))
{
var key = detail.Key.Substring(0, 3);
var asset = balanceDetailsList.Where(c => c.currency == key).SingleOrDefault();
if (asset == null)
{
balanceDetailsList.Add(new BalanceDetailViewModel
{
currency = key,
balance = detail.Value.ToString(),
available = "0",
pending = "0",
});
}
else
{
asset.balance = detail.Value.ToString();
}
}
else if (detail.Key.Contains("reserved"))
{
var key = detail.Key.Substring(0, 3);
var asset = balanceDetailsList.Where(c => c.currency == key).SingleOrDefault();
if (asset == null)
{
balanceDetailsList.Add(new BalanceDetailViewModel
{
currency = key,
balance = "0",
available = "0",
pending = detail.Value.ToString()
});
}
else
{
asset.pending = detail.Value.ToString();
}
}
/*balanceDetailsList.Add(
* new BalanceDetailViewModel
* {
* currency = detail["detail"].ToString(),
* balance = detail[1].ToString(),
* available = detail[2].ToString(),
* pending = detail[3].ToString()
* }
* );*/
}
}
else if (exchangeId == "4")
{
var balancesJson = jsonResult["result"];
var obj = JObject.Parse(balancesJson.ToString());
foreach (var asset in obj)
{
balanceDetailsList.Add(
new BalanceDetailViewModel
{
currency = asset.Key.Substring(1),
balance = String.Format("{0:F8}", asset.Value.ToString()),
/*available = detail["free"].ToString(),
* pending = detail["locked"].ToString()*/
}
);
}
}
balances = new BalanceViewModel
{
pairs = balanceDetailsList
};
return(balances);
}
public async Task <IActionResult> CreateBalance([FromBody] BalanceViewModel <int> Balance)
{
return(await _BalancesControllerProxy.CreateBalance(Balance));
}
public EditBalanceWindow(BalanceViewModel balanceModelView)
{
InitializeComponent();
BalanceMV = balanceModelView;
}
public Numeros()
{
balancePageViewModel = new BalanceViewModel();
InitializeComponent();
this.BindingContext = balancePageViewModel;
}
public Balance()
{
InitializeComponent();
DataContext = new BalanceViewModel();
}
public void CalculateTotals()
{
BalanceViewModels = new ObservableCollection <BalanceViewModel>();
decimal debitbalance = 0;
decimal creditbalance = 0;
var balance = 0m;
string suffix = "";
debitbalance = Ledgergenerals.Where(b => b.LedgerAccountId == SelectedLedgerAccount.LedgerAccountId)
.Where(b => b.JournalEntryDate.Date <= ToDate).Sum(b => b.Debit);
creditbalance = Ledgergenerals.Where(b => b.LedgerAccountId == SelectedLedgerAccount.LedgerAccountId)
.Where(b => b.JournalEntryDate.Date <= ToDate).Sum(b => b.Credit);
var debitbalancetotal = Ledgergenerals.Where(b => b.LedgerAccountId == SelectedLedgerAccount.LedgerAccountId)
.Sum(b => b.Debit);
var creditbalancetotal = Ledgergenerals.Where(b => b.LedgerAccountId == SelectedLedgerAccount.LedgerAccountId)
.Sum(b => b.Credit);
if (debitbalance > creditbalance)
{
balance = debitbalance - creditbalance;
suffix = "Dr";
}
if (debitbalance < creditbalance)
{
balance = creditbalance - debitbalance;
suffix = "Cr";
}
var balancetotal = 0m;
if (debitbalancetotal > creditbalancetotal)
{
balancetotal = debitbalancetotal;
}
if (debitbalancetotal < creditbalancetotal)
{
balancetotal = creditbalancetotal;
}
BalanceViewModel balancevm1 = new BalanceViewModel
{
BalanceId = 1,
TotalString = "Total " + balancetotal.ToString("C")
};
BalanceViewModel balancevm2 = new BalanceViewModel
{
BalanceId = 2,
TotalString = " Balance C/D " + balance.ToString("C") + suffix
};
BalanceViewModels.Add(balancevm1);
BalanceViewModels.Add(balancevm2);
if (BalanceViewModels.Count() > 0)
{
IsBalanceAvailable = true;
}
else
{
IsBalanceAvailable = false;
}
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
_balance = e.Parameter as BalanceViewModel;
}
public async Task <IActionResult> Update(BalanceViewModel balanceViewModel)
{
return(View(balanceViewModel));
}
private bool IsFinOpsInBalanceDay(BalanceViewModel balance)
{
var finops = _unitOfWork.FinOpRepository.GetFinOpByOrgAccount(balance.OrgAccountId);
return(finops.Where(x => x.FinOpDate.Date >= balance.BalanceDate.Date).Any());
}
