public async Task <IActionResult> CreateAsync([FromBody] UserCreationDto userDto)
{
return(await userService.CreateAsync(userDto.Role, userDto.Login, userDto.FirstName,
userDto.LastName,
userDto.Password,
userDto.PermitNumber));
}
public IActionResult CreateUser([FromBody] UserCreationDto user)
{
if (user == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(UnprocessableEntity(ModelState));
}
// if (String.IsNullOrEmpty(user.Login) || user.Login.Any(c => !Char.IsLetterOrDigit(c)))
if (user.Login.Any(c => !Char.IsLetterOrDigit(c)))
{
ModelState.AddModelError("login", "Некорректный логин");
return(UnprocessableEntity(ModelState));
}
var userEntity = mapper.Map <UserEntity>(user);
var createdUserEntity = userRepository.Insert(userEntity);
return(CreatedAtRoute(
nameof(GetUserById),
new { userId = createdUserEntity.Id },
createdUserEntity.Id));
}
public ApplicationResult <UserDto> Create(UserCreationDto userDto)
{
var userEdit = UserEdit.Create(userDto.ExternalId, userDto.UserName, userDto.FullName, userDto.Email);
var brokenRules = userEdit.GetBrokenValidationRules();
if (!brokenRules.IsValid)
{
return new ApplicationResult <UserDto> {
Errors = brokenRules.Errors.ToList(), IsSuccessful = false, IsFailure = true
}
}
;
userEdit = _userRepository.Create(userEdit);
if (userDto.Keys.Any())
{
foreach (var key in userDto.Keys)
{
var keyEdit = KeyEdit.Create(userEdit, key.Password);
_userRepository.CreateKey(userEdit.Id, keyEdit);
}
}
UnitOfWork.Commit();
return(new ApplicationResult <UserDto>()
{
Data = Mapper.Map <UserDto>(userEdit), IsSuccessful = true, IsFailure = false
});
}
public int AddUser(UserCreationDto user)
{
var client = _context.Clients.Where(c => c.ClientId == user.ClientEntityId)
.FirstOrDefault();
if (client == null)
{
return(-1);
}
UserEntity userEntity = mapperConfiguration.CreateMapper()
.Map <UserEntity>(user);
userEntity.ClientEntityId = client.ClientId;
userEntity.ClientEntity = client;
_context.Users.Add(userEntity);
if (_context.SaveChanges() > 0)
{
return(userEntity.Id);
}
else
{
return(-1);
}
}
public async Task <IHttpActionResult> CreateUser(UserCreationDto dto)
{
if (UserNameExists(dto.UserName))
{
return(BadRequest("已存在此登录名"));
}
//create user
var user = new User
{
UserName = dto.UserName,
DisplayName = dto.DisplayName,
Class = dto.ClassNumber,
Grade = dto.Grade,
Roles = new HashSet <UserRole>()
};
var result = await _userManager.CreateAsync(user, dto.Password);
if (!result.Succeeded)
{
return(BadRequest(string.Join(" ", result.Errors)));
}
var userId = (await _userManager.FindByNameAsync(user.UserName)).Id;
//add to role
dto.Roles.ToList().ForEach(rs => { _userManager.AddToRole(userId, rs); });
return(StatusCode(HttpStatusCode.Accepted));
}
public async Task <AppSrvResult <long> > CreateAsync(UserCreationDto input)
{
if (await _userRepository.AnyAsync(x => x.Account == input.Account))
{
return(Problem(HttpStatusCode.BadRequest, "账号已经存在"));
}
var user = Mapper.Map <SysUser>(input);
user.Id = IdGenerater.GetNextId();
user.Account = user.Account.ToLower();
user.Salt = SecurityHelper.GenerateRandomCode(5);
user.Password = HashHelper.GetHashedString(HashType.MD5, user.Password, user.Salt);
var cacheKey = _cacheService.ConcatCacheKey(CachingConsts.UserValidateInfoKeyPrefix, user.Id);
var bloomFilterCacheKey = _bloomFilterFactory.GetBloomFilter(nameof(BloomFilterCacheKey));
await bloomFilterCacheKey.AddAsync(cacheKey);
var bloomFilterAccount = _bloomFilterFactory.GetBloomFilter(nameof(BloomFilterAccount));
await bloomFilterAccount.AddAsync(user.Account);
await _userRepository.InsertAsync(user);
return(user.Id);
}
public void CreateUser(UserCreationDto dto)
{
var newUser = _userRepository.Create(new User
{
DateCreated = DateTime.Now,
DateModified = DateTime.Now,
FirstName = dto.FirstName,
LastName = dto.LastName,
Username = dto.Username,
Password = dto.Password,
RoleId = dto.RoleId,
TeamId = dto.TeamId,
DepartmentId = dto.DepartmentId
});
_userRepository.Save();
if (dto.ContractStartDate == null || dto.ContractEndDate == null)
{
return;
}
_contractRepository.Create(new Contract
{
EmployeeId = newUser.Id,
ContractNumber = new Random().Next(),
DateCreated = DateTime.Now,
StartTime = dto.ContractStartDate.Value,
EndDateTime = dto.ContractEndDate.Value
});
_contractRepository.Save();
}
public async Task <string> SignIn(UserCreationDto model)
{
IdentityResult userResult = await userManager.CreateAsync(new User
{
Email = model.Email,
NormalizedEmail = model.Email.ToUpper(),
UserName = model.Email,
NormalizedUserName = model.Email.ToUpper()
}, model.Password);
if (!userResult.Succeeded)
{
throw new SignInException("Error while registring the user");
}
User user = await userManager.FindByEmailAsync(model.Email);
IdentityResult roleResult = await userManager.AddToRoleAsync(user, model.Role);
if (!roleResult.Succeeded)
{
throw new SignInException("Error on assigning role to the user");
}
return(await Login(new Credentials { Email = model.Email, Password = model.Password }));
}
public async void CreateUser()
{
// Delete it if it already exists
foreach (var existingUser in await PortalClient.GetAllAsync(new Filter <User>
{
FilterItems = new List <FilterItem <User> >
{
new Eq <User>(nameof(User.UserName), "test")
}
}).ConfigureAwait(false))
{
await PortalClient.DeleteAsync(existingUser).ConfigureAwait(false);
}
var userCreationDto = new UserCreationDto
{
ViewPermission = new ViewPermission
{
Alerts = true,
Dashboards = true,
Devices = true,
Reports = true,
Websites = true,
Settings = true
},
Username = "******",
FirstName = "first",
LastName = "last",
Email = "*****@*****.**",
#pragma warning disable SCS0015 // Hardcoded password
Password = "******",
#pragma warning restore SCS0015 // Hardcoded password
Password1 = "Abc123!!!",
ForcePasswordChange = true,
TwoFAEnabled = false,
SmsEmail = "",
SmsEmailFormat = "sms",
Timezone = "",
ViewPermissions = new List <bool> {
true, true, true, true, true, true
},
Status = "active",
Note = "note",
Roles = new List <Role>
{
new Role {
Id = 1
}
},
ApiTokens = new List <object>(),
Phone = "+447761503941",
ApiOnly = false
};
var user = await PortalClient.CreateAsync(userCreationDto).ConfigureAwait(false);
// Delete again
await PortalClient.DeleteAsync(user).ConfigureAwait(false);
}
public async Task <IActionResult> Register([FromBody] UserCreationDto user,
[FromHeader(Name = "Accept")] string mediaType)
{
if (user == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
var newUser = _mapper.Map <User>(user);
var result = await _userManager.CreateAsync(newUser, user.Password);
if (!result.Succeeded)
{
return(new UnprocessableEntityObjectResult(result));
}
result = await _userManager.AddToRoleAsync(newUser, nameof(Roles.User));
if (!result.Succeeded)
{
return(new UnprocessableEntityObjectResult(result));
}
if (!await _userService.Save())
{
throw new Exception("Creating a user failed on save.");
}
var token = await _userManager.GenerateEmailConfirmationTokenAsync(newUser);
var confirmationUrl = Url.Action("ConfirmEmail", "Users", new { token, email = newUser.Email },
protocol: HttpContext.Request.Scheme);
//TODO Activate Mailing Service + Edit appsettings.json
//var confirmAccountModel = new AccountEmailViewModel(confirmationUrl, user.UserName);
//var body = await _razorViewRenderer.RenderViewToStringAsync("/Views/ConfirmAccountEmail.cshtml", confirmAccountModel);
//await _emailService.SendAsync(user.Email, "Activate your account", body, MailType.Confirmation);
var returnedUser = _mapper.Map <UserDto>(newUser);
if (mediaType == "application/json+hateoas")
{
var links = CreateUserLinks(returnedUser.Id, null);
var linkedResource = returnedUser.ShapeData(null) as IDictionary <string, object>;
linkedResource.Add("links", links);
return(CreatedAtRoute("GetUser", new { id = returnedUser.Id }, linkedResource));
}
else
{
return(CreatedAtRoute("GetUser", new { id = returnedUser.Id }, returnedUser));
}
}
public async Task <ActionResult <UserDto> > Add(UserCreationDto item)
{
var na = new User(ObjectId.Empty, ObjectId.Empty, item.Name, item.DateOfBirth, item.Gender, item.GoalWeight, item.Height, item.Email, item.PhoneNumber, item.Weight, new List <ObjectId>(), new List <ObjectId>(), new List <ObjectId>(), new List <ObjectId>(), new List <ObjectId>(), new List <ObjectId>(), new List <ObjectId>(), item.ActivityLevel);
await userCollection.InsertOneAsync(na);
return(CreatedAtRoute(nameof(GetSingleUser), new { id = na.Id },
new UserDto(na.Id.ToString(), na.Name, na.DateOfBirth, na.Gender, na.GoalWeight, na.Height, na.Email, na.PhoneNumber, na.Weight, na.ActivityLevel)));
}
public async Task <IActionResult> Upload(List <IFormFile> files, UserCreationDto userDto)
{
if (ModelState.IsValid)
{
if (_userRepository.DoesExist(x => x.Email == userDto.Email))
{
return(BadRequest("Email already exist"));
}
var Userfiles = new List <Document>();
foreach (var file in files)
{
var ext = Path.GetExtension(file.FileName);
if (!IsValidFile(ext))
{
continue;
}
var path = Path.Combine(_env.WebRootPath, "uploads", file.FileName);
using (var stream = new FileStream(path, FileMode.Create))
{
await file.CopyToAsync(stream);
}
var url = string.Format("{0}://{1}/{2}", HttpContext.Request.Scheme, HttpContext.Request.Host, "Uploads");
Userfiles.Add(new Document
{
Name = file.FileName,
Path = path,
Url = $"{url}/{file.FileName}"
});
}
var user = _mapper.Map <User>(userDto);
user.Id = Guid.NewGuid();
user.TransactionNumber = Guid.NewGuid().ToString().Replace("-", "");
user.Documents = Userfiles;
_userRepository.Add(user);
await _userRepository.Save();
await _emailSendingChannel.AddMessageAsync(new EmailData
{
Email = user.Email,
Message = "Uploaded Documents",
Subject = "Documents",
Documents = _mapper.Map <List <DocumentDto> >(user.Documents)
});
return(Ok(user.TransactionNumber));
}
return(BadRequest());
}
/// <summary>
///
/// </summary>
/// <param name="createUser"></param>
/// <returns></returns>
public CreateUserResult CreateNewUser(UserCreationDto createUser, ClaimsPrincipal claims)
{
CreateUserResult result = new CreateUserResult()
{
CreationError = UserCreationError.NoError,
IsCreatedSuccesfully = true
};
// First check if user alredy exists in database
var users = userRepo.GetUsers(new UserQueryParameters()
{
UserName = createUser.UserName
});
if (users.Any(u => string.Compare(u.UserName, createUser.UserName, StringComparison.OrdinalIgnoreCase) == 0))
{
result.IsCreatedSuccesfully = false;
result.CreationError = UserCreationError.LoginAlreadyExists;
return(result);
}
Users user = Mapper.Map <Users>(createUser);
// Create appropriate user data according to flags
if (createUser.IsTeacher)
{
Teachers teacher = Mapper.Map <Teachers>(createUser);
teacherRepo.AddTeacher(teacher, claims);
teacherRepo.Save();
user.TeacherId = teacher.TeacherId;
result.CreatedUser = Mapper.Map <UserDto>(teacher);
}
if (createUser.IsStudent)
{
Students student = Mapper.Map <Students>(createUser);
studentRepo.AddStudent(student, claims);
studentRepo.Save();
user.StudentId = student.StudentId;
result.CreatedUser = Mapper.Map <UserDto>(student);
}
if (createUser.IsParent)
{
Parents parent = Mapper.Map <Parents>(createUser);
parentRepo.AddParent(parent, claims);
parentRepo.Save();
user.ParentId = parent.ParentId;
result.CreatedUser = Mapper.Map <UserDto>(parent);
}
userRepo.CreateUser(user, claims);
userRepo.Save();
result.CreatedUser.UserId = user.UserId.ToString();
return(result);
}
public async Task <IActionResult> SignIn(UserCreationDto model)
{
string token = await userService.SignIn(model);
return(Ok(new TokenDto
{
Token = token
}));
}
public User Create(UserCreationDto userDto)
{
var user = this.iUserMapper.Convert(userDto);
this.iUserRepository.Insert(user);
var result = this.iUserRepository.GetAll().FirstOrDefault(x => x.Username == user.Username);
return(result);
}
/// <summary>
/// The create user.
/// </summary>
/// <param name="userCreationDto">
/// The user creation dto.
/// </param>
/// <param name="userName">
/// The user name.
/// </param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
private async Task <ActionResult <UserDto> > CreateUser(UserCreationDto userCreationDto, string userName)
{
var user = await userManager.FindByNameAsync(userName).ConfigureAwait(false);
userCreationDto.UserName = userName;
if (user == null)
{
var newUser = Mapper.Map <ApplicationUser>(userCreationDto);
newUser.UserName = userName;
var claims = Mapper.Map <Claim[]>(userCreationDto);
using (var transaction = await context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
var result = await userManager.CreateAsync(newUser, userCreationDto.Password).ConfigureAwait(false);
if (result.Succeeded)
{
result = await userManager.AddClaimsAsync(newUser, claims).ConfigureAwait(false);
if (result.Succeeded)
{
transaction.Commit();
var userDto = Mapper.Map <UserDto>(newUser);
Mapper.Map(claims, userDto);
return(Created($"{Request.Scheme}://{Request.Host}{Request.PathBase}/users/{newUser.UserName}", userDto));
}
transaction.Rollback();
}
}
}
else
{
var lastCharIdx = -1;
for (lastCharIdx = userName.Length - 1; lastCharIdx >= 0; lastCharIdx--)
{
if (char.IsDigit(userName[lastCharIdx]))
{
continue;
}
break;
}
if (lastCharIdx == userName.Length - 1)
{
return(await CreateUser(userCreationDto, $"{userName}1").ConfigureAwait(false));
}
return(await CreateUser(userCreationDto, $"{userName.Substring(0, lastCharIdx + 1)}{int.Parse(userName.Substring(lastCharIdx + 1)) + 1}").ConfigureAwait(false));
}
return(StatusCode((int)HttpStatusCode.InternalServerError, "There was an error encountered creating the user"));
}
public async Task <IActionResult> Post(UserCreationDto userCreationDto)
{
var result = await _usersService.CreateUserAsync(userCreationDto);
var json = new
{
message = string.Join(", ", result.Errors.Select(x => x.Description))
};
return(Ok(json));
}
public async Task <UserDto> CreateUser(UserCreationDto userDto)
{
var user = _mapper.Map <User>(userDto);
var addedUser = await _context.Users.AddAsync(user);
await _context.SaveChangesAsync();
var dto = _mapper.Map <UserDto>(addedUser.Entity);
return(dto);
}
public async Task <ActionResult <UserDto> > Post([FromBody] UserCreationDto userCreationDto)
{
if (userCreationDto == null)
{
return(BadRequest());
}
var userName = $"{userCreationDto.FirstName[0]}{userCreationDto.LastName}";
return(await CreateUser(userCreationDto, userName).ConfigureAwait(false));
}
public UserCreationDto Convert(UserRegisterRequest source)
{
var result = new UserCreationDto
{
Email = source.Email,
Username = source.Username,
Password = source.Password
};
return(result);
}
public async Task <UserDto> RegisterUser(UserCreationDto userDto)
{
var usernameValid = await _userRepository.IfValid(userDto.Username);
if (!usernameValid)
{
_logger.LogInformation("Error while registering a user");
throw new InvalidUsernameException();
}
var result = await _userRepository.CreateUser(userDto);
return(result);
}
public User Convert(UserCreationDto source)
{
var result = new User
{
Email = source.Email,
Username = source.Username,
Password = source.Password,
CreatedAd = DateTime.Now,
LastModifiedAt = DateTime.Now
};
return(result);
}
public async Task <IActionResult> DeleteUser(UserCreationDto dto)
{
try
{
await _userRepository.Delete(dto);
return(Ok());
}
catch (Exception e)
{
return(NotFound("This User cannot be delete"));
}
}
public async Task <ActionResult <UserDto> > CreateUser([FromBody] UserCreationDto userToAdd)
{
var client = await MicrosoftGraphClient.GetGraphServiceClient();
try
{
await _azureAdRepository.GetUser(client, userToAdd.Id.ToString());
}
catch (ServiceException e)
{
if (e.StatusCode == HttpStatusCode.NotFound)
{
ModelState.AddModelError("azureAdUserNotFound",
$"User with id: {userToAdd.Id} was not found on Azure AD");
}
}
var userExists = await _userRepository.UserExists(userToAdd.Id);
if (userExists)
{
return(Conflict("User already exists"));
}
if (userToAdd.SmartLockUsers.Count > 0)
{
foreach (var smartLockUser in userToAdd.SmartLockUsers)
{
var smartLockExist = await _smartLockRepository.SmartLockExists(smartLockUser.SmartLockId);
if (!smartLockExist)
{
ModelState.AddModelError("smartLockNotExist",
$"Smart lock with id: {smartLockUser.SmartLockId} doesn't exist");
}
}
}
if (!ModelState.IsValid)
{
return(ValidationProblem(ModelState));
}
var userEntity = _mapper.Map <User>(userToAdd);
_userRepository.AddUser(userEntity);
await _userRepository.Save();
var userDto = _mapper.Map <UserDto>(userEntity);
return(CreatedAtAction("GetUser", new { userId = userDto.Id }, userDto));
}
public async Task <IActionResult> Post([FromBody] UserCreationDto dto)
{
var cmd = new CreateUserCommand {
UserName = dto.UserName, Password = dto.Password
};
var result = await _sagaBus.InvokeAsync <CreateUserCommand, UserCreationResult>(cmd);
if (result.Succeed)
{
return(Created(Url.Action(nameof(GetById), new { id = result.UserId }), null));
}
// currently, the only reason for failure is that a user of the same username exists.
return(StatusCode(412, result.Message));
}
public async Task CreateUserAsync(UserCreationDto userDto)
{
var user = Mapper.Map <User>(userDto);
await _usersRepository.AddAsync(user);
await _unitOfWorkEf.CommitAsync();
user.Titles.ToList().ForEach(x => x.UserId = user.Id);
await _titlesRepository.AddRangeAsync(user.Titles);
await _unitOfWorkMongo.CommitAsync();
}
public UserDE Create(UserCreationDto user)
{
// default password when admin creates a user
if (string.IsNullOrWhiteSpace(user.Password))
{
user.Password = "******";
}
// validation
if (_context.tbl_user.Any(x => x.UserName == user.UserName))
{
throw new AppException("Username \"" + user.UserName + "\" is already taken");
}
if (user.Email != null)
{
if (_context.tbl_user.Any(x => x.Email == user.Email))
{
throw new AppException("Email \"" + user.Email + "\" is already taken");
}
}
if (user.PhoneNo == null)
{
if (_context.tbl_user.Any(x => x.PhoneNo == user.PhoneNo))
{
throw new AppException("Phone number \"" + user.PhoneNo + "\" is already taken");
}
}
byte[] passwordHash, passwordSalt;
CreatePasswordHash(user.Password, out passwordHash, out passwordSalt);
UserDE newUser = new UserDE
{
UserId = new Guid(),
UserName = user.UserName,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt,
Email = user.Email,
PhoneNo = user.PhoneNo,
Role = user.Role
};
_context.tbl_user.Add(newUser);
_context.SaveChanges();
return(newUser);
}
public async Task <IActionResult> CreateUser(UserCreationDto dto)
{
var newUser = new UserCreationDto
{
UserName = dto.UserName,
Password = dto.Password,
IsBlocked = dto.IsBlocked,
Admin = dto.Admin,
PersonId = dto.PersonId
};
await _userRepository.Create(newUser);
return(Ok(dto));
}
public async Task <IActionResult> CreateUser([FromBody] UserCreationDto user)
{
var userEntity = _mapper.Map <User>(user);
AuthExtensions.CreatePasswordHash(user.password, out byte[] passwordHash, out byte[] passwordSalt);
userEntity.passwordHash = passwordHash;
userEntity.passwordSalt = passwordSalt;
_repository.User.CreateUser(userEntity);
await _repository.SaveAsync();
var createdUser = _mapper.Map <UserDto>(userEntity);
return(CreatedAtRoute("UserById", new { id = createdUser.userId }, createdUser));
}
public async Task <AppSrvResult <long> > CreateAsync(UserCreationDto input)
{
if (await _userRepository.AnyAsync(x => x.Account == input.Account))
{
return(Problem(HttpStatusCode.BadRequest, "账号已经存在"));
}
var user = Mapper.Map <SysUser>(input);
user.Id = IdGenerater.GetNextId();
user.Salt = SecurityHelper.GenerateRandomCode(5);
user.Password = HashHelper.GetHashedString(HashType.MD5, user.Password, user.Salt);
await _userRepository.InsertAsync(user);
return(user.Id);
}
