public static MainUser MapAddUserModelToUser(AddUserModel model)
{
MainUser u = new MainUser();
u.UserName = model.UserName;
u.Password = model.Password;
u.UserType = model.UserType;
UserDetail d = new UserDetail();
d.FirstName = model.FirstName;
d.LastName = model.LastName;
d.Language = model.Language;
d.PhoneNumber = model.PhoneNumber;
d.BirthDate = model.BirthDate;
d.HobbiesAndInterest = model.HobbiesAndInterest;
d.CivilStatus = model.CivilStatus;
d.Gender = model.Gender;
d.Address = model.Address;
d.Country = model.Country;
d.State = model.State;
u.Details = d;
return(u);
}
public JsonResult ThemUser(AddUserModel item)
{
var result = false;
if (ModelState.IsValid)
{
var userByEmail = (from u in db.User
where u.Email == item.txtEmail
select u).FirstOrDefault();
if (userByEmail != null)
{
result = false;
}
else
{
User user = new User();
user.Email = item.txtEmail;
user.LoginId = item.txtUser;
user.Password = item.txtPass;
user.IsActive = item.level;
user.Balance = 0;
db.User.Add(user);
db.SaveChanges();
result = true;
}
// RedirectToAction("ThanhToan", "ThanhToan", new { @Idproduct = _idProduct });
}
return(Json(new { result }, JsonRequestBehavior.AllowGet));
}
private Connection CreateConnection()
{
var addUserModel = new AddUserModel
{
Name = "name",
Surname = "surname",
Email = "*****@*****.**",
Password = "******",
};
User user = userController.Create(addUserModel);
LoginModel model = new LoginModel
{
Email = "*****@*****.**",
Password = "******",
OS = "Windows",
Browser = "Firefox"
};
Connection connection = controller.Login(model);
return(connection);
}
public async Task <ApplicationUser> RegisterUser(AddUserModel userModel, string UserDepartment, bool IsHeadOfdepartment)
{
var _userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(_ctx));
ApplicationUser user = new ApplicationUser
{
UserName = userModel.UserName,
Email = userModel.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, userModel.Password);
if (UserDepartment == "Procurement" && IsHeadOfdepartment == false)
{
var AddUserToProcurement = _userManager.AddToRole(user.Id, "Procurement Officer");
}
if (UserDepartment != "Procurement" && IsHeadOfdepartment == false)
{
var AddUserToEmployee = _userManager.AddToRole(user.Id, "Employee");
}
if (UserDepartment == "Procurement" && IsHeadOfdepartment == true)
{
var AddUserToProcurement = _userManager.AddToRole(user.Id, "Procurement Head");
}
if (UserDepartment != "Procurement" && IsHeadOfdepartment == false)
{
var AddUserToEmployee = _userManager.AddToRole(user.Id, "Head of Department");
}
return(user);
}
public async Task <ActionResult> AddUser(AddUserModel model)
{
if (!ModelState.IsValid)
{
return(AddUser());
}
var(userId, result) = await _addUserCommand.Execute(model, UserManager);
if (!result.Succeeded)
{
model.GlobalSettingsTabEnumerations = GetGlobalSettingsTabsWithUsersSelected();
AddErrors(result);
return(View(model));
}
_editUserRoleCommand.Execute(new EditUserRoleModel
{
UserId = userId,
RoleId = Role.Admin.Value.ToString()
});
SuccessToastMessage("New User added successfully. \n Please inform the user of the initial password.");
return(RedirectToAction("Users", "GlobalSettings"));
}
public async Task <IActionResult> AddNewUser([FromBody] AddUserModel addUserModel)
{
if (ModelState.IsValid)
{
IdentityResult result, result1;
AppUser findedUser = null;
var user = new AppUser
{
UserName = addUserModel.Email,
PasswordHash = addUserModel.password,
Email = addUserModel.Email,
EmailConfirmed = true,
AgeRangeId = addUserModel.AgeRangeId
};
result = await _userManager.CreateAsync(user, user.PasswordHash);
if (result.Succeeded)
{
findedUser = await _userManager.FindByEmailAsync(user.Email);
result1 = await _userManager.AddToRoleAsync(findedUser, "User");
await _signInManager.PasswordSignInAsync(addUserModel.Email, addUserModel.password, true, false);
return(Ok("done"));
}
return(Ok(result));
}
return(BadRequest(""));
}
public async Task <IActionResult> CreateNewUser(AddUserModel model)
{
if (ModelState.IsValid)
{
UserModel user = new UserModel()
{
UserName = model.UserName,
Email = model.Email,
PhoneNumber = model.PhoneNumber,
EmailConfirmed = model?.ConfirmEmail == true,
EmailVerificationKey = model.EmailConfirmationString.ToUpper(),
};
IdentityResult result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(RedirectToAction("UsersList"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(model));
}
public async Task <IDataResult <Int64> > AddAsync(AddUserModel addUserModel)
{
if (addUserModel is null)
{
throw new ArgumentNullException(nameof(addUserModel));
}
var validation = new AddUserModelValidator().Validate(addUserModel);
if (validation.IsError)
{
return(DataResult <Int64> .Error(validation.Message));
}
addUserModel.SignIn = _signInService.CreateSignIn(addUserModel.SignIn);
var userEntity = UserFactory.Create(addUserModel);
userEntity.Add();
await _userRepository.AddAsync(userEntity).ConfigureAwait(false);
await _unitOfWork.SaveChangesAsync().ConfigureAwait(false);
return(DataResult <Int64> .Success(userEntity.Id));
}
public async Task <IDataResult <long> > AddAsync(AddUserModel addUserModel)
{
var validation = new AddUserModelValidator().Valid(addUserModel);
if (!validation.Success)
{
return(new ErrorDataResult <long>(validation.Message));
}
addUserModel.Login = UserDomainService.GenerateHash(addUserModel.Login);
addUserModel.Password = UserDomainService.GenerateHash(addUserModel.Password);
var userDomain = UserDomainFactory.Create(addUserModel);
userDomain.Add();
var userEntity = userDomain.Map <UserEntity>();
await UserRepository.AddAsync(userEntity);
await DatabaseUnitOfWork.SaveChangesAsync();
return(new SuccessDataResult <long>(userEntity.UserId));
}
public async Task <ApplicationUser> AddUserAsync(AddUserModel model)
{
if (model == null)
{
return(null);
}
var user = new ApplicationUser
{
UserName = model.Username,
Email = model.Email,
EmailConfirmed = model.EmailConfirmed,
Country = model.Country,
PhoneNumber = model.PhoneNumber,
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
if (await _roleManager.RoleExistsAsync("User"))
{
if (!await _userManager.IsInRoleAsync(user, "User") && !await _userManager.IsInRoleAsync(user, "Admin"))
{
await _userManager.AddToRoleAsync(user, "User");
}
}
return(user);
}
return(null);
}
public JsonResult Add(AddUserModel model)
{
CommonModelResult result = new CommonModelResult();
try
{
_userService.CreateNewUser(new LoginUserInfo()
{
UserId = model.UserId,
FullName = model.FullName,
Status = UserStatus.Enable,
Rights = new List <UserRightCode>(CommonUtils.GetListDefaultUserRightCode())
}, CommonConstant.DefaultPassword);
}
catch (BusinessException exception)
{
_logger.DebugFormat("BusinessException: {0}-{1}", exception.ErrorCode, exception.Message);
result.ErrorCode = exception.ErrorCode;
result.ErrorDescription = CommonUtils.GetErrorMessage(exception);
}
catch (Exception exception)
{
_logger.Error(string.Format("Iternal error {0}", exception));
result.ErrorCode = ErrorCode.InternalErrorException;
result.ErrorDescription = CommonUtils.GetEnumDescription(ErrorCode.InternalErrorException);
}
return(Json(result));
}
public IActionResult AddUser()
{
AddUserModel addUserModel = new AddUserModel();
addUserModel.Genders = _db.Genders.ToList();
return(View(addUserModel));
}
public User Create([FromBody] AddUserModel model)
{
if (userRepository.Exists(a => a.Email == model.Email))
{
ModelState.ThrowModelError("email", "Cet adresse électronique est déjà utilisée");
}
User user = new User
{
Name = model.Name,
Surname = model.Surname,
Email = model.Email
};
string username = model.Name + model.Surname.Substring(0, 1).ToUpper() + model.Surname.Substring(1);
long usernameUsage = userRepository.Count(a => a.Name == model.Name && a.Surname == model.Surname);
if (usernameUsage == 0)
{
user.Username = username;
}
else
{
user.Username = username + usernameUsage;
}
string password = passwordHasher.HashPassword(user, model.Password);
user.Password = password;
user = userRepository.Save(user);
return(user);
}
public async Task ShouldAddUserWithRequirePasswordChangeAsTrue()
{
var guidString = Guid.NewGuid().ToString("N");
var newUser = new AddUserModel
{
Email = $"test{guidString}@test.com",
Password = "******",
ConfirmPassword = "******"
};
await ScopedAsync <UserManager <AdminAppUser> >(async manager =>
{
var command = new AddUserCommand();
var(userId, identityResult) = await command.Execute(newUser, manager);
string.Join(Environment.NewLine, identityResult.Errors.Select(x => x.Description)).ShouldBe("");
identityResult.Succeeded.ShouldBeTrue();
var addedUser = Query(userId);
addedUser.UserName.ShouldBe($"test{guidString}@test.com");
addedUser.Email.ShouldBe($"test{guidString}@test.com");
addedUser.RequirePasswordChange.ShouldBe(true);
});
}
public ActionResult Add(AddUserModel model)
{
if (ModelState.IsValid)
{
if (_empRepo.AlreadyRegistered(model.UserName))
{
ModelState.AddModelError("UserName", "UserName already used.");
}
else
{
if (IsValidCountryAndStates(model.Country, model.State))
{
MainUser u = UserHelper.MapAddUserModelToUser(model);
u.IsActive = true;
u.AddedDate = DateTime.Now;
_empRepo.Add(u);
LogActivity("Add User", u.UserName + " is Added by " + User.Identity.Name);
return(RedirectToAction("Index", "Employees"));
}
ModelState.AddModelError("Country", "Country or state is invalid");
}
}
model.Countries = GetCountries();
return(View(model));
}
public IActionResult AddUser(AddUserModel addUser)
{
if (!ModelState.IsValid)
{
return(View(addUser));
}
UserAddModel user = new UserAddModel()
{
IntialBalance = addUser.IntialBalance,
Name = addUser.Name,
Password = addUser.Password,
UserName = addUser.UserName,
AdminUserId = User.FindFirstValue(ClaimTypes.NameIdentifier)
};
var result = userService.AddUser(user);
if (!result.IsSuccessFul)
{
ModelState.AddModelError("", result.Data);
return(View(addUser));
}
return(RedirectToAction("UserList", "Account"));
}
public async Task <IActionResult> Index()
{
var protectorProvider = _provider.GetService <IDataProtectionProvider>();
var protector = protectorProvider.CreateProtector(_dataProtectionKeys.ApplicationUserKey);
var userProfile = await _userSvc.GetUserProfileByIdAsync(protector.Unprotect(_cookieSvc.Get("user_id")));
var addUserModel = new AddUserModel();
var protectorSendGrid = protectorProvider.CreateProtector(_dataProtectionKeys.SendGridProtectionKey);
var dashboard = new DashBoardModel();
_adminBaseViewModel = new AdminBaseViewModel
{
Profile = userProfile,
AddUser = addUserModel,
AppSetting = _appSettings,
SmtpOption = _writableSvcSmtpOptions.Value,
SendGridOption = _writableSvcSendGridOptions.Value,
SiteWideSetting = _writableSiteWideSettings.Value,
Dashboard = dashboard
};
_adminBaseViewModel.SendGridOption.SendGridKey =
protectorSendGrid.Protect(_adminBaseViewModel.SendGridOption.SendGridKey);
_adminBaseViewModel.SmtpOption.SmtpPassword =
protectorSendGrid.Protect(_adminBaseViewModel.SmtpOption.SmtpPassword);
return(View("Index", _adminBaseViewModel));
}
public PartialViewResult Add()
{
var model = new AddUserModel();
ViewData["culture-options"] = _getUserCultureOptions.Get();
return(PartialView(model));
}
public ActionResult AddUser(AddUserModel model)
{
string userName = User.Identity.Name,
roleName = null;
if (ModelState.IsValid)
{
// Attempt to register the user
MembershipCreateStatus createStatus;
Membership.CreateUser(model.UserName, model.Password, model.Email, null, null, true, null, out createStatus);
if (createStatus == MembershipCreateStatus.Success)
{
using (hunterCVEntities context = new hunterCVEntities())
{
roleName = context.Users.Where(u => u.UserName == userName).Single().Roles.Single().RoleName;
var user = context.Users.Single(u => u.UserName == model.UserName);
user.ApplicationRole = model.ApplicationRole;
context.SaveChanges();
}
Roles.AddUserToRole(model.UserName, roleName);
return(RedirectToAction("Manage", "Account"));
}
}
// If we got this far, something failed, redisplay form
return(RedirectToAction("Manage", "Account"));
}
public ActionResult AddNewUser(string login)
{
if ((Session["UserLogin"] == null) || (Session["UserLogin"] != null && Session["UserLogin"].ToString() != "admin"))
{
return(HttpNotFound());
}
if (UserController.ContainsUser(login))
{
ViewBag.UserAlreadyExist = true;
var addUserModel = new AddUserModel(login);
return(View("AddUser", addUserModel));
}
else
{
foreach (var user in UserController.Users)
{
if (user.Login == login)
{
return(RedirectToAction("Index"));
}
}
UserController.Users.Add(new UserProfile(login, new List <string>()));
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> AddUser([FromBody] AddUserModel ajaxModel)
{
if (!IsClientRegistered(ajaxModel.authKey))
{
return(StatusCode(403));
}
//Na początku sprawdzamy czy nie ma już osoby o takim imieniu i nazwisku
var user1 = (from a in db.Users where (a.forname.ToUpper() + a.surname.ToUpper()) == (ajaxModel.forname.ToUpper() + ajaxModel.surname.ToUpper()) select a).FirstOrDefault();
if (user1 != null)
{
//Sprawdzamy czy ten użytkownik jest włączony
if (!user1.enabled)
{
user1.enabled = true;
db.Users.Update(user1);
await db.SaveChangesAsync();
return(Content("true"));
}
else
{
return(Content("false"));
}
}
var user = new User(ajaxModel.forname, ajaxModel.surname);
db.Users.Add(user);
await db.SaveChangesAsync();
return(Content("true"));
}
[HttpPost("customeradd")] //добавление пользователя - Ok
public async Task <IActionResult> AddCustomer([FromBody] AddUserModel request)
{
if (ModelState.IsValid)
{
if (await unitOfWork.Customers.GetAsync(request.Email) == null)
{
var customer = new Customer()
{
Name = request.Name,
UserName = request.Email,
Email = request.Email,
Address = request.Address,
Code = request.Code,
Discount = request.Discount
};
string pass = new Generator().GetPass();
await unitOfWork.Customers.CreateAsync(customer, pass);
return(Ok(pass));
}
else
{
return(BadRequest("This user already exists"));
}
}
else
{
return(BadRequest("Request model is invalid"));
}
}
public async Task <Users> AddUser(AddUserModel view, string role)
{
var user = new Users
{
Address = view.Address,
Document = view.Document,
FirstName = view.FirstName,
LastName = view.LastName,
Movil = view.Movil,
Activo = view.Activo,
DateRegistro = DateTime.Now,
Email = view.Username,
UserName = view.Username
};
var result = await AddUserAsync(user, view.Password);
if (result != IdentityResult.Success)
{
return(null);
}
var newUser = await GetUserByEmailAsync(view.Username);
await AddUserToRoleAsync(newUser, role);
return(newUser);
}
public virtual ActionResult addUser(AddUserModel user)
{
Authentication auth = new Authentication();
if (auth.isAdmin(this) || Authentication.DEBUG_bypassAuth)
{
if (ModelState.IsValid)
{
LDAPConnection newConnection = new LDAPConnection();
List <string> userInfo = newConnection.create(user.UserName);
//Code here for creating TARSUser object; this will require
// changing the LDAPConnection.create function to only
// return the user information that is pertinent to TARS
/*
* var userEntry = new TARSUser();
* userEntry.userName = userInfo[1];
* TARSUserDB.TARSUserList.Add(userEntry);
*/
return(RedirectToAction("userMaintanence"));
}
return(View(user));
}
else
{
return(View("error"));
}
}
public IHttpActionResult PutUser(string id, AddUserModel user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
User _user = null;
using (SoilCareEntities db = new SoilCareEntities())
{
_user = db.Users.Find(id);
if (_user == null)
{
return(NotFound());
}
// Map model to entity
Mapper.Map <AddUserModel, User>(user, _user);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
}
return(Ok());
}
public async Task <IActionResult> AddAsync(AddUserModel addUserModel)
{
var signIn = addUserModel.SignIn;
await _userApplicationService.AddAsync(addUserModel);
return(Result(await _userApplicationService.SignInAsync(signIn)));
}
public async Task <IHttpActionResult> AddUser(AddUserModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new ApplicationUser()
{
UserName = model.UserName, Email = model.Email,
//StudyGroupId = model.StudyGroupId
};
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
//Add to role
UserManager.AddToRole(user.Id, "User");
return(Ok());
}
public ActionResult CreateUser(AddUserModel model)
{
if (ModelState.IsValid)
{
try
{
HttpPostedFileBase file = Request.Files["ImageData"];
_UsersManagementService.CreateUser(file, model);
TempData["Success"] = "Success";
return(RedirectToAction("AddUser"));
}
catch (Exception e)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
ModelState.AddModelError("", e.Message);
TempData["Fail"] = "Fail";
return(View("AddUser", model));
}
}
else
{
TempData["ModelsError"] = "Error";
return(RedirectToAction("AddUser"));
}
}
public ActionResult AddUser()
{
if (Session["Email"] != null && Session["UserID"] != null)
{
ViewBag.ActiveMenu = "AddUser";
AddUserModel _AddUserModel = new AddUserModel();
DataSet dbInitial = _UsersManagementService.LoadDetail(Session["Email"].ToString());
_AddUserModel.Position = dbInitial.Tables[0].AsEnumerable().Select(row => new PositionModel
{
PositionId = Convert.ToInt32(row["GR_CODE"]),
PositionName = Convert.ToString(row["DESCRIPTION"])
});
_AddUserModel.Area = dbInitial.Tables[1].AsEnumerable().Select(row => new AreaModel
{
AreaCode = Convert.ToInt32(row["AREA_CODE"]),
AreaName = Convert.ToString(row["AREA_NAME"])
});
_AddUserModel.sex = _SystemTools.GetGender();
return(View(_AddUserModel));
}
else
{
return(RedirectToAction("Login", "Account"));
}
}//..End User
public async Task <IActionResult> UpdateUser(AddUserModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest());
}
var user = await this.userManager.FindByNameAsync(model.UserName);
if (user == null)
{
throw new ApplicationException($"Could not found a use with named {model.UserName}.");
}
if (model.Email != user.Email)
{
var setEmailResult = await this.userManager.SetEmailAsync(user, model.Email);
if (!setEmailResult.Succeeded)
{
throw new ApplicationException($"Unexpected error occurred setting email for user with ID '{user.Id}'.");
}
}
if (model.PhoneNumber != user.PhoneNumber)
{
var setPhoneNumberResult = await this.userManager.SetEmailAsync(user, model.Email);
if (!setPhoneNumberResult.Succeeded)
{
throw new ApplicationException($"Unexpected error occurred setting phone number for user with ID '{user.Id}'.");
}
}
bool changed = false;
if (model.FirstName != user.FirstName)
{
user.FirstName = model.FirstName;
changed = true;
}
if (model.LastName != user.LastName)
{
user.LastName = model.LastName;
changed = true;
}
if (changed)
{
var updateUserResult = await this.userManager.UpdateAsync(user);
if (!updateUserResult.Succeeded)
{
throw new ApplicationException($"Unexpected error occurred while updating user with ID '{user.Id}'.");
}
}
return(this.Ok());
}
public ActionResult Create(AddUserModel User)
{
// var errors = ModelState
//.Where(x => x.Value.Errors.Count > 0)
//.Select(x => new { x.Key, x.Value.Errors })
//.ToArray();
var chkemailid = ChkValidEmailID(User.Email_id);
if (chkemailid.Data != "false")
{
ModelState.AddModelError("Email_id" ,"This Email id has already Registered");
}
if (ModelState.IsValid)
{
try
{
// string usrpwd = Encode(User.Usr_pwd);
// Insert Product
User_Info objnewUser = new User_Info();
objnewUser.UidNo = (db.User_Info.Max(i => (int?)i.UidNo) ?? 0) + 1; //Convert.ToInt32(db.PRODUCTs.Max(x => x.Pid)) + 1;
objnewUser.First_name = User.First_name;
objnewUser.Last_name = User.Last_name;
objnewUser.Isactive = true;
objnewUser.E_mail_id = User.Email_id;
objnewUser.Mobile_number = User.Mobile_number;
objnewUser.Address_Communication = User.Address_Communication;
objnewUser.DOB=User.DOB;
objnewUser.Gender=User.Gender;
objnewUser.Usr_pwd = Encode(User.Usr_pwd);
db.User_Info.Add(objnewUser);
db.SaveChanges();
TempData["Usr_Message"] = ConfigurationManager.AppSettings["INS_SUC"];
ModelState.Clear();
return RedirectToAction("UserLogin", "UserInfo");
}
catch (Exception exception)
{
}
return RedirectToAction("Create", "UserInfo");
}
var list = new SelectList(new[] { new { ID = "M", Name = "Male" }, new { ID = "F", Name = "FeMale" }, new { ID = "O", Name = "Others" } }, "ID", "Name", 1);
ViewBag.Genders = list;
return View(User);
}
public virtual ActionResult addUser(AddUserModel user)
{
Authentication auth = new Authentication();
if (auth.isAdmin(this) || Authentication.DEBUG_bypassAuth)
{
if (ModelState.IsValid)
{
LDAPConnection newConnection = new LDAPConnection();
List<string> userInfo = newConnection.create(user.UserName);
//Code here for creating TARSUser object; this will require
// changing the LDAPConnection.create function to only
// return the user information that is pertinent to TARS
/*
var userEntry = new TARSUser();
userEntry.userName = userInfo[1];
TARSUserDB.TARSUserList.Add(userEntry);
*/
return RedirectToAction("userMaintanence");
}
return View(user);
}
else
{
return View("error");
}
}
