public async Task<IActionResult> Start(RegistrationModel model) {
var token = Guid.NewGuid().ToString();
_logger.Log(x => x.Information, () => string.Format("Starting registration process - {0} ", new { model.Name, token }));
var registrationRequest = _database.RegistrationRequests.Add(model.Name, model.Consented, token);
await _database.SaveChangesAsync();
var requestUri = Request.GetUri();
var redirectUri = requestUri.ToString().Replace(requestUri.Segments.Last(), "");
redirectUri += "complete";
var authorizationRequest = OnboardingUrl.FormatUrlWith(
_settings.ClientID,
GraphUrl,
redirectUri,
registrationRequest.Token
);
if(model.Consented) {
authorizationRequest += "&prompt={0}".FormatUrlWith("admin_consent");
}
else {
return View("RegistrationError", new RegistrationErrorModel("Consent Not Given", "You Must Give Consent"));
}
return Redirect(authorizationRequest);
}
public RegistrationResponse RegisterDevice(string ChannelUri, short DeviceType)
{
// Get the body. This will be the devices channel URI
RegistrationModel model = new RegistrationModel();
string pinCode = model.SaveDeviceRegistration(ChannelUri);
return new RegistrationResponse() { PinCode = pinCode };
}
public ActionResult Index(RegistrationModel model)
{
if (ModelState.IsValid)
{
return View(model);
}
List<RegistrationModel> list = Session[Storage.DbKey] as List<RegistrationModel> ?? new List<RegistrationModel>();
list.Add(model);
Session[Storage.DbKey] = list;
return RedirectToAction("List" , "User");
}
public bool IsValid(RegistrationModel registrationModel)
{
if (String.IsNullOrEmpty(registrationModel.Username))
{
return false;
}
if (registrationModel.Username.Contains('_'))
{
return false;
}
return true;
}
public ActionResult AccessCode(RegistrationCheck check)
{
RegistrationModel model = new RegistrationModel();
string pinCode = GetPin(check);
DeviceRegistration deviceRegistration = model.GetRegistration(GetPin(check));
if (deviceRegistration != null)
{
check.ChannelUri = deviceRegistration.ChannelUri;
}
return RedirectToAction("Information", new { pinCode = pinCode });
}
public bool IsValid(RegistrationModel registrationModel)
{
if (String.IsNullOrEmpty(registrationModel.Email))
{
return false;
}
if (!registrationModel.Email.Contains('@'))
{
return false;
}
if (!registrationModel.Email.Contains('.'))
{
return false;
}
return true;
}
public bool IsValid(RegistrationModel registrationModel)
{
if (String.IsNullOrEmpty(registrationModel.Password))
{
return false;
}
if (registrationModel.Password.Length < MinimumLength)
{
return false;
}
if (!Capital.IsMatch(registrationModel.Password) || !Lowercase.IsMatch(registrationModel.Password))
{
return false;
}
return true;
}
public async Task<IHttpActionResult> Register(RegistrationModel model)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var user = new AppStoreUser() { UserName = model.Email, Email = model.Email };
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return GetErrorResult(result);
}
return Ok();
}
public void PinGeneration()
{
RegistrationModel model = new RegistrationModel();
List<string> generatedPins = new List<string>();
for (int i = 0; i < 10000; i++)
{
string newPin = model.GeneratePin();
if (generatedPins.Contains(newPin))
{
Assert.Fail("Duplication pin found at index " + i);
return;
}
generatedPins.Add(newPin);
}
}
public async Task <IHttpActionResult> Register(RegistrationModel model)
{
// 1. Server Side Validation
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// 2. Pass the registration onto AuthRepository
var result = await _repo.RegisterUser(model);
// 3. Check to see that the registration was successful
if (result.Succeeded)
{
return(Ok());
}
else
{
return(BadRequest("Registration form was invalid."));
}
}
public Task RegisterUser(RegistrationModel registrationModel)
{
if (registrationModel == null)
{
throw new ArgumentNullException(nameof(registrationModel));
}
if (string.IsNullOrEmpty(registrationModel.FirstName))
{
throw new ArgumentNullException(nameof(registrationModel.FirstName));
}
if (string.IsNullOrEmpty(registrationModel.Username))
{
throw new ArgumentNullException(nameof(registrationModel.Username));
}
if (string.IsNullOrEmpty(registrationModel.Password))
{
throw new ArgumentNullException(nameof(registrationModel.Password));
}
return(RegisterUserAsync(registrationModel));
}
public void Test1()
{
//Arrange
RegistrationModel temp = new RegistrationModel();
string name = "testName";
string surname = "testSurname";
string email = "*****@*****.**";
string password = "******";
//Act
temp.Name = name;
temp.Surname = surname;
temp.Email = email;
temp.Password = password;
//Assert
Assert.Equal(name, temp.Name);
Assert.Equal(surname, temp.Surname);
Assert.Equal(email, temp.Email);
Assert.Equal(password, temp.Password);
}
public async Task <IActionResult> Register([FromBody] RegistrationModel registration)
{
var newUser = new User
{
UserName = registration.Email,
Email = registration.Email,
FirstName = registration.FirstName,
LastName = registration.LastName
};
var result = await _userManager.CreateAsync(newUser, registration.Password);
if (result.Succeeded)
{
return(Ok(newUser.ToApiModel()));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> Create([FromBody] RegistrationModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.ToDictionary()));
}
var result = await _authServices.Registration(model);
if (!result.Succeeded && result.Errors.Any())
{
foreach (var err in result.Errors)
{
ModelState.AddModelError(err.Code, err.Description);
}
return(BadRequest(ModelState.ToDictionary()));
}
return(Ok());
}
private async Task <ApplicationUser> CreateNewUser(RegistrationModel registrationModel)
{
var user = await _userManager.FindByEmailAsync(registrationModel.Username);
if (user == null)
{
user = MapToNewUser(registrationModel);
var createResult = await _userManager.CreateAsync(user, registrationModel.Password);
if (!createResult.Succeeded)
{
ProcessErrors("Creating new user failed.", createResult);
}
}
else
{
throw new InvalidOperationException($"Unable to create user with email {registrationModel.Username} as it already exists.");
}
return(user);
}
/// <summary>
/// Registration by registration model
/// </summary>
/// <param name="model">Model for the registration with main data</param>
/// <returns>Result of the registration</returns>
public async System.Threading.Tasks.Task Registration(RegistrationModel model)
{
var appUser = new User
{
UserName = model.UserName,
Email = model.Email,
FullName = model.FullName
};
var result = await this._userManager.CreateAsync(appUser, model.Password);
if (result.Succeeded)
{
var user = await this._userManager.FindByNameAsync(appUser.UserName);
await this._userManager.AddToRoleAsync(user, Roles.NormalWebsiteRole);
this._logger.LogInformation($"{user.UserName}'s registration was successfully with e-mail {user.Email}");
this._notificationService.AddSystemNotificationByType(SystemNotificationType.Registration, user);
}
else
{
throw new MessageException(this._utilsService.ErrorsToString(result.Errors));
}
}
private void Search_Student_Details()
{
Reset_Controls();
if (string.IsNullOrEmpty(txtRegistrationNo.Text))
{
MessageBox.Show("Registration Number is required.", "Student TC", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
StudentRegistration registration = new StudentRegistration();
RegistrationModel _registrationModel = new RegistrationModel();
_registrationModel = registration.Get_Student_Detail(Convert.ToInt64(txtRegistrationNo.Text));
if (_registrationModel.RegistrationNo == null)
{
_registrationModel = registration.Get_InActive_Student_Detail(Convert.ToInt64(txtRegistrationNo.Text));
}
if (_registrationModel.RegistrationNo != null)
{
lblStudentNameValue.Text = _registrationModel.FullName;
lblClassValue.Text = _registrationModel.ClassSection;
lblStudentNameValue.Visible = true;
lblClassValue.Visible = true;
lblStudentName.Visible = true;
lblClass.Visible = true;
panelInfo.Visible = true;
_class_ID = _registrationModel.CurrentClass;
_section_ID = _registrationModel.CurrentSection;
_student_ID = (long)_registrationModel.StudentID;
Get_Student_TC_Details();
}
else
{
MessageBox.Show("Invalid Registration Number.", "Student TC", MessageBoxButtons.OK, MessageBoxIcon.Information);
Reset_Controls();
txtRegistrationNo.Text = string.Empty;
}
}
}
public bool RegistrateUser(RegistrationModel registrationModel)
{
User existingUser;
try
{
existingUser = Find(registrationModel.Email);
}
catch
{
existingUser = null;
}
if (existingUser != null)
{
return(false);
}
var user = new User
{
Name = registrationModel.Name,
Email = registrationModel.Email,
Password = SecurityManager.GetHashString(registrationModel.Password),
Status = UserStatus.Unconfirmed
};
try
{
Data.Users.Add(user);
Data.SaveChanges();
SendConfirmationMail(user);
}
catch
{
Data.Users.Remove(user);
return(false);
}
return(true);
}
public ActionResult Register(RegistrationModel info)
{
using (BusinessLogicLayer.ContextBll ctx = new BusinessLogicLayer.ContextBll())
{
if (!ModelState.IsValid)
{
return(View(info));
}
BusinessLogicLayer.UserBLL user = ctx.FindUserByEmail(info.EMail);
if (user != null)
{
info.Message = $"The Email Address '{info.EMail}' already exists in the database";
return(View(info));
}
user = new BusinessLogicLayer.UserBLL();
user.EmailAdderess = info.EMail;
//user.Password = System.Web.Helpers.Crypto.
// GenerateSalt(Constants.SaltSize);
user.Password = info.Password;
user.Hash = System.Web.Helpers.Crypto.
HashPassword(info.Password);
// + user.Hash
user.RoleID = 3;
string GetUntil(string text, string limiter = "@")
{
int charLocation = text.IndexOf(limiter, StringComparison.Ordinal);
return(text.Substring(0, charLocation));
}
user.Name = GetUntil(info.EMail); // extract all letters befor @
ctx.CreateUser(user);
Session["AUTHUsername"] = (user.EmailAdderess);
Session["AUTHRoles"] = user.Role;
Session["AUTHTYPE"] = "HASHED";
return(RedirectToAction("Index"));
}
}
public ActionResult Index(RegistrationModel registrationModel)
{
try
{
if (ModelState.IsValid)
{
Registration reg = new Registration();
registrationModel.UserType = "O";
int _uid = reg.Createuser(registrationModel);
if (_uid == -1)
{
ViewBag.Message = "Email Already Exist, Please Enter some Different Email Id.";
return(View());
}
else if (_uid == 1)
{
Session["UserId"] = _uid;
Session["UserName"] = registrationModel.UserName;
ViewBag.UserName = Session["UserName"].ToString();
ViewBag.Message = "Welcome " + Session["UserName"].ToString();
return(RedirectToAction("Index", "Dashboard", new { @pageNo = 0 }));
}
else
{
ViewBag.Message = "Internal Error Occurred, Please Try After Some Time.";
return(View());
}
}
else
{
return(View(registrationModel));
}
}catch (Exception ex)
{
ViewBag.Message = "Some Problem at User Registration, Please try again.";
return(RedirectToAction("", ""));
}
}
public ActionResult Register(RegistrationModel info)
{
try
{
using (ContextBLL context = new ContextBLL())
{
UserBLL user = context.UserFindByEmail(info.Email);
if (user != null)
{
info.Message = $"The EMail Address '{info.Email}' already exists in the database";
ModelState.Clear();
return(View(info));
}
if (!ModelState.IsValid)
{
return(View(info));
}
user = new UserBLL
{
Email = info.Email,
Salt = System.Web.Helpers.Crypto.
GenerateSalt(Constants.SaltSize)
};
user.Hash = System.Web.Helpers.Crypto.
HashPassword(info.Hash + user.Salt);
user.RoleID = 3;
context.UserCreate(user.Email, user.Hash, user.Salt, Constants.NonVerifiedUser);
Session["AUTHUsername"] = user.Email;
Session["AUTHRoles"] = user.RoleName;
Session["AUTHTYPE"] = "HASHED";
return(RedirectToAction("Index"));
}
}
catch (Exception ex)
{
Logger.Log(ex);
return(View("Error", ex));
}
}
public async Task <IActionResult> Register(RegistrationModel model)
{
if (ModelState.IsValid)
{
// Copy data from RegistrationModel to IdentityUser
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
PhoneNumber = model.PhoneNumber,
City = model.City,
Gender = model.Gender
};
// Store user data in AspNetUsers database table
var result = await userManager.CreateAsync(user, model.Password);
// If user is successfully created, sign-in the user using
// SignInManager and redirect to index action of HomeController
if (result.Succeeded)
{
await signInManager.SignInAsync(user, isPersistent : false);
bookDBContext.LoginTable.Add(model);
bookDBContext.SaveChanges();
string Message = "Register Sucess Fully";
return(this.Ok(new { Message }));
}
// If there are any errors, add them to the ModelState object
// which will be displayed by the validation summary tag helper
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
string message = "Put right pattern of email and password";
return(this.BadRequest(new { message }));
}
public async Task <IActionResult> Register(RegistrationModel model)
{
if (ModelState.IsValid)
{
var user = new PizzaUser
{
UserName = model.EmailAddress.ToLower(),
Email = model.EmailAddress.ToLower(),
PhoneNumber = NormalizePhoneNumber(model.PhoneNumber),
EncryptionAlgorithm = model.EncryptionAlgorithm,
ReceivesEmails = model.ReceivesEmails,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneExtension = model.PhoneExtension,
Country = model.Country,
StreetAddress = model.StreetAddress,
ApartmentNumber = model.ApartmentNumber,
City = model.City,
State = model.State,
ZipCode = model.ZipCode
};
IdentityResult result = await _userManager.CreateAsync(user, model.PasswordHash);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
model.Registered = true;
return(View(model));
}
else
{
AddErrors(result);
}
}
return(View(model));
}
public ActionResult Registration(RegistrationModel model)
{
if (ModelState.IsValid)
{
LibraryUser libraryUser = null;
using (LibraryUserContext db = new LibraryUserContext())
{
libraryUser = db.LibraryUsers.FirstOrDefault(l => l.Login == model.Name);
}
if (libraryUser == null)
{
using (LibraryUserContext db = new LibraryUserContext())
{
db.LibraryUsers.Add(new LibraryUser
{
Login = model.Name,
Password = model.Password,
Email = model.Email,
FirstName = model.FirstName,
MiddleName = model.MiddleName,
LastName = model.LastName
});
db.SaveChanges();
libraryUser = db.LibraryUsers.Where(l => l.Login == model.Name && l.Password == model.Password).FirstOrDefault();
}
if (libraryUser != null)
{
FormsAuthentication.SetAuthCookie(model.Name, true);
return(RedirectToAction("MyPublications", "Manage"));
}
}
}
else
{
ModelState.AddModelError("", "Пользователь с таким логином уже существует");
}
return(View(model));
}
public void RegistrationTest()
{
var userData = new Mock <IUserRepositoryManager>();
var user = new UserBusinessManagerService(userData.Object);
////Object of RegistrationModel
var registrationModelData = new RegistrationModel()
{
UserName = "******",
FirstName = "FirstName",
LastName = "LastName",
EmailId = "EmailId",
Password = "******",
Image = "Image"
};
////Act
var data = user.Registration(registrationModelData);
////Asert
Assert.NotNull(data);
}
public DatabaseCode Register(RegistrationModel registerModel)
{
registerModel.User.ID = Guid.NewGuid();
(int CompanyID, DatabaseCode CompanyStatus)companyInserted = companyService.Insert(registerModel.Company);
if (companyInserted.CompanyStatus == DatabaseCode.Error)
{
return(companyInserted.CompanyStatus);
}
registerModel.User.CompanyID = companyInserted.CompanyID;
DatabaseCode userInserted = userRepository.Insert(userMapper.ToEntity(registerModel.User));
if (userInserted == DatabaseCode.Inserted)
{
registerModel.Contact.UserID = registerModel.User.ID;
registerModel.Contact.CompanyID = companyInserted.CompanyID;
contactService.CreateContact(registerModel.Contact);
registerModel.MainAddress.UserID = registerModel.User.ID;
registerModel.MainAddress.CompanyID = companyInserted.CompanyID;
return(addressService.CreateAddress(registerModel.MainAddress).dbCode);
}
return(userInserted);
}
public IActionResult AddUser([FromForm] RegistrationModel registrationModel)
{
try
{
var result = _regisService.AddUser(registrationModel);
if (result == null)
{
return(NotFound(new ServiceResponse <RegistrationModel> {
StatusCode = (int)HttpStatusCode.NotFound, Message = "Internal server error", Data = null
}));
}
return(Ok(new ServiceResponse <RegistrationModel> {
StatusCode = (int)HttpStatusCode.OK, Message = "Added Successful", Data = result
}));
}
catch (Exception)
{
return(BadRequest(new ServiceResponse <RegistrationModel> {
StatusCode = (int)HttpStatusCode.BadRequest, Message = "Page not found ", Data = null
}));
}
}
public IActionResult LoginUser([FromForm] RegistrationModel registrationModel)
{
try
{
var result = _regisService.checkLoginUser(registrationModel);
if (result == null)
{
return(NotFound(new ServiceResponse <RegistrationModel> {
StatusCode = (int)HttpStatusCode.NotFound, Message = "user is not identified", Data = null
}));
}
return(Ok(new ServiceResponse <string> {
StatusCode = (int)HttpStatusCode.OK, Message = "login successfully", Data = result
}));
}
catch (Exception)
{
return(BadRequest(new ServiceResponse <RegistrationModel> {
StatusCode = (int)HttpStatusCode.BadRequest, Message = "Page not found ", Data = null
}));
}
}
public ActionResult Settings(AccountSettingsViewModel model)
{
if (ModelState.IsValid)
{
var account = new RegistrationModel
{
Email = model.Email,
Password = model.FirstPassword,
UserName = model.UserName
};
var result = userService.ChangeAccountSettings(User.Identity.GetUserId <int>(), model.OldPassword, account);
if (!result.Succedeed)
{
ModelState.AddModelError(string.Empty, result.Message);
}
else
{
ViewBag.Message = result.Message;
}
}
return(View(new AccountSettingsViewModel()));
}
public async Task Registratation([FromBody] RegistrationModel registrationModel)
{
await _userService.Registration(registrationModel);
UserModel userModel = await _userService.GetUserModelByEmaiil(registrationModel.Email);
string confirmToken = await _userService.GetEmailConfirmationToken(userModel);
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append($"{Request.Scheme}://{Request.Host}/api/account/confirmation/");
stringBuilder.Append($"?email={HttpUtility.UrlEncode(registrationModel.Email)}");
stringBuilder.Append($"&confirmToken={HttpUtility.UrlEncode(confirmToken)}");
string callbackUrl = stringBuilder.ToString();
await _mailService.SendEmailAsync(registrationModel.Email, "Confirmation",
$"Подтвердите регистрацию, перейдя по ссылке: <a href='{callbackUrl}'>link</a>");
}
public async Task <IActionResult> Registration(RegistrationModel model)
{
if (ModelState.IsValid)
{
if (model.Pass1 != model.Pass2)
{
ModelState.AddModelError("", "Введенные вами пароли не совпадают");
return(View(model));
}
User user = new User {
Name = model.Name,
UserName = model.UserName,
Email = model.Email,
Joined = DateTime.Now
};
IdentityResult result = await _userManager.CreateAsync(user, model.Pass1);
if (result.Succeeded)
{
TempData["Message"] = "Регистрация завершена успешно";
string token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
string mailMessage = $"Регистрация завершена. Для подтверждения регистрации перейдите по ссылке -> {Url.Action("ConfirmEmail", "Account", new {userId = user.Id, token = token}, protocol:HttpContext.Request.Scheme)}";
await MyExtensions.SendEmailAsync(user.Email, "Подтверждение регистрации", mailMessage);
return(RedirectToAction("index", "home"));
}
else
{
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(model));
}
public string Registration(RegistrationModel model)
{
SetSessionVariable("UserId", "");
SetSessionVariable("CoreId", "");
if (model != null)
{
if (ModelState.IsValid)
{
if (!RemoteProcedureCallClass
.GetUserChannel()
.IsRegisteredUser(model.Nickname, model.PasswordHash))
{
if (RemoteProcedureCallClass
.GetUserChannel()
.RegisterUserToTable(model.FirstName,
model.SecondName, model.PasswordHash,
model.Nickname, model.Email))
{
FormsAuthentication.SetAuthCookie(model.Nickname, true);
return(model.ToJson());
}
return("");
}
else
{
return("");
}
}
else
{
return("");
}
}
else
{
return("");
}
}
public async Task RegisterAsync_ReturnsFailed_WhenOfficeNotExists()
{
// Arrange
_mockOfficeRepo.Setup(s => s.ReadAsync(It.IsAny <int>())).ReturnsAsync((OfficeLocation)null).Verifiable();
var model = new RegistrationModel
{
Username = "******",
Email = "TestEmail",
Password = "******",
FirstName = "Test",
LastName = "Test",
OfficeLocationId = 1,
PhoneNumber = "18001111111",
Title = "Test"
};
// Act
var result = await _accountService.RegisterAsync(model);
// Assert
Assert.That(result.Succeeded, Is.False);
}
public async Task RegisterAsync_ReturnsFailed_WhenUserManagerFails()
{
// Arrange
_mockUserManager.Setup(_ => _.CreateAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Failed(new IdentityError())).Verifiable();
var model = new RegistrationModel
{
Username = "******",
Email = "TestEmail",
Password = "******",
FirstName = "Test",
LastName = "Test",
OfficeLocationId = 1,
PhoneNumber = "18001111111",
Title = "Test"
};
// Act
var result = await _accountService.RegisterAsync(model);
// Assert
Assert.That(result.Succeeded, Is.False);
}
public ActionResult Register(RegistrationModel model)
{
try
{
var password = EncryptPassword(model.Password);
var passwordHash = MD5Hasher.GetMd5Hash(model.Email);
var role = _roleService.Get(1);
var user = new User
{
ContactNumber = model.ContactNumber,
Email = model.Email,
Name = model.FirstName,
Surname = model.LastName,
CreatedAt = DateTime.Now,
ModifiedAt = DateTime.Now,
Password = password,
PasswordHash = passwordHash
};
role.CreatedAt = DateTime.Now;
role.ModifiedAt = DateTime.Now;
user.AddRole(role);
var id = _userService.Save(user);
if (id > 0)
{
return(RedirectToAction("Login", "User"));
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
return(View());
}
public ServiceResponse <UserModel> Register(RegistrationModel model)
{
var response = new ServiceResponse <UserModel>();
var users = _userRepository.Select();
var user = users.FirstOrDefault(x => x.Username.ToUpper() == model.Username.ToUpper());
if (user != null)
{
return(response.AddError("Логин уже занят"));
}
user = new AppUser
{
Username = model.Username,
Password = Crypto.HashPassword(model.Password),
Role = UserRole.Player
};
_userRepository.InsertOrUpdate(user);
response.Object = Mapper.Map <UserModel>(user);
return(response);
}
public ActionResult ResetPassword(RegistrationModel resetModel)
{
UserProcess userProcessor = new UserProcess();
int result = userProcessor.ResetPassword(resetModel.EmployeeID);
if (result == FASTConstant.RETURN_VAL_SUCCESS)
{
TempData[FASTConstant.TMPDATA_RESULT] = FASTConstant.SUCCESSFUL;
TempData[FASTConstant.TMPDATA_EXTRAMESSAGE] = "An email confirmation will be sent to you. This will contain a random generated initial password. You can change the password inside the user area";
}
else
{
TempData[FASTConstant.TMPDATA_RESULT] = FASTConstant.FAILURE;
TempData[FASTConstant.TMPDATA_EXTRAMESSAGE] = "Reset password failed. Please try again or contact the AppAdmin";
}
TempData[FASTConstant.TMPDATA_SOURCE] = "Reset Password";
TempData[FASTConstant.TMPDATA_CONTROLLER] = "Home";
TempData[FASTConstant.TMPDATA_ACTION] = "Index";
return(View("~/Views/Shared/Result.cshtml"));
}
public async Task <ActionResult> RegisterUser(RegistrationModel registrationModel)
{
var user = await userManager.FindByNameAsync(registrationModel.UserName);
if (user != null)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new Response {
Status = "Error", Message = "Such username already exists"
}));
}
if (!await roleManager.RoleExistsAsync(registrationModel.Role))
{
return(StatusCode(StatusCodes.Status400BadRequest, new Response {
Status = "Error", Message = "No such role"
}));
}
ApplicationUser applicationUser = new ApplicationUser()
{
UserName = registrationModel.UserName,
Email = registrationModel.Email
};
var result = await userManager.CreateAsync(applicationUser, registrationModel.Password);
if (!result.Succeeded)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new Response {
Status = "Error", Message = "User creation failed! Please check user details and try again."
}));
}
await AddToRoleAsync(applicationUser, registrationModel.Role);
return(Ok(new Response {
Status = "Success", Message = "User created"
}));
}
public IActionResult Registration(RegistrationModel client)
{
if (ModelState.IsValid)
{
var existClient = _client.Read(new ClientBindingModel
{
Login = client.Login
}).FirstOrDefault();
if (existClient != null)
{
ModelState.AddModelError("", "Данный логин уже занят");
return(View(client));
}
existClient = _client.Read(new ClientBindingModel
{
Email = client.Email
}).FirstOrDefault();
if (existClient != null)
{
ModelState.AddModelError("", "Данный E-Mail уже занят");
return(View(client));
}
_client.CreateOrUpdate(new ClientBindingModel
{
Login = client.Login,
Password = client.Password,
Email = client.Email,
Phone = client.Phone
});
return(RedirectToAction("Login"));
}
return(View(client));
}
public async Task<ActionResult> Register(RegistrationModel model)
{
if (ModelState.IsValid)
{
var task = checkLastNameAsync(model.LastName, model.GroupId);
var student = task != null ? await task : null;
if (student == null || student.HasUserAccount)
{
ModelState.AddModelError("LastName", Resource.NoLastNameFound);
return View(model);
}
if (!await CheckCaptcha())
{
ModelState.AddModelError("", Resource.ConfirmNoRobot);
return View(model);
}
var emailUser = await Manager.FindByEmailAsync(model.Email);
User user = null;
IdentityResult result;
if(!student.AccountId.IsEmpty())
user = await Manager.FindByIdAsync(student.AccountId);
if (emailUser != null && (user == null || user.Id != emailUser.Id))
{
ModelState.AddModelError("Email", Resource.EmailIsUsed);
return View(model);
}
if (user != null)
{
user.GroupId = model.GroupId;
user.Email = TransformEmail(model.Email);
user.StudentId = student.Id;
var hashedNewPassword = Manager.PasswordHasher.HashPassword(model.Password);
user.PasswordHash = hashedNewPassword;
result = await Manager.UpdateAsync(user);
/*var store = new UserStore<User>();
await store.SetPasswordHashAsync(user, hashedNewPassword);*/
}
else
{
model.Email = TransformEmail(model.Email);
user = Map<RegistrationModel, User>(model);
user.LoginKey = Guid.NewGuid().ToString("N").Substring(0, 8);
user.StudentId = student.Id;
result = await Manager.CreateAsync(user, model.Password);
}
if (result.Succeeded)
{
student.HasUserAccount = true;
Site.StudentManager.Update(student);
Mailer.Send(ConirmRegistrationMail, model.Email, CreateConfirmTags(user.Id.Or(model.Id)));
return View("_Success");
}
else
{
foreach (string error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
}
return View(model);
}
public ActionResult Information(DeviceRegistration registration)
{
if (ModelState.IsValid)
{
using (AzureManagerContext context = new AzureManagerContext())
{
DeviceRegistration deviceRegistration = context.DeviceRegistrations.Find(registration.Id);
if (HttpContext.Request.Files.Count > 0)
{
using (BinaryReader r = new BinaryReader(HttpContext.Request.Files[0].InputStream))
{
byte[] buffer = new byte[HttpContext.Request.ContentLength];
r.Read(buffer, 0, HttpContext.Request.ContentLength);
deviceRegistration.Certificate = buffer;
}
}
deviceRegistration.SubscriptionId = registration.SubscriptionId;
context.SaveChanges();
RegistrationModel model = new RegistrationModel();
String response = model.NotifyDeviceOfInformation(deviceRegistration);
ViewBag.Response = response;
}
return RedirectToAction("InformationSent");
}
return View(registration);
}
public RegistrationViewModel()
{
_registrationModel = new RegistrationModel();
}
