public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
UserManager.AddToRole(user.Id, "Applicant");
UserDetail newUserDeets = new UserDetail();
newUserDeets.UserId = user.Id;
newUserDeets.FirstName = model.FirstName;
newUserDeets.LastName = model.LastName;
JobBoardEntities db = new JobBoardEntities();
db.UserDetails.Add(newUserDeets);
db.SaveChanges();
return(View("Login"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public ActionResult Edit([Bind(Include = "ApplicationID,OpenPositionID,UserID,ApplicationDate,ManagerNotes,ApplicationStatusID,ResumeFileName")] Application application)
{
if (ModelState.IsValid)
{
// we don't want the users to be able to edit all of the fields so we have to got back and get those read only fields
// geting two instances of the same object from the same instnce of JobBoardEntities cause errors so we create a secound JobBoardEntities
using (JobBoardEntities db2 = new JobBoardEntities())
{
Application oldApplication = (from x in db2.Applications
where x.ApplicationID == application.ApplicationID
select x).Single();
application.ApplicationDate = oldApplication.ApplicationDate;
application.OpenPositionID = oldApplication.OpenPositionID;
application.UserID = oldApplication.UserID;
application.ResumeFileName = oldApplication.ResumeFileName;
string userID = User.Identity.GetUserId();
if (!User.IsInRole("Admin"))
{
// the user is not an admin
if (userID != oldApplication.OpenPosition.Location.ManagerID)
{
return(new HttpStatusCodeResult(HttpStatusCode.Forbidden));
}
}
}
db.Entry(application).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ApplicationStatusID = new SelectList(db.ApplicationStatus1, "ApplicationStatusID", "StatusName", application.ApplicationStatusID);
ViewBag.UserID = new SelectList(db.UserDetails, "UserID", "FirstName", application.UserID);
return(View(application));
}
public async Task <ActionResult> Register(RegisterViewModel model, HttpPostedFileBase ResumeFilename)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
UserManager.AddToRole(user.Id, "Seeker");
string resume = "noImage.png";
if (ResumeFilename != null)
{
//Reassing the variable to the filename sent over
resume = ResumeFilename.FileName;
//Create a variable for the extension
string ext = resume.Substring(resume.LastIndexOf('.'));
//create a list of valid extensions
string[] goodExts = { ".jpg", ".jpeg", ".pdf", ".docx", ".txt", ".doc" };
if (goodExts.Contains(ext.ToLower()))
{
ResumeFilename.SaveAs(Server.MapPath("~/Content/Assets/Resumes/" + resume));
}
else
{
resume = "noImage.png";
}
}
#region Dealing with custom user details
UserDetail newUserDeets = new UserDetail();
newUserDeets.UserID = user.Id;
newUserDeets.FirstName = model.FirstName;
newUserDeets.LastName = model.LastName;
newUserDeets.ResumeFilename = resume;
JobBoardEntities db = new JobBoardEntities();
db.UserDetails.Add(newUserDeets);
db.SaveChanges();
#endregion
var 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 this link: <a href=\"" + callbackUrl + "\">link</a>");
ViewBag.Link = callbackUrl;
return(RedirectToAction("Login"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> Create(RegisterViewModel userViewModel, params string[] selectedRoles)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = userViewModel.Email, Email = userViewModel.Email
};
var adminresult = await UserManager.CreateAsync(user, userViewModel.Password);
//Add User to the selected Roles
if (adminresult.Succeeded)
{
#region Custom Details
UserDetail newDetails = new UserDetail();
newDetails.UserId = user.Id;
newDetails.FirstName = userViewModel.FirstName;
newDetails.LastName = userViewModel.LastName;
newDetails.ResumeFilename = userViewModel.ResumeFilename;
JobBoardEntities db = new JobBoardEntities();
db.UserDetails.Add(newDetails);
db.SaveChanges();
#endregion
if (selectedRoles != null)
{
var result = await UserManager.AddToRolesAsync(user.Id, selectedRoles);
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First());
ViewBag.RoleId = new SelectList(await RoleManager.Roles.ToListAsync(), "Name", "Name");
return(View());
}
}
}
else
{
ModelState.AddModelError("", adminresult.Errors.First());
ViewBag.RoleId = new SelectList(RoleManager.Roles, "Name", "Name");
return(View());
}
return(RedirectToAction("Index"));
}
ViewBag.RoleId = new SelectList(RoleManager.Roles, "Name", "Name");
return(View());
}
public async Task <ActionResult> Register(RegisterViewModel model, HttpPostedFileBase resumeFile)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
#region Dealing with Custom User Details
UserDetail newUserDeets = new UserDetail();
newUserDeets.UserId = user.Id; newUserDeets.FirstName = model.FirstName; newUserDeets.LastName = model.LastName;
string fileName = "no.pdf";
if (resumeFile != null)
{
fileName = Guid.NewGuid() + ".pdf";
string path = Server.MapPath("~/Content/Resumes/");
resumeFile.SaveAs(path + fileName);
newUserDeets.ResumeFileName = fileName;
}
JobBoardEntities db = new JobBoardEntities();
db.UserDetails.Add(newUserDeets);
db.SaveChanges();
UserManager.AddToRole(user.Id, "Employee");
ViewBag.RegConfirmed = "Thank You! You have successfully registered a new account. Please Log in.";
#endregion
return(View("Login"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public ActionResult Help(ContactViewModel cvm)
{
if (!ModelState.IsValid)
{
return(View(cvm));
}
JobBoardEntities db = new JobBoardEntities();
string fullName = db.UserDetails.Find(User.Identity.GetUserId()).FullName;
string email = User.Identity.GetUserName();
string message = $"Message from: {fullName} at {email}<br />Message: {cvm.Message}";
MailMessage mm = new MailMessage("*****@*****.**", "*****@*****.**", cvm.Subject, message)
{
IsBodyHtml = true,
Priority = MailPriority.High
};
mm.ReplyToList.Add(email);
SmtpClient client = new SmtpClient("mailServer")
{
Credentials = new NetworkCredential("username", "password")
};
try
{
//client.Send(mm);
TempData["demoMode"] = true;
}
catch (Exception ex)
{
ViewBag.emailError = ex;
return(View(cvm));
}
TempData["emailSuccess"] = true;
return(RedirectToAction("Help"));
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
// This doen't count login failures towards lockout only two factor authentication
// To enable password failures to trigger lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
using (JobBoardEntities db = new JobBoardEntities())
{
string userID = (from x in db.AspNetUsers
where x.Email == model.Email
select x.Id).Single();
var userDetailCheck = from x in db.UserDetails
where x.UserID == userID
select x;
if (userDetailCheck.Count() == 0)
{
return(Redirect("/UserDetails/Create"));
}
}
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.RequiresVerification:
return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
public async Task <ActionResult> Delete(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var user = await UserManager.FindByIdAsync(id);
JobBoardEntities db = new JobBoardEntities();
var userDetails = db.UserDetails.Find(id);
if (user == null)
{
return(HttpNotFound());
}
if (userDetails.Applications.Count > 0 || userDetails.Locations.Count > 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.Forbidden));
}
return(View(user));
}
public async Task <ActionResult> DeleteConfirmed(string id)
{
if (ModelState.IsValid)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var user = await UserManager.FindByIdAsync(id);
JobBoardEntities db = new JobBoardEntities();
var userDetails = await db.UserDetails.FindAsync(id);
if (user == null)
{
return(HttpNotFound());
}
if (userDetails.Applications.Count > 0 || userDetails.Locations.Count > 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.Forbidden));
}
var result = await UserManager.DeleteAsync(user);
db.UserDetails.Remove(userDetails);
db.SaveChanges();
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First());
return(View());
}
return(RedirectToAction("Index"));
}
return(View());
}
public async Task <ActionResult> Register(RegisterViewModel model, HttpPostedFileBase Resume)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
#region Add Custom UserDetails
Final_Project_Data.UserDetail applicant = new UserDetail()
{
UserId = user.Id,
FirstName = model.FirstName,
LastName = model.LastName,
ResumeFilename = null
};
if (Resume != null)
{
//if there is a photo, make sure it's an image
string file = Resume.FileName;
string ext = file.Substring(file.LastIndexOf('.'));
//create a white list of acceptable extensions
string[] goodExts = { ".pdf" };
if (goodExts.Contains(ext))
{
if (Resume.ContentLength <= 10000000) //10mb
{
file = Guid.NewGuid() + ext;
Resume.SaveAs(Server.MapPath("~/Content/resumes/" + file));
applicant.ResumeFilename = file;
}
}
}
JobBoardEntities db = new JobBoardEntities();
db.UserDetails.Add(applicant);
db.SaveChanges();
UserManager.AddToRole(user.Id, "applicant");
#endregion
var 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 this link: <a href=\"" + callbackUrl + "\">link</a>");
ViewBag.Link = callbackUrl;
return(View("DisplayEmail"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> Register(RegisterViewModel model, HttpPostedFileBase resumeFile)
{
if (ModelState.IsValid)
{
string resumeName = "noResume.docx";
if (resumeFile != null)
{
resumeName = resumeFile.FileName;
string ext = resumeName.Substring(resumeName.LastIndexOf('.'));
string[] goodExts = { ".docx", ".pdf" };
if (goodExts.Contains(ext.ToLower()))
{
resumeName = Guid.NewGuid() + ext;
resumeFile.SaveAs(Server.MapPath("~/Content/resumes/" + resumeName));
}
else
{
resumeName = "noResume.docx";
}
}
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
UserDetail newUserDeets = new UserDetail();
newUserDeets.UserId = user.Id;
newUserDeets.FirstName = model.FirstName;
newUserDeets.LastName = model.LastName;
newUserDeets.ResumeFilename = resumeName;
JobBoardEntities db = new JobBoardEntities();
db.UserDetails.Add(newUserDeets);
db.SaveChanges();
if (!String.IsNullOrEmpty(model.Passcode))
{
if (model.Passcode.ToLower() == "manager")
{
UserManager.AddToRole(user.Id, "Manager");
}
else
{
UserManager.AddToRole(user.Id, "Employee");
}
}
else
{
UserManager.AddToRole(user.Id, "Employee");
}
var 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 this link: <a href=\"" + callbackUrl + "\">link</a>");
ViewBag.Link = callbackUrl;
return(View("DisplayEmail"));
}
AddErrors(result);
}
// If we got this far, something failed, re display form
return(View(model));
}
public async Task <ActionResult> Register(RegisterViewModel model, HttpPostedFileBase newResume, params string[] selectedRoles)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var adminresult = await UserManager.CreateAsync(user, model.Password);
if (adminresult.Succeeded)
{
#region Dealing with custom user details
//create user deatails at registion
UserDetail newUserDeets = new UserDetail();
newUserDeets.UserID = user.Id;
newUserDeets.FirstName = model.FirstName;
newUserDeets.LastName = model.LastName;
newUserDeets.CurrentEmployee = true; //defualted to true untill appication becomes open to the public
newUserDeets.DepartmentId = 8; //defaulted to defualt
if (adminresult.Succeeded)
{
if (selectedRoles != null)
{
var result = await UserManager.AddToRolesAsync(user.Id, selectedRoles);
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First());
ViewBag.RoleId = new SelectList(await RoleManager.Roles.ToListAsync(), "Name", "Name");
return(View());
}
}
else
{
var result = await UserManager.AddToRolesAsync(user.Id, "Employee");
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First());
ViewBag.RoleId = new SelectList(await RoleManager.Roles.ToListAsync(), "Name", "Name");
return(View());
}
}
}
else
{
ModelState.AddModelError("", adminresult.Errors.First());
ViewBag.RoleId = new SelectList(RoleManager.Roles, "Name", "Name");
return(View());
}
//resume upload
#region file upload
string resName = "noResume.pdf";
if (newResume != null)
{
resName = newResume.FileName;
string ext = resName.Substring(resName.LastIndexOf("."));
string[] goodExts = { ".pdf", ".doc", ".docx", ".docm", ".txt" };
if (goodExts.Contains(ext.ToLower()))
{
resName = Guid.NewGuid() + ext.ToLower();
string savePath = Server.MapPath("~/Resumes/");
newResume.SaveAs(savePath + resName);
}
else
{
resName = "noResume.pdf";
}
}
#endregion
newUserDeets.ResumeFileName = resName;
JobBoardEntities db = new JobBoardEntities();
db.UserDetails.Add(newUserDeets);
db.SaveChanges();
#endregion
var 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 this link: <a href=\"" + callbackUrl + "\">link</a>");
ViewBag.Link = callbackUrl;
return(RedirectToAction("Index", "Home"));
}
AddErrors(adminresult);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
