public async Task <AccountItemViewModel> GetProfile()
{
_sharedService.WriteLogs("GetProfile started by:" + _userSettings.UserName, true);
try
{
var account = _identityContext.Users.Where(p => p.UserName == _userSettings.UserName).FirstOrDefault();
var vm = new AccountItemViewModel()
{
Id = account.Id,
FirstName = account.FirstName,
LastName = account.LastName,
Email = account.Email,
NormalizedEmail = account.NormalizedEmail,
PhoneNumber = account.PhoneNumber,
UserName = account.UserName,
LockoutEnabled = account.LockoutEnabled,
LockoutEnd = account.LockoutEnd,
CountryID = account.CountryID,
ProvinceID = account.ProvinceID
};
return(vm);
}
catch (Exception ex)
{
_sharedService.WriteLogs("GetProfile failed:" + ex.Message, false);
var vm = new AccountItemViewModel();
return(vm);
}
}
public async Task <AccountItemViewModel> GetAccountItem(string accountId)
{
_sharedService.WriteLogs("GetAccountItem started by:" + _userSettings.UserName, true);
try
{
var account = await _accountRepository.GetByIdAsync(accountId);
string countryname = string.Empty;
string provincename = string.Empty;
if (account.CountryID.HasValue)
{
countryname = _dbContext.Countries.Where(p => p.Id == account.CountryID.Value).FirstOrDefault().English;
}
if (account.ProvinceID.HasValue)
{
provincename = _dbContext.Provinces.Where(p => p.Id == account.ProvinceID.Value).FirstOrDefault().English;
}
var vm = new AccountItemViewModel()
{
Id = account.Id,
FirstName = account.FirstName,
LastName = account.LastName,
Email = account.Email,
EmailConfirmed = account.EmailConfirmed,
NormalizedEmail = account.NormalizedEmail,
PhoneNumber = account.PhoneNumber,
PhoneNumberConfirmed = account.PhoneNumberConfirmed,
UserName = account.UserName,
LockoutEnabled = account.LockoutEnabled,
LockoutEnd = account.LockoutEnd,
Lockout = account.LockoutEnabled == true ? "Yes" : "No",
CountryID = account.CountryID,
Country = countryname,
ProvinceID = account.ProvinceID,
Province = provincename
};
vm.Roles = await GetRoles();
var roles = await _userManager.GetRolesAsync(account);
if (roles != null && roles.Count > 0)
{
vm.RoleID = _accountRepository.GetRoleIDByname(roles.First());
}
return(vm);
}
catch (Exception ex)
{
_sharedService.WriteLogs("GetAccountItem failed:" + ex.Message, false);
var vm = new AccountItemViewModel();
return(vm);
}
}
private AccountItemViewModel CreateAccountItem(GitHubAccount githubAccount)
{
var viewModel = new AccountItemViewModel(githubAccount);
viewModel.Selected = Equals(githubAccount, ActiveAccount);
viewModel.DeleteCommand.Subscribe(_ => DeleteAccountCommand.ExecuteIfCan(githubAccount));
viewModel.GoToCommand.Subscribe(_ => LoginCommand.ExecuteIfCan(githubAccount));
return(viewModel);
}
public List <AccountItemViewModel> GetAccountList()
{
List <AccountItemViewModel> accountsVM = new List <AccountItemViewModel>();
var accounts = database.GetAccounts().OrderByDescending(a => a.Amount).ToList();
foreach (var item in accounts)
{
var account = new AccountItemViewModel(item);
accountsVM.Add(account);
}
return(accountsVM);
}
public async Task CreateAccountAsync(AccountItemViewModel account)
{
_sharedService.WriteLogs("CreateAccountAsync started by:" + _userSettings.UserName, true);
try
{
if (!string.IsNullOrEmpty(account.Email))
{
if (!ValidateExtension.IsEmailValid(account.Email))
{
_sharedService.WriteLogs("Email: " + account.Email + " is invalid.", false);
return;
}
}
var user = new EDIApplicationUser
{
UserName = account.Email,
Email = account.Email,
PhoneNumber = account.PhoneNumber,
FirstName = account.FirstName,
LastName = account.LastName,
CountryID = account.CountryID,
ProvinceID = account.ProvinceID
};
var result = await _userManager.CreateAsync(user);
if (!string.IsNullOrEmpty(account.RoleID))
{
var role = await _accountRepository.GetRoleByIdAsync(account.RoleID);
await _userManager.AddToRoleAsync(user, role.Name);
}
if (result.Succeeded)
{
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//var callbackUrl = _urlHelper.EmailConfirmationLink(user.Id, code, account.Scheme);
var callbackUrl = @"htts://fanout.phri.ca";
await _emailSender.SendEmailConfirmationAsync(account.Email, callbackUrl, user.FirstName);
_logger.LogInformation("User created a new account with password.");
}
}
catch (Exception ex)
{
_sharedService.WriteLogs("CreateAccount failed:" + ex.Message, false);
}
}
public async Task UpdateAccountAsync(AccountItemViewModel account)
{
_sharedService.WriteLogs("UpdateAccountAsync started by:" + _userSettings.UserName, true);
try
{
var _account = await _accountRepository.GetByIdAsync(account.Id);
_account.LastName = account.LastName;
_account.FirstName = account.FirstName;
//_account.OrganizationId = account.OrganizationId;
_account.CountryID = account.CountryID;
_account.ProvinceID = account.ProvinceID;
_account.Email = account.Email;
_account.PhoneNumber = account.PhoneNumber;
if (!string.IsNullOrEmpty(account.Password))
{
var newPassword = _userManager.PasswordHasher.HashPassword(_account, account.Password);
_account.PasswordHash = newPassword;
}
if (!string.IsNullOrEmpty(account.RoleID))
{
var roles = await _userManager.GetRolesAsync(_account);
await _userManager.RemoveFromRolesAsync(_account, roles);
var role = await _accountRepository.GetRoleByIdAsync(account.RoleID);
await _userManager.AddToRoleAsync(_account, role.Name);
}
await _userManager.UpdateAsync(_account);
}
catch (Exception ex)
{
_sharedService.WriteLogs("UpdateAccountAsync failed:" + ex.Message, false);
}
}
internal void DeleteAccount(AccountItemViewModel accountItem)
{
var account = accountItem.Account;
var totalt = (from i in Transfers
where i.AccountIn.Name.Equals(account.Name) || i.AccountOut.Name.Equals(account.Name)
select i).Count();
var totali = (from i in Incomings
where i.Account.Name.Equals(account.Name)
select i).Count();
var totale = (from e in Expenses
where e.Account.Name.Equals(account.Name)
select e).Count();
if (totale == 0 && totali == 0)
{
Accounts.Remove(account);
SaveAccounts();
}
else
{
throw new DataHasChildrenException();
}
}
