public JsonResult CreateUpdate(Sales sales)
{
using (TalentContext db = new TalentContext())
{
if (sales.Id == 0)
{
db.Sales.Add(sales);
db.SaveChanges();
}
else
{
var salesData = db.Sales.Where(x => x.Id == sales.Id).FirstOrDefault();
salesData.DateSold = sales.DateSold;
salesData.ProductId = sales.ProductId;
salesData.CustomerId = sales.CustomerId;
salesData.StoreId = sales.StoreId;
db.SaveChanges();
}
return(Json(new
{
redirectUrl = Url.Action("Index", "Sales"),
isRedirect = true
}));
}
//return null;
}
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 ActionResult StartOnboarding(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
JobSeeker applicant = db.Applicants.Find(id);
if (applicant == null)
{
return(HttpNotFound());
}
var employeerecord = db.Employees.Where(s => s.UserId == applicant.UserId);
Employee employee = new Employee();
if (!employeerecord.Any())
{
employee = new Employee
{
FirstName = applicant.FirstName,
LastName = applicant.LastName,
Address = applicant.Address,
DateOfBirth = applicant.DateOfBirth,
UserId = applicant.UserId,
EmploymentDate = DateTime.Now,
PhoneNumber = applicant.PhoneNumber
};
db.Employees.Add(employee);
db.SaveChanges();
}
ViewBag.OfficePositionID = new SelectList(db.OfficePositions, "OfficePositionID", "Title", employee.OfficePositionID);
return(View(employee));
}
public ActionResult VerifyMatchedApplicant(int id, int applicantid)
{
try
{
using (var db = new TalentContext())
{
var existingapplication = db.JobApplications.Where(x => x.JobRequisitionID == id && x.JobSeekerID == applicantid);
if (existingapplication.Any())
{
existingapplication.First().ApplicationStatus = ApplicationStatus.Screened;
db.SaveChanges();
}
else
{
var application = new JobApplication()
{
JobRequisitionID = id,
JobSeekerID = applicantid,
ApplicationStatus = ApplicationStatus.Screened,
RegistrationDate = DateTime.Now
};
db.JobApplications.Add(application);
db.SaveChanges();
}
}
return(RedirectToAction("Matchskill/" + id, "Admin"));
}
catch (Exception ex)
{
return(View("Error"));
}
}
public ActionResult CreateGuide(int?applicantid, WelcomeGuide guide)
{
ViewBag.Templates = db.OnboardingTemplates.ToList();
ViewBag.Branches = db.Branches.ToList();
if (!ModelState.IsValid)
{
guide.DateCreated = DateTime.UtcNow;
guide.StartDate = DateTime.UtcNow.AddDays(7);
return(View(guide));
}
using (var db = new TalentContext())
{
guide.Status = Status.Review;
db.WelcomeGuides.Add(guide);
db.SaveChanges();
if (guide.TemplateID != null)
{
guide.WelcomeMessage = db.OnboardingTemplates.Find(guide.TemplateID).WelcomeMessage;
var activities = db.CompletedActivities.Where(x => x.OnboardingTemplateID == guide.ID).ToList();
var guideactivities = OnboardingUtilityHelper.ConvertToGuideActivities(activities, guide.ID);
//guide.CompletedActivities = OnboardingUtilityHelper.ConvertToGuideActivities(db.OnboardingTemplates.Find(guide.TemplateID).CompletedActivities.ToList(), guide.ID);
guide.previewurl = Guid.NewGuid().ToString();
db.CompletedActivities.AddRange(guideactivities);
db.SaveChanges();
}
}
return(RedirectToAction("Guide/Customize/" + guide.Name + "/" + guide.ID, "Onboarding"));
}
public ActionResult Create(JobRequisition requisition, List <CheckModel> checks)
{
var req = new TalentContext().JobRequisitions.Count();
requisition.RequisitionNo = "TR" + String.Format("{0:D6}", req + 1);
if (DateTime.Now.Year > requisition.StartDate.Year)
{
ViewBag.Message = "Invalid Start Date for Requisition";
//ViewBag.Message = requisition.StartDate + " " + requisition.ClosingDate+ " " + requisition.PublishedDate;
return(View(requisition));
}
if (DateTime.Now.Year > requisition.ClosingDate.Year)
{
ViewBag.Message = "Invalid Closing Date for Requisition";
//ViewBag.Message = requisition.StartDate + " " + requisition.ClosingDate+ " " + requisition.PublishedDate;
return(View(requisition));
}
if (!ModelState.IsValid)
{
ViewBag.Message = "Couldn't Create Requisition; Form was not Completed Properly";
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();
requisition.Status = JobRequisition.JobRequisitionStatus.Created;
//requisition.StartDate = DateTime.UtcNow;
//requisition.ClosingDate = DateTime.UtcNow;
requisition.PublishedDate = DateTime.UtcNow;
using (var db = new TalentContext())
{
var skills = db.Skills
.Where(x => selectedint.Contains(x.ID))
.ToList();
db.JobRequisitions.Add(requisition);
db.SaveChanges();
requisition.Skills.Union(skills);
requisition.Skills.Intersect(skills);
requisition.Skills = skills;
db.SaveChanges();
}
ViewBag.Message = "Successfully Created Requisition";
return(View());
}
catch
{
return(View("Error"));
}
}
public ActionResult Create([Bind(Include = "JobRequisitionID,JobTitle,Status,NoOfPositionsAvailable,JobDescription,HumanResourcePersonnelID,HeadOfDepartmentID,StartDate,ClosingDate,JobUrl")] JobRequisition jobRequisition)
{
if (ModelState.IsValid)
{
db.JobRequisitions.Add(jobRequisition);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(jobRequisition));
}
public ActionResult Create([Bind(Include = "ID,ApplicantNumber,RegistrationDate,UserId,FirstName,LastName,DateOfBirth,Password,Address,PhoneNumber")] JobSeeker jobSeeker)
{
if (ModelState.IsValid)
{
db.Applicants.Add(jobSeeker);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(jobSeeker));
}
public ActionResult Create([Bind(Include = "Id,Name")] Group group)
{
if (ModelState.IsValid)
{
db.Groups.Add(group);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(group));
}
public ActionResult Create([Bind(Include = "ID,LeaveType,Limit,RequiresPlan")] LeaveType_Limit leaveType_Limit)
{
if (ModelState.IsValid)
{
db.LeaveType_Limits.Add(leaveType_Limit);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(leaveType_Limit));
}
public ActionResult Create([Bind(Include = "ID,QualificationType,QualificationCode,Description")] JobQualification jobQualification)
{
if (ModelState.IsValid)
{
db.JobQualifications.Add(jobQualification);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(jobQualification));
}
public ActionResult Create([Bind(Include = "ID,InterviewID,EvaluationCode,EvaluationDescription,Deleted")] EvaluationCategory evaluationCategory)
{
if (ModelState.IsValid)
{
db.EvaluationCategories.Add(evaluationCategory);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.InterviewID = new SelectList(db.Interviews, "InterviewID", "SchedulingFinalNote", evaluationCategory.InterviewID);
return(View(evaluationCategory));
}
public ActionResult Create([Bind(Include = "ID,Name,IndustryId")] Skill skill)
{
if (ModelState.IsValid)
{
db.Skills.Add(skill);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.IndustryId = new SelectList(db.Industries, "IndustryId", "Name", skill.IndustryId);
return(View(skill));
}
public ActionResult CreateTemplate(OnboardingTemplate template)
{
if (ModelState.IsValid)
{
template.DateCreated = DateTime.Now;
template.DateEdited = DateTime.Now;
db.OnboardingTemplates.Add(template);
db.SaveChanges();
return(RedirectToAction("Onboarding", "Admin"));
}
return(View(template));
}
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);
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);
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 ScreenedPage(int requisitionid, int applicationid)
{
var req = db.JobApplications.Find(applicationid);
if (req.ApplicationStatus <= ApplicationStatus.Screened)
{
req.ApplicationStatus = ApplicationStatus.Screened;
}
db.SaveChanges();
//careful here
ViewBag.pageid = requisitionid;
ViewBag.applicationid = applicationid;
return(PartialView());
}
// GET: Role/Delete/5
public ActionResult Delete(int id)
{
var dbposition = new OfficePosition();
using (var db = new TalentContext())
{
dbposition = db.OfficePositions.Include("JobRequirements").Where(x => x.OfficePositionID == id).FirstOrDefault();
db.JobRequirements.RemoveRange(dbposition.JobRequirements);
db.SaveChanges();
db.OfficePositions.Remove(dbposition);
db.SaveChanges();
}
return(RedirectToAction("Jobmanager", "Admin"));
}
// GET: Cash
public async Task <ActionResult> CashRequest(CashRequisition model, List <CashLineItem> Line)
{
ViewBag.Branches = db.Branches.ToList();
ViewBag.Employees = db.Employees.Select(p => new { Id = p.ID, Name = p.FirstName + " " + p.LastName, Number = p.EmployeeNumber, Department = p.OfficePosition.Department.DepartmentName });
ViewBag.CashRequisitionTypeCode = new SelectList(db.CashRequisitionTypes, "Code", "Description");
try
{
if (ModelState.IsValid)
{
var Userid = User.Identity.GetUserId();
var currentUser = db.Employees.Where(x => x.UserId == Userid).First();
var userid = currentUser.ID;
bool flow = await _workFlowHelper.IsEmployeeAuthorizedForAction("cash", userid);
if (!flow)
{
ViewBag.Error = "Not Authorized To Make Cash Requisition";
return(View(model));
}
if (Line == null)
{
ViewBag.Error = "Line Items Empty! Add Appropriate Line Items in Requisition";
return(View(model));
//db.CashRequisitions.Add(model);
//db.SaveChanges();
//return RedirectToAction("Transaction/Create", "Expenses");
}
else
{
bool itemscheck = CheckLineItems(Line, model);
if (itemscheck)
{
db.CashRequisitions.Add(model);
bool itemsstatus = UpdateLineItems(Line, model);
var entries = await _workFlowHelper.GenerateApprovalEntries(model, "cash", model.No, userid);
db.SaveChanges();
}
return(RedirectToAction("Transaction/Create", "Expenses"));
}
}
return(View(model));
}
catch (Exception ex)
{
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"));
}
}
public ActionResult _GetEvaluations(int id, int stageid, int officeid, Dictionary <string, int> maxscores)
{
ViewBag.stageid = stageid;
ViewBag.maxscores = maxscores;
var applicantmetrics = db.ApplicantEvaluationMetrics.Where(x => x.OfficePositionID == officeid);
// ViewBag.ApplicantMetrics = applicantmetrics;
var evaluations = new List <Evaluation>();
using (var db = new TalentContext())
{
var evaluationss = db.Evaluations.Where(x => x.InterviewEvaluationID == id).ToList();
if (evaluationss.Count() != applicantmetrics.Count())
{
foreach (var metric in applicantmetrics)
{
evaluations.Add(new Evaluation
{
EvaluationCode = metric.EvaluationCode,
EvaluationDescription = metric.EvaluationDescription,
InterviewEvaluationID = id
});
}
db.Evaluations.AddRange(evaluations);
db.SaveChanges();
}
else
{
evaluations = evaluationss;
}
}
return(PartialView(evaluations));
}
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"));
}
}
public ActionResult Apply(int id,JobSeeker jobseeker)
{
if (id == 0)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
JobRequisition job = db.JobRequisitions.Find(id);
ViewBag.Industries = db.Industries.ToList();
ViewBag.jobRequisition = job;
if (job == null)
{
return HttpNotFound();
}
try
{
//get the details of the applicant
var IsProfileCompleted = checkalluserfields();
var IsApplicationExisting = checkIfApplicationExists(User.Identity.GetUserId(),id);
if (IsApplicationExisting)
{
ViewBag.Message = "FoundApplication";
return View(jobseeker);
}
if (IsProfileCompleted)
{
//run check to see if there is an existing application with the clientid and job requisitionid
//Display Message to indicate Success
//Create new Job Application
var application = new JobApplication();
application.ApplicationStatus = ApplicationStatus.Applied;
application.JobSeekerID = getuserid();
application.RegistrationDate = DateTime.Now;
application.JobRequisitionID = id;
using(var db=new TalentContext())
{
db.JobApplications.Add(application);
db.SaveChanges();
}
ViewBag.Message = "True";
}
else
{
ViewBag.Message = "False";
}
//Obtain List of Fields to be Updated
//Display Message to indicate Success
return View(jobseeker);
}
catch
{
ViewBag.Message = "Please Re-Apply";
return View(jobseeker);
}
}
public ActionResult Create([Bind(Include = "ID,EmployeeId,EmployeeName,StartDate,EndDate,Duration,ApplyDate,Status,LeaveType,LeaveLimit,LeaveType_Limit_ID")] ManageEmployeeLeave manageEmployeeLeave)
{
if (ModelState.IsValid)
{
if (manageEmployeeLeave.LeaveLimit < manageEmployeeLeave.Duration)
{
ViewBag.Error = "Your " + manageEmployeeLeave.LeaveType + " Leave Duration Cannot exceed leave limit of " + manageEmployeeLeave.LeaveLimit + " days !";
manageEmployeeLeave.EndDate = manageEmployeeLeave.StartDate.AddDays((double)manageEmployeeLeave.LeaveLimit - 1);
return(View(manageEmployeeLeave));
}
//LeaveType_Limit leavetypelimit = new LeaveType_Limit();
//if (leavetypelimit.ID == 0)
//{
// ModelState.AddModelError("", "Select Leave Type");
//}
//int selectvalue = leavetypelimit.ID;
//ViewBag.SelectedValue = leavetypelimit.Limit;
//List<LeaveType_Limit> leavetypelist = new List<LeaveType_Limit>();
//leavetypelist = (from c in db.LeaveType_Limits select c).ToList();
//leavetypelist.Insert(0, new LeaveType_Limit { ID = 0, LeaveType = "Select" });
SetEmployeeSessionID();
var id = Session["employeeid"];
var empdetails = db.Employees.Select(c => c.EmployeeNumber).FirstOrDefault();
var empname = db.Employees.Select(c => c.FirstName).FirstOrDefault();
var emplastname = db.Employees.Select(c => c.LastName).FirstOrDefault();
var empfullname = empname + " " + emplastname;
manageEmployeeLeave.EmployeeId = empdetails.ToString();
manageEmployeeLeave.EmployeeName = empfullname.ToString();
var diff1 = (manageEmployeeLeave.EndDate - manageEmployeeLeave.StartDate).Days;
manageEmployeeLeave.Duration = diff1;
manageEmployeeLeave.ApplyDate = DateTime.Now;
//var status = (int)ManageEmployeeLeave.LeaveStatus.Pending;
//manageEmployeeLeave.LeaveType = ViewBag.SelectedValue;
manageEmployeeLeave.Status = ManageEmployeeLeave.LeaveStatus.Pending;
//manageEmployeeLeave.LeaveType = db.LeaveType_Limits.Distinct().Select(c => new SelectListItem() { Text = c.LeaveType, Value = c.ID.ToString()}).ToString();
db.ManageEmployeeLeaves.Add(manageEmployeeLeave);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(manageEmployeeLeave));
}
public ActionResult Create(OfficePosition position, IEnumerable <BusinessLogic.UpdatedDomain.JobRequirement> requirements)
{
// position.IsAvailable = false;
position.DateCreated = DateTime.Now;
position.Reqirements = "";
if (!ModelState.IsValid)
{
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();
}
return(View(position));
}
//Select Job Requirements that have data from those that dont
List <BusinessLogic.UpdatedDomain.JobRequirement> selectedrequirements = requirements.Where(x => x.QualificationCode != null && x.QualificationType != null).ToList();
// Perform Validation for Each JobRequirement
try
{
using (var db = new TalentContext())
{
db.OfficePositions.Add(position);
db.SaveChanges();
foreach (var requirement in requirements)
{
requirement.OfficePositionID = position.OfficePositionID;
requirement.OfficePosition = position;
db.JobRequirements.Add(requirement);
db.SaveChanges();
}
//Insert Logic to prevent adding the same role title 2 or more times to a single department
}
return(RedirectToAction("jobmanager", "Admin"));
}
catch
{
return(View("Error"));
}
}
private void setupSuperAdminAccount()
{
ApplicationDbContext context = new ApplicationDbContext();
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(context));
var UserManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));
// In Startup iam creating first Admin Role and creating a default Admin User
if (!roleManager.RoleExists("SuperAdmin"))
{
bool admiRoleIsCreated = roleManager.RoleExists("Admin");
// first we create Admin rool
var role = new Microsoft.AspNet.Identity.EntityFramework.IdentityRole();
role.Name = "SuperAdmin";
roleManager.Create(role);
var role2 = new Microsoft.AspNet.Identity.EntityFramework.IdentityRole();
if (!admiRoleIsCreated)
{
role2.Name = "Admin";
roleManager.Create(role2);
}
//Here we create a Admin super user who will maintain the website
var user = new ApplicationUser();
user.UserName = "******";
//set System Administrator email for Account
user.Email = "*****@*****.**";
//set System Administrator Password for Account
string userPWD = "Trixter34!";
var chkUser = UserManager.Create(user, userPWD);
//Add default User to Role Admin
if (chkUser.Succeeded)
{
var employee = new Employee()
{
UserId = user.Id, FirstName = user.UserName, LastName = user.Email
};
TalentContext _context = new TalentContext();
_context.Employees.Add(employee);
_context.SaveChanges();
var result1 = UserManager.AddToRole(user.Id, "SuperAdmin");
if (!admiRoleIsCreated)
{
var result2 = UserManager.AddToRole(user.Id, "Admin");
}
var userrole = UserManager.GetRoles(user.Id);
if (userrole.Count > 0)
{
//redirect to Employees Page
}
}
}
}
public ActionResult _SubmitInterview(Interview data)
{
using (var db = new TalentContext())
{
var interview = db.Interviews.Find(data.InterviewID);
interview.ScheduledDate = data.ScheduledDate;
db.SaveChanges();
}
return(RedirectToAction("manage_application/" + data.JobApplicationID));
}
public ActionResult Create(OfficePosition position, List <JobRequirement> Line, IEnumerable <BusinessLogic.UpdatedDomain.ApplicantEvaluationMetrics> applicantmetrics)
{
// position.IsAvailable = false;
position.DateCreated = DateTime.Now;
position.Reqirements = "";
if (!ModelState.IsValid)
{
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();
ViewBag.Error = "Form was not Submitted. Please fill all Mandatory Fields";
}
return(View(position));
}
try
{
using (var db = new TalentContext())
{
db.OfficePositions.Add(position);
db.SaveChanges();
var quals = db.JobQualifications.ToList();
foreach (var item in Line)
{
item.QualificationID = quals.Where(x => x.QualificationCode == item.QualificationCode &&
x.QualificationType == item.QualificationType).FirstOrDefault().ID;
item.OfficePositionID = position.OfficePositionID;
item.OfficePosition = position;
db.JobRequirements.Add(item);
}
db.SaveChanges();
//Insert Logic to prevent adding the same role title 2 or more times to a single department
}
return(RedirectToAction("jobmanager", "Admin"));
}
catch
{
return(View("Error"));
}
}
public ActionResult Edit([Bind(Include = "ID,EmployeeId,EmployeeName,StartDate,EndDate,Duration,ApplyDate,Status")] ManageEmployeeLeave manageEmployeeLeave)
{
if (ModelState.IsValid)
{
db.Entry(manageEmployeeLeave).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(manageEmployeeLeave));
}
public ActionResult _ConfirmApplicantOnboarding(int requisitionid, int applicationid)
{
using (var db = new TalentContext())
{
var application = db.JobApplications.Where(x => x.JobApplicationID == applicationid).First();
application.ApplicationStatus = ApplicationStatus.Onboarding;
db.SaveChanges();
}
return(RedirectToAction("onboarding", "Admin", new { requisitionid = requisitionid, applicationid = applicationid }));
}
public ActionResult Edit([Bind(Include = "ID,EmployeeId,EmployeeName,StartDate,EndDate,Duration,ApplyDate,Status,LeaveType,LeaveLimit,LeaveType_Limit_ID")] ManageEmployeeLeave manageEmployeeLeave)
{
if (ModelState.IsValid)
{
// manageEmployeeLeave.TotalLeaveAvailable = manageEmployeeLeave.Duration;
db.Entry(manageEmployeeLeave).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(manageEmployeeLeave));
}
