[EnableCors("any")] //解决跨域问题
public dynamic Post(JObject json)
{
JobDBContext jobdb = new JobDBContext();
List <JobInfo> l = new List <JobInfo>();
string query = json["query"].ToString();
int page = Convert.ToInt32(json["page"]);
int limit = Convert.ToInt32(json["limit"]);
if (string.IsNullOrEmpty(query))
{
l = jobdb.JobInfo.OrderByDescending(x => x.JobDate).ToList();
}
else
{
l = jobdb.JobInfo.Where(x => x.JobTitle.Contains(query)).OrderByDescending(x => x.JobDate).ToList();
}
//.Skip((page - 1) * limit).Take(limit)
var j = new {
list = l.Skip((page - 1) * limit).Take(limit),
count = l.Count(),
};
return(j);
}
public List <JobInfo> Post()
{
JobDBContext jobdb = new JobDBContext();
List <JobInfo> list = jobdb.JobInfo.ToList();
return(list);
}
[EnableCors("any")] //解决跨域问题
public dynamic Post(JObject Job)
{
JobDBContext jobdb = new JobDBContext();
int JobId = Convert.ToInt32(Job["JobId"]);
JobInfo j = jobdb.JobInfo.Where(x => x.JobId == JobId).FirstOrDefault();
List <JobImg> i = jobdb.JobImg.Where(x => x.JobId == JobId).ToList();
var json = new {
jobinfo = j,
jobimg = i
};
return(json);
}
public UnitOfWork(JobDBContext _context)
{
context = _context;
Awards = new AwardRepository(context);
FamilyMembers = new FamilyMemberRepository(context);
FamilyMemberRoles = new FamilyMemberRoleRepository(context);
Families = new FamilyRepository(context);
Goals = new GoalRepository(context);
JobCategories = new JobCategoryRepository(context);
Jobs = new JobRepository(context);
JobTemplates = new JobTemplateRepository(context);
MemberJobs = new MemberJobRepository(context);
MemberGoals = new MemberGoalRepository(context);
}
public JobTemplateRepository(JobDBContext context) : base(context)
{
}
public FamilyMemberRepository(JobDBContext context) : base(context)
{
}
public GoalRepository(JobDBContext context) : base(context)
{
}
public JobCategoryRepository(JobDBContext context) : base(context)
{
}
public ActionResult ApplicantMatches()
{
MatchDBContext dbMatch = new MatchDBContext();
JobDBContext dbJob = new JobDBContext();
Applicant applicant = db.Applicants.Find(User.Identity.Name);
var requriedEducationarray = applicant.Education.Split('|');
var requriedIntrestedJobsarray = applicant.IntrestedJobs.Split('|');
//var test = dbApplicant.Applicants.Any(str => str.Education.Split('|').Intersect(education.Split('|')).Any());
var result = from p in dbJob.Jobs
where requriedEducationarray.Any(val => p.Education.Contains(val))
select p;
//type=job
var allPossibleJobs = from p in result
where requriedIntrestedJobsarray.Any(val => p.Tags.Contains(val))
select p;
//Job matches that the user already has
var thisApplicantMatches = dbMatch.Matches.Where(x => (x.ApplicantEmailAddress.Equals(User.Identity.Name)));
//Convert the jobs into matches
List <Match> matches = new List <Match>();
foreach (var job in allPossibleJobs)
{
var educationListOfCurrentApplicant = job.Education.Split('|');
var countSimilarityEducation = requriedEducationarray.Intersect(educationListOfCurrentApplicant).Count();
var intrestedJobsListOfCurrentApplicant = job.Tags.Split('|');
var countSimilarityIntrestedJobs = requriedIntrestedJobsarray.Intersect(intrestedJobsListOfCurrentApplicant).Count();
var startScore = 5;
var a1 = requriedEducationarray.Length - countSimilarityEducation;
var a2 = requriedIntrestedJobsarray.Length - countSimilarityIntrestedJobs;
var overAll = startScore - (a1 + a2);
Match match = new Match
{
EmployerEmailAddress = job.EmployerEmailAddress,
JobTitle = job.JobTitle,
PublishDate = job.PublishDate,
ApplicantEmailAddress = User.Identity.Name,
ApplicantName = applicant.firstName + " " + applicant.lastName,
overAllScore = overAll,
acceptedByApplicant = false,
acceptedByEmployer = false,
rejectedByApplicant = false,
rejectedByEmployer = false
};
matches.Add(match);
}
//Now start removing existing matches
//var newMatches = matches.Where(y => (thisApplicantMatches.Any(z => z.JobTitle != y.JobTitle))&&
//thisApplicantMatches.Any(z => z.PublishDate != y.PublishDate));
//var matchesAll = thisApplicantMatches.Select(a => new { a.JobTitle, a.EmployerEmailAddress, a.PublishDate });
//var toAddMatches = matches.Where(a => !matchesAll.Contains(new { a.JobTitle, a.EmployerEmailAddress, a.PublishDate })).ToList();
var toAddMatches = matches.Where(sc => !thisApplicantMatches.Any(dc => dc.JobTitle == sc.JobTitle &&
dc.PublishDate == sc.PublishDate && dc.EmployerEmailAddress == sc.EmployerEmailAddress));
foreach (var item in toAddMatches)
{
dbMatch.Matches.Add(item);
}
dbMatch.SaveChanges();
var thisApplicantMatches2 = dbMatch.Matches.Where(x => (x.ApplicantEmailAddress.Equals(User.Identity.Name)));
// Only showing matches which were not rejected by this employer
var filteredBasedOnRejectedByEmployer = thisApplicantMatches2.Where(x => x.rejectedByEmployer == false);
// Only showing matches which were not rejected by an applicant
var filteredBasedOnRejectedByApplicantList = filteredBasedOnRejectedByEmployer.Where(x => x.rejectedByEmployer == false);
//return View(thisApplicantMatches);
return(View(filteredBasedOnRejectedByApplicantList.ToList()));
}
public Repository(JobDBContext _context) // check on interface later
{
this.context = _context;
}
public MemberJobRepository(JobDBContext context) : base(context)
{
}
public AwardRepository(JobDBContext context) : base(context)
{
}
public JobController(JobDBContext context)
{
_context = context;
}
public JobRepository(JobDBContext userDBContext)
{
_jobDBContext = userDBContext;
}
