public virtual ActionResult Register(UserRegister reg)
{
var user = new User
{
Email = reg.Email,
FirstName = reg.FirstName,
LastName = reg.LastName,
Address = reg.Address,
Company = reg.Company,
Gender = reg.Gender,
Mobile = reg.Mobile,
Password = reg.PlainTextPassword,
PostCode = reg.PostCode,
Telephone = reg.Telephone,
Status = UserStatus.Unactivated,
Roles = new[] { new UserRole {
Role = Role.Customer
} },
Deliveries = new[] { new Delivery {
Address = reg.Address, Phone = reg.Mobile, PostCode = reg.PostCode, Receiver = reg.FirstName + " " + reg.LastName
} }
};
using (var context = new AllureContext())
{
context.Set <User>().Add(user);
context.SaveChanges();
}
ViewBag.ActivateUrl = "/user/activate?token=" + Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(prefix + user.Email));
return(View(MVC.User.Views.RegisterSuccess, CreateViewModel()));
}
public static string DoRegisterUser(UserRegister InputuserRegister, out User userRegister)
{
string msg = "";
userRegister = null;
if (msg.Length > 0)
{
return(msg);
}
msg = DoRegisterUser_Validate(InputuserRegister);
if (msg.Length > 0)
{
return(msg);
}
msg = DoRegisterUser_ObjectToDB(InputuserRegister, out userRegister);
if (msg.Length > 0)
{
return(msg);
}
return("");
}
public ActionResult Index(UserRegister user)
{
UDbTable model = new UDbTable
{
Username = user.Username,
Password = user.Password,
Email = user.Email
};
model.LastLogin = DateTime.Now;
if (ModelState.IsValid)
{
using (DBModels db = new DBModels())
{
if (db.UDbTables.Any(x => x.Username == model.Username))
{
return(View("Index"));
}
else
{
db.UDbTables.Add(model);
db.SaveChanges();
}
}
return(RedirectToAction("Stream", "Home", user));
}
return(View("Index"));
}
public async Task <(UserDto userCreds, string token)> Register(UserRegister newUser)
{
var exists = await UsernameExists(newUser.Username) || await EmailExists(newUser.Email);
if (exists)
{
return(null, null);
}
User user = new User()
{
Username = newUser.Username,
Email = newUser.Email,
NormalizedUsername = newUser.Username.ToLower(),
NormalizedEmail = newUser.Email.ToLower(),
PasswordHash = Helper.ComputeHash(newUser.Password)
};
await _context.Users.AddAsync(user);
await _context.SaveChangesAsync();
var loginResult = await Login(new UserLogin()
{
Parameter = user.NormalizedEmail,
Password = newUser.Password
});
return(loginResult);
}
public IActionResult Register(UserRegister user)
{
if (ModelState.IsValid)
{
User logged = _context.users.SingleOrDefault(we => we.Email == user.Email);
if (logged != null)
{
TempData["Rerror"] = "Email already registered";
return(View("Index", user));
}
string hashed = HashedPass(user.Password);
User newUser = new User
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
Password = hashed,
};
_context.users.Add(newUser);
_context.SaveChanges();
logged = _context.users.SingleOrDefault(we => we.Email == user.Email);
int userId = logged.Id;
HttpContext.Session.SetInt32("loggedId", userId);
return(RedirectToAction("GameSelect", "Home"));
}
return(View("Index", user));
}
public async Task <IActionResult> Register([FromBody] UserRegister userToCreate)
{
var _user = _mapper.Map <User>(userToCreate);
if (await _userRepo.UserExists(_user.Username))
{
return(BadRequest(new { message = "Username already exists" }));
}
var user = await _userRepo.Register(_user);
if (user == null)
{
return(BadRequest(new { message = "Error while registering..." }));
}
var userToReturn = _mapper.Map <UserDto>(user);
var loginCreds = new Login()
{
Username = userToCreate.Username,
Password = userToCreate.Password
};
return(await Login(loginCreds));
}
public JObject PostRegistrationApplication(string userName, string phone, string email, string industry,
string city)
{
//var jObject = new JObject();
try
{
var entity = new UserRegister
{
UserName = userName,
Phone = phone,
EMail = email,
Industry = industry,
City = city
};
_userRegisterService.AddUserRegister(entity);
_userRegisterService.Save();
return(new JObject
{
{ "Result", "success" },
{ "Info", "感谢您申请试用智地数据平台，我们的工作人员会尽快与你取得联系。" }
});
}
catch (Exception ex)
{
return(new JObject
{
{ "Result", "fail" },
{ "Info", ex.ToString() }
});
}
}
public ActionResult Register(UserRegister Usermodel)
{
try
{
if (ModelState.IsValid)
{
UserRegister postmodel = new UserRegister
{
firm = Usermodel.firm,
email = Usermodel.email,
password = Encryption(Usermodel.password.Trim()),
mobileNo = Usermodel.mobileNo,
authToken = null,
softdelete = null
};
context.UserRegisters.Add(postmodel);
if (postmodel.email != null && postmodel.password != null)
{
Session["em@il"] = postmodel.email;
Session["passw0rd"] = postmodel.password;
context.SaveChanges();
return(RedirectToAction("Login"));
}
return(RedirectToAction("Error"));
}
return(RedirectToAction("Error"));
}
catch (Exception)
{
return(RedirectToAction("Error"));
}
}
public async Task <IActionResult> RegisterUser(UserRegister userRegister)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = userRegister.Email,
Email = userRegister.Email,
FirstName = userRegister.FirstName,
LastName = userRegister.LastName,
DepartmentID = userRegister.DepartmentID
};
var result = await _userManager.CreateAsync(user, userRegister.password);
if (result.Succeeded)
{
await _userManager.AddToRolesAsync(user, new[] { "Regular" });
_logger.LogInformation(3, "User Created a New Account With Password.");
return(RedirectToAction("Index", new { Message = MessageNote.Exist }));
}
AddErrors(result);
}
return(View(userRegister));
}
public ActionResult Register(UserRegister model)
{
var user = db.User.FirstOrDefault(x => x.Username == model.Username);
if (user != null)
{
ModelState.AddModelError("", "Tài khoản đã tồn tại.");
}
else if (model.Password != model.ConfirmPassword)
{
ModelState.AddModelError("", "Mật khẩu phải giống nhau");
}
else
{
User result = new User()
{
Email = model.Email,
Name = model.Fullname,
Password = model.Password,
Phone = model.Phone,
Username = model.Username,
UserGroup_ID = 2
};
db.User.Add(result);
db.SaveChanges();
return(RedirectToAction("Login", "Login"));
}
return(View());
}
public async Task <IActionResult> Login([FromBody] UserRegister model)
{
var user = await _dataAccess.Login(model);
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
new Claim(ClaimTypes.Name, user.UserName),
new Claim(ClaimTypes.Surname, user.FirmName), //using FirmId in the Givenname of the ClaimTypes
new Claim(ClaimTypes.GivenName, user.FirmId.ToString())
};
var key = new SymmetricSecurityKey(Encoding.UTF8
.GetBytes(_config.GetSection("AppSettings:Token").Value));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = System.DateTime.Now.AddDays(1),
SigningCredentials = creds
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
return(Ok(new
{
token = tokenHandler.WriteToken(token),
user
}));
}
public async System.Threading.Tasks.Task <bool> cleanUserTotalPoint(string emailStr)
{
bool result = false;
if (NetworkCheck.IsInternet())
{
using (var client = new HttpClient())
{
var postData = new UserRegister
{
email = emailStr
};
var json = JsonConvert.SerializeObject(postData);
var content = new StringContent(json, Encoding.UTF8, "application/json");
var uri = app.url + "/AR_admin/UserCleanTotalPoint";
var postResult = await client.PostAsync(uri, content);
if (postResult.IsSuccessStatusCode)
{
var resultString = await postResult.Content.ReadAsStringAsync();
var response = JsonConvert.DeserializeObject <Result>(resultString);
if (response != null && response.result != null && response.result != "" && response.result == "0")
{
result = true;
}
}
}
}
else
{
await Application.Current.MainPage.DisplayAlert("訊息", app.networkMessage, "OK");
}
return(result);
}
public ActionResult Add(UserRegister userRegister)
{
if (ModelState.IsValid)
{
HokejistiUserDao hokejistiUserDao = new HokejistiUserDao();
if (hokejistiUserDao.GetByLogin(userRegister.Login) == null)
{
HokejistiRole vyukaRole = new HokejistiRoleDao().GetById(2);
HokejistiUser user = new HokejistiUser()
{
Login = userRegister.Login,
Name = userRegister.Name,
Surname = userRegister.Surname,
Password = userRegister.Password.HashPassword(),
Role = vyukaRole,
};
hokejistiUserDao.Create(user);
FormsAuthentication.SetAuthCookie(user.Login, false);
TempData["message-success"] = "Login " + user.Login + " byl úspěšně přidán.";
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("Login", "Uživatel již existuje! Zvolte jiný login.");
return(View("Index", userRegister));
}
return(View("Index", userRegister));
}
public async Task <DataResult> Register(UserRegister model)
{
if (!ModelState.IsValid)
{
return new DataResult()
{
Success = false, Message = "Preencha o formulário corretamente.."
}
}
;
UserResult result = await _service.Register(model);
if (result.Success == false)
{
return new DataResult()
{
Success = false, Message = result.Message
}
}
;
return(new DataResult()
{
Success = true, Message = string.Empty
});
}
/// <summary>
/// generate token for user
/// </summary>
/// <param name="result">user data retrieve from database</param>
/// <returns>token and expiration date</returns>
public async Task <object> generateToken(UserRegister result)
{
var roles = await userManager.GetRolesAsync(result);
DateTime currentDate = DateTime.Now.AddHours(1);
List <Claim> claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Sub, result.UserName),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Exp, currentDate.ToString())
};
foreach (var item in roles)
{
claims.Add(new Claim(ClaimTypes.Role, item));
}
var signingKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("MySuperSecureKey"));
var token = new JwtSecurityToken(
issuer: "http://localhost",
audience: "http://localhost",
expires: currentDate,
claims: claims,
signingCredentials: new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256));
var results = new
{
token = new JwtSecurityTokenHandler().WriteToken(token)
};
await userManager.AddClaimsAsync(result, claims);
return(results);
}
public async Task <IActionResult> Register(UserRegister userRegister)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var user = new IdentityUser
{
UserName = userRegister.Email,
Email = userRegister.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, userRegister.Password);
if (result.Succeeded)
{
return(CustomResponse(await GenerateJwt(userRegister.Email)));
}
foreach (var error in result.Errors)
{
AddProcessErrors(error.Description);
}
return(CustomResponse());
}
public async Task <IActionResult> RegisterAsync(UserRegister data)
{
var user = new ApplicationUser
{
UserName = data.UserName,
Email = data.Email,
DateOfBirth = data.DateofBirth,
FirstName = data.FirstName,
LastName = data.LastName,
PhoneNumber = ExtractPhoneNumber.RemoveNonNumeric(data.PhoneNumber),
AccountType = AccountType.Regular,
Gender = data.Gender
};
var result = await _userManager.CreateAsync(user, data.Password);
if (result.Succeeded)
{
_logger.LogInformation("New user created.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
await _emailSender.SendEmailConfirmationAsync(data.Email, callbackUrl);
return(Ok());
}
return(BadRequest());
}
public async Task<IActionResult> Register(UserRegister model, string returnUrl = null)
{
if (ModelState.IsValid)
{
var checkUser = await _userManager.FindByEmailAsync(model.Email);
if(checkUser != null)
{
ModelState.AddModelError("","Email already exists");
return View(model);
}
User user = new User { Name = model.Name, Designation = model.Designation, Role = model.Role, Location = model.Location, ProfileImage = "assets/images/users.png" };
long userId = _userServices.AddNewuser(user);
var appUser = new AppUser { UserName = model.Email, Email = model.Email, UserId = userId };
var result = await _userManager.CreateAsync(appUser, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(appUser, isPersistent: false);
if (returnUrl == null)
return Redirect("~/home");
return Redirect(returnUrl);
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return View(model);
}
public HttpResponseMessage Register(UserRegister model)
{
HttpResponseMessage response;
try
{
if (ModelState.IsValid)
{
LoginHelpers User = new LoginHelpers();
var existingUser = User.RegisterHelpers(model);
if (existingUser.Count != 0)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "User or Email already exist."));
}
//Create user and save to database
var user = CreateUser(model);
object dbUser;
//Create token and save to database
var token = CreateToken(user[0], out dbUser);
User.SaveToken(user[0].User_Id, token);
response = Request.CreateResponse(new { dbUser, token });
}
else
{
response = Request.CreateResponse(HttpStatusCode.BadRequest, new { success = false });
}
}
catch (SqlException)
{
response = Request.CreateResponse(HttpStatusCode.InternalServerError);
}
return(response);
}
public IActionResult ProcessRegister(UserRegister model)
{
if (ModelState.IsValid)
{
List <User> emails = _dBContext.Users.Where(u => u.Email == model.Email).ToList();
if (emails.Count > 0)
{
ModelState.AddModelError("Email", "Email already exits");
return(View("Register", model));
}
else
{
//Hash password
PasswordHasher <UserRegister> hasher = new PasswordHasher <UserRegister>();
string hashedPassword = hasher.HashPassword(model, model.Password);
User newUser = new User
{
Email = model.Email,
Password = hashedPassword,
};
_dBContext.Add(newUser);
_dBContext.SaveChanges();
HttpContext.Session.SetInt32("loggedUser", newUser.ID);
return(RedirectToAction("Index", "Home"));
}
}
return(View("Register", model));
}
private IEnumerator RegisterUser()
{
UnityWebRequest httpClient = new UnityWebRequest(player.HttpServerAddress + "/api/Account/Register", "POST");
UserRegister newUser = new UserRegister();
newUser.Email = emailInputField.text;
newUser.Password = passwordInputField.text;
newUser.ConfirmPassword = confirmPasswordInputField.text;
string jsonData = JsonUtility.ToJson(newUser);
byte[] dataToSend = Encoding.UTF8.GetBytes(jsonData);
httpClient.uploadHandler = new UploadHandlerRaw(dataToSend);
//Error, it's Content-type, not Content-Type
httpClient.SetRequestHeader("Content-type", "application/json");
//We need the certificate to return true, so we create a class that will always return true.
httpClient.certificateHandler = new ByPassCertificate();
yield return(httpClient.SendWebRequest());
if (httpClient.isNetworkError || httpClient.isHttpError)
{
throw new Exception("OnRegisterButtonClick: Error > " + httpClient.error);
}
Debug.Log("\nOnRegisterButtonClick: " + httpClient.responseCode);
httpClient.Dispose();
}
public void AWSCICDDb_IntegrationTest_ReturnFullySuccess()
{
var user = new UserRegister {
FirstName = "Ahmet", LastName = "Karadað", UserName = "******", EMail = "*****@*****.**", Password = "******"
};
using (var context = new AWSCICDAppDbContext())
{
context.Set <UserRegister>().Add(user);
context.SaveChanges();
}
using (var context = new AWSCICDAppDbContext())
{
context.Entry(user).State = EntityState.Modified;
context.SaveChanges();
}
using (var context = new AWSCICDAppDbContext())
{
context.Set <UserRegister>().ToList();
}
using (var context = new AWSCICDAppDbContext())
{
context.Set <UserRegister>().Find(1);
}
using (var context = new AWSCICDAppDbContext())
{
context.Set <UserRegister>().Remove(user);
context.SaveChanges();
}
}
public IHttpActionResult SaveUserAsync(UserAllDataDto dto)
{
IRegisterUser regster = new UserRegister();
regster.SaveUser <AccommodationContext>(dto.User, dto.UserData, dto.Address);
return(Ok());
}
public IHttpActionResult GetNewUserAsync(UserCredentialDto dto)
{
IRegisterUser register = new UserRegister();
User user = register.GetNewUser(dto.Username, dto.Password);
return(Ok(user));
}
public IHttpActionResult Post([FromBody] UserRegister value)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Response <Dictionary <string, string> > response = new Response <Dictionary <string, string> >();
Status status = new Status();
try
{
Database1Entities db = new Database1Entities();
var isExist = db.Users.Where(x => x.MobileNumber == value.phoneNumber).Select(x => x).ToList();
if (isExist.Count != 0)
{
status.code = 304;
status.Message = "Phone Number Duplicate";
response.Status = status;
return(Json(response));
}
User user = new User();
try
{
if (value.dob != "--")
{
DateTime dob = Convert.ToDateTime(value.dob);
user.DateOfBirth = dob;
}
}catch (Exception E)
{
status.code = 304;
status.Message = "Kosongkan Tanggal atau isi dengan benar";
response.Status = status;
return(Json(response));
}
user.MobileNumber = value.phoneNumber;
user.FirstName = value.firstname;
user.LastName = value.lastName;
user.Gender = value.gender;
user.Email = value.email;
user.IsDeleted = 0;
user.CreatedAt = DateTime.Now;
db.Users.Add(user);
db.SaveChanges();
status.code = 200;
status.Message = "success";
response.Status = status;
return(Json(response));
}
catch (Exception e)
{
status.code = 500;
status.Message = "INTERNAL SERVER EROR";
response.Status = status;
return(Json(response));
}
}
public async Task <UserRegister> Register(UserRegister userRegister)
{
var existingUser = await _userRepository.GetByEmail(userRegister.Email);
if (existingUser != null)
{
throw new ValidationException("Ya se ha registrado con usuario con el correo electrónico");
}
var user = Domain.Entities.User.Create(userRegister.Name, userRegister.LastName, userRegister.Phone,
userRegister.Email);
var secretKey = Encryptor.GetSecretKey();
var passwordEncrypted = Encryptor.GetHash(userRegister.Password, secretKey);
await _userRepository.Create(user);
var identityRegister = new AuthRegister
{
UserId = user.Id,
Email = user.Email,
Password = passwordEncrypted,
PasswordKey = secretKey,
FullName = $"{user.Name} {user.LastName}",
};
_authPublisher.RegisterAuth(identityRegister);
return(new UserRegister
{
Name = user.Name,
Email = user.Email,
LastName = user.LastName
});
}
public ActionResult Register(UserRegister ur)
{
IUser user = new IUser(ur);
if (ModelState.IsValid)
{
IUserDal ud = new IUserDal();
//check if user allready exist
List <IUser> userToCheck = (from x in ud.Users
where x.Email == user.Email
select x).ToList <IUser>();
if (userToCheck.Count == 1)
{
TempData["RegisterMessage"] = "Mail is allready exist";
TempData["Register"] = "Register";
return(View("Register"));
}
//password hashing
PWEncryption enc = new PWEncryption();
user.Password = enc.createHash(user.Password);
ud.Users.Add(user);
ud.SaveChangesAsync();
Session["UserName"] = user.UserName;
Session["Location"] = RegionInfo.CurrentRegion.DisplayName;
return(RedirectToAction("Index", "Home", user));
}
return(View("Register"));
}
public async Task <IActionResult> Register(UserRegister userRegister)
{
if (!ModelState.IsValid)
{
return(View(userRegister));
}
// API - Registro
var response = await _authenticationService.Register(userRegister);
if (ResponseHasErrors(response.ResponseResult))
{
return(View(userRegister));
}
//Realizar login na APP
await ProcessLogin(response);
return(RedirectToAction("Index", "Home"));
//if (ResponsePossuiErros(resposta.ResponseResult)) return View(userRegister);
//await RealizarLogin(resposta);
}
public ActionResult AddAdmin(UserRegister userInfo)
{
if (Session["AdminId"] == null)
{
return(RedirectToAction("Login", "Home"));
}
else
{
if (db.UserInfoes.Any(e => e.Email == userInfo.Email))
{
ModelState.AddModelError("Email", "Email is already in use");
}
if (ModelState.IsValid)
{
UserInfo ui = new UserInfo();
ui.Type = userInfo.Type;
ui.Name = userInfo.Name;
ui.Passward = CryptPassword.Hash(userInfo.Passward);
ui.Email = userInfo.Email;
ui.Gender = userInfo.Gender;
ui.DepId = null;
ui.Active = null;
ui.Accepted = null;
ui.AbsenceHours = null;
db.UserInfoes.Add(ui);
db.SaveChangesAsync();
return(RedirectToAction("Users", "Admin"));
}
return(View(userInfo));
}
}
public async Task <IActionResult> Register([FromBody] UserRegister registerUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new AuthUser
{
Name = registerUser.Name,
UserName = registerUser.Email,
Email = registerUser.Email
};
var result = await db.CreateAsync(user, registerUser.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
await db.AddClaimAsync(user, new Claim("userName", user.UserName));
await db.AddClaimAsync(user, new Claim("name", user.Name));
await db.AddClaimAsync(user, new Claim("userId", user.Id));
await db.AddClaimAsync(user, new Claim("role", Roles.USER));
return(Ok(new UserResponse(user)));
}
public ActionResult Register(UserRegister model) {
if (ModelState.IsValid) {
/*User result = userService.Create(model);
if (result ! = null) {
SignInAsync(result, isPersistent: false);
return RedirectToAction("Index", "Home");
} else {
AddErrors(result);
}*/
}
return ViewBase("#dialogsContainer", "RegisterForm", model);
}
public HttpResponseMessage LoginUser(UserRegister user)
{
User userEntity = this.unitOfWork.UsersRepository.Find(us => us.Username == user.Username
&& us.Password == user.Password).FirstOrDefault();
if (userEntity == null)
{
throw new HttpResponseException(HttpStatusCode.NotAcceptable);
}
string sessionKey = this.unitOfWork.SessionsRepository.LoginUser(userEntity);
this.unitOfWork.Save();
UserRegister registeredUser = new UserRegister()
{
Id = userEntity.Id,
AvatarUrl = userEntity.AvatarUrl,
Username = userEntity.Username,
SessionKey = sessionKey
};
var response = Request.CreateResponse<UserRegister>(HttpStatusCode.OK, registeredUser);
return response;
}
