public IActionResult Add([FromBody] AddUserDTO userToAdd)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
ClaimsPrincipal jwtSecurity;
try
{
jwtSecurity = new JwtSecurityTokenHandler().ValidateToken(userToAdd.Token, new TokenValidationParameters(), out _);
}
catch (Exception)
{
return(BadRequest());
}
var email = jwtSecurity.Claims.FirstOrDefault(claim => claim.Type == "Email").Value;
var passwordHash = BCrypt.Net.BCrypt.HashPassword(userToAdd.Password);
_userServices.AddUserToDataBase(new User()
{
Username = userToAdd.Username, PasswordHash = passwordHash, Email = email, RoleId = 1
});
return(Accepted(userToAdd));
}
public async Task<IActionResult> Register(AddUserViewModel model)
{
Result result = new Result();
try
{
string userRole = HttpContext.Session.GetString(SessionHelper.ROLES) ?? "";
string userId = HttpContext.Session.GetString(SessionHelper.USER_ID) ?? "";
model.Role = Role.USER.ToString();
var user = await _userManager.GetUserAsync(HttpContext.User);
AddUserDTO dto = _mapper.Map<AddUserDTO>(model);
if (user == null || user.Id.ToString() == null || user.Id.ToString() == "")
{
var adminUser = await _userManager.FindByNameAsync("superadmin");
dto.CreatedBy = userId;
}
else
{
dto.CreatedBy = userId;
}
result = await _accountService.CreateUser(dto);
}
catch (Exception e)
{
_logger.LogError("Error Exception on Register: " + e.Message.ToString());
}
return Json(result);
}
public async Task <IActionResult> AddUser(AddUserViewModel model)
{
Result result = new Result();
try
{
string userRole = HttpContext.Session.GetString(SessionHelper.ROLES) ?? "";
string userId = HttpContext.Session.GetString(SessionHelper.USER_ID) ?? "";
var user = await _userManager.GetUserAsync(HttpContext.User);
AddUserDTO dto = _mapper.Map <AddUserDTO>(model);
dto.CreatedBy = userId;
result = await _maintenanceService.CreateUser(dto);
//redirect to user list after add
if (result.Success)
{
result.IsRedirect = true;
result.RedirectUrl = "Maintenance/User";
}
}
catch (Exception e)
{
_logger.LogError("Error Exception on AddUser: " + e.Message.ToString());
}
return(Json(result));
}
public async Task <long> AddNewAsync(AddUserDTO dto)
{
UserEntity en = new UserEntity();
en.Email = dto.Email;
en.Gender = dto.Gender;
en.NickName = dto.NickName;
en.Salt = MD5Helper.GetSalt(10);
en.PasswordHash = MD5Helper.CalcMD5(dto.Password + en.Salt);
using (UserContext ctx = new UserContext())
{
BaseService <UserEntity> bs = new BaseService <UserEntity>(ctx);
var emailEntity = await bs.GetAll().SingleOrDefaultAsync(e => e.Email == dto.Email || e.NickName == dto.NickName);
if (emailEntity != null)
{
throw new Exception("用户邮箱或者昵称已存在");
}
await ctx.Users.AddAsync(en);
await ctx.SaveChangesAsync();
return(en.Id);
}
}
public async Task<bool> ChangePassword(string userName, string oldPw, AddUserDTO user)
{
if (string.IsNullOrEmpty(userName) || string.IsNullOrEmpty(oldPw) || user == null)
{
return false;
}
var requestString = BaseUri.AbsoluteUri + "/ChangePassword";
var credentials = new NetworkCredential(userName, oldPw);
using (var client = new HttpClient(new HttpClientHandler() { Credentials = credentials }))
{
var result = await DatabaseStatusService.StartRequestWhenReady(async () => await client.PostAsXmlAsync(requestString, user), Enums.UpdateKind.Saving);
if (result.IsSuccessStatusCode)
{
return true;
}
else if (result.StatusCode == HttpStatusCode.Unauthorized)
{
throw new UserNotAuthorizedException("Could not change password - old password incorrect");
}
else
{
throw new WebException("Could not change password - " + result.StatusCode);
}
}
}
public async Task <ActionResult> AddUserAsync(AddUserDTO dto)
{
try
{
if (ModelState.IsValid)
{
await UserService.AddUserAsync(dto);
return(Ok(true));
}
else
{
IEnumerable <ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors);
StringBuilder sb = new StringBuilder();
foreach (var modelState in allErrors)
{
sb.Append(modelState.ErrorMessage);
sb.Append("\n");
}
throw new Exception(sb.ToString());
}
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public bool AddNewUser(AddUserDTO userToAdd)
{
using (var db = new SqlConnection(_connectionString))
{
var sql = @"INSERT INTO[dbo].[User]
([DateCreated]
,[FirebaseKey]
,[FirstName]
,[LastName]
,[Location]
,[Email]
,[Password]
,[Bio]
,[ProfilePhotoUrl])
VALUES
(@DateCreated
, @FirebaseKey
, @FirstName
, @LastName
, @Location
, @Email
, @Password
, @Bio
, @ProfilePhotoUrl)";
return(db.Execute(sql, userToAdd) == 1);
}
}
public MessageModel UpdataUser(int id, AddUserDTO dto)
{
// zCustomUser zCustom1 = new zCustomUser() { Name = "小名" };
zCustomUser model = _mapper.Map <zCustomUser>(dto);
Expression <Func <zCustomUser, zCustomUser> > column = p => model;
Expression <Func <zCustomUser, bool> > where = k => k.Id == id;
_msg.Success = _userver.Update(column, where) > 0;
return(_msg);
}
public IActionResult EditUser(AddUserDTO user, IFormFile image)
{
if (ModelState.IsValid)
{
if (_userData.ExistUsername(user.Username, user.Id))
{
ViewBag.Message = "Username already exist";
return(Json("Username aleady exist"));
}
var editUser = _userData.GetById(user.Id);
if (editUser == null)
{
return(NotFound());
}
editUser.FirstName = user.FirstName;
editUser.LastName = user.LastName;
if (user.Password != null)
{
editUser.Password = user.Password;
}
editUser.Email = user.Email;
editUser.Description = user.Description;
if (user.Image != null)
{
editUser.ProfilePictureUrl = AddImage(editUser.Username, user.Image);
}
editUser = _userData.Update(editUser);
var contentType = Request.ContentType;
if (contentType != null)
{
if (contentType.Equals("application/json"))
{
UserForVideoComment userDto = UserForVideoComment.ConvertUserForVideoComment(editUser);
return(Json(userDto));
}
else if (contentType.Equals("text/html"))
{
SingleUserDTO newDTO = SingleUserDTO.ConvertUserToDTO(editUser);
return(View("SingleUserInfo", newDTO));
}
else if (contentType.Equals("application/x-www-form-urlencoded"))
{
return(RedirectToAction(nameof(GetById), user.Id));
}
return(RedirectToAction(nameof(GetById), user.Id));;
}
return(Json("Success"));
}
else
{
return(BadRequest());
}
}
public async Task <IActionResult> Update(AddUserDTO request)
{
User user = _mapper.Map <User>(request);
ServiceResponse <GetUserDTO> response = await _accountService.Update(user);
if (!response.Success)
{
return(NotFound(response));
}
return(Ok(response));
}
public async Task <IActionResult> Register(AddUserDTO request)
{
ServiceResponse <int> response = await _accountService.Register(
_mapper.Map <User>(request), request.Password
);
if (!response.Success)
{
return(BadRequest(response));
}
return(Ok(response));
}
public IHttpActionResult AddUser(AddUserDTO newUser)
{
try
{
var user = _userRepository.AddUser(newUser);
return(Ok(user));
}
catch (Exception e)
{
return(BadRequest("Error has occured. Exception: " + e.Message));
}
}
public async Task Update(long id, AddUserDTO user, string newPassword)
{
var entity = await Unit.Users.Get(id);
Mapper.Map(user, entity);
if (!string.IsNullOrEmpty(newPassword))
{
entity.PasswordHash = Hasher.HashPassword(entity, newPassword);
}
await Unit.Complete();
}
//[Authorize(Roles = "AddUser")]
public IActionResult AddUser([FromBody] AddUserDTO addUserDTO)
{
try
{
addUserDTO.Name = addUserDTO.Name.Trim();
User simelarUserName = _userRepositroy.Get(c => c.Username == addUserDTO.Username).FirstOrDefault();
if (simelarUserName != null)
{
var message = Messages.Exist;
message.ActionName = "Add User";
message.ControllerName = "User";
return(Conflict(message));
}
User user = _mapper.Map <User>(addUserDTO);
user.Password = MD5Hash.GetMd5Hash(user.Password);
//check for groups Id
var groupsId = _groupRepository.Get().Select(c => c.Id);
if (addUserDTO.GroupIds != null && addUserDTO.GroupIds.Count > 0)
{
if (addUserDTO.GroupIds.Except(groupsId).Any())
{
var message = Messages.NotFound;
message.ActionName = "Add User";
message.ControllerName = "User";
message.Message = "يوجد مجموعة على الاقل غير موجودة";
return(NotFound(message));
}
}
//end checking
_abstractUnitOfWork.Add(user, UserName());
if (addUserDTO.GroupIds != null && addUserDTO.GroupIds.Count > 0)
{
foreach (var item in addUserDTO.GroupIds)
{
UserGroup userGroup = new UserGroup()
{
UserId = user.Id,
GroupId = item,
};
_abstractUnitOfWork.Add(userGroup, UserName());
}
}
_abstractUnitOfWork.Commit();
return(Ok(_mapper.Map <UserResponDTO>(user)));
}
catch (Exception ex)
{
return(BadRequest(Messages.AnonymousError));
}
}
public async Task <IActionResult> Register(AddUserDTO addUserDTO)
{
ServiceResponse <int> response = await _authRepository.Register(
new User { UserName = addUserDTO.UserName }, addUserDTO.Password
);
if (response.Success)
{
return(Ok(response));
}
return(BadRequest(response));
}
public async Task <IActionResult> Register(AddUserDTO request)
{
ServiceResponse <int> response = await _authRepo.Register(
new User { Username = request.Username },
request.Password
);
if (!response.Success)
{
return(BadRequest(response));
}
return(Ok(response));
}
public async Task <ActionResult <AddUserDTO> > CreateUser([FromBody] AddUserDTO addUserResources)
{
User userModel = mapper.Map <AddUserDTO, User>(addUserResources);
var newUser = await _userService.CreateUser(userModel);
if (newUser == null)
{
return(NotFound());
}
var user = await _userService.GetUserById(newUser.Id);
var userModelDTO = mapper.Map <User, AddUserDTO>(user);
return(Ok(userModelDTO));
}
public async Task <long> Add(AddUserDTO user, bool isAdmin = false)
{
var entity = Mapper.Map <User>(user);
entity.PublicId = Guid.NewGuid().ToString();
entity.IsAdmin = isAdmin;
await Unit.Users.Add(entity);
await Unit.Complete();
await SetPassword(entity.Id, user.Password);
await Unit.Complete();
return(entity.Id);
}
public async Task <ActionResult <UserDTO> > AddUser(AddUserDTO addUserDTO)
{
var user = new UserEntity()
{
Id = Guid.NewGuid(),
Name = addUserDTO.Name,
Email = addUserDTO.Email,
PhoneNumber = addUserDTO.PhoneNumber,
PasswordHashed = ""
};
await userRepository.AddUser(user);
var fullUser = await userRepository.GetUserByEmail(user.Email);
return(new ActionResult <UserDTO>(Mapper.ToUserDTO(fullUser)));
}
public async Task <ServiceResponse <GetUserDTO> > AddUser(string userToken, AddUserDTO newUser)
{
ServiceResponse <GetUserDTO> serviceResponse = new ServiceResponse <GetUserDTO>();
try
{
var userInformation = await _auth0Service.GetUserInfo(userToken);
if (userInformation.ContainsKey("sub") && userInformation.ContainsKey("name") && userInformation.ContainsKey("email"))
{
var userId = userInformation["sub"].ToString();
if (await _context.Users.FindAsync(userId) == null)
{
var user = _mapper.Map <User>(newUser);
user.Id = userId;
user.Name = userInformation["name"].ToString();
user.Mail = userInformation["email"].ToString();
user.CreatedAt = DateTime.Now.ToUniversalTime();
await _context.Users.AddAsync(user);
await _context.SaveChangesAsync();
serviceResponse.Data = _mapper.Map <GetUserDTO>(user);
}
else
{
serviceResponse.Success = false;
serviceResponse.Message = $"User with id '{userId}' already exists.";
}
}
else
{
serviceResponse.Success = false;
serviceResponse.Message = $"Could not get all needed user information from auth0.";
}
}
catch (Exception ex)
{
serviceResponse.Success = false;
serviceResponse.Exception = ex.Message;
}
return(serviceResponse);
}
public async Task <IActionResult> Add([FromBody] AddUserDTO addedUser)
{
try
{
var test = _configuration["Auth0:ApiIdentifier"];
// request user information from auth0
var userInformation = await GetAuth0UserInformation();
var userId = userInformation.Single(x => x.Key == "sub").Value;
var userName = userInformation.Single(x => x.Key == "name").Value;
var userMail = userInformation.Single(x => x.Key == "email").Value;
return(Ok(await _userService.AddUser(userId, userName, userMail, addedUser)));
}
catch (Exception ex)
{
return(StatusCode(500, $"Error while creating user: {ex.Message}"));
}
}
public IHttpActionResult Post([FromBody] AddUserDTO userDto)
{
if (userDto == null)
{
return(BadRequest("Content was null"));
}
if (userDto.UserId != User.Identity.GetUserId() && User.IsInRole(LeagueRoles.Admin) == false)
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
using (var userManager = CreateUserManager())
{
userManager.UserTokenProvider = new TotpSecurityStampBasedTokenProvider <IdentityUser, string>();
var resetToken = userManager.GeneratePasswordResetToken(userDto.UserId);
userManager.ResetPassword(userDto.UserId, resetToken, userDto.Password);
}
return(Ok());
}
public async Task <IActionResult> Put(AddUserModel model)
{
var user = await UserSvc.GetByEmailAsync(model.Email);
if (user != null)
{
return(new JsonResult(new APIResult <long>()
{
ErrorMsg = "邮箱已存在", Data = 400
})
{
StatusCode = 400
});
}
var nameUser = await UserSvc.GetByNickNameAsync(model.NickName);
if (nameUser != null)
{
return(new JsonResult(new APIResult <long>()
{
ErrorMsg = "昵称已存在", Data = 400
})
{
StatusCode = 400
});
}
AddUserDTO dto = new AddUserDTO();
dto.Email = model.Email;
dto.Gender = model.Gender;
dto.NickName = model.NickName;
dto.Password = model.Password;
return(new JsonResult(new APIResult <long>()
{
Data = await UserSvc.AddNewAsync(dto)
})
{
});
}
public async Task AddUserAsync(AddUserDTO dto)
{
IdentityUser userExist = await userManager.FindByNameAsync(dto.UserName);
if (userExist == null)
{
Guid NewId = Guid.NewGuid();
userExist = new IdentityUser(dto.UserName);
userExist.Id = NewId.ToString();
IdentityResult result = await userManager.CreateAsync(userExist, dto.Password);
StringBuilder Stringerror = new StringBuilder();
foreach (var error in result.Errors)
{
Stringerror.Append(error.Description);
Stringerror.Append("\n");
}
if (result.Errors.Count() > 0)
{
throw new Exception(Stringerror.ToString());
}
else
{
UsuarioPerfilDTO usuartioPerfilDTO = new UsuarioPerfilDTO()
{
UsuperId = NewId,
UsuperDesc = dto.Descripcion,
UsuperGit = dto.Git,
UsuperBlog = dto.Blog,
UsuperWeb = dto.Web
};
await ServiceUsuarioPerfil.InsertWithID(usuartioPerfilDTO);
}
}
else
{
throw new Exception($"The username({dto.UserName}) is being used");
}
}
public async Task<UserProfileDTO> AddUserAsync(AddUserDTO user)
{
if (user == null)
return null;
var requestString = BaseUri.AbsoluteUri + "/User";
using (var client = new HttpClient())
{
var request = await DatabaseStatusService.StartRequestWhenReady(async () => await client.PostAsXmlAsync(requestString, user), Enums.UpdateKind.Saving);
if (request.IsSuccessStatusCode)
{
var result = await request.Content.ReadAsAsync<UserProfileDTO>();
return result;
}
else if (request.StatusCode == HttpStatusCode.Conflict)
{
throw new UserExistsException();
}
}
return null;
}
public User AddUser(AddUserDTO newUser)
{
using (var context = new TwitterContext())
{
try
{
User user = new User();
user.Id = GetNumberOfUsers() + 1;
user.Username = newUser.Username;
user.Password = newUser.Password;
user.Name = newUser.Name;
user.Lastname = newUser.Lastname;
user.Email = newUser.Email;
context.Users.Add(user);
context.SaveChanges();
return(user);
}
catch (Exception e)
{
throw new Exception("Could not add new user. Exception: " + e.Message);
}
}
}
public async Task <Result> CreateUser(AddUserDTO dto)
{
var response = new Result();
try
{
var valResult = await _validationService.IsValidAccountInfo(dto.UserName, dto.Email, dto.Password, dto.ConfirmPassword);
if (!valResult.IsValid)
{
response.Message = valResult.Message;
response.ErrorCode = ErrorCode.INVALID_INPUT;
return(response);
}
if (string.IsNullOrEmpty(dto.DepartmentId))
{
response.Message = "Please fill in the required fields.";
response.ErrorCode = ErrorCode.INVALID_INPUT;
return(response);
}
if (!Enum.IsDefined(typeof(TypeOfNotification), dto.TypeOfNotification))
{
response.Message = "Please fill in the required fields.";
response.ErrorCode = ErrorCode.INVALID_INPUT;
return(response);
}
ExtendedIdentityUser user = new ExtendedIdentityUser
{
FirstName = dto.FirstName,
LastName = dto.LastName,
Email = dto.Email,
UserName = dto.UserName,
DepartmentId = dto.DepartmentId,
CreatedBy = dto.CreatedBy,
EmailConfirmed = true,
TypeOfNotification = dto.TypeOfNotification,
HasPasswordChanged = false
};
var result = await _userManager.CreateAsync(user, dto.Password);
if (result.Succeeded)
{
var addrole = await _userManager.AddToRoleAsync(user, dto.Role);
//Default Module Access Rights
var modules = _repo.GetAll <Module>();
foreach (var item in modules)
{
var rights = new UserRights();
rights.UserId = user.Id;
rights.ModuleId = item.Id;
rights.View = true;
rights.Add = true;
rights.Edit = true;
if (dto.Role == "USER")
{
if (item.Name == "Maintenance")
{
rights.Add = false;
rights.Edit = false;
}
else if (item.Name == "Approval")
{
rights.View = true;
rights.Add = false;
rights.Edit = false;
}
}
rights.Delete = false;
_repo.Create(rights);
await _repo.SaveAsync();
}
;
response.Success = true;
response.Message = "User has been successfully added.";
response.ErrorCode = ErrorCode.DEFAULT;
}
}
catch (Exception e)
{
response.Message = "Error adding company";
response.ErrorCode = ErrorCode.EXCEPTION;
_logger.LogError("Error calling AddCompany: {0}", e.Message);
}
return(response);
}
public MessageModel AddUser(AddUserDTO dto, string type)
{
_msg.Success = _userver.AddUser(dto) > 0;
return(_msg);
}
public async Task <IActionResult> PostUser(AddUserDTO user)
{
if (user == null || string.IsNullOrEmpty(user.FirstName) || string.IsNullOrEmpty(user.FamilyName) || string.IsNullOrEmpty(user.Email) || string.IsNullOrEmpty(user.Phone))
{
return(BadRequest());
}
Company comp = _companyRepo.GetById(user.Company);
if (comp == null)
{
return(BadRequest());
}
if (!_categoryRepo.CategoriesExist(user.Categories))
{
return(BadRequest());
}
if (!_therapistRepo.TherapistsExist(user.Therapists))
{
return(BadRequest());
}
List <Category> categories = _categoryRepo.GetCategoriesById(user.Categories).ToList();
User u = new User {
FirstName = user.FirstName,
FamilyName = user.FamilyName,
Phone = user.Phone,
Email = user.Email,
Company = comp,
Contract = comp.Contract
};
if (_userRepo.UserExists(u))
{
return(StatusCode(303));
}
try
{
List <CategoryUser> catUsers = _categoryRepo.GetCategoriesById(user.Categories).Select(c => new CategoryUser {
Category = c, User = u
}).ToList();
u.AddCategories(catUsers);
List <TherapistUser> tUser = _therapistRepo.GetTherapistsById(user.Therapists).Select(t => new TherapistUser {
Therapist = t, User = u
}).ToList();
u.AddTherapists(tUser);
IdentityUser userLogin = new IdentityUser {
UserName = user.Email, Email = user.Email
};
var result = await _userManager.CreateAsync(userLogin, "Multimed@" + user.FirstName + user.FamilyName + user.Phone);
await _userManager.AddToRoleAsync(userLogin, "User");
if (result.Succeeded)
{
//return ok so the user knows the account has been created
_userRepo.AddUser(u);
_userRepo.SaveChanges();
_categoryRepo.SaveChanges();
return(Ok());
}
User usr = _userRepo.GetByEmail(u.Email);
usr.AddCategories(categories.Select(c => Model.User.MapCategoryToCategoryUser(c, usr)).ToList());
_userRepo.SaveChanges();
}
catch (Exception e) {
return(StatusCode(500));
}
return(StatusCode(303));
}
public User AddUser(AddUserDTO userToAdd)
{
_repo.AddNewUser(userToAdd);
return(_repo.GetUserByUserId(userToAdd.Id));
}
