public AccountDetailsDTO GetAccountDetails(string MemberCode, string Connectionstring)
{
AccountDetailsDTO AccountDetailsDTO = new AccountDetailsDTO();
try
{
AccountDetailsDTO.RDAccountDetailsDTOList = new List <RDAccountDetailsDTO>();
string query = "select rdaccountid,rdaccountno,membername, accountid from tbltransrdcreation where upper(membercode) ='" + ManageQuote(MemberCode.ToUpper()) + "' and accountstatus='N' order by rdaccountno";
using (NpgsqlDataReader dr = NPGSqlHelper.ExecuteReader(Connectionstring, CommandType.Text, query))
{
while (dr.Read())
{
RDAccountDetailsDTO objAccountdetails = new RDAccountDetailsDTO();
objAccountdetails.paccountid = Convert.ToInt64(dr["rdaccountid"]);
objAccountdetails.paccountno = dr["rdaccountno"];
objAccountdetails.pMembername = dr["membername"];
objAccountdetails.pSubledgerid = Convert.ToInt64(dr["accountid"]);
AccountDetailsDTO.RDAccountDetailsDTOList.Add(objAccountdetails);
}
}
AccountDetailsDTO.RDSavingsAccountDetailsDTOList = GetAdjustmentDetils(MemberCode, Connectionstring);
}
catch (Exception ex)
{
throw ex;
}
return(AccountDetailsDTO);
}
public AccountDetailsDTO GetAccountInfoByUsername(string username)
{
try
{
using (var context = new HugoLANDContext())
{
CompteJoueur account = context.CompteJoueurs
.Where(p => p.NomJoueur == username)
.First();
AccountDetailsDTO a = new AccountDetailsDTO
{
Id = account.Id,
Email = account.Courriel,
LastName = account.Nom,
PlayerName = account.NomJoueur,
FirstName = account.Prenom,
TypeUtilisateur = account.TypeUtilisateur
};
return(a);
}
}
catch
{
return(null);
}
}
public IActionResult GetAccountDetails(string Membercode)
{
AccountDetailsDTO lstAccountDetails = new AccountDetailsDTO();
try
{
lstAccountDetails = objRdReceipt.GetAccountDetails(Membercode, Con);
return(lstAccountDetails != null?Ok(lstAccountDetails) : (IActionResult)StatusCode(StatusCodes.Status204NoContent));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
throw;
}
}
public async Task ReturnUser_WhenUserIsFound()
{
var userId = "userId";
var user = new User()
{
Id = userId
};
var userManagerWrapperMocked = new Mock <IUserManagerWrapper <User> >();
var mappingProviderMocked = new Mock <IMappingProvider>();
var dateTimeWrapperMocked = new Mock <IDateTimeWrapper>();
var role = "manager";
var roles = new List <string> {
role
};
var accountDetailsDTO = new AccountDetailsDTO
{
Id = userId
};
userManagerWrapperMocked.Setup(um => um.GetRolesAsync(It.IsAny <User>())).ReturnsAsync(roles);
User mapInput = user;
mappingProviderMocked.Setup(mpm => mpm.MapTo <AccountDetailsDTO>(It.IsAny <User>()))
.Returns(accountDetailsDTO);
AccountTestUtils.GetContextWithUser(nameof(ReturnUser_WhenUserIsFound), userId);
using (var assertContext = new AlphaHotelDbContext(AccountTestUtils.GetOptions(nameof(ReturnUser_WhenUserIsFound))))
{
var accountService = new AccountService(assertContext, userManagerWrapperMocked.Object, mappingProviderMocked.Object, dateTimeWrapperMocked.Object);
var account = await accountService.FindAccountAsync(userId);
Assert.AreEqual(userId, mapInput.Id);
Assert.AreEqual(role, account.Role);
}
}
public async Task <AccountDetailsDTO> GetAccountDetailsAsync(TransactionsFilter filter)
{
Account account;
if (filter != null && filter.AccountsIds != null && filter.AccountsIds.Any())
{
account = await accountRepository.GetAccountAsync(filter.AccountsIds.First());
}
else if (filter != null && filter.AccountsExternalIds != null && filter.AccountsExternalIds.Any())
{
account = await accountRepository.GetAccountAsync(filter.AccountsExternalIds.First().ToString());
}
else
{
throw new ArgumentNullException();
}
var dto = new AccountDetailsDTO
{
Currency = account.Currency.Code,
CurrencyId = account.CurrencyId,
CurrencySymbol = account.Currency.Symbol,
Id = account.Id,
ExternalId = Guid.Parse(account.ExternalId),
IsIncludedInTotal = account.IsIncludedToTotal,
Name = account.Name,
Comment = account.Comment,
AccountGroupId = account.AccountGroupId,
Type = account.Type,
ParentAccountId = account.ParentAccountId,
Order = account.Order,
Income = await accountRepository.GetIncomeAsync(account.Id, filter.FromDate, filter.ToDate),
Expense = await accountRepository.GetExpenseAsync(account.Id, filter.FromDate, filter.ToDate),
Amount = await accountRepository.GetActualBalanceAsync(account.Id),
};
return(dto);
}
public async Task CallAccountServiceOnce()
{
var accountId = "test";
var accountServiceMocked = new Mock <IAccountService>();
var businessServiceMocked = new Mock <IBusinessService>();
var mapperMocked = new Mock <IMappingProvider>();
var accountDTO = new AccountDetailsDTO {
Role = "Manager"
};
var accountVM = new AccountViewModel();
accountServiceMocked.Setup(a => a.FindAccountAsync(accountId))
.ReturnsAsync(accountDTO);
mapperMocked.Setup(m => m.MapTo <AccountViewModel>(accountDTO))
.Returns(accountVM);
var accountController = new AccountController(accountServiceMocked.Object, businessServiceMocked.Object, mapperMocked.Object);
await accountController.EditAccount(accountId);
accountServiceMocked.Verify(a => a.FindAccountAsync(accountId), Times.Once);
}
public IActionResult AccountDetails()
{
try
{
var CurrentUser = _context.Users.Find(userManager.GetUserId(User));
if (CurrentUser is null)
{
throw new DomainException(ErrorMessages.NotSignedIn);
}
var existingAccount = _userStore.GetByIdentityUserId(CurrentUser.Id);
if (existingAccount.AccountStatus.Equals(Status.Suspended))
{
signInManager.SignOutAsync();
}
var AccountDetails = new AccountDetailsDTO()
{
FirstName = existingAccount.FirstName,
LastName = existingAccount.LastName,
Username = existingAccount.Username,
EmailAddress = CurrentUser.Email
};
return(View(AccountDetails));
}
catch (DomainException ex)
{
_logger.LogError(ex.Message);
return(RedirectToAction("Login", "Accounts"));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(RedirectToAction("ServerError"));
}
}
public async Task ReturnCorrectViewModel_WhenRoleIsNotManager()
{
var accountId = "test";
var accountServiceMocked = new Mock <IAccountService>();
var businessServiceMocked = new Mock <IBusinessService>();
var mapperMocked = new Mock <IMappingProvider>();
var accountDTO = new AccountDetailsDTO {
Role = "Admin"
};
var accountVM = new AccountViewModel();
accountServiceMocked.Setup(a => a.FindAccountAsync(accountId))
.ReturnsAsync(accountDTO);
mapperMocked.Setup(m => m.MapTo <AccountViewModel>(accountDTO))
.Returns(accountVM);
var accountController = new AccountController(accountServiceMocked.Object, businessServiceMocked.Object, mapperMocked.Object);
var result = await accountController.EditAccount(accountId) as ViewResult;
businessServiceMocked.Verify(b => b.ListBusinessLogbooksAsync(0), Times.Never);
Assert.IsInstanceOfType(result.Model, typeof(AccountViewModel));
}
