public ActionResult GetAll()
{
try
{
using (var context = new PrincipalContext(ContextType.Machine))
{
using (var user = new UserPrincipal(context))
{
using (var searcher = new PrincipalSearcher(user))
{
var resultList = searcher.FindAll().ToList();
List <UserIdentityViewModel> viewModel = new List <UserIdentityViewModel>();
foreach (var item in resultList)
{
var tmp = new UserIdentityViewModel()
{
Name = item.Name,
DisplayName = item.DisplayName,
Description = item.Description
};
viewModel.Add(tmp);
}
return(PartialView("_GetAll", viewModel));
}
}
}
}
catch
{
throw;
}
}
public UserIdentityPage()
{
InitializeComponent();
userIdentityViewModel = new UserIdentityViewModel();
userIdentityViewModel.navigation = Navigation;
this.BindingContext = userIdentityViewModel;
}
private async Task <string> CreateCustomer(UserIdentityViewModel user, CustomerInfoViewModel model)
{
try
{
var customer = new Customer
{
FullName = model.FullName,
CustomerCode = model.CustomerCode,
Email = model.Email,
Address = model.Address,
Phone = model.PhoneNumber,
SelectedReceiverId = model.SelectedReceiverId,
CreatedOn = DateTimeOffset.Now,
CreatedBy = user?.UserId
};
_unitOfWork.CustomerRepository.Add(customer);
await _unitOfWork.SaveChangeAsync();
return(customer.CustomerId.ToString());
}
catch (Exception ex)
{
return("Save.Error");
}
}
private async Task <string> UpdateReceiver(UserIdentityViewModel user, ReceiverInfoViewModel model)
{
try
{
var customer = _unitOfWork.ReceiverRepository.All().FirstOrDefault(s => s.ReceiverId == model.ReceiverId);
customer.ReceiverName = model.ReceiverName;
customer.ReceiverIdentityCard = model.ReceiverIdentityCard;
customer.IDIssueDate = model.IDIssueDate;
customer.ReceiverPhone1 = model.ReceiverPhone1;
customer.ReceiverPhone2 = model.ReceiverPhone2;
customer.BankName = model.BankName;
customer.BankAccount = model.BankAccount;
customer.BranchName = model.BranchName;
customer.Province = model.Province;
customer.District = model.District;
customer.UpdatedBy = user.UserId;
customer.UpdatedOn = DateTimeOffset.Now;
await _unitOfWork.SaveChangeAsync();
return("Save.Success");
}
catch (Exception)
{
return("Save.Error");
}
}
public TransactionDetailViewModel GetTransactionDetail(UserIdentityViewModel user, int customerId)
{
var storeName = _unitOfWork.UserRepository.All().FirstOrDefault(s => s.Id == user.UserId)?.StoreName;
var customer = _unitOfWork.CustomerRepository.All().FirstOrDefault(s => s.CustomerId == customerId);
var defaultReceiver = _unitOfWork.ReceiverRepository.All().FirstOrDefault(s => s.ReceiverId == customer.SelectedReceiverId);
var sender = Utils.GetSenderInfo();
return(new TransactionDetailViewModel
{
TransactionNo = GenerateTransactionNo(customerId),
StoreName = storeName,
CustomerId = customer.CustomerId,
CustomerCode = customer.CustomerCode,
CustomerName = customer.FullName,
CustomerPhone = customer.Phone,
ReceiverId = defaultReceiver.ReceiverId,
ReceiverName = defaultReceiver.ReceiverName,
ReceiverPhone = defaultReceiver.ReceiverPhone1,
ReceiverAccountNumber = defaultReceiver.BankAccount,
BankName = defaultReceiver.BankName,
BranchName = defaultReceiver.BranchName,
Province = defaultReceiver.Province,
District = defaultReceiver.District,
IDNumber = defaultReceiver.ReceiverIdentityCard,
IDIssueDate = defaultReceiver.IDIssueDate,
SenderName = sender.Name,
SenderPhone = sender.Phone
});
}
private async Task <string> CreateReceiver(UserIdentityViewModel user, ReceiverInfoViewModel model)
{
try
{
var receiver = new Receiver
{
CustomerId = model.CustomerId,
ReceiverName = model.ReceiverName,
ReceiverIdentityCard = model.ReceiverIdentityCard,
IDIssueDate = model.IDIssueDate,
ReceiverPhone1 = model.ReceiverPhone1,
ReceiverPhone2 = model.ReceiverPhone2,
BankName = model.BankName,
BankAccount = model.BankAccount,
BranchName = model.BranchName,
Province = model.Province,
District = model.District,
CreatedOn = DateTimeOffset.Now,
CreatedBy = user.UserId
};
_unitOfWork.ReceiverRepository.Add(receiver);
await _unitOfWork.SaveChangeAsync();
return("Save.Success");
}
catch (Exception)
{
return("Save.Error");
}
}
public async Task UpdateUserIdentity_WhenCalledWithoutModelAndIdentifierIsKnown_ReturnsViewResultWhereModelIsUserIdentityViewModel()
{
IList <Claim> claimCollection = _fixture.CreateMany <Claim>(_random.Next(5, 10)).ToList();
IList <Claim> userIdentityClaimCollection = claimCollection.Take(2).ToList();
IUserIdentity userIdentity = _fixture.BuildUserIdentityMock(claims: userIdentityClaimCollection).Object;
Controller sut = CreateSut(claimCollection, userIdentity: userIdentity);
ViewResult result = (ViewResult)await sut.UpdateUserIdentity(_fixture.Create <int>());
Assert.That(result.Model, Is.TypeOf <UserIdentityViewModel>());
UserIdentityViewModel userIdentityViewModel = (UserIdentityViewModel)result.Model;
Assert.That(userIdentityViewModel, Is.Not.Null);
Assert.That(userIdentityViewModel.Identifier, Is.EqualTo(userIdentity.Identifier));
Assert.That(userIdentityViewModel.ExternalUserIdentifier, Is.EqualTo(userIdentity.ExternalUserIdentifier));
Assert.That(userIdentityViewModel.EditMode, Is.EqualTo(EditMode.Edit));
Assert.That(userIdentityViewModel.Claims, Is.Not.Null);
Assert.That(userIdentityViewModel.Claims, Is.Not.Empty);
Assert.That(userIdentityViewModel.Claims.Count(), Is.EqualTo(claimCollection.Count));
foreach (Claim claim in claimCollection)
{
Assert.That(userIdentityViewModel.Claims.SingleOrDefault(m => string.CompareOrdinal(m.ClaimType, claim.Type) == 0), Is.Not.Null);
}
Assert.That(userIdentityViewModel.Claims.Count(m => m.IsSelected), Is.EqualTo(userIdentityClaimCollection.Count));
foreach (Claim claim in userIdentityClaimCollection)
{
Assert.That(userIdentityViewModel.Claims.SingleOrDefault(m => m.IsSelected && string.CompareOrdinal(m.ClaimType, claim.Type) == 0 && string.Compare(m.ActualValue, claim.Value) == 0), Is.Not.Null);
}
}
public async Task UpdateUserIdentity_WhenCalledWithValidModel_ReturnsRedirectToActionResultWhereActionNameIsEqualToUserIdentities()
{
Controller sut = CreateSut();
UserIdentityViewModel model = CreateModel();
RedirectToActionResult result = (RedirectToActionResult)await sut.UpdateUserIdentity(model);
Assert.That(result.ActionName, Is.EqualTo("UserIdentities"));
}
public async Task CreateUserIdentity_WhenCalledWithValidModel_ReturnsRedirectToActionResultWhereContollerNameIsEqualToSecurity()
{
Controller sut = CreateSut();
UserIdentityViewModel model = CreateModel();
RedirectToActionResult result = (RedirectToActionResult)await sut.CreateUserIdentity(model);
Assert.That(result.ControllerName, Is.EqualTo("Security"));
}
public async Task UpdateUserIdentity_WhenCalledWithValidModel_ReturnsRedirectToActionResult()
{
Controller sut = CreateSut();
UserIdentityViewModel model = CreateModel();
IActionResult result = await sut.UpdateUserIdentity(model);
Assert.That(result, Is.TypeOf <RedirectToActionResult>());
}
public async Task UpdateUserIdentity_WhenCalledWithInvalidModel_ReturnsViewResultWhereViewNameIsEqualToUpdateUserIdentity()
{
Controller sut = CreateSut(modelIsValid: false);
UserIdentityViewModel model = CreateModel();
ViewResult result = (ViewResult)await sut.UpdateUserIdentity(model);
Assert.That(result.ViewName, Is.EqualTo("UpdateUserIdentity"));
}
public CharacterIdentityViewModel(
long id,
string name,
UserIdentityViewModel owner)
{
Id = id;
Name = name;
Owner = owner;
}
public async Task CreateUserIdentity_WhenCalledWithInvalidModel_ReturnsViewResult()
{
Controller sut = CreateSut(modelIsValid: false);
UserIdentityViewModel model = CreateModel();
IActionResult result = await sut.CreateUserIdentity(model);
Assert.That(result, Is.TypeOf <ViewResult>());
}
public async Task UpdateUserIdentity_WhenCalledWithValidModel_AssertPublishAsyncWasCalledOnCommandBus()
{
Controller sut = CreateSut();
UserIdentityViewModel model = CreateModel();
await sut.UpdateUserIdentity(model);
_commandBusMock.Verify(m => m.PublishAsync(It.Is <IUpdateUserIdentityCommand>(command => command.Identifier == model.Identifier && string.CompareOrdinal(command.ExternalUserIdentifier, model.ExternalUserIdentifier) == 0 && command.Claims.Count() == model.Claims.Count(claimViewModel => claimViewModel.IsSelected))), Times.Once);
}
public void DeleteUser(Guid id, UserIdentityViewModel CurrentUserIdentity)
{
var user = _unitOfWork.UserRepository.All().FirstOrDefault(s => s.Id == id);
user.DeletedBy = CurrentUserIdentity.UserId;
user.DeletedOn = DateTimeOffset.UtcNow;
_unitOfWork.UserRepository.Update(user);
_unitOfWork.SaveChange();
}
public async Task UpdateUserIdentity_WhenCalledWithInvalidModel_AssertPublishAsyncWasNotCalledOnCommandBus()
{
Controller sut = CreateSut(modelIsValid: false);
UserIdentityViewModel model = CreateModel();
await sut.UpdateUserIdentity(model);
_commandBusMock.Verify(m => m.PublishAsync(It.IsAny <IUpdateUserIdentityCommand>()), Times.Never);
}
// GET: Users
public ActionResult ListUsers()
{
ViewBag.Title = "All Users";
UserIdentityViewModel userData = GetAllUserData();
userData.UserData = userData.UserData.OrderBy(u => u.YearOfBirth)
.ToList();
ViewBag.UserData = userData;
return(View());
}
public async Task <string> SaveTransaction(UserIdentityViewModel user, TransactionDetailViewModel model)
{
if (string.IsNullOrEmpty(model.TransactionNo))
{
return(await CreateTransaction(user, model));
}
else
{
return(await UpdateTransaction(user, model));
}
}
public async Task <IActionResult> CreateUserIdentity()
{
IEnumerable <Claim> systemClaims = await _queryBus.QueryAsync <EmptyQuery, IEnumerable <Claim> >(new EmptyQuery());
UserIdentityViewModel userIdentityViewModel = new UserIdentityViewModel
{
Claims = BuildClaimViewModelCollection(systemClaims, new List <Claim>(0)),
EditMode = EditMode.Create
};
return(View("CreateUserIdentity", userIdentityViewModel));
}
public async Task UpdateUserIdentity_WhenCalledWithInvalidModel_ReturnsViewResultWhereModelIsEqualToInvalidModel()
{
Controller sut = CreateSut(modelIsValid: false);
UserIdentityViewModel model = CreateModel();
ViewResult result = (ViewResult)await sut.UpdateUserIdentity(model);
Assert.That(result.Model, Is.TypeOf <UserIdentityViewModel>());
UserIdentityViewModel userIdentityViewModel = (UserIdentityViewModel)result.Model;
Assert.That(userIdentityViewModel, Is.EqualTo(model));
}
public async Task <string> DeleteReceiver(UserIdentityViewModel user, int id)
{
var receiver = _unitOfWork.ReceiverRepository.All().FirstOrDefault(s => s.ReceiverId == id);
if (receiver == null)
{
return("Receiver.NotExist");
}
_unitOfWork.ReceiverRepository.Delete(receiver);
await _unitOfWork.SaveChangeAsync();
return("Delete.Success");
}
public async Task <string> DeleteCustomer(UserIdentityViewModel user, int id)
{
string result = string.Empty;
var customer = _unitOfWork.CustomerRepository.All().FirstOrDefault(s => s.CustomerId == id);
if (customer == null)
{
return("Customer.NotExist");
}
result = await DeleteReceiver(user, id);
return(result);
}
public async Task <string> SaveCustomer(UserIdentityViewModel user, CustomerInfoViewModel model)
{
string result = string.Empty;
if (model.CustomerId == 0)
{
result = await CreateCustomer(user, model);
}
else
{
result = await UpdateCustomer(user, model);
}
return(result);
}
public async Task <IActionResult> CreateUserIdentity(UserIdentityViewModel userIdentityViewModel)
{
NullGuard.NotNull(userIdentityViewModel, nameof(userIdentityViewModel));
if (ModelState.IsValid == false)
{
return(View("CreateUserIdentity", userIdentityViewModel));
}
ICreateUserIdentityCommand command = _securityViewModelConverter.Convert <UserIdentityViewModel, CreateUserIdentityCommand>(userIdentityViewModel);
await _commandBus.PublishAsync(command);
return(RedirectToAction("UserIdentities", "Security"));
}
public void Constructor_Always_ReturnsIdentity(
ulong id,
string username,
string discriminator)
{
var result = new UserIdentityViewModel(
id,
username,
discriminator);
result.Id.ShouldBe(id);
result.Username.ShouldBe(username);
result.Discriminator.ShouldBe(discriminator);
}
public string UpdateUserInfo(UserBasicInfoViewModel model, UserIdentityViewModel cruser)
{
//var existed = _unitOfWork.UserRepository.All().Where(s => s.DeletedBy == null && s.CompanyId == cruser.CompanyId).Select(s => s.Email).Any(s => s == model.Email);
//if (existed)
//{
// return "User.EmailDuplicate";
//}
var user = _unitOfWork.UserRepository.All().FirstOrDefault(s => s.DeletedBy == null && s.Id == cruser.UserId);
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.PhoneNumber = model.Phone;
//user.Email = model.Email;
_unitOfWork.SaveChange();
return(string.Empty);
}
public async Task <IActionResult> UpdateUserIdentity(int identifier)
{
IEnumerable <Claim> systemClaims = await _queryBus.QueryAsync <EmptyQuery, IEnumerable <Claim> >(new EmptyQuery());
IUserIdentity userIdentity = await _queryBus.QueryAsync <IGetUserIdentityQuery, IUserIdentity>(new GetUserIdentityQuery { Identifier = identifier });
if (userIdentity == null)
{
return(RedirectToAction("UserIdentities", "Security"));
}
UserIdentityViewModel userIdentityViewModel = _securityViewModelConverter.Convert <IUserIdentity, UserIdentityViewModel>(userIdentity);
userIdentityViewModel.Claims = BuildClaimViewModelCollection(systemClaims, userIdentity.ToClaimsIdentity().Claims);
userIdentityViewModel.EditMode = EditMode.Edit;
return(View("UpdateUserIdentity", userIdentityViewModel));
}
public async Task <string> CreateUser(RegisterViewModel model, UserIdentityViewModel CurrentUserIdentity)
{
var user = new User
{
FirstName = model.FirstName,
LastName = model.LastName,
UserName = model.UserName,
Email = model.Email,
PhoneNumber = model.PhoneNumber,
LanguageId = model.LanguageId,
CreatedOn = DateTimeOffset.UtcNow,
};
string passWord = "******"; //UserCommon.GeneratePassword();
var existed = _unitOfWork.UserRepository.All().Any(s => s.DeletedBy == null &&
(s.UserName == user.UserName || s.PhoneNumber == model.PhoneNumber));
if (existed)
{
return("User.Existed");
}
user.EmailConfirmed = true;
var result = await _userManager.CreateAsync(user, passWord);
//If failed, return bad request
if (result.Succeeded)
{
// set user as active (already confirm the email)
var role = _unitOfWork.RoleRepository.All().FirstOrDefault(s => s.Name == "R2").Id;
var userRole = new UserRole()
{
RoleId = role,
UserId = user.Id
};
_unitOfWork.UserRoleRepository.Add(userRole);
await _unitOfWork.SaveChangeAsync();
//If failed, return bad request
return("SignUp.SavedSucess");
}
return("User.CreateUserFailed");
}
private async Task <string> UpdateCustomer(UserIdentityViewModel user, CustomerInfoViewModel model)
{
try
{
var customer = _unitOfWork.CustomerRepository.All().FirstOrDefault(s => s.CustomerId == model.CustomerId);
customer.CustomerCode = model.CustomerCode;
customer.FullName = model.FullName;
customer.Email = model.Email;
customer.Address = model.Address;
customer.Phone = model.PhoneNumber;
customer.SelectedReceiverId = model.SelectedReceiverId;
customer.UpdatedBy = user.UserId;
customer.UpdatedOn = DateTimeOffset.Now;
await _unitOfWork.SaveChangeAsync();
return(customer.CustomerId.ToString());
}
catch (Exception)
{
return("Save.Error");
}
}
private async Task <string> UpdateTransaction(UserIdentityViewModel user, TransactionDetailViewModel model)
{
try
{
var transaction = _unitOfWork.TransactionRepository.All().FirstOrDefault(s => s.TransactionId == model.TransactionId);
if (transaction == null)
{
return("Transaction.NotExist");
}
transaction.ReceiverId = model.ReceiverId;
transaction.CurrencyId = model.CurrencyId;
transaction.Amount = model.Amount;
transaction.UpdatedOn = DateTimeOffset.Now;
transaction.UpdatedBy = user.UserId;
await _unitOfWork.SaveChangeAsync();
}
catch (Exception ex)
{
return("Transaction.SaveError");
}
return("Transaction.SaveSuccess");
}
