public void ConfigAllMapAutoMapperTest()
{
var list = new List <Action <IMapperConfigurationExpression> >();
list.Add(ConfigAllMap);
Action <IMapperConfigurationExpression> action = mapperConfigurationExpression =>
{
FindAndAutoMapTypes(mapperConfigurationExpression);
foreach (var configurator in list)
{
configurator(mapperConfigurationExpression);
}
};
Mapper.Initialize(action);
var userInput = new AddUserInput
{
Name = "lex"
};
var user = userInput.MapTo <User>();
user.Name.ShouldBe("lex");
}
public ActionResult <Player> makePlayer([FromBody] AddUserInput newUser)
{
PlayerManager PM = new PlayerManager();
Player player = PM.makePlayer(newUser.Username, newUser.Email, newUser.Password);
return(player);
}
public override Task <ResponseMessage> AddUser(AddUserInput request, ServerCallContext context)
{
var user = new User()
{
Email = request.Email,
Name = request.Name,
Password = request.Password,
IsConnected = request.IsLoggedIn
};
if (_userRepository.ContainsUser(user))
{
return(Task.FromResult(new ResponseMessage
{
Status = "Error",
Message = "No se puede crear un usuario con el mismo mail",
}));
}
else
{
_userRepository.SaveUser(user);
return(Task.FromResult(new ResponseMessage
{
Status = "Ok",
Message = "Usuario agregado correctamente",
}));
}
}
public async Task <AddUserPayload> AddUserAsync(
AddUserInput input,
[ScopedService] ApplicationDbContext context)
{
// hash password
// var hashedPass = BC.HashPassword(input.Password);
// create new user
var user = new User
{
Name = input.Name,
Email = input.Email,
// Password = hashedPass,
Password = input.Password,
Address = input.Address
};
// add to db-context
context.Users.Add(user);
// save changes
await context.SaveChangesAsync();
return(new AddUserPayload(user));
}
public IActionResult AddUser([FromBody] AddUserInput user)
{
var request = Request.Query;
int id = _userService.Add(user);
return(Created("", new { id }));
}
public ActionResult Add(AddUserInput input)
{
var services = CreateService <IAccountAppService>();
if (services.ExistUserName(input.UserName))
{
throw new InvalidDataException("用户名[{0}]已存在".ToFormat(input.UserName));
}
else
{
string userSecretkey = UserHelper.GenUserSecretkey();
string encryptedPassword = PasswordHelper.Encrypt(input.Password, userSecretkey);
Sys_User user = new Sys_User
{
UserName = input.UserName,
RoleId = input.RoleId,
RealName = input.RealName,
IsEnabled = input.IsEnabled,
Description = input.Description,
UserSecretkey = userSecretkey,
UserPassword = encryptedPassword,
CreateUserId = CurrentSession.UserId,
CreateTime = DateTime.Now,
LogOnCount = 0
};
services.Insert(user);
}
return(AddSuccessMsg());
}
public async Task <IActionResult> UpdateUserAysnc(AddUserInput input)
{
var user = await _userRepository.GetEntityAsync(x => x.Id == input.Id);
user.UserName = input.UserName;
user.Phone = input.Phone;
return(new JsonResult(await _userRepository.UpdateAsync(user)));
}
public ActionResult Add(AddUserInput input)
{
input.CreatorId = this.CurrentSession.UserId;
this.Service.Add(input);
return(this.AddSuccessMsg());
}
/// <summary>
/// 添加用户数据
/// </summary>
/// <param name="addUserInput"></param>
/// <returns></returns>
public async Task <long> AddUser(AddUserInput addUserInput)
{
var entity = Mapper.Map <AddUserInput, User>(addUserInput);
if (entity != null)
{
entity.CreateTime = DateTime.Now;
entity.Status = (int)Status.normal;
}
return(await _userRepository.Add(entity));
}
public async Task <AddUserPayload> AddUserAsync(AddUserInput input, [ScopedService] LeagueDbContext context)
{
User user = new User
{
Username = input.Username,
Password = input.Password
};
context.Users.Add(user);
await context.SaveChangesAsync();
return(new AddUserPayload(user));
}
public ActionResult <int> Add([FromBody] AddUserInput dto)
{
if (!ModelState.IsValid)
{
return(0);
}
var user = new User {
Name = dto.Name
};
return(_userService.Add(user));
}
public virtual async Task AddUser(AddUserInput input)
{
Ensure.NotNull(input, nameof(input));
var user = User.Create(input.UserAccount, input.UserName, input.Password, input.Email,
input.CellPhone,
input.Description);
using (var work = CurrentUnitOfWork.SetTenantId(input.TenantId))
{
_userRepository.Insert(user);
await CurrentUnitOfWork.CommitAsync();
}
}
public Result <int> AddUser(AddUserInput input)
{
var userCount = _userRepository.Count();
var user = input.MapTo <Domain.Core.Model.User>();
var result = _userRepository.Insert(user);
if (result != null)
{
return(Result.FromData(userCount));
}
return(Result.FromError <int>("发生错误"));
}
/// <summary>
/// 新增管理员
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task AddSysOperatorAsync(AddUserInput input)
{
var account = await GetAccountByName(input.UserName);
if (account != null)
{
throw new FriendlyException($"{input.UserName}账号已经存在!", 404);
}
var entity = Map <AddUserInput, Account>(input);
var(salt, encryptpwd) = _passwordHadler.GenerateEncryptPassword(entity.Password);
entity.Password = encryptpwd;
entity.Salt = salt;
await _accountRepository.InsertAsync(entity);
}
public User Add(AddUserInput userInput)
{
var login = new Login(userInput.UserName, userInput.Password, userInput.Password);
var email = new Email(userInput.Email);
var user = new User(login, email, userInput.Name);
if (user.Invalid)
{
return(user);
}
_respository.Add(user);
_uow.Commit();
return(user);
}
public async Task <IActionResult> CreateUser([FromBody] AddUserInput addUserInput)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var newUserResult = await userCrud.AddUser(addUserInput);
foreach (var error in newUserResult.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(Ok());
}
public async Task <AddUserPayload> AddUserAsync(
AddUserInput input,
[Service] MtgDbContext context)
{
var user = new UserEntity
{
Id = Guid.NewGuid(),
Name = input.Name,
RolesString = input.Roles,
PasswordHash = input.PasswordHash
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
return(new AddUserPayload(input.ClientMutationId, user));
}
public async Task <AddUserPayload> CreateUserAsync(
AddUserInput input,
[ScopedService] ApplicationDbContext context,
[Service] ITokenService tokenService,
CancellationToken cancellationToken)
{
var user = new User
{
Username = input.Name,
HashedPassword = BC.HashPassword(input.Password),
BirthDate = input.BirthDate
};
context.Users.Add(user);
await context.SaveChangesAsync(cancellationToken);
return(new AddUserPayload(user, tokenService.Create(user)));
}
public async Task <ResponseDto> AddUserAsync(UserDto user)
{
var input = new AddUserInput()
{
Email = user.Email,
Name = user.Name,
Password = user.Password,
IsLoggedIn = user.IsLogedIn
};
var response = await _client.AddUserAsync(input);
return(new ResponseDto()
{
Message = response.Message,
Status = response.Status,
});
}
public void AddUser(AddUserInput input)
{
input.Validate();
string userName = input.UserName.ToLower();
bool exists = this.DbContext.GetSys_Users().Where(a => a.UserName == userName).Any();
if (exists)
{
throw new InvalidDataException("用户名[{0}]已存在".ToFormat(input.UserName));
}
Sys_User user = this.CreateEntity <Sys_User>();
user.UserName = userName;
user.DepartmentId = input.DepartmentId;
user.RoleId = input.RoleId;
user.DutyId = input.DutyId;
user.RealName = input.RealName;
user.Gender = input.Gender;
user.MobilePhone = input.MobilePhone;
user.Birthday = input.Birthday;
user.WeChat = input.WeChat;
user.Email = input.Email;
user.IsEnabled = input.IsEnabled;
user.Description = input.Description;
string userSecretkey = UserHelper.GenUserSecretkey();
string encryptedPassword = PasswordHelper.Encrypt(input.Password, userSecretkey);
Sys_UserLogOn logOnEntity = new Sys_UserLogOn();
logOnEntity.Id = IdHelper.CreateGuid();
logOnEntity.UserId = user.Id;
logOnEntity.UserSecretkey = userSecretkey;
logOnEntity.UserPassword = encryptedPassword;
this.DbContext.DoWithTransaction(() =>
{
this.DbContext.Insert(user);
this.DbContext.Insert(logOnEntity);
});
}
public async Task <AddUserPayload> RegisterAsync(AddUserInput input, [ScopedService] AppDbContext dbContext, CancellationToken cancellationToken)
{
var hashedPassword = BC.HashPassword(input.Password);
var newUser = new User
{
Name = input.Name,
Email = input.Email,
Password = hashedPassword,
Address = input.Address
};
dbContext.Users.Add(newUser);
await dbContext.SaveChangesAsync(cancellationToken);
var payload = new AddUserPayload(newUser);
return(payload);
}
public async Task <GetUserOutput> Add(AddUserInput input)
{
var user = new User()
{
UserName = input.UserName,
Password = input.Password
};
user = await _userRepository.InsertAsync(user);
using (var uow = _unitOfWorkManager.Begin())
{
user.UserInfo = await AddUserInfo(user.Id, input.Name, input.Age);
uow.Complete();
return(user.MapTo <GetUserOutput>());
}
}
public async Task <AddUserOutput> AddUserAsync(AddUserInput input)
{
var user = new User()
{
Id = Guid.NewGuid().ToString(),
UserName = input.UserName,
Password = EncryptHelper.AesEncrypt(Configuration["EncryptionKey"], input.Password),
Phone = input.Phone
};
await DbContext.User.AddAsync(user);
var result = await DbContext.SaveChangesAsync();
return(new AddUserOutput()
{
IsSuccess = result > 0,
Msg = result > 0 ? "新增成功" : "新增失败"
});
}
public void UserExists_AddUser()
{
AddUserInput input = new AddUserInput
{
email = "*****@*****.**",
name = "Neil",
phone = "4323432",
password = "******",
username = "******"
};
MongoDBHelperSingleton.instance.CreateRecord(Arg.Any <BsonDocument>(), "UserCollection")
.Returns(true);
var result = userController.AddUser(input);
var jsonToReturn = JObject.FromObject(result);
Assert.False(jsonToReturn.Value <bool>("success"));
}
public void AddUser(AddUserInput input)
{
input.Validate();
string userName = input.UserName.ToLower();
bool exists = this.DbContext.GetInv_users().Where(a => a.username == userName).Any();
if (exists)
{
throw new InvalidDataException("用户名[{0}]已存在".ToFormat(input.UserName));
}
MALU_Users user = this.CreateEntity <MALU_Users>();
user.username = userName;
user.RoleId = input.RoleId;
user.DutyId = input.DutyId;
user.RealName = input.RealName;
user.Gender = input.Gender;
user.MobilePhone = input.MobilePhone;
user.Birthday = input.Birthday;
user.IsEnabled = 1;
user.companyguid = input.companyguid;
user.IsFirst = 1;
string userSecretkey = UserHelper.GenUserSecretkey();
string encryptedPassword = PasswordHelper.Encrypt(input.Password, "invtax");
user.password = encryptedPassword;
//Sys_UserLogOn logOnEntity = new Sys_UserLogOn();
//logOnEntity.Id = IdHelper.CreateGuid();
//logOnEntity.UserId = user.Id;
//logOnEntity.UserSecretkey = userSecretkey;
//logOnEntity.UserPassword = encryptedPassword;
this.DbContext.DoWithTransaction(() =>
{
this.DbContext.Insert(user);
});
}
public void ValidInput_AddUser()
{
AddUserInput input = new AddUserInput
{
email = "*****@*****.**",
name = "Neil",
phone = "4323432",
password = "******",
username = "******"
};
MongoDBHelperSingleton.instance.CreateRecord(Arg.Any <BsonDocument>(), "UserCollection")
.Returns(false);
MongoDBHelperSingleton.instance.CreateRecord(Arg.Any <BsonDocument>(), "AccountCollection")
.Returns(false);
MongoDBHelperSingleton.instance.GetRecords("UserCollection", Arg.Any <FilterDefinition <BsonDocument>[]>())
.Returns(new List <BsonDocument>());
object result = userController.AddUser(input);
var jsonToReturn = JObject.FromObject(result);
Assert.True(jsonToReturn.Value <bool>("success"), "Oh it failed");
}
public IActionResult Add(AddUserInput user)
{
try
{
var userInput = _service.Add(user);
if (userInput.Invalid)
{
return(BadRequest(new ResultViewModel {
Success = false, Docs = userInput.Notifications
}));
}
return(Created($"v1/people/{userInput.Id}", new ResultViewModel {
Success = true, Docs = userInput
}));
}
catch (Exception ex)
{
return(BadRequest(new ResultViewModel {
Success = false, Message = ex.Message, Docs = ex
}));
}
}
public void Post([FromBody] AddUserInput input)
{
_userAppService.AddUser(input);
}
public ActionResult Add(AddUserInput input)
{
this.CreateService <IUserAppService>().AddUser(input);
return(this.AddSuccessMsg());
}
public async Task <ApiResult> Add(AddUserInput input)
{
await passportService.AddSysOperatorAsync(input);
return(ApiResult.Success);
}
