protected override async Task OnInitializedAsync()
{
try
{
EmployeeService = ScopedServices.GetRequiredService <IEmployeeService>();
TemplateService = ScopedServices.GetRequiredService <ITemplateService>();
LdapService = ScopedServices.GetRequiredService <ILdapService>();
RemoteDeviceConnectionsService = ScopedServices.GetRequiredService <IRemoteDeviceConnectionsService>();
Employee = await EmployeeService.GetEmployeeByIdAsync(EmployeeId);
Templates = await TemplateService.GetTemplatesAsync();
PersonalAccount = new AccountAddModel()
{
EmployeeId = EmployeeId
};
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
await ModalDialogCancel();
}
}
public async Task <ActionResult <Account> > CreateAccount(CreateAccountDto accountDto)
{
Account createdAccount;
try
{
var personalAccount = new AccountAddModel()
{
Name = accountDto.Name,
Urls = accountDto.Urls,
Apps = accountDto.Apps,
LoginType = accountDto.LoginType,
Login = accountDto.Login,
EmployeeId = accountDto.EmployeeId,
Password = accountDto.Password,
OtpSecret = accountDto.OtpSecret
};
createdAccount = await _employeeService.CreatePersonalAccountAsync(personalAccount);
_remoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(await _employeeService.GetEmployeeVaultIdsAsync(createdAccount.EmployeeId));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(StatusCode(500, new { error = ex.Message }));
}
return(CreatedAtAction("GetAccountById", new { id = createdAccount.Id }, createdAccount));
}
public ActionResult AddForAjax(AccountAddModel model)
{
if (ModelState.IsValid)
{
if (model.Password != model.ConfirmPassword)
{
return(Json(new ServiceResult("密码输入").IsFailed()));
}
SYS_User user = new SYS_User()
{
SystemUserId = Guid.NewGuid().ToString(),
CreateTime = DateTime.Now,
Email = model.Email,
Mobile = model.Mobile,
Password = AuthorizeHelper.GetEncPassword(model.Password),
RealName = model.RealName,
UserName = model.UserName,
UserType = model.UserType,
Status = model.Status
};
return(Json(this.accountService.Add(user)));
}
else
{
return(Json(new ServiceResult(GetModelStateMessage()).IsFailed()));
}
}
public async Task <IActionResult> Create(AccountAddModel account)
{
ResultLog resultLog = new ResultLog();
if (ModelState.IsValid)
{
if (!await _redisService.IsExistKey(accountTableKey, account.AccountNumber))
{
//ToDo: Use AutoMapper and DTO
resultLog.IsError = !await _redisService.CreateHashSetDataAsync(accountTableKey, account.AccountNumber,
new Account
{
AccountNumber = account.AccountNumber,
Balance = Math.Round(account.Balance, 2), //limited 2 digits
CurrencyCode = account.CurrencyCode.ToString()
});
if (resultLog.IsError)
{
return(StatusCode((int)Enums.Enums.StatusCode.ISSUER_OR_SWITCH_INOPERATIVE, resultLog));
}
return(StatusCode((int)Enums.Enums.StatusCode.CREATED, resultLog));
}
else
{
return(StatusCode((int)Enums.Enums.StatusCode.CONFLICT,
ActionResultHelper.CreateActionResultJson(Enums.Enums.StatusCode.CONFLICT, "AccountNumber should be unique")));
}
}
return(ValidationProblem());
}
public async Task <ActionResult> Add(WebUser user, AccountAddModel model)
{
if (ModelState.IsValid)
{
var account = new Account()
{
AccountName = model.AccountName,
Cash = model.Cash,
Use = model.Use,
UserId = user.Id
};
try
{
await _accountService.CreateAsync(account);
return(RedirectToAction("Index"));
}
catch (ServiceException e)
{
throw new WebUiException($"Ошибка в контроллере {nameof(AccountController)} в методе {nameof(Add)}", e);
}
}
return(PartialView(model));
}
public async Task <IResultModel <Guid> > Add(AccountAddModel model, IUnitOfWork uow = null)
{
var result = new ResultModel <Guid>();
var account = _mapper.Map <AccountEntity>(model);
var exists = await Exists(account);
if (!exists.Successful)
{
return(exists);
}
//设置默认密码
if (account.Password.IsNull())
{
var config = _configProvider.Get <AdminConfig>();
account.Password = config.DefaultPassword.NotNull() ? config.DefaultPassword : "******";
}
account.Password = _passwordHandler.Encrypt(account.UserName, account.Password);
//如果uow参数为空，需要自动处理工作单元
var noUow = uow == null;
if (noUow)
{
uow = _dbContext.NewUnitOfWork();
}
if (await _accountRepository.AddAsync(account, uow))
{
if (model.Roles != null && model.Roles.Any())
{
var accountRoleList = model.Roles.Select(m => new AccountRoleEntity {
AccountId = account.Id, RoleId = m
}).ToList();
if (await _accountRoleRepository.AddAsync(accountRoleList, uow))
{
if (noUow)
{
uow.Commit();
}
return(result.Success(account.Id));
}
}
else
{
if (noUow)
{
uow.Commit();
}
return(result.Success(account.Id));
}
}
return(result.Failed());
}
public async Task <Account> CreatePersonalAccountAsync(AccountAddModel personalAccount)
{
if (personalAccount == null)
{
throw new ArgumentNullException(nameof(personalAccount));
}
_dataProtectionService.Validate();
var account = new Account()
{
Id = Guid.NewGuid().ToString(),
Name = personalAccount.Name,
Urls = Validation.VerifyUrls(personalAccount.Urls),
Apps = personalAccount.Apps,
Login = await ValidateAccountNameAndLoginAsync(personalAccount.EmployeeId, personalAccount.Name, personalAccount.GetLogin()),
AccountType = AccountType.Personal,
LoginType = personalAccount.LoginType,
CreatedAt = DateTime.UtcNow,
PasswordUpdatedAt = DateTime.UtcNow,
OtpUpdatedAt = Validation.VerifyOtpSecret(personalAccount.OtpSecret) != null ? new DateTime?(DateTime.UtcNow) : null,
Password = _dataProtectionService.Encrypt(personalAccount.Password),
OtpSecret = _dataProtectionService.Encrypt(personalAccount.OtpSecret),
UpdateInActiveDirectory = personalAccount.UpdateInActiveDirectory,
EmployeeId = personalAccount.EmployeeId,
StorageId = new StorageId().Data
};
Employee employee = await GetEmployeeByIdAsync(personalAccount.EmployeeId);
List <HardwareVaultTask> tasks = new List <HardwareVaultTask>();
foreach (var vault in employee.HardwareVaults)
{
tasks.Add(_hardwareVaultTaskService.GetAccountCreateTask(vault.Id, account.Id, account.Password, account.OtpSecret));
}
using (TransactionScope transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await _accountService.AddAsync(account);
await SetAsPrimaryAccountIfEmptyAsync(account.EmployeeId, account.Id);
if (tasks.Count > 0)
{
await _hardwareVaultTaskService.AddRangeTasksAsync(tasks);
await _hardwareVaultService.UpdateNeedSyncAsync(employee.HardwareVaults, true);
}
transactionScope.Complete();
}
return(account);
}
public async Task <IResultModel <Guid> > Add(AccountAddModel model)
{
var result = new ResultModel <Guid>();
var account = _mapper.Map <AccountEntity>(model);
var exists = await Exists(account);
if (!exists.Successful)
{
return(exists);
}
//默认未激活状态，用户首次登录激活
account.Status = AccountStatus.Inactive;
//设置默认密码
if (account.Password.IsNull())
{
account.Password = DefaultPassword;
}
account.Password = EncryptPassword(account.UserName.ToLower(), account.Password);
using (var tran = _accountRepository.BeginTransaction())
{
if (await _accountRepository.AddAsync(account, tran))
{
if (model.Roles != null && model.Roles.Any())
{
var accountRoleList = model.Roles.Select(m => new AccountRoleEntity {
AccountId = account.Id, RoleId = m
}).ToList();
if (await _accountRoleRepository.AddAsync(accountRoleList, tran))
{
tran.Commit();
return(result.Success(account.Id));
}
}
else
{
tran.Commit();
return(result.Success(account.Id));
}
}
}
return(result.Failed());
}
public async Task AddModelStateValidReturnsRedirectToIndex()
{
var accountViewModel = new AccountAddModel()
{
AccountName = "Acc1"
};
var target = new AccountController(_mockAccountService.Object);
var result = await target.Add(new WebUser()
{
Id = "1"
}, accountViewModel);
Assert.IsInstanceOfType(result, typeof(RedirectToRouteResult));
}
public void Add_ValidObjectPassed_ReturnsCreatedResponse()
{
// Arrange
var newAccount = new AccountAddModel
{
AccountNumber = 88,
Balance = 100,
CurrencyCode = Enums.CurrencyCode.TRY
};
// Act
var createdResponse = _accountsController.Create(newAccount).Result;
// Assert
var objectResult = Assert.IsType <ObjectResult>(createdResponse);
Assert.Equal(201, objectResult.StatusCode);
}
public void Add_AlreadyExistObjectPassed_ReturnsConflictRequest()
{
// Arrange
var newAccount = new AccountAddModel
{
AccountNumber = 99,
Balance = 10,
CurrencyCode = Enums.CurrencyCode.TRY
};
// Act
var conflictResponse = _accountsController.Create(newAccount).Result;
// Assert
var objectResult = Assert.IsType <ObjectResult>(conflictResponse);
Assert.Equal(409, objectResult.StatusCode);
}
public async Task <IResultModel> Add(UserAddModel model)
{
var entity = _mapper.Map <UserEntity>(model);
var maxJobNumber = await _repository.GetMaxJobNumber();
if (maxJobNumber < 1)
{
maxJobNumber = _options.UserInitialJobNumber;
}
if (maxJobNumber < 1)
{
//д╛хо100000
maxJobNumber = 100000;
}
entity.JobNo = maxJobNumber + 1;
var account = new AccountAddModel
{
Type = 1,
UserName = model.UserName,
Phone = model.Phone,
Email = model.Email,
Name = model.Name,
Roles = model.Roles,
Password = model.Password
};
_adminUow.BeginTransaction();
var result = await _accountService.Add(account);
if (result.Successful)
{
entity.AccountId = result.Data;
_uow.BeginTransaction();
if (await _repository.AddAsync(entity))
{
_adminUow.Commit();
_uow.Commit();
return(ResultModel.Success());
}
}
return(result);
}
public async Task Cannot_Add_Invalid_Account()
{
var accountViewModel = new AccountAddModel()
{
AccountName = "Acc1"
};
var target = new AccountController(null);
target.ModelState.AddModelError("error", "error");
var result = await target.Add(new WebUser()
{
Id = "1"
}, accountViewModel);
Assert.IsInstanceOfType(result, typeof(PartialViewResult));
}
public async Task <Account> AddAccount(AccountAddModel account)
{
Account exitedAccount = await unitOfWork.AccountRepository.SingleOrDefaultAsync(a => a.Name == account.Name && a.UserId == account.UserId);
if (exitedAccount == null)
{
await unitOfWork.AccountRepository.AddAsync(mapper.Map <AccountAddModel, Account>(account));
await unitOfWork.Complete();
return(null);
}
else
{
return(exitedAccount);
}
}
public async Task <IResultModel> Add(AccountAddModel model)
{
var account = _mapper.Map <Account>(model);
var exists = await Exists(account);
if (!exists.Successful)
{
return(exists);
}
//默认未激活状态，用户首次登录激活
account.Status = AccountStatus.Inactive;
//设置默认密码
if (account.Password.IsNull())
{
account.Password = EncryptPassword(account.UserName.ToLower(), DefaultPassword);
}
_uow.BeginTransaction();
var result = await _accountRepository.AddAsync(account);
if (result)
{
if (model.Roles != null && model.Roles.Any())
{
var accountRoleList = model.Roles.Select(m => new AccountRole {
AccountId = account.Id, RoleId = m
}).ToList();
if (await _accountRoleRepository.AddAsync(accountRoleList))
{
_uow.Commit();
return(ResultModel.Success());
}
}
else
{
_uow.Commit();
return(ResultModel.Success());
}
}
return(ResultModel.Failed());
}
public async Task <IResultModel <Guid> > Add(AccountAddModel model)
{
var result = new ResultModel <Guid>();
var account = _mapper.Map <AccountEntity>(model);
var exists = await Exists(account);
if (!exists.Successful)
{
return(exists);
}
//设置默认密码
if (account.LoginPwd.IsNull())
{
account.LoginPwd = "123456";
}
account.PassSalt = new StringHelper().GenerateRandom(8);
account.LoginPwd = Zoomtel.Utils.Helpers.Encrypt.DESEncrypt(account.LoginPwd, account.PassSalt);
_accountRepository.BeginTrans();
if (await _accountRepository.InsertAsync(account) > 0)
{
//插入角色绑定信息
if (model.RoleList != null && model.RoleList.Count > 0)
{
var accountRoleList = model.RoleList.Select(m => new AccountRoleEntity {
Uid = account.Uid, RoleId = m
}).ToList();
if (await _accountRoleRepository.InsertAsync(accountRoleList) > 0)
{
_accountRepository.Commit();
return(result.Success(account.Uid));
}
}
else
{
_accountRepository.Commit();
return(result.Success(account.Uid));
}
}
return(result.Failed());
}
protected override async Task OnInitializedAsync()
{
try
{
EmployeeService = ScopedServices.GetRequiredService <IEmployeeService>();
HardwareVaultService = ScopedServices.GetRequiredService <IHardwareVaultService>();
OrgStructureService = ScopedServices.GetRequiredService <IOrgStructureService>();
SharedAccountService = ScopedServices.GetRequiredService <ISharedAccountService>();
RemoteDeviceConnectionsService = ScopedServices.GetRequiredService <IRemoteDeviceConnectionsService>();
Companies = await OrgStructureService.GetCompaniesAsync();
Departments = new List <Department>();
Positions = await OrgStructureService.GetPositionsAsync();
SharedAccounts = await SharedAccountService.GetAllSharedAccountsAsync();
SharedAccountId = SharedAccounts.FirstOrDefault()?.Id;
await LoadHardwareVaultsAsync();
Employee = new Employee()
{
Id = Guid.NewGuid().ToString()
};
EmployeeContext = new EditContext(Employee);
PersonalAccount = new AccountAddModel {
EmployeeId = Employee.Id, LoginType = LoginType.Local
};
PersonalAccountContext = new EditContext(PersonalAccount);
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
SetLoadFailed(ex.Message);
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
await ModalDialogService.CloseAsync();
}
}
public async Task <IActionResult> Add([FromBody] AccountAddModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorList()));
}
if (await _userManager.Users.AnyAsync(x => x.UserName.Equals(model.Email)))
{
return(BadRequest("User already exists"));
}
var user = new AppUser
{
UserName = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
CreatedOn = Utilities.Utility.GetDateTime(),
Status = Constants.RecordStatus.Active,
EmailConfirmed = true,
Role = model.RoleId
};
try
{
IdentityResult identityResult = await _userManager.CreateAsync(user, model.Password);
var role = await _roleManager.FindByIdAsync(model.RoleId);
identityResult = await _userManager.AddToRoleAsync(user, role.Name);
return(Ok());
}
catch (Exception)
{
return(BadRequest("unable to add user"));
}
}
public async Task Consume(ConsumeContext <SubscriptionAdded> context)
{
var message = context.Message;
var brokerId = message.SubscriptionId.ToString();
// TODO: must be extracted to service layer
var account = new AccountAddModel();
account.BrokerId = brokerId;
account.Name = "Fee Account";
var newAccount = await _accountsClient.Account.AddAsync(account);
var settings = new Settings();
settings.BrokerId = message.SubscriptionId.ToString();
settings.FeeAccountId = newAccount.Id;
settings.FeeWalletId = newAccount.Wallets.Single().Id;
await _settingsService.AddAsync(settings);
_logger.LogInformation("SubscriptionAdded command has been processed {@context}", message);
}
public async Task <IResultModel> Add(EmployeeAddModel model)
{
if (model.Password.NotNull() && !model.Password.Equals(model.ConfirmPassword))
{
return(ResultModel.Failed("两次输入的密码不同"));
}
var entity = _mapper.Map <EmployeeEntity>(model);
entity.JoinDate = entity.JoinDate.Date;
var account = new AccountAddModel
{
Type = AccountType.User,//使用User账户类型
UserName = model.UserName,
Name = model.Name,
Password = model.Password,
IsLock = true,
Roles = model.Roles,
Status = AccountStatus.Active
};
var result = await _accountService.Add(account);
if (result.Successful)
{
entity.AccountId = result.Data;
if (await _repository.AddAsync(entity))
{
await _cacheHandler.RemoveAsync(CacheKeys.EMPLOYEE_TREE);
return(ResultModel.Success());
}
}
return(result);
}
public Task <IResultModel <Guid> > Add(AccountAddModel model)
{
return(_service.Add(model));
}
public async Task <IResultModel <Guid> > Add(AccountAddModel model, IUnitOfWork uow = null)
{
var result = new ResultModel <Guid>();
var account = _mapper.Map <AccountEntity>(model);
var exists = await Exists(account);
if (!exists.Successful)
{
return(exists);
}
//默认未激活状态，用户首次登录激活
account.Status = AccountStatus.Inactive;
//设置默认密码
if (account.Password.IsNull())
{
account.Password = DefaultPassword;
}
account.Password = EncryptPassword(account.UserName, account.Password);
//如果uow参数为空，需要自动处理工作单元
var noUow = uow == null;
if (noUow)
{
uow = _dbContext.NewUnitOfWork();
}
if (await _accountRepository.AddAsync(account, uow))
{
if (model.Roles != null && model.Roles.Any())
{
var accountRoleList = model.Roles.Select(m => new AccountRoleEntity {
AccountId = account.Id, RoleId = m
}).ToList();
if (await _accountRoleRepository.AddAsync(accountRoleList, uow))
{
if (noUow)
{
uow.Commit();
}
return(result.Success(account.Id));
}
}
else
{
if (noUow)
{
uow.Commit();
}
return(result.Success(account.Id));
}
}
return(result.Failed());
}
public EmployeeServiceTestingOptions(int employeeCount, int crudEmployeeId, int accountsEmployeeId)
{
EmployeesCount = employeeCount;
CrudEmployeeId = $"{crudEmployeeId}";
AccountsEmployeeId = $"{accountsEmployeeId}";
NewAccountName = "New name";
TestingEmployees = GetTestEmployees();
DataLoadingOptions = new DataLoadingOptions <EmployeeFilter>()
{
Skip = 0,
Take = EmployeesCount,
SortDirection = ListSortDirection.Ascending,
SortedColumn = nameof(Employee.Id),
SearchText = string.Empty,
Filter = null
};
PersonalAccount = new AccountAddModel()
{
Name = "stackoverflow",
Urls = "stackoverflow.com",
Login = "******",
Password = "******",
ConfirmPassword = "******",
EmployeeId = AccountsEmployeeId
};
//WorkstationAccount = new WorkstationAccount()
//{
// Name = "local",
// UserName = "******",
// Password = "******",
// ConfirmPassword = "******",
// EmployeeId = AccountsEmployeeId,
// Type = WorkstationAccountType.Local
//};
//WorkstationDomainAccount = new WorkstationDomain()
//{
// Name = "domain",
// UserName = "******",
// Password = "******",
// ConfirmPassword = "******",
// EmployeeId = AccountsEmployeeId,
//};
//WorkstationMsAccount = new WorkstationAccount()
//{
// Name = "ms",
// UserName = "******",
// Password = "******",
// ConfirmPassword = "******",
// EmployeeId = AccountsEmployeeId,
// Type = WorkstationAccountType.Microsoft
//};
//WorkstationAzureAccount = new WorkstationAccount()
//{
// Name = "azure",
// UserName = "******",
// Password = "******",
// ConfirmPassword = "******",
// EmployeeId = AccountsEmployeeId,
// Type = WorkstationAccountType.AzureAD
//};
AccountsCount = 5;
}
public async Task <IActionResult> AddAccount(AccountAddModel account)
{
var result = await accountService.AddAccount(account);
return(result == null?Ok(new { message = "Adding account was successful" }) : (IActionResult)Conflict(new { message = "User already has account with this name" }));
}
