public async Task <IActionResult> RegisterNewTeacher(RegisterTeacherViewModel viewModel)
{
if (ModelState.IsValid)
{
var newUser = new IdentityUser()
{
Email = viewModel.Email, UserName = viewModel.Email
};
var result = await _userManager.CreateAsync(newUser, viewModel.Password);
if (result.Succeeded)
{
Teacher newTeacher = new Teacher()
{
Salary = viewModel.Salary, HireDate = viewModel.HireDate, AppUserId = newUser.Id
};
_dbContext.Add(newTeacher);
_dbContext.SaveChanges();
await _userManager.AddToRoleAsync(newUser, "TeacherRole");
await _signInManager.SignInAsync(newUser, true);
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("Email", "This Email already exists");
}
}
return(View(viewModel));
}
public ActionResult RegisterTeacher(RegisterTeacherViewModel model)
{
//extract data from model to login table
var login = new Login();
login.Adress = model.Adress;
login.Description = model.Description;
login.Email = model.Email;
login.imageUrl = model.imageUrl;
login.Name = model.Name;
login.Password = model.Password;
login.phone = model.phone;
login.userType = model.userType;
//extract data from model to login table
var teacher = new Teacher();
teacher.Adress = model.Adress;
teacher.Description = model.Description;
teacher.Email = model.Email;
teacher.imageUrl = model.imageUrl;
teacher.Name = model.Name;
teacher.Password = model.Password;
teacher.phone = model.phone;
teacher.DegreeImageUrl = model.DegreeImageUrl;
teacher.currentAccountStatus = "UnVerified";
LoginServices.Instance.SaveLogin(login);
TeacherServices.Instance.SaveTeacher(teacher);
return(View());
}
public IActionResult RegisterTeacherForm()
{
RegisterTeacherViewModel model = new RegisterTeacherViewModel();
model.Subjects = _dbContext.GetSubjects();
return(View(model));
}
public ActionResult RegisterTeacher()
{
if (bool.TryParse(ConfigurationManager.AppSettings["UseRecaptcha"], out var useRecaptcha))
{
var model = new RegisterTeacherViewModel
{
UseRecaptcha = useRecaptcha
};
if (ConfigurationManager.AppSettings["AllowRegisterTeacher"] == "true")
{
return(View(model));
}
else
{
TempData["Message"] = "Регистрация новых учителей в системе запрещена администратором.";
}
//ViewBag.ErrorMessage = "Регистрация новых учителей в системе запрещена администратором.";
}
else
{
TempData["Message"] = "Не удалось считать параметр конфигурации приложения.";
}
//ViewBag.ErrorMessage = "Не удалось считать параметр конфигурации приложения.";
return(RedirectToAction("Index", "Home"));
//return View("Error");
}
public async Task <ActionResult> RegisterTeacher(RegisterTeacherViewModel model)
{
var userdb = ApplicationDbContext.Create();
//check if the user already registered in our system
if (ModelState.IsValid)
{
var usercheck = await UserManager.FindByEmailAsync(model.Email);
if (usercheck != null)
{
ModelState.AddModelError("Email", "User Already registered");
}
}
if (!await RoleManager.RoleExistsAsync("teacher"))
{
ModelState.AddModelError("", "Unkown Error , Teacher role deleted from the database maybe?");
}
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, PhoneNumber = model.PhoneNumber
};
//Auto generate password and set it to the account
string genpas = PasswordGenerator();
var result = await UserManager.CreateAsync(user, genpas);
//put the user in the choosed role
await UserManager.AddToRoleAsync(user.Id, "teacher");
if (result.Succeeded)
{
// await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser:false);
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
#region //create message body
StringBuilder message = new StringBuilder();
// generating the message
message.Append("Welcome " + user.FullName + "! You registered in our System as Teacher");
message.AppendLine("And Your password is (" + genpas + ") .<br/>");
message.AppendLine("We suggest you to change your auto generated pssword for more security .<br/>");
message.AppendLine(" Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a><br/>");
#endregion
await UserManager.SendEmailAsync(user.Id, "Confirm your account", message.ToString());
return(RedirectToAction("Index", "Courses"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View());
}
public Register()
{
InitializeComponent();
regTeacher = new RegisterTeacherViewModel();
cbxCourses.ItemsSource = regTeacher.GetByEducation();
//coursesList.ItemsSource = regTeacher.GetByEducation();
//regTeacher.CreateCrazy(ShowCourse);
}
public async Task <ActionResult> RegisterTeacher(RegisterTeacherViewModel model)
{
if (ModelState.IsValid)
{
var appDbContext = HttpContext.GetOwinContext().Get <ApplicationDbContext>();
using (var identitydbContextTransaction = appDbContext.Database.BeginTransaction())
{
try
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
IdentityResult result1 = null;
IdentityResult result2 = null;
if (0 == user.Claims.Where(c => c.ClaimType == "Department").Count())
{
result1 = await UserManager.AddClaimAsync(user.Id, new Claim("Department", model.Department));
}
if (0 == user.Claims.Where(c => c.ClaimType == "MobilePhone").Count())
{
result2 = await UserManager.AddClaimAsync(user.Id, new Claim("MobilePhone", model.MobilePhone));
}
if (result1.Succeeded && result2.Succeeded)
{
identitydbContextTransaction.Commit();
return(RedirectToAction("Index", "Home"));
}
if (!result1.Succeeded)
{
AddErrors(result1);
}
if (!result2.Succeeded)
{
AddErrors(result2);
}
}
else
{
ModelState.AddModelError("", "User not saved. Please retry in 5 minutes.");
}
}
catch (Exception)
{
identitydbContextTransaction.Rollback();
ModelState.AddModelError("", "Unhandled exception. Please retry in 5 minutes.");
}
}
}
return(View(model));
}
public IActionResult TeacherRegister()
{
RegisterTeacherViewModel model = new RegisterTeacherViewModel
{
DeparmentItems = populateDepartments(),
PositionItems = populatePositions(),
Birthday = DateTime.Now
};
return(View(model));
}
public async Task RegisterTeacher([FromBody] RegisterTeacherViewModel model)
{
try
{
var userName = User.Identity.Name;
if (ModelState.IsValid)
{
Teacher user = new Teacher {
UserName = model.UserName,
FIO = model.FIO,
Email = model.Email
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var managerResult = await userManager.AddToRoleAsync(user, "teacher");
managerResult = await userManager.AddToRoleAsync(user, "user");
if (managerResult.Succeeded)
{
Response.StatusCode = StatusCodes.Status200OK;
var body = JsonConvert.SerializeObject(new { user.Id },
new JsonSerializerSettings {
Formatting = Formatting.Indented
});
await Response.WriteAsync(body);
}
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
await Response.BadRequestHelper(ModelState.Values);
}
}
else
{
await Response.BadRequestHelper(ModelState.Values);
}
}
catch (Exception e)
{
ModelState.AddModelError("Error", e.Message);
await Response.BadRequestHelper(ModelState.Values);
}
}
public RedirectToRouteResult RegisterTeacher(RegisterTeacherViewModel model)
{
Login login = new Login(model.Id, model.Password, false, true, false, "");
List <Subject> subjects = _dbContext.GetSubjects().Select(x => x).Where(x => model.SubjectsId.Contains(x.Id)).ToList();
Teacher teacher = new Teacher(model.FullName, model.Faculty, subjects, model.Cathedra, model.Id, model.Email);
_dbContext.SetTeacher(teacher);
_dbContext.SetLogin(login);
return(RedirectToRoute(new {
controller = "Admin",
action = "RegisteredSuccessful"
}));
}
public IActionResult CreateTeacher()
{
RegisterTeacherViewModel model = new RegisterTeacherViewModel
{
DeparmentItems = PopulateDepartments(),
PositionItems = PopulatePositions(),
Birthday = DateTime.Now
};
ViewData["Title"] = "Добавление преподавателя";
return(View(model));
}
public async Task <IActionResult> TeacherRegister(RegisterTeacherViewModel registerUserViewModel)
{
registerUserViewModel.DeparmentItems = populateDepartments();
registerUserViewModel.PositionItems = populatePositions();
if (_databaseWorker.DepartmentExists(registerUserViewModel.DepartmentId) && _databaseWorker.PositionExists(registerUserViewModel.PositionId))
{
if (ModelState.IsValid)
{
IdentityResult result = await _authentication.CreateUserAsync(registerUserViewModel);
if (result.Succeeded)
{
User user = await _authentication.FindUserByEmailAsync(registerUserViewModel.Email);
if (!await _authentication.CreateTeacherUserAsync(user.Id, registerUserViewModel.DepartmentId, registerUserViewModel.PositionId))
{
await _authentication.DeleteUserAsync(user);
return(View(registerUserViewModel));
}
// установка куки
await _authentication.SignInAsync(user);
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
}
else
{
ModelState.AddModelError(string.Empty, "Choosen Department or Position does not exists!");
}
return(View(registerUserViewModel));
}
public async System.Threading.Tasks.Task <ActionResult> CreateTeacher(RegisterTeacherViewModel model, HttpPostedFileBase ImgFile)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
string fileName = Guid.NewGuid().ToString() + ".jpg";
string image = Server.MapPath(UniversityManager.Helpers.Constants.ImagePath) + "//" + fileName;
using (Bitmap img = new Bitmap(ImgFile.InputStream))
{
Bitmap saveImg = ImageWorker.CreateImage(img, 400, 400);
if (saveImg != null)
{
saveImg.Save(image, ImageFormat.Jpeg);
_ctx.TeacherAdditionalInfos.Add(new Models.EF.TeacherAdditionalInfo()
{
FullName = model.FullName,
Address = model.Address,
Image = fileName,
Id = user.Id,
Skills = model.Skills
});
_ctx.SaveChanges();
}
}
UserManager.AddToRole(user.Id, "Teacher");
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Index", "Home", new { area = "" }));
}
AddErrors(result);
}
return(View(model));
}
public async Task <IActionResult> RegisterTeacher(RegisterTeacherViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
bool registerRole = new Create().RegisterRole(user.Id);
if (result.Succeeded && model.LevelSelect == "teacher")
{
bool isCreate = new Create().CreateTeacher(user.Id, model.Studio, model.Cert, null, null, false, model.TeacherName);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Action(nameof(ConfirmEmail), "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
await _emailSender.SendEmailAsync(model.Email, "Confirm your account",
$"Please confirm your account by clicking this link: <a href='{callbackUrl}'>link</a>");
_logger.LogInformation(3, "User created a new account with password.");
string url = string.Format("/Account/AccountCreated");
return(Redirect(url));
}
else
{
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Action(nameof(ConfirmEmail), "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
await _emailSender.SendEmailAsync(model.Email, "Confirm your account",
$"Please confirm your account by clicking this link: <a href='{callbackUrl}'>link</a>");
_logger.LogInformation(3, "User created a new account with password.");
string url = string.Format("/Account/AccountCreated");
return(Redirect(url));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> CreateTeacher(RegisterTeacherViewModel registerUserViewModel)
{
registerUserViewModel.DeparmentItems = PopulateDepartments();
registerUserViewModel.PositionItems = PopulatePositions();
if (_databaseWorker.DepartmentExists(registerUserViewModel.DepartmentId) && _databaseWorker.PositionExists(registerUserViewModel.PositionId))
{
if (ModelState.IsValid)
{
IdentityResult result = await _authentication.CreateUserAsync(registerUserViewModel);
if (result.Succeeded)
{
User user = await _authentication.FindUserByEmailAsync(registerUserViewModel.Email);
if (!await _authentication.CreateTeacherUserAsync(user.Id, registerUserViewModel.DepartmentId, registerUserViewModel.PositionId))
{
await _authentication.DeleteUserAsync(user);
return(View("CreateTeacher", registerUserViewModel));
}
return(RedirectToAction("Users"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
}
else
{
ModelState.AddModelError(string.Empty, "Выбирете кафедру для преподователя");
}
return(View("CreateTeacher", registerUserViewModel));
}
public async Task <IActionResult> RegisterNewTeacher(RegisterTeacherViewModel model)
{
if (ModelState.IsValid)
{
var newUser = new IdentityUser()
{
UserName = model.username, Email = model.Email
};
var result = await _userManager.CreateAsync(newUser, model.Password);
if (result.Succeeded)
{
var newTeacher = new Teacher()
{
name = model.name, subject = model.subject, age = model.age, TUserId = newUser.Id
};
_dbContext.teachers.Add(newTeacher);
_dbContext.SaveChanges();
await _userManager.AddToRoleAsync(newUser, "TeacherRole");
await _signInManager.SignInAsync(newUser, true);
return(RedirectToAction("index", "Home"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(model));
}
public async Task <ActionResult> RegisterTeacher(RegisterTeacherViewModel model)
{
if (ModelState.IsValid)
{
User user = new User {
UserName = model.Email, Active = true, FirstName = model.FirstName, LastName = model.LastName, Password = Utils.Hash(model.Password), Role = "Teacher"
};
if (!string.IsNullOrEmpty(model.MobilePhone))
{
user.Claims.Add(new UserClaims {
ClaimType = ClaimTypes.MobilePhone, ClaimValue = model.MobilePhone
});
}
if (!string.IsNullOrEmpty(model.Department))
{
user.Claims.Add(new UserClaims {
ClaimType = "Department", ClaimValue = model.Department
});
}
var result = await _userService.AddUserAsync(user);
if (result > 0)
{
//_authenticationService.SignIn(user);
ModelState.AddModelError("", "User successfully saved.");
return(View(new RegisterTeacherViewModel()));
//return RedirectToAction("Index", "Home");
}
else
{
ModelState.AddModelError("", "User not saved. Please retry in 5 minutes or contact the administrator.");
}
}
return(View(model));
}
public async Task <ActionResult> RegisterTeacher(RegisterTeacherViewModel model)
{
if (ModelState.IsValid)
{
string roleId = _unitOfWork.AspNetRoleRepository.Get()
.Where(r => r.Name == "Teacher") //"Student")
.Select(r => r.Id)
.FirstOrDefault();
string defaultPassword = "******";
var store = new UserStore <ApplicationUser>(context);
var manager = new ApplicationUserManager(store);
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
IsActive = true,
RoleId = roleId
};
await manager.CreateAsync(user, defaultPassword);
await manager.AddToRoleAsync(user.Id, "Teacher");
await SendEmail(fullName : string.Format("{0} {1}", user.FirstName, user.LastName),
email : user.Email,
template : "RegisterTeacherEmailTemplate",
emailTitle : "Teacher registration");
return(RedirectToAction("ApproveRegistration", "Admin"));
}
return(View(model));
}
public async Task<ActionResult> RegisterTeacher(RegisterTeacherViewModel model)
{
if (model == null)
{
return PartialView("_RegisterTeacher", model);
}
if (ModelState.IsValid)
{
var user = new User { UserName = model.Username, Email = model.Email };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
var newUser = _db.Users.FirstOrDefault(x => x.UserName == user.UserName);
if (newUser != null)
{
var roleUser = this.UserManager.AddToRole(newUser.Id, "Teacher");
}
return RedirectToAction("Index", "Home");
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return PartialView("_RegisterTeacher",model);
}
public async System.Threading.Tasks.Task <ActionResult> RegisterTeacher(RegisterTeacherViewModel model)
{
if (ModelState.IsValid)
{
if (await UserManager.Users.AnyAsync(u => u.Email == model.Email))
{
ModelState.AddModelError("", "Пользователь с таким email уже существует.");
}
else
{
if (model.UseRecaptcha)
{
var recaptchaHelper = this.GetRecaptchaVerificationHelper();
if (string.IsNullOrEmpty(recaptchaHelper.Response))
{
ModelState.AddModelError("", "Ответ капчи не может быть пустым.");
return(View(model));
}
var recaptchaResult =
await recaptchaHelper.VerifyRecaptchaResponseTaskAsync();
if (recaptchaResult != RecaptchaVerificationResult.Success)
{
ModelState.AddModelError("", "Капча введена неверно.");
return(View(model));
}
}
var userInfo = new UserInfo
{
Id = Guid.NewGuid(),
CreatedDate = DateTime.Now,
LastVisitDate = DateTime.Now,
School = model.School,
Grade = 0,
HomeTown = model.HomeTown
};
var user = new ApplicationUser
{
UserName = model.UserName,
Email = model.Email,
LastName = model.LastName,
FirstName = model.FirstName,
MiddleName = model.MiddleName,
Ip = GetLocalIP4().ToString(),
UserInfoId = userInfo.Id,
UserInfo = userInfo,
IsDeleted = true,
Rating = 0,
TeamId = null
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
UserManager.AddToRole(user.Id, "teacher");
return(RedirectToAction("Index", "Home"));
}
else
{
AddErrors(result);
}
}
}
return(View(model));
}
