protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
IUnityContainer container = new UnityContainer();
var customXmlRW = new DataBase(@"C:\Users\stefan\Desktop\db.xml");
// Register ViewModels
var loginViewModel = new LoginViewModel(customXmlRW);
container.RegisterInstance <LoginViewModel>(loginViewModel);
var showImagesViewModel = new ImagesViewModel();
container.RegisterType <ImagesViewModel>();
var addImageViewModel = new AddImageViewModel();
container.RegisterType <AddImageViewModel>();
var accountDetailsViewModel = new AccountDetailsViewModel();
container.RegisterType <AccountDetailsViewModel>();
var contentViewModel = new ContentViewModel(container, customXmlRW);
container.RegisterInstance <ContentViewModel>(contentViewModel);
var mainWindowViewModel = new MainWindowViewModel(container);
container.RegisterInstance <MainWindowViewModel>(mainWindowViewModel);
var mainWindow = container.Resolve <MainWindow>();
mainWindow.DataContext = container.Resolve <MainWindowViewModel>();
Application.Current.MainWindow = mainWindow;
Application.Current.MainWindow.Show();
}
public ActionResult AccountDetails(AccountDetailsViewModel model)
{
string alertType = "danger";
string alertMsg = Resources.Global.ChangeAccountDetailsFailed;
if (ModelState.IsValid)
{
try
{
var currentUserId = User.Identity.GetUserId();
var currentUser = this.users.All().FirstOrDefault(x => x.Id == currentUserId);
this.users.Update(currentUser);
currentUser.PhoneNumber = model.PhoneNumber;
currentUser.Country = model.Country;
currentUser.City = model.City;
currentUser.Address = model.Address;
this.users.SaveChanges();
alertType = "success";
alertMsg = Resources.Global.ChangeAccountDetailsSuccess;
}
catch (Exception ex)
{
// Log the exception somewhere
}
}
return(Json(new { alertType, alertMsg }, JsonRequestBehavior.AllowGet));
}
public AccountMapView(AccountDetailsViewModel vm)
{
this.Title = "Map";
this.Icon = "map.png";
this.BindingContext = vm;
ViewModel.PropertyChanged += (sender, args) =>
{
if (args.PropertyName == "Account")
{
MakeMap();
}
};
map = new Map()
{
IsShowingUser = true
};
MakeMap();
var stack = new StackLayout {
Spacing = 0
};
map.VerticalOptions = LayoutOptions.FillAndExpand;
map.HeightRequest = 100;
map.WidthRequest = 960;
stack.Children.Add(map);
Content = stack;
}
public AccountDetailsTabView(Account account)
{
try
{
if (account != null)
{
this.Title = account.Company;
}
else
{
this.Title = "New Lead";
}
//ToolbarItems.Add(new ToolbarItem
//{
// Icon = "refresh.png",
// Name = "refresh"
// //Command = viewModelOrder.LoadOrdersCommand
//});
viewModelAcct = new AccountDetailsViewModel(account)
{
Navigation = Navigation
};
viewModelOrder = new OrdersViewModel(true, account.Id)
{
Navigation = Navigation
};
viewModelHistory = new OrdersViewModel(false, account.Id)
{
Navigation = Navigation
};
viewAcctDetails = new AccountDetailsView(viewModelAcct, viewModelHistory);
this.Children.Add(viewAcctDetails);
viewAcctOrders = new AccountOrdersView(account.Id, viewModelOrder)
{
Title = "Orders"
};
this.Children.Add(viewAcctOrders);
viewAcctHistory = new AccountHistoryView(viewModelHistory)
{
Title = "History"
};
this.Children.Add(viewAcctHistory);
viewAcctMap = new AccountMapView(viewModelAcct);
this.Children.Add(viewAcctMap);
}
catch (Exception exc)
{
System.Diagnostics.Debug.WriteLine("EXCEPTION: AccountDetailsTabView.Constructor(): " + exc.Message + " | " + exc.StackTrace);
}
} //end ctor
public AccountDetailsView(AccountDetailsViewModel vmAcct, OrdersViewModel vmOrders)
{
InitializeComponent();
vmOrders.Account = vmAcct.Account;
this.BindingContext = viewModelOrders = vmOrders;
this.Icon = "account.png";
this.Title = "Account";
}
public AccountNotesView(AccountDetailsViewModel vm)
{
SetBinding(Page.TitleProperty, new Binding("Title"));
SetBinding(Page.IconProperty, new Binding("Icon"));
this.BindingContext = viewModel = vm;
this.Content = this.BuildView();
} //end ctor
public ActionResult Create(string returnUrl)
{
returnUrl.ThrowIfNullOrEmpty();
var viewModel = new AccountDetailsViewModel {
ReturnUrl = returnUrl
};
return(View(viewModel));
}
public AccountContactView(AccountDetailsViewModel vm)
{
InitializeComponent();
SetBinding(Page.TitleProperty, new Binding("Title"));
//SetBinding(Page.IconProperty, new Binding("Icon"));
this.Icon = "contact.png";
this.BindingContext = vm;
} //end ctor
private void DetailsButton_Click(object sender, RoutedEventArgs e)
{
string name = acctTextBox.Text;
AccountDetailsViewModel vm = BankControlForm.Bank.GetDetailsByName(name);
if (vm != null)
{
acctDetailsGrid.DataContext = vm;
acctDetailsPanel.Visibility = Visibility.Visible;
}
}
private void InterestButton_Click(object sender, RoutedEventArgs e)
{
AcctListView_SelectionChanged(acctListView, null);
AccountDetailsViewModel vm = BankControlForm.Bank.GetDetailsByName(Vm.ActiveAccountName);
if (vm != null)
{
float interest = (vm.Type == AccountType.INTEREST_CHECKING ? BankControlForm.Bank.CheckingInterest : BankControlForm.Bank.SavingsInterest);
BankControlForm.Bank.PerformAction(Vm.ActiveAccountName, "accrue", interest);
}
}
private void AcctListView_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
int idx = (sender as ListView).SelectedIndex;
AccountDetailsViewModel details = BankControlForm.Bank.GetDetailsByIndex(idx);
if (details != null)
{
Vm.ActiveAccountName = details.AccountName;
}
acctDetailsPanel.Visibility = Visibility.Hidden;
}
public ActionResult Details(int id)
{
var crmAccount = _crmAccountRepository.GetBy(a => a.Id == id, "AssignedToEmployee.User.Person");
var contacts = _crmContactRepository.GetAllBy(c => c.ParentAccountId == crmAccount.Id, "Person").ToList();
var vm = new AccountDetailsViewModel(crmAccount)
{
Contacts = contacts
};
return(View(vm));
}
public async Task <IActionResult> AccountDetails(AccountDetailsViewModel details)
{
var user = await _usermanager.GetUserAsync(User);
if (user == null)
{
Challenge();
}
if (ModelState.IsValid)
{
// check if current password is correct
var passwordCheck = await _usermanager.CheckPasswordAsync(user, details.CurrentPassword);
if (passwordCheck)
{
// Check if password field is not empty, then change password.
if (!string.IsNullOrEmpty(details.NewPassword) && !string.IsNullOrEmpty(details.ConfirmNewPassword))
{
var changePassword = await
_usermanager.ChangePasswordAsync(user, details.CurrentPassword, details.NewPassword);
if (!changePassword.Succeeded)
{
// Append Errors
ModelState.AddModelError(nameof(AccountDetailsViewModel.NewPassword), "Password change failed");
ModelState.AddModelError(nameof(AccountDetailsViewModel.ConfirmNewPassword), "");
}
}
// Check if mail is not empty, then change email
if (!string.IsNullOrWhiteSpace(details.NewEmail))
{
var token = await _usermanager.GenerateChangeEmailTokenAsync(user, details.NewEmail);
var changeEmail = await _usermanager.ChangeEmailAsync(user, details.NewEmail, token);
if (!changeEmail.Succeeded)
{
// Append errors to model
ModelState.AddModelError(nameof(AccountDetailsViewModel.NewEmail), "Changing email failed");
}
else
{
details.CurrentEmail = details.NewEmail;
return(RedirectToAction("AccountDetails"));
}
}
}
else
{
ModelState.AddModelError(nameof(AccountDetailsViewModel.CurrentPassword), "Invalid password");
}
}
return(View(details));
}
public LeadDetailsTabView(Account l)
{
if (l != null)
{
this.Title = l.Company;
}
else
{
this.Title = "New Lead";
}
Account lead = l == null ? new Account()
{
IsLead = true
} : l;
viewModel = new AccountDetailsViewModel(lead)
{
Navigation = Navigation
};
//this.Children.Add(new LeadDetailsView(viewModel)
this.Children.Add(new LeadDetailsView(viewModel)
{
Title = "Company"
});
this.Children.Add(new AccountContactView(viewModel)
{
Title = "Contact"
});
this.Children.Add(new AccountMapView(viewModel)
{
Title = "Map"
});
ToolbarItems.Add(new ToolbarItem("Done", "save.png", async() =>
{
var confirmed = await DisplayAlert("Unsaved Changes", "Save changes?", "Save", "Discard");
if (confirmed)
{
viewModel.SaveAccountCommand.Execute(null);
}
else
{
viewModel.GoBack();
System.Diagnostics.Debug.WriteLine("cancel changes!");
}
}));
} //end ctor
public ActionResult Index()
{
var userViewModel = new AccountDetailsViewModel()
{
UserID = CurrentUser.Id,
Email = CurrentUser.Email,
Bio = CurrentUser.Bio,
StoryTellerName = CurrentUser.StoryTellerName
};
return(View(userViewModel));
}
public async Task <IActionResult> Account(int _accountId)
{
AccountDetailsViewModel model = await _mediator.Send(new GetAccountDetailsQuery { AccountId = _accountId });
if (model == null)
{
return(RedirectToAction("Overview"));
}
else
{
return(View(model));
}
}
public async Task <IActionResult> EditProfile(AccountDetailsViewModel model)
{
var user = await _userManager.GetUserAsync(User);
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.Address = model.Address;
user.FavoriteBook = model.FavoriteBook;
await _userManager.UpdateAsync(user);
return(View(model));
}
public frmCustomerAccount(Customer customer)
{
InitializeComponent();
FillTextBoxSince(customer);
this.customer = customer;
accountDetails = BLL.AccountServices.GetAccountDetails(customer);
var account = BLL.AccountServices.FindById(customer.CustomerID);
txtAccumulatedPoints.Text = accountDetails.AccumulatedPoints.ToString();
txtCashEquivalents.Text = accountDetails.CashEquivalent.ToString("C4");
}
public async Task <ActionResult> Details(AccountDetailsViewModel model)
{
var user = UserManager.Users.Where(u => u.Id == model.Id).FirstOrDefault();
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.PhoneNumber = model.PhoneNumber;
user.Email = model.Email;
await UserManager.UpdateAsync(user);
return(RedirectToAction("Index"));
}
//
// GET: /Manage/Index
public async Task <ActionResult> Index()
{
var userId = User.Identity.GetUserId();
var user = UserManager.FindById(userId);
var model = new AccountDetailsViewModel
{
HasPassword = HasPassword(),
UserDetails = user.UserDetails
};
return(View(model));
}
private async Task <AccountDetailsViewModel> GetAccountDetails()
{
var accountDetails = await _auth.AccountDetailsGetAsync(AccountId);
if (object.Equals(accountDetails, null))
{
return(null);
}
var accountDetailsViewModel = new AccountDetailsViewModel();
return(Mapper.Map(accountDetails, accountDetailsViewModel));
}
// GET: Accounts/Details/5
public async Task <ActionResult> Details(int?id)
{
Account account = db.Accounts.FirstOrDefault(x => x.Id == id);
//ApplicationUser user = db.Users.FirstOrDefault(x => x.UserName == User.Identity.Name);
//Household household = db.Households.FirstOrDefault(x => x.Id == account.HouseholdId);
//if (!household.Members.Contains(user))
//{
// throw new HttpException(401, "Unauthorized access");
//}
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
//Budget budget = new Budget();
AccountDetailsViewModel accountDetailsViewModel = new AccountDetailsViewModel();
//var account = await db.Accounts.FindAsync(id);
var budget = await db.Budgets.FindAsync(id);
//Passing my accounts and createTransactionViewModel properties to new accountDetailsViewModel in order
//to get everything on my accounts page to be functional
accountDetailsViewModel.Id = account.Id;
accountDetailsViewModel.HouseholdId = account.HouseholdId;
accountDetailsViewModel.Balance = account.Balance;
accountDetailsViewModel.Name = account.Name;
accountDetailsViewModel.ReconciledBalance = account.ReconciledBalance;
accountDetailsViewModel.Transactions = account.Transactions;
accountDetailsViewModel.TransactionCount = account.Transactions.Count();
if (budget != null)
{
accountDetailsViewModel.TotalBudgetAmount = budget.TotalBudgetAmount;
accountDetailsViewModel.AvailableToSpend = budget.TotalBudgetAmount - account.Balance;
accountDetailsViewModel.ProgressBar =
Decimal.ToInt32(Decimal.Round(Decimal.Divide(100 * account.Balance, budget.TotalBudgetAmount)));
}
accountDetailsViewModel.createTransactionViewModel = new CreateTransactionViewModel();
accountDetailsViewModel.createTransactionViewModel.AccountId = account.Id;
accountDetailsViewModel.createTransactionViewModel.Categories = new SelectList(db.Categories, "Id", "Name");
if (accountDetailsViewModel == null)
{
return(HttpNotFound());
}
IEnumerable <Transaction> Transactions = accountDetailsViewModel.Transactions.OrderByDescending(t => t.Date);
return(View(accountDetailsViewModel));
}
public ContentViewModel(IUnityContainer container, DataBase db)
{
_container = container;
_dataBase = db;
_ImagesViewModel = _container.Resolve <ImagesViewModel>();
_addImageViewModel = _container.Resolve <AddImageViewModel>();
_accountDetailsViewModel = _container.Resolve <AccountDetailsViewModel>();
CurrentContentViewModel = _ImagesViewModel;
NavCommand = new Command <string>(OnNav);
}
public ActionResult Accountant(AccountDetailsViewModel accountDetailsVM)
{
var installmentDetail = _installmentDetailService.GetInstallmentDetailById(accountDetailsVM.InstallmentId);
if (Session["UserDetails"] != null)
{
var user = Session["UserDetails"] as UserViewModel;
var instSigning = new InstallmentSigning();
instSigning.InstallmentId = installmentDetail.InstallmentId;
instSigning.Sign = accountDetailsVM.Sign;
instSigning.UserId = user.UserId;
instSigning.RoleId = (int)Common.Roles.Accountant;
instSigning.CreatedDate = DateTime.Now;
instSigning.CreatedBy = user.UserName;
instSigning.CompanyID = user.CompanyID;
installmentDetail.TransactionID = accountDetailsVM.TransactionId;
installmentDetail.ModifiedBy = user.UserName;
installmentDetail.ModifiedDate = DateTime.Now;
installmentDetail.StageID = (int)Common.WorkFlowStages.Accountant;
installmentDetail.TransactionDate = accountDetailsVM.TransactionDate;
installmentDetail.TransactionType = accountDetailsVM.TransactionType;
if (ModelState.IsValid)
{
installmentDetail.InstallmentSignings.Add(instSigning);
_installmentDetailService.Update(installmentDetail);
_installmentDetailService.SaveChanges();
ViewBag.Message = "sussess message";
return(View("_Accountant", accountDetailsVM));
}
else
{
var benificiaryDetails = _benificiaryService.GetBenificiaryById(installmentDetail.BeneficiaryId);
accountDetailsVM.InstallmentId = Convert.ToInt32(accountDetailsVM.InstallmentId);
accountDetailsVM.LoanAmnt = Convert.ToInt32(installmentDetail.LoanAmnt);
accountDetailsVM.IFSCCode = benificiaryDetails.IFSCCode;
accountDetailsVM.AccountNo = benificiaryDetails.AccountNo.ToString();
accountDetailsVM.LoanAmtInRupees = accountDetailsVM.LoanAmnt.ConvertNumbertoWords();
return(View("_Accountant", accountDetailsVM));
}
}
else
{
return(RedirectToAction("Login", "User"));
}
}
public void VerifyResetPasswordViewModel_PublicProperties()
{
var changeDate = DateTime.Now;
var lockoutDate = DateTime.Now;
var obj = new AccountDetailsViewModel
{
LastPasswordChangedDate = changeDate,
LockoutEndDateUtc = lockoutDate,
EmailConfirmed = true
};
Assert.AreEqual(changeDate, obj.LastPasswordChangedDate);
Assert.AreEqual(lockoutDate, obj.LockoutEndDateUtc);
Assert.AreEqual(true, obj.EmailConfirmed);
}
public async Task <IHttpActionResult> Details(AccountDetailsViewModel model)
{
try
{
var accountsDetail = new ViewAccountDetails();
accountsDetail = Mapper.Map(model, accountsDetail);
accountsDetail.Id = AccountId;
accountsDetail.GeoIp = IpAddressDetector.IpAddress;
await _auth.AccountDetailsSetAsync(accountsDetail);
}
catch (Exception exc) { return(Request.HttpExceptionResult(exc)); }
return(Ok());
}
public async Task <IActionResult> AccountDetails()
{
var model = new AccountDetailsViewModel();
var user = await _usermanager.GetUserAsync(User);
if (user == null)
{
Challenge();
}
model.UserName = user.UserName;
model.CurrentEmail = user.Email;
return(View(model));
}
public ActionResult EditAccount(string id, AccountDetailsViewModel model)
{
if (this.ModelState.IsValid)
{
AppUser userToEdit = this.users.GetUserDetails(id);
userToEdit.Avatar = model.Avatar;
userToEdit.Email = model.Email;
userToEdit.UserName = model.UserName;
userToEdit.FirstName = model.FirstName;
userToEdit.LastName = model.LastName;
this.users.UpdateUser(userToEdit);
return(this.RedirectToAction("ViewAccount", "Account", new { id = id }));
}
return(this.View(model));
}
public ActionResult Details()
{
var userId = User.Identity.GetUserId();
var user = UserManager.Users.Where(u => u.Id == userId).FirstOrDefault();
var model = new AccountDetailsViewModel
{
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
Id = user.Id,
PhoneNumber = user.PhoneNumber,
Username = user.UserName
};
return(View(model));
}
public IActionResult Transaction(AccountDetailsViewModel input)
{
var model = TempData.Get <AccountDetailsViewModel>("Model");
if (ModelState.IsValid)
{
var sender = _accountService.GetAccountById(input.InputTransaction.FromAccountWithId);
if (sender == null)
{
model.Message = "Error, account does not exist, please try again!";
return(View("../Account/DetailsAccount", model));
}
// is the senders balance sufficient
if (sender.Balance <= input.InputTransaction.Amount)
{
model.Message = "Error, insufficient funds in user account!";
return(View("../Account/DetailsAccount", model));
}
var recipient = _accountService.GetAccountByIBAN(input.InputTransaction.ToIBAN);
if (recipient != null)
{
if (sender.Id == recipient.Id)
{
model.Message = "Error, can't send money to same user account!";
return(View("../Account/DetailsAccount", model));
}
}
int currentUserId = int.Parse(_userService.GetUserId(User));
int transactionId = _financialTransactionService.EnactTransaction(sender, input.InputTransaction.Amount, currentUserId, input.InputTransaction.ToIBAN, recipient);
if (transactionId == int.MinValue)
{
model.Message = "There was an error while enacting the transaction, please try again later.";
return(View("../Account/DetailsAccount", model));
}
return(RedirectToAction("DetailsAccount", "Account", new { model.Id }));
}
return(View("../Account/DetailsAccount", model));
}