public IActionResult EditJobPosting(JobPosting jPosting, IEnumerable <int> checkResponse)
{
if (ModelState.IsValid)
{
// method needs to be implemented in repository
postRepository.AddPosting(jPosting);
return(RedirectToAction("Index"));
}
else
{
return(View(jPosting));
}
}
public IHttpActionResult AddJobPosting([FromBody] JobPosting jobposting)
{
//Will Validate according to data annotations specified on model
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.jobPostings.Add(jobposting);
db.SaveChanges();
return(Ok(jobposting.jobPostingId));
}
public async Task <JobPosting> Put(int id, JobPosting jobPosting)
{
try
{
await _ctx.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(!ExistsById(id) ? null : jobPosting);
}
return(jobPosting);
}
public ActionResult Edit([Bind(Include = "Id,JobTypeId,CompanyId,JobLocationId,UserAccountId,CreatedDate,JobTitle,JobDescription,NumOpenings,HoursPerWeek,WageSalary,StartDate,EndDate,Qualifications,ApplicationInstructions,ApplicationWebsite,PostingDate,ExpirationDate,Enabled,NumViews")] JobPosting jobPosting)
{
if (ModelState.IsValid)
{
db.Entry(jobPosting).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Id = new SelectList(db.Companies, "Id", "Name", jobPosting.Id);
ViewBag.JobLocationId = new SelectList(db.JobLocations, "Id", "Address1", jobPosting.JobLocationId);
ViewBag.JobTypeId = new SelectList(db.JobTypes, "Id", "Name", jobPosting.JobTypeId);
return(View(jobPosting));
}
public ActionResult Create([Bind(Include = "JobPostingID,JobID,BranchID,DatePosted,CreatedBy,CreatedDate,LastEditedBy,LastEditedDate,IsActive,HireMgrEmail")] JobPosting jobPosting)
{
if (ModelState.IsValid)
{
db.JobPostings.Add(jobPosting);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.BranchID = new SelectList(db.Branches, "BranchID", "BranchName", jobPosting.BranchID);
ViewBag.JobID = new SelectList(db.Jobs, "jobID", "JobTitle", jobPosting.JobID);
return(View(jobPosting));
}
public ActionResult Edit([Bind(Include = "Id,JobTitle,JobDescription,UserId,CultureId,SkillRequirementId")] JobPosting jobPosting)
{
if (ModelState.IsValid)
{
db.Entry(jobPosting).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CultureId = new SelectList(db.Cultures, "Id", "Id", jobPosting.CultureId);
ViewBag.SkillRequirementId = new SelectList(db.SkillRequirements, "Id", "Id", jobPosting.SkillRequirementId);
ViewBag.UserId = new SelectList(db.Users, "Id", "FirstName", jobPosting.UserId);
return(View(jobPosting));
}
public ActionResult Show(int?id)
{
if ((id == null) || (db.JobPostings.Find(id) == null))
{
return(NotFound());
}
string query = "select * from jobposting where jobpostingid=@id";
SqlParameter param = new SqlParameter("@id", id);
JobPosting jobpostshow = db.JobPostings.Include(jp => jp.Hospital).Include(jp => jp.Department).SingleOrDefault(h => h.JobPostingID == id);
return(View(jobpostshow));
}
public async Task <bool> Exists(TestCheckDTO tcDTO)
{
JobPosting jobPosting = await _ctx.JobPostings
.Where(x => x.Description.Equals(tcDTO.description) == true &&
x.Title.Equals(tcDTO.title) == true)
.FirstOrDefaultAsync();
if (jobPosting != null)
{
return(true);
}
return(false);
}
// GET: JobPosting/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new StatusCodeResult(400));
}
JobPosting jobposting = db.JobPostings.Find(id);
if (jobposting == null)
{
return(NotFound());
}
return(View(jobposting));
}
private JobPosting UpdateJobPosting(JobPosting job, JobPosting jobToUpdate)
{
jobToUpdate.JobTitle = job.JobTitle;
jobToUpdate.InterviewerFirstName = job.InterviewerFirstName;
jobToUpdate.InterviewerLastName = job.InterviewerLastName;
jobToUpdate.InterviewerEmail = job.InterviewerEmail;
jobToUpdate.InterviewerPhoneNumber = job.InterviewerPhoneNumber;
jobToUpdate.CompanyName = job.CompanyName;
jobToUpdate.PostedComp = job.PostedComp;
jobToUpdate.DateApplied = job.DateApplied;
jobToUpdate.ApplicationStatus = job.ApplicationStatus;
job.ConversationNotes = job.ConversationNotes;
return(jobToUpdate);
}
public async Task <IActionResult> Create([Bind("ID,Title,Description,Salary,Company")] JobPosting jobPosting)
{
if (ModelState.IsValid)
{
string currentUserId = User.Identity.GetUserId();
IdentityUser currentUser = _context.Users.FirstOrDefault(x => x.Id == currentUserId);
jobPosting.User = currentUser;
_context.Add(jobPosting);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(jobPosting));
}
public IHttpActionResult DeleteJobPosting(int id)
{
JobPosting JobPosting = db.JobPosting.Find(id);
if (JobPosting == null)
{
return(NotFound());
}
db.JobPosting.Remove(JobPosting);
db.SaveChanges();
return(Ok(JobPosting));
}
internal JobPosting GetJobPosting(int jobPostingID)
{
JobPosting aJobPosting = new JobPosting();
SqlConnection con;
con = new SqlConnection();
con.ConnectionString = ConfigurationManager.ConnectionStrings["key"].ConnectionString;
SqlCommand cmd;
cmd = new SqlCommand();
cmd.CommandType = CommandType.StoredProcedure;
cmd.Connection = con;
cmd.CommandText = "GetJobPosting";
SqlParameter JobPostingID;
JobPostingID = new SqlParameter();
JobPostingID.ParameterName = "@JobPostingID";
JobPostingID.SqlDbType = SqlDbType.Int;
JobPostingID.Direction = ParameterDirection.Input;
JobPostingID.Value = jobPostingID;
cmd.Parameters.Add(JobPostingID);
con.Open();
SqlDataReader reader;
reader = cmd.ExecuteReader();
while (reader.Read())
{
aJobPosting.JobPostingID = Convert.ToInt32(reader["JobPostingID"]);
aJobPosting.EmployerPhone = reader["EmployerPhone"].ToString();
aJobPosting.CompanyName = reader["CompanyName"].ToString();
aJobPosting.Description = reader["Description"].ToString();
aJobPosting.Date = DateTime.Parse(reader["Date"].ToString());
aJobPosting.Skillsets = GetJobSkills(jobPostingID);
aJobPosting.ProfessionID = int.Parse(reader["ProfessionID"].ToString());
aJobPosting.RegionID = int.Parse(reader["RegionID"].ToString());
}
con.Close();
return(aJobPosting);
}
// GET: JobPostings/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
JobPosting jobPosting = db.JobPostings.Find(id);
if (jobPosting == null)
{
return(HttpNotFound());
}
return(View(jobPosting));
}
public ActionResult MarkListingAsFailedImport(string id)
{
JobPostingClient jpc = new JobPostingClient();
JobPosting posting = new JobPosting();
posting.PostedDateTime = DateTime.UtcNow;
posting.ReferenceId = id;
posting.Source = "TEN";
posting.JobTitle = "FAILED IMPORT";
jpc.AddNewItem(posting);
return(RedirectToAction("new20"));
}
public string GetToolTipText(int contextKey)
{
try
{
//根据职位编号获取职位对象
JobPosting job = JobPosting.GetPosting(contextKey);
//返回职位描述
return(job.Description);
}
catch (Exception ex)
{
return(ex.Message);
}
}
public async Task <JobPosting> DeleteById(int id)
{
JobPosting jobPosting = await _ctx.JobPostings.FindAsync(id);
if (jobPosting == null)
{
return(null);
}
_ctx.JobPostings.Remove(jobPosting);
await _ctx.SaveChangesAsync();
return(jobPosting);
}
//Jobseeker responds to a jobposting
// GET: Application/ NewSubmission
public ActionResult NewSubmission(Guid?id)
{
//find user logged in
var userId = User.Identity.GetUserId();
Jobseeker jobseeker = db.Jobseekers.FirstOrDefault(j => j.ApplicationId == userId);
//find jobPosting that user clicked apply on
JobPosting jobPostingRespondingTo = db.JobPostings.Where(i => i.JobPostingId == id).SingleOrDefault();
new Application {
ApplicationId = Guid.NewGuid()
};
return(View(new Application {
ApplicationId = Guid.NewGuid(), JobPostingId = jobPostingRespondingTo.JobPostingId
}));
}
public IActionResult Details(int?id)
{
if (id == null) //JobPostingID not specified
{
return(View("Error", new String[] { "JobPostingID not specified - which job posting do you want to view?" }));
}
JobPosting jobPosting = _context.JobPostings.Include(j => j.Category).FirstOrDefault(j => j.JobPostingID == id);
if (jobPosting == null) //Job posting does not exist in database
{
return(View("Error", new String[] { "Job posting not found in database" }));
}
//if code gets this far, all is well
return(View(jobPosting));
}
// GET: JobPostings
/*public ActionResult Index()
* {
* var jobPostings = db.JobPostings.Include(j => j.Company).Include(j => j.JobLocation).Include(j => j.JobType).Include(j => j.Company.BusinessIndustry);
* return View(jobPostings.ToList());
* }*/
// GET: JobPostings/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
JobPosting jobPosting = db.JobPostings.Include(j => j.Company).Include(j => j.JobLocation).Include(j => j.JobType).Single(j => j.Id == id);
if (jobPosting == null)
{
return(HttpNotFound());
}
return(View(jobPosting));
}
public async Task <JobPosting> Create(JobPosting jobPosting)
{
try
{
jobPosting.Id = 0;
await _ctx.JobPostings.AddAsync(jobPosting);
await _ctx.SaveChangesAsync();
}
catch (Exception ex)
{
Console.WriteLine(ex.InnerException);
}
return(jobPosting);
}
public async Task <bool> InsertJobPosting(JobPosting jobPosting)
{
bool inserted = false;
try
{
await _jobPostings.InsertOneAsync(jobPosting);
inserted = true;
return(inserted);
} catch
{
return(inserted);
}
}
public async Task <JobPosting> GetJobPosting(string url)
{
JobPosting posting = null;
try
{
posting = await _jobPostings.Find(x => x.URL == url).FirstOrDefaultAsync();
return(posting);
}
catch (Exception e)
{
return(null);
}
}
// GET: JobPostings/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
JobPosting jobPosting = db.JobPostings.Find(id);
if (jobPosting == null)
{
return(HttpNotFound());
}
ViewBag.EmployerID = new SelectList(db.Employers, "EmployerID", "Name", jobPosting.EmployerID);
return(View(jobPosting));
}
public async Task <bool> UpdateJobPosting(JobPosting jobPosting)
{
bool updated = false;
try
{
await _jobPostings.ReplaceOneAsync(x => x.URL == jobPosting.URL, jobPosting);
updated = true;
return(updated);
} catch
{
return(updated);
}
}
public async Task <IActionResult> OnGetAsync(Guid?id)
{
if (id == null)
{
return(NotFound());
}
JobPosting = await _context.JobPosting.FirstOrDefaultAsync(m => m.JobId == id);
if (JobPosting == null)
{
return(NotFound());
}
return(Page());
}
public ActionResult Create([Bind(Include = "Id,JobTitle,JobDescription,UserId,CultureId,SkillRequirementId")] JobPosting jobPosting)
{
if (ModelState.IsValid)
{
jobPosting.Id = Guid.NewGuid();
db.JobPostings.Add(jobPosting);
db.SaveChanges();
return(RedirectToAction("Details", new { id = jobPosting.Id }));
}
ViewBag.CultureId = new SelectList(db.Cultures, "Id", "Id", jobPosting.CultureId);
ViewBag.SkillRequirementId = new SelectList(db.SkillRequirements, "Id", "Id", jobPosting.SkillRequirementId);
ViewBag.UserId = new SelectList(db.Users, "Id", "FirstName", jobPosting.UserId);
return(View(jobPosting));
}
public static JobInfo JobInformation(this JobInfo jobInfo, JobPosting jobPosting)
{
return(new JobInfo
{
CompanyEmail = jobPosting.Client.User.Email,
CompanyName = jobPosting.Client.User.FirstName,
AllApplicationsCount = jobPosting.Applications.Count,
DateTo = jobPosting.DateTo.ToString("d", DateTimeFormatInfo.InvariantInfo),
Id = jobPosting.Id,
JobTitle = jobPosting.Title,
JobType = jobPosting.EmpCategory.ToString(),
Location = jobPosting.Location,
Status = jobPosting.Status.ToString(),
});
}
public async Task <IActionResult> Create([Bind("Id,JobTitle,InterviewerFirstName,InterviewerLastName,InterviewerEmail,InterviewerPhoneNumber,CompanyName,PostedComp,DateApplied,ApplicationStatus,RecruiterId,CustomerId")] JobPosting job)
{
if (ModelState.IsValid)
{
var userId = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
var customer = _repo.Customer.GetCustomer(userId);
job.CustomerId = customer.Id;
_context.Add(job);
await _context.SaveChangesAsync();
return(RedirectToAction("Index", "Customers"));
}
ViewData["CustomerId"] = new SelectList(_context.Customers, "Id", "Id", job.CustomerId);
return(View(job));
}
public async Task <GeneralResponse> CreateJobPosting(JobSubmit jobSubmit, int currentUserId)
{
var userRole = await _userManager.GetRolesAsync(await _userManager.FindByIdAsync(currentUserId.ToString()));
var response = new GeneralResponse();
if (jobSubmit.Id != currentUserId && !userRole.Contains(RoleConstants.ADMIN))
{
return(response.ErrorHandling(ErrorConstants.UnauthorizedAccess, _logger, jobSubmit.Id, currentUserId));
}
var company = new Client();
company = GetById <Client>(jobSubmit.Id);
var jobPost = new JobPosting()
{
Client = company,
};
jobPost = _mapper.Map(jobSubmit, jobPost);
bool dateFromParse = DateTime.TryParse(jobSubmit.DateFrom, out DateTime dateFrom);
bool dateToParse = DateTime.TryParse(jobSubmit.DateTo, out DateTime dateTo);
bool educationParse = Enum.TryParse(jobSubmit.Education, out EducationType education);
bool empCategoryParse = Enum.TryParse(jobSubmit.EmpCategory, out JobType empCategory);
if (!dateFromParse || !dateToParse || !educationParse || !empCategoryParse || dateFrom > dateTo)
{
return(response.ErrorHandling(ErrorConstants.InvalidInput, _logger, dateFrom, dateTo, education, empCategory));
}
jobPost.DateFrom = dateFrom;
jobPost.DateTo = dateTo;
jobPost.EmpCategory = empCategory;
jobPost.Education = education;
if (userRole.Contains(RoleConstants.CLIENT))
{
jobPost.Status = JobPostingStatus.Pending;
Create(jobPost, company.User.FirstName);
}
else
{
jobPost.Status = JobPostingStatus.Approved;
Create(jobPost, RoleConstants.ADMIN);
}
response.Succeeded = true;
return(response);
}
