public ActionResult Register()
{
var model = new UserRegisterVM();
model.dateDeNaissance = DateTime.Now;
return(View(model));
}
[ValidateAntiForgeryToken] // Prevents XSRF/CSRF attacks
public async Task <IActionResult> Register(UserRegisterVM userRegisterVM)
{
if (userRegisterVM == null)
{
throw new ArgumentNullException(nameof(userRegisterVM));
}
if (ModelState.IsValid)
{
using var client = _httpClientFactory.CreateClient("MMDB_API");
using var userContent = new StringContent(JsonSerializer.Serialize(userRegisterVM), Encoding.UTF8, "application/json");
HttpResponseMessage httpResponseMessage = await client.PostAsync("users/register", userContent).ConfigureAwait(false);
if (httpResponseMessage.IsSuccessStatusCode)
{
var responseStream = await httpResponseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
UserVM userVM = await JsonSerializer.DeserializeAsync <UserVM>(responseStream);
_stateHelper.SetState(userVM, true);
return(RedirectToAction("Index", "Home", new { area = "" }));
}
}
return(View(userRegisterVM));
}
public ActionResult Register(UserRegisterVM u)
{
try
{
///creating company
UserBiz userBiz = new UserBiz();
/// creating user
CRMUser user = new CRMUser();
user.Password = u.Password;
user.Username = u.EmailId;
user.CompanyName = u.CompanyName;
user.CompanyId = 0;
string guid = userBiz.RegisterUser(user);
//string CurrentURL = Request.Url.AbsoluteUri;
string Msg = "Dear Customer,<br/><br/> Thank you for Registring with us<br/>" +
"Plese Click below link for Activation<br/><br/>" +
"<a href='http://*****:*****@gmail.com", "Company Registration", Msg, true);
ViewBag.Message = "Succefully Registered";
return(View("RegisterSuccess"));
}
catch (Exception Ex)
{
ModelState.AddModelError("VE", Ex.Message);
return(View(u));
}
}
public ActionResult <IdentityResult> Register(UserRegisterVM userVM)
{
var result = userService.Register(userVM.UserName, userVM.Email, userVM.Password);
if (result.Succeeded)
{
return(Ok(result));
}
return(BadRequest(result));
}
public ActionResult Create(UserRegisterVM model)
{
if (ModelState.IsValid)
{
db.User.Add(model.user);
db.SaveChanges();
}
return(RedirectToAction("Index", "Home"));
}
public async Task <JsonResult> Register([FromBody] UserRegisterVM model)
{
if (!ModelState.IsValid)
{
return(new JsonAPIResult(_apiResult.CreateVMWithModelState(modelStateDictionary: ModelState),
StatusCodes.Status400BadRequest));
}
User entity = _mapper.Map <UserRegisterVM, User>(model);
entity.Id = Guid.NewGuid();
entity.CreateDateTime = DateTime.UtcNow;
var claims = new Claim[] {
new Claim(JwtRegisteredClaimNames.Sub, entity.Id.ToString()),
new Claim(JwtRegisteredClaimNames.UniqueName, entity.UserName),
new Claim("UserId", entity.Id.ToString())
};
TokenCacheVM authData = new TokenCacheVM();
authData.AccessToken = _tokenService.GenerateAccessToken(claims);
authData.RefreshToken = _tokenService.GenerateRefreshToken();
authData.AccessTokenExpiryTime = new JwtSecurityTokenHandler().ReadToken(authData.AccessToken)?.ValidTo ?? DateTime.MinValue;
authData.RefreshTokenExpiryTime = DateTime.UtcNow.AddDays(1);
authData.Id = entity.Id;
var identityResult = await _userManager.CreateAsync(entity, model.Password);
if (!identityResult.Succeeded)
{
return(new JsonAPIResult(_apiResult.CreateVMWithIdentityErrors(errors: identityResult.Errors),
StatusCodes.Status422UnprocessableEntity));
}
TimeSpan expiryTimeSpan = TimeSpan.FromSeconds(_tokenService.GetTokenExpiryDuration());
var cacheResult = _tokenService.Redis.Insert(authData, expiryTimeSpan);
if (!cacheResult.IsSuccessful)
{
return(new JsonAPIResult(_apiResult.CreateVMWithStatusCode(null, false, APIStatusCode.ERR01011),
StatusCodes.Status409Conflict));
}
await _signInManager.SignInAsync(entity, isPersistent : false);
UserAuthenticationVM returnVM = new UserAuthenticationVM();
returnVM = _mapper.Map <User, UserAuthenticationVM>(entity);
returnVM.TokenData = authData;
return(new JsonAPIResult(_apiResult.CreateVMWithRec <UserAuthenticationVM>(returnVM, entity.Id, true),
StatusCodes.Status201Created));
}
public ActionResult Register(UserRegisterVM model)
{
var result = this.context.Register(model.adresseMail, model.motDePasse, model.prenom, model.nom, model.dateDeNaissance);
if (result)
{
return(RedirectToAction("LogIn", "Authentification"));
}
return(View(model));
}
public async Task <UserVM> Create(UserRegisterVM src)
{
//Create the new entity
var entity = new User(src);
//Add and save the changes to the database
await _context.UserEntities.AddAsync(entity);
await _context.SaveChangesAsync();
return(new UserVM(entity));
}
public ActionResult Register(UserRegisterVM model)
{
var user = new AppUser()
{
Email = model.Login,
UserName = model.Login,
};
var res = manager.Create(user, model.Password);
if (res.Succeeded)
{
return(RedirectToAction("Index", "Room"));
}
return(View());
}
public string Register(UserRegisterVM user)
{
var http = (HttpWebRequest)WebRequest.Create(new Uri(_url + "/register"));
http.Accept = "application/json";
http.ContentType = "application/json";
http.Method = "POST";
string parsedContent = JsonConvert.SerializeObject(user);
UTF8Encoding encoding = new UTF8Encoding();
Byte[] bytes = encoding.GetBytes(parsedContent);
Stream newStream = http.GetRequestStream();
newStream.Write(bytes, 0, bytes.Length);
newStream.Close();
var response = http.GetResponse();
var stream = response.GetResponseStream();
var sr = new StreamReader(stream);
var content = sr.ReadToEnd();
var tokenObject = JsonConvert.DeserializeAnonymousType(content, new
{
token = ""
});
var handler = new JwtSecurityTokenHandler();
var jsonToken = handler.ReadToken(tokenObject.token);
var tokenS = handler.ReadToken(tokenObject.token) as JwtSecurityToken;
//DbConnection connection = GetConnection("jon");
using (var context = new EFContext())
{
Credential credential = new Credential
{
Token = tokenObject.token,
DateCreate = DateTime.Now,
DateExtToken = 12342134,
UserName = tokenS.Claims.ToArray()[1].Value
};
context.Credentials.Add(credential);
//context.Dependants.Add(new Dependant() { Description = "Dependant description", MainEntity = new EF6.Migrations.Test.Model01.Entity() { Description = "Entity description" } });
context.SaveChanges();
}
return(content);
}
public async Task <IActionResult> Register([FromForm] UserRegisterVM model)
{
var result = await _accountService.CreateAccount(model);
if (!result.Success)
{
return(BadRequest(new AuthentificationResult
{
Errors = result.Errors
}));
}
return(Ok(new AuthentificationResult()
{
Errors = new List <string>()
}));
}
public async Task <IActionResult> Register([FromBody] JObject model)
{
try
{
UserRegisterVM userRegisterVm = model.ToObject <UserRegisterVM>();
var user = await _userService.Register(userRegisterVm);
}
catch (RegisterUserException ex)
{
BadRequest(ex.Message);
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
return(Ok(model));
}
public async Task <ApplicationUser> Register(UserRegisterVM model)
{
ApplicationUser user = new ApplicationUser();
user.UserName = model.UserName;
user.Email = model.Email;
user.FullName = model.FullName;
user.BirthDate = model.BirthDate;
IdentityResult result = await _userManager.CreateAsync
(user, model.Password);
if (!result.Succeeded)
{
throw new RegisterUserException(result.Errors.ToString());
}
if (!_roleManager.RoleExistsAsync("NormalUser").Result)
{
IdentityRole role = new IdentityRole();
role.Name = "NormalUser";
IdentityResult roleResult = _roleManager.
CreateAsync(role).Result;
if (!roleResult.Succeeded)
{
throw new RegisterUserException(roleResult.Errors.ToString());
}
}
_userManager.AddToRoleAsync(user,
"NormalUser").Wait();
PerformCommand(() =>
{
_baseRepository.Insert(new UserProfile()
{
UserId = user.Id,
});
});
return(user);
}
public async Task <ActionResult> Register(UserRegisterVM user)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (!ModelState.IsValid)
{
return(PartialView("Register", user));
}
await _userService.Create(Mapper.Map <UserDTO>(user));
var result = new { success = true };
return(Json(result));
}
public IActionResult Register(UserRegisterVM model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
User u = new User()
{
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
Password = model.Password,
Username = model.Username
};
UsersRepository repo = new UsersRepository();
repo.Save(u);
return(RedirectToAction("Login"));
}
public IActionResult Register(UserRegisterVM model)
{
if (ModelState.IsValid)
{
User user = new User();
user.UserName = model.username;
user.EMail = model.email;
user.Password = model.password;
_context.Users.Add(user);
_context.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
else
{
TempData["error2"] = "Passwords do not match!";
return(RedirectToAction("Index", "Home"));
}
}
public ActionResult Register(UserRegisterVM model)
{
var user = new AppUser
{
Email = model.Login,
UserName = model.Login
};
var res = UserManager.Create(user, model.Password);
if (res.Succeeded)
{
// AuthenticationManager.SignIn(DefaultAuthenticationTypes.ApplicationCookie);
return(RedirectToAction("Index", "Rooms"));
}
else
{
ViewBag.Errors = res.Errors;
}
return(View());
}
public async Task <IActionResult> Create([Bind("FirstName,LastName,PhoneNumber,BirthDate,Email,Password,ConfirmPassword")] UserRegisterVM userr)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
FirstName = userr.FirstName,
LastName = userr.LastName,
FullName = userr.FirstName + " " + userr.LastName,
UserName = userr.Email,
NormalizedUserName = userr.Email.ToUpper(),
Email = userr.Email,
NormalizedEmail = userr.Email.ToUpper(),
BirthDate = userr.BirthDate,
PhoneNumber = userr.PhoneNumber,
EmailConfirmed = true,
};
var result = await _userManager.CreateAsync(user, userr.Password);
if (result.Succeeded)
{
_logger.LogInformation("Patient created a new account with password.");
await _userManager.AddToRoleAsync(user, Roles.Patient.ToString());
await _context.Patient.AddAsync(new Patient { UserId = user.Id });
await _context.SaveChangesAsync();
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(RedirectToAction(nameof(Index)));
}
return(View(userr));
}
public async Task <AuthentificationResult> CreateAccount(UserRegisterVM model)
{
var existingUser = await _accountRepository.FindByNameAccount(model.Email);
if (existingUser != null)
{
return(new AuthentificationResult
{
Errors = new[] { "User with this email already exists!" }
});
}
Account account = new Account {
Email = model.Email, UserName = model.Email, UName = model.Name, USurname = model.Surname, PhoneNumber = model.Mobile
};
var result = await _accountRepository.CreateAccount(account, model.Password);
if (!result.Succeeded)
{
return(new AuthentificationResult
{
Errors = result.Errors
.Select(x => x.Description)
});
}
//await _userRepository.AddToRole(account);
var code = await _accountRepository.GenerateEmailConfirmationToken(account);
return(new AuthentificationResult
{
Success = true,
Code = code
});
}
public async Task <IActionResult> PostUser(UserRegisterVM userreg)
{
if (string.IsNullOrEmpty(userreg.username))
{
return(GetErrorResult("bad_arg"));
}
if (_context.Users.Any(u => u.username == userreg.username))
{
return(GetErrorResult("dup_user"));
}
var user = new User
{
role = UserRole.User,
username = userreg.username,
passwd = Utils.HashPassword(userreg.passwd),
lists = new List <int>()
};
_context.Users.Add(user);
var loginRecord = _context.UserService.CreateLoginRecord_NoSave(user);
await _context.SaveChangesAsync();
return(await GetUser(user, true, loginRecord.token));
}
// GET: Users/Create
public ActionResult Create()
{
UserRegisterVM model = new UserRegisterVM()
{
ShoppingPOIs = new List <ScorePOIModel>(),
LandscapePOIs = new List <ScorePOIModel>(),
ReligionPOIs = new List <ScorePOIModel>(),
HumanitiesPOIs = new List <ScorePOIModel>(),
HistoricalSitePOIs = new List <ScorePOIModel>(),
user = new User()
};
//載入購物類景點
string[] ShoppingName = { "台中中友百貨", "一中街商圈", "台中逢甲商圈", "豐原廟東夜市", "台中大遠百" };
int i = 1;
foreach (string name in ShoppingName)
{
ScorePOIModel POI = new ScorePOIModel()
{
POIName = name,
ImgUrl = "../Images/ScorePOI/Shopping/Shopping" + i.ToString() + ".jpg",
type = "Shopping"
};
i++;
model.ShoppingPOIs.Add(POI);
}
//載入風景類景點
string[] LandscapeName = { "高美濕地", "誠品綠園道", "大坑風景區", "秋紅谷", "台中中山公園" };
i = 1;
foreach (string name in LandscapeName)
{
ScorePOIModel POI = new ScorePOIModel()
{
POIName = name,
ImgUrl = "../Images/ScorePOI/Landscape/Landscape" + i.ToString() + ".jpg",
type = "Landscape"
};
i++;
model.LandscapePOIs.Add(POI);
}
//載入宗教類景點
string[] ReligionName = { "台中文昌廟", "豐原慈濟宮", "清水紫雲巖", "台中孔廟", "台中天后宮" };
i = 1;
foreach (string name in ReligionName)
{
ScorePOIModel POI = new ScorePOIModel()
{
POIName = name,
ImgUrl = "../Images/ScorePOI/Religion/Religion" + i.ToString() + ".jpg",
type = "Religion"
};
i++;
model.ReligionPOIs.Add(POI);
}
//載入人文類景點
string[] HumanitiesName = { "國立自然博物館", "國立台灣美術館", "台中火車站", "台中創意園區", "彩虹眷村" };
i = 1;
foreach (string name in HumanitiesName)
{
ScorePOIModel POI = new ScorePOIModel()
{
POIName = name,
ImgUrl = "../Images/ScorePOI/Humanities/Humanities" + i.ToString() + ".jpg",
type = "Humanities"
};
i++;
model.HumanitiesPOIs.Add(POI);
}
//載入古蹟類景點
string[] HistoricalSiteName = { "摘星山莊", "霧峰林家", "台中州廳", "臺中刑務所演武場", "台中放送局" };
i = 1;
foreach (string name in HistoricalSiteName)
{
ScorePOIModel POI = new ScorePOIModel()
{
POIName = name,
ImgUrl = "../Images/ScorePOI/HistoricalSite/HistoricalSite" + i.ToString() + ".jpg",
type = "HistoricalSite"
};
i++;
model.HistoricalSitePOIs.Add(POI);
}
return(View(model));
}
public async Task <IActionResult> Register([FromBody] UserRegisterVM model)
{
if (!ModelState.IsValid)
{
var errors = CustomValidator.GetErrorsByModel(ModelState);
return(BadRequest(errors));
}
var str_name = model.Name;
var name_regex = @"^[A-Za-z-а-яА-Я]+$";
var str_email = model.Email;
var email_regex = @"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$";
var match_name = Regex.Match(str_name, name_regex);
var match_email = Regex.Match(str_email, email_regex);
if (!match_name.Success)
{
return(BadRequest(new { Name = "Неправильний формат поля." }));
}
if (!match_email.Success)
{
return(BadRequest(new { Email = "Неправильний формат поля." }));
}
string roleName = "Employee";
var role = _roleManager.FindByNameAsync(roleName).Result;
if (role == null)
{
role = new DbRole {
Name = roleName
};
}
var userEmail = model.Email;
//var user = _userManager.FindByEmailAsync(userEmail).Result;
if (_userManager.FindByEmailAsync(userEmail).Result != null)
{
return(BadRequest(new { Email = "Така електронна пошта вже існує!" }));
}
var user = new DbUser
{
Email = userEmail,
UserName = model.Name
};
//user.UserRoles = new List<DbRole>();
var result = _userManager.CreateAsync(user, model.Password).Result;
if (!result.Succeeded)
{
return(BadRequest(new { Password = "******" }));
}
result = _userManager.AddToRoleAsync(user, roleName).Result;
if (!result.Succeeded)
{
return(BadRequest(new { Password = "******" }));
}
return(Ok(
new
{
token = CreateTokenJwt(user)
}));
}
public User(UserRegisterVM src)
{
FirstName = src.FirstName;
LastName = src.LastName;
Email = src.Email;
}
public Task <string> RegisterAsync(UserRegisterVM user)
{
return(Task.Run(() => Register(user)));
}
public async Task <IActionResult> Register([FromBody] UserRegisterVM vm)
{
var _vm = Mapper.Map <User>(vm);
return(ExecMethod <User, UserReturnVM>(() => ValidateEntry(new UserRegisterValidation(repo), _vm), () => repo.Register(_vm)));
}
public async Task <ActionResult <UserRegisterResponseVM> > Register([FromBody] UserRegisterVM vm)
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid Data"));
}
else if (vm.Password != vm.PasswordConfirmation)
{
return(BadRequest("Password and password confirmation do not match"));
}
else
{
var entity = await _context.Cities.SingleOrDefaultAsync(b => b.Name == vm.City);
if (entity == null)
{
return(BadRequest("Could not find city"));
}
}
//var user = new User(vm);
var user = new User
{
UserName = vm.Email,
Email = vm.Email,
FirstName = vm.FirstName,
LastName = vm.LastName,
NormalizedEmail = _normalizer.NormalizeEmail(vm.Email),
Tos = vm.Tos,
PhoneNumber = vm.Phone,
CityName = vm.City
};
var result = await _userManager.CreateAsync(user, vm.Password);
//result = await _userManager.AddPasswordAsync(user, vm.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, "user");
//normalize
await _userManager.UpdateNormalizedEmailAsync(user);
//generate email confirmation token
var confirmation = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//email token to user
var apiKey = Environment.GetEnvironmentVariable("SENDGRID_API_KEY");
var client = new SendGridClient(apiKey);
var from = new EmailAddress("*****@*****.**", "Example User");
var subject = "You are now registered!";
var to = new EmailAddress(vm.Email, vm.FirstName);
var plainTextContent = "Confirmation: " + confirmation;
var htmlContent = "Confirmation: " + confirmation;
var msg = MailHelper.CreateSingleEmail(from, to, subject, plainTextContent, htmlContent);
var response = await client.SendEmailAsync(msg);
return(Ok(new UserRegisterResponseVM("200 ok, awesome!")));
}
else
{
return(BadRequest("Register failed :("));
}
}
