//[HttpPost]
//[ValidateAntiForgeryToken]
public JsonResult _SubmitApplicantMetricsForm(IEnumerable <ApplicantEvaluationMetrics> submittedmetrics)
{
bool action = false;
if (submittedmetrics != null && submittedmetrics.Count() >= 0)
{
var categories = submittedmetrics.ToList();
foreach (ApplicantEvaluationMetrics metrics in submittedmetrics)
{
if (ModelState.IsValid)
{
if (metrics.ID == 0)
{
db.ApplicantEvaluationMetrics.Add(metrics);
}
else
{
db.Entry(metrics).State = System.Data.Entity.EntityState.Modified;
}
db.SaveChanges();
}
action = true;
}
}
return(Json(action, JsonRequestBehavior.AllowGet));
}
//[ValidateAntiForgeryToken]
public JsonResult _SubmitCategoriesForm(IEnumerable <EvaluationCategory> submittedcategories)
{
bool action = false;
if (submittedcategories != null && submittedcategories.Count() >= 0)
{
var categories = submittedcategories.ToList();
foreach (EvaluationCategory category in categories)
{
if (ModelState.IsValid)
{
if (category.ID == 0)
{
db.EvaluationCategories.Add(category);
}
else
{
db.Entry(category).State = System.Data.Entity.EntityState.Modified;
}
db.SaveChanges();
}
action = true;
}
}
return(Json(action, JsonRequestBehavior.AllowGet));
}
public ActionResult Reject(int?id, JobRequisition requisition)
{
if (id == null)
{
return(View("Error"));
}
try
{
JobRequisition jobRequisition;
using (var db = new TalentContext())
{
jobRequisition = db.JobRequisitions.Find(id);
if (string.IsNullOrEmpty(jobRequisition.RequisitionNo))
{
var req = new TalentContext().JobRequisitions.Count();
jobRequisition.RequisitionNo = "TR" + String.Format("{0:D6}", req + 1);
}
jobRequisition.RejectionNote = requisition.RejectionNote;
jobRequisition.Status = JobRequisition.JobRequisitionStatus.Rejected;
db.Entry(jobRequisition).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
ViewBag.Message = "Action Successful";
return(RedirectToAction("Requisitions", "Admin"));
}
}
catch (Exception ex)
{
return(View("Error"));
}
}
internal async Task <ActionResult> SaveBioDetails(JobSeeker applicant)
{
try
{
if (ModelState.IsValid)
{
using (var db = new TalentContext())
{
var id = applicant.ID;
var originaluserdata = GetUserProfile(id);
originaluserdata.FirstName = applicant.FirstName;
originaluserdata.LastName = applicant.LastName;
originaluserdata.PhoneNumber = applicant.PhoneNumber;
originaluserdata.Address = applicant.Address;
originaluserdata.DateOfBirth = applicant.DateOfBirth;
db.Entry(originaluserdata).State = EntityState.Modified;
await db.SaveChangesAsync();
//db.SaveChanges();
}
return(RedirectToAction("Education", "Applicant"));
}
return(View("ManageProfile", "Applicant", applicant));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex);
return(View("Error"));
//return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
}
public JsonResult _SubmitCandidateAvailabilityForm(Interview interview)
{
bool action = false;
if (ModelState.IsValid)
{
using (var db = new TalentContext())
{
//var InterviewExistingCheck = db.Interviews.Where(o => o.JobRequisitionID == interview.JobRequisitionID && o.JobApplicationID == interview.JobApplicationID);
if (interview.InterviewID != 0)
{
db.Interviews.Add(interview);
db.Entry(interview).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
else
{
db.Interviews.Add(interview);
db.SaveChanges();
}
var applicant = db.JobApplications.Include("JobSeeker").Where(x => x.JobApplicationID == interview.JobApplicationID).First().JobSeeker;
ApplicationDbContext context = new ApplicationDbContext();
var UserManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));
var applicantemail = UserManager.FindById(applicant.UserId).Email;
SendEmailToApplicant();
action = true;
}
}
var response = new Dictionary <string, dynamic>();
response.Add("action", (bool)action);
response.Add("interviewid", (int)interview.InterviewID);
return(Json(response, JsonRequestBehavior.AllowGet));
}
public JsonResult GetGrievanceActions(List <GrievanceAction> actions)
{
foreach (var action in actions)
{
if (db.GrievanceActions.Where(x => x.Code == action.Code).Any())
{
db.GrievanceActions.Add(action);
db.Entry(action).State = System.Data.Entity.EntityState.Modified;
}
else
{
db.GrievanceActions.Add(action);
}
}
db.SaveChanges();
return(Json(new { status = "True", actions = actions }, JsonRequestBehavior.AllowGet));
}
public JsonResult GetTrainingCourses(List <TrainingCourse> courses)
{
foreach (var course in courses)
{
if (db.TrainingCourses.Where(x => x.Code == course.Code).Any())
{
db.TrainingCourses.Add(course);
db.Entry(course).State = System.Data.Entity.EntityState.Modified;
}
else
{
db.TrainingCourses.Add(course);
}
}
db.SaveChanges();
return(Json(new { status = "True", courses = courses }, JsonRequestBehavior.AllowGet));
}
public ActionResult Edit(int?id, JobRequisition requisition, List <CheckModel> checks)
{
ViewBag.Message = "Changes Were Not Saved. Pls Try Again";
if (!ModelState.IsValid)
{
return(View(requisition));
}
try
{
//List<Skill> selectedskills = checks.Where(x => x.Checked == true)
// .Select(o => new Skill { ID = o.Id, Name = o.Name }).ToList();
//var selectedint = selectedskills.Select(o => o.ID).ToList();
using (var db = new TalentContext())
{
JobRequisition jobRequisition = db.JobRequisitions.Find(id);
if (string.IsNullOrEmpty(jobRequisition.RequisitionNo))
{
var req = new TalentContext().JobRequisitions.Count();
jobRequisition.RequisitionNo = "TR" + String.Format("{0:D6}", req + 1);
}
jobRequisition.JobResponsibilities = requisition.JobResponsibilities;
jobRequisition.EducationalRequirements = requisition.EducationalRequirements;
jobRequisition.AgeLimit = requisition.AgeLimit;
jobRequisition.JobDescription = jobRequisition.JobDescription;
jobRequisition.Location = requisition.Location;
jobRequisition.ClosingDate = requisition.ClosingDate;
jobRequisition.StartDate = requisition.StartDate;
jobRequisition.YearsOfExperience = requisition.YearsOfExperience;
jobRequisition.NoOfPositionsAvailable = requisition.NoOfPositionsAvailable;
jobRequisition.Status = JobRequisition.JobRequisitionStatus.Created;
jobRequisition.PublishedDate = DateTime.Now;
db.Entry(jobRequisition).State = System.Data.Entity.EntityState.Modified;
//var skills = db.Skills
// .Where(x => selectedint.Contains(x.ID))
// .ToList();
// db.JobRequisitions.Add(requisition);
//jobRequisition.Skills.Clear();
//jobRequisition.Skills = selectedskills;
db.SaveChanges();
//requisition.Skills.Union(skills);
//requisition.Skills.Intersect(skills);
//requisition.Skills = skills;
// db.SaveChanges();
ViewBag.Message = "Changes Were succesfully Saved";
return(RedirectToAction("Requisitions", "Admin"));
//return View(requisition);
}
}
catch
{
//return;
return(View("Error"));
}
}
public ActionResult Edit([Bind(Include = "JobRequisitionID,JobTitle,Status,NoOfPositionsAvailable,JobDescription,HumanResourcePersonnelID,HeadOfDepartmentID,StartDate,ClosingDate,JobUrl")] JobRequisition jobRequisition)
{
if (ModelState.IsValid)
{
db.Entry(jobRequisition).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(jobRequisition));
}
public ActionResult Edit([Bind(Include = "ID,QualificationType,QualificationCode,Description")] JobQualification jobQualification)
{
if (ModelState.IsValid)
{
db.Entry(jobQualification).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(jobQualification));
}
public ActionResult Edit([Bind(Include = "ID,LeaveType,Limit,RequiresPlan")] LeaveType_Limit leaveType_Limit)
{
if (ModelState.IsValid)
{
db.Entry(leaveType_Limit).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(leaveType_Limit));
}
public ActionResult Edit([Bind(Include = "ID,EmployeeId,EmployeeName,StartDate,EndDate,Duration,ApplyDate,Status,LeaveType,LeaveLimit,LeaveType_Limit_ID")] ManageEmployeeLeave manageEmployeeLeave)
{
if (ModelState.IsValid)
{
db.Entry(manageEmployeeLeave).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(manageEmployeeLeave));
}
public ActionResult Edit([Bind(Include = "Id,Name")] Group group)
{
if (ModelState.IsValid)
{
db.Entry(group).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(group));
}
async Task <ApprovalEntry> IApprovalService.UpdateApprovalEntry(ApprovalEntry entry)
{
entry.Status = "Approved";
db.ApprovalEntries.Add(entry);
db.Entry(entry).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
await Task.Delay(5);
return(entry);
}
public ActionResult Edit([Bind(Include = "ID,ApplicantNumber,RegistrationDate,UserId,FirstName,LastName,DateOfBirth,Password,Address,PhoneNumber")] JobSeeker jobSeeker)
{
if (ModelState.IsValid)
{
db.Entry(jobSeeker).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(jobSeeker));
}
public async Task <ActionResult> Edit([Bind(Include = "LeaveAppID,LeavePlanID,EmployeeId,EmployeeName,LeaveType,LeaveLimit,TotalLeaveTaken,TotalLeaveAvailable,StartDate,EndDate,Duration,ApplyDate,LeavePlanStatus,LeaveAppStatus")] LeaveApplication leaveApplication)
{
if (ModelState.IsValid)
{
db.Entry(leaveApplication).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("LeaveApplication", "Admin"));
}
return(View(leaveApplication));
}
public async Task <ActionResult> Edit([Bind(Include = "ID,LeaveAppID,EmployeeId,EmployeeName,StartDate,ResumptionDate,Duration,Status,ApplyDate,LeaveType")] LeaveResumption leaveResumption)
{
if (ModelState.IsValid)
{
var employee = _repo.GetEmployee(int.Parse(leaveResumption.EmployeeId));
if (leaveResumption.Status == LeaveResumption.LeaveResumptionStatus.Approved)
{
LeaveApplication leaveapplication = db.LeaveApplications.Find(leaveResumption.LeaveAppID);
if (leaveapplication.LeavePlanID != null)
{
ManageEmployeeLeave leaveplan = db.ManageEmployeeLeaves.Find(leaveapplication.LeavePlanID);
if (leaveplan.TotalLeaveAvailable == null)
{
leaveplan.TotalLeaveAvailable = leaveplan.LeaveLimit;
}
if (leaveplan.TotalLeaveTaken == null)
{
leaveplan.TotalLeaveTaken = 0;
}
leaveplan.TotalLeaveTaken += leaveResumption.Duration;
leaveplan.TotalLeaveAvailable -= leaveResumption.Duration;
}
if (leaveapplication.TotalLeaveAvailable == null)
{
leaveapplication.TotalLeaveAvailable = leaveapplication.LeaveLimit;
}
if (leaveapplication.TotalLeaveTaken == null)
{
leaveapplication.TotalLeaveTaken = 0;
}
leaveapplication.TotalLeaveAvailable -= leaveResumption.Duration;
leaveapplication.TotalLeaveTaken += leaveResumption.Duration;
string FilePath = Server.MapPath("~/Assets/EmailTemplate/LeaveApproved.cshtml");
StreamReader str = new StreamReader(FilePath);
string MailText = str.ReadToEnd();
str.Close();
MailText = MailText.Replace("[Date]", DateTime.Now.ToShortDateString());
MailText = MailText.Replace("[StartDate]", leaveResumption.StartDate.ToShortDateString());
MailText = MailText.Replace("[ResumptionDate]", leaveResumption.ResumptionDate.ToShortDateString());
MailText = MailText.Replace("[Name]", employee.FullName);
MailText = MailText.Replace("[HRName]", "Bolaji Fashola");
_emailhandler = new LeaveApplicationAcceptedEmail(MailText);
_emailhandler.SendEmail("*****@*****.**", "");
}
db.Entry(leaveResumption).State = EntityState.Modified;
await db.SaveChangesAsync();
//await Task.Delay(50);
return(RedirectToAction("Index"));
}
return(View(leaveResumption));
}
public ActionResult Edit([Bind(Include = "ID,EmployeeNumber,EmploymentDate,OfficePositionID,UserId,FirstName,LastName,DateOfBirth,Password,Address,PhoneNumber")] Employee employee)
{
if (ModelState.IsValid)
{
db.Entry(employee).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.OfficePositionID = new SelectList(db.OfficePositions, "OfficePositionID", "Title", employee.OfficePositionID);
return(View(employee));
}
public async Task <ActionResult> Edit([Bind(Include = "No,EmployeeNo,EmployeeName,Reason,OtherReasons,LeavingOn,ReEmploy,InterviewDate,InterviewerNo,InterviewerName,Comment,Status,ApproveProcess,ProcessCompleted")] ExitInterview exitInterview)
{
if (ModelState.IsValid)
{
db.Entry(exitInterview).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(exitInterview));
}
public async Task <ActionResult> Edit([Bind(Include = "Id,Sender,ProcessName,NoOfApprovals,Approver1Id,Approver2Id,Approver3Id,Approver4Id,Approver5Id,IsEnabled")] DocumentWorkFlow documentWorkFlow)
{
if (ModelState.IsValid)
{
db.Entry(documentWorkFlow).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(documentWorkFlow));
}
public ActionResult Edit([Bind(Include = "ID,InterviewID,EvaluationCode,EvaluationDescription,Deleted")] EvaluationCategory evaluationCategory)
{
if (ModelState.IsValid)
{
db.Entry(evaluationCategory).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.InterviewID = new SelectList(db.Interviews, "InterviewID", "SchedulingFinalNote", evaluationCategory.InterviewID);
return(View(evaluationCategory));
}
public ActionResult Edit([Bind(Include = "ID,Name,IndustryId")] Skill skill)
{
if (ModelState.IsValid)
{
db.Entry(skill).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.IndustryId = new SelectList(db.Industries, "IndustryId", "Name", skill.IndustryId);
return(View(skill));
}
public async Task <ActionResult> Edit([Bind(Include = "BranchId,Location")] Branch branch)
{
if (ModelState.IsValid)
{
db.Entry(branch).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(branch));
}
public ActionResult EditTemplate(int id, OnboardingTemplate template)
{
if (ModelState.IsValid)
{
template.DateEdited = DateTime.Now;
db.OnboardingTemplates.Add(template);
db.Entry(template).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Onboarding", "Admin"));
}
return(View(template));
}
public ActionResult _SubmitCandidateEvaluationForm(InterviewEvaluation interviewevaluation, List <Evaluation> evaluations)
{
if (ModelState.IsValid)
{
using (var db = new TalentContext())
{
foreach (var evaluation in evaluations)
{
if (evaluation.ID == 0)
{
db.Evaluations.Add(evaluation);
}
else
{
db.Evaluations.Add(evaluation);
db.Entry(evaluation).State = System.Data.Entity.EntityState.Modified;
}
db.SaveChanges();
}
// interviewevaluation.EvaluationNo = "TR" + String.Format("{0:D6}", interviewid + db.InterviewEvaluations.Where(x => x.InterviewID == interviewevaluation.InterviewID).Count());
if (interviewevaluation.ID == 0)
{
db.InterviewEvaluations.Add(interviewevaluation);
db.SaveChanges();
}
else
{
db.Entry(interviewevaluation).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
}
// return PartialView("_getcandidateevaluationform",interviewevaluation);
return(RedirectToAction("_getcandidateevaluationform", "Application", new { interviewid = interviewevaluation.InterviewID, employeeid = interviewevaluation.EmployeeID, status = "successful" }));
// return RedirectToAction("Dashboard", "Admin");
}
// return PartialView(interviewevaluation);
return(RedirectToAction("_getcandidateevaluationform", "Application", new { interviewid = interviewevaluation.InterviewID, employeeid = interviewevaluation.EmployeeID }));
}
internal async Task <ActionResult> SaveBioDetails(JobSeeker applicant)
{
//try
//{
if (ModelState.IsValid)
{
using (var db = new TalentContext())
{
var id = applicant.ID;
var originaluserdata = GetUserProfile(id);
originaluserdata.FirstName = applicant.FirstName;
originaluserdata.LastName = applicant.LastName;
originaluserdata.PhoneNumber = applicant.PhoneNumber;
originaluserdata.Address = applicant.Address;
originaluserdata.DateOfBirth = applicant.DateOfBirth;
originaluserdata.IndustryID = applicant.IndustryID;
originaluserdata.HighestQualification = applicant.HighestQualification;
// originaluserdata.Skills.Add(db.Skills.Find(1));
// db.Entry(originaluserdata).State = EntityState.Modified;
//await db.SaveChangesAsync();
// var skills = db.Skills.Include("JobSeekers").ToList();
var selectedint = applicant.Skills.Select(o => o.ID).ToList();
// var selectedint = new List<int>() {1,2,3 };
var skills = db.Skills
.Where(x => selectedint.Contains(x.ID))
.ToList();
db.Entry(originaluserdata).State = EntityState.Modified;
db.SaveChanges();
await Task.Delay(100);
//originaluserdata.Skills = new List<Skill>();
originaluserdata.Skills.Union(skills);
originaluserdata.Skills.Intersect(skills);
originaluserdata.Skills = skills;
//System.Threading.Thread.Sleep(500);
await db.SaveChangesAsync();
}
ViewBag.userid = applicant.ID;
return(RedirectToAction("Profile", "Applicant"));
}
ViewBag.userid = applicant.ID;
return(View("ManageProfile", "Applicant", applicant));
//}
//catch (Exception ex)
//{
// ModelState.AddModelError("", ex);
// return View("Error");
// //return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
//}
}
public ActionResult EditGuide(int id, WelcomeGuide guide)
{
if (!ModelState.IsValid)
{
return(View(guide));
}
using (var db = new TalentContext())
{
db.WelcomeGuides.Add(guide);
db.Entry(guide).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
return(RedirectToAction("Onboarding", "Admin"));
}
public ActionResult EditTemplate(int id, OnboardingTemplate template, string htmlMessage, ICollection <ActivityViewModel> Line)
{
string htmlEncoded = WebUtility.HtmlEncode(htmlMessage);
if (ModelState.IsValid)
{
template.DateEdited = DateTime.Now;
template.WelcomeMessage = htmlEncoded;
db.OnboardingTemplates.Add(template);
db.Entry(template).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Onboarding", "Admin"));
}
return(View(template));
}
public ActionResult Reject(int?id, JobRequisition requisition)
{
JobRequisition jobRequisition;
using (var db = new TalentContext())
{
jobRequisition = db.JobRequisitions.Find(id);
jobRequisition.RejectionNote = requisition.RejectionNote;
jobRequisition.Status = JobRequisition.JobRequisitionStatus.Rejected;
db.Entry(jobRequisition).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
ViewBag.Message = "Action Successful";
}
return(View());
}
public ActionResult Edit(int id, OfficePosition position, List <JobRequirement> Line, List <ApplicantEvaluationMetrics> Evals, IEnumerable <JobRequirement> requirements, IEnumerable <ApplicantEvaluationMetrics> applicantmetrics)
{
position.DateCreated = DateTime.Now;
var dbposition = new OfficePosition();
using (var db = new TalentContext())
{
ViewBag.Departments = db.Departments.ToList();
ViewBag.Industries = db.Industries.ToList();
ViewBag.Branches = db.Branches.ToList();
ViewBag.Positions = db.OfficePositions.ToList();
if (requirements != null)
{
ViewBag.SelectedRequirements = requirements.ToList();
}
else
{
ViewBag.SelectedRequirements = new List <JobRequirement>();
}
}
var status = UpdateApplicantMetrics(applicantmetrics);
if (!ModelState.IsValid)
{
ModelState.AddModelError("Title", "Error");
ViewBag.ErrorMessage = "Error";
return(View(position));
}
try
{
using (var db = new TalentContext())
{
db.OfficePositions.Add(position);
db.Entry(position).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
var action = UpdateJobRequirements(Line, position.OfficePositionID);
var action2 = UpdateApplicantEvaluationRequirements(Evals, position.OfficePositionID);
db.SaveChanges();
// Insert Logic to prevent adding the same role title 2 or more times to a single department
}
ViewBag.Message = "Changes Made Successfully";
return(RedirectToAction("Job/Edit/" + position.OfficePositionID, "Admin"));
}
catch
{
return(View("Error"));
}
}
