public List <JobGroupBySkill> GroupJobBySkill(List <JobSearchResult> list)
{
List <JobGroupBySkill> data = new List <JobGroupBySkill>();
var grouped = list.OrderBy(x => x.ma_cong_viec)
.GroupBy(x => x.ma_cong_viec);
foreach (var iGrouped in grouped)
{
JobSearchResult first = iGrouped.First();
JobGroupBySkill temp = new JobGroupBySkill
{
ma_cong_viec = iGrouped.Key,
ten_cong_viec = first.ten_cong_viec,
ma_doanh_nghiep = first.ma_doanh_nghiep,
ten_cong_ty = first.ten_cong_ty,
dia_chi = first.dia_chi,
don_vi_tien_te = first.don_vi_tien_te,
luong_toi_thieu = first.luong_toi_thieu,
luong_toi_da = first.luong_toi_da,
ngay_bat_dau = first.ngay_bat_dau,
skills = new List <string>(),
mo_ta_cong_viec = first.mo_ta_cong_viec,
};
temp.skills.AddRange(iGrouped.Select(x => x.ten_skill).ToList());
data.Add(temp);
}
return(data);
}
public ActionResult JobSearchResult()
{
List <JobSearchResult> result = new List <JobSearchResult>();
string connectionString = ConfigurationManager.ConnectionStrings["dbconnection"].ConnectionString;
SqlConnection conn = new SqlConnection(connectionString);
using (conn)
{
SqlCommand cmd = new SqlCommand {
Connection = conn
};
conn.Open();
cmd.CommandText = @"SELECT CJ.Id, CP.Id, CJD.Job_Name, CJD.Job_Descriptions, CL.City_Town, CL.State_Province_Code, CD.Company_Name, CP.Company_Website FROM Company_Profiles AS CP INNER JOIN Company_Descriptions AS CD ON CP.Id = CD.Company INNER JOIN Company_Locations AS CL ON CL.Company = CP.Id INNER JOIN Company_Jobs AS CJ ON CJ.Company = CP.Id INNER JOIN Company_Jobs_Descriptions AS CJD ON CJD.Job = CJ.Id WHERE CD.LanguageID = 'EN' AND CJD.Job_Name LIKE '%'+@JobTitle+'%' AND CL.City_Town LIKE '%'+@Location+'%'";
cmd.Parameters.AddWithValue("@JobTitle", (TempData["JobTitle"] != null)? TempData["JobTitle"].ToString().Trim():"");
TempData.Keep();
cmd.Parameters.AddWithValue("@Location", (TempData["Location"] != null)? TempData["Location"].ToString().Trim():"");
TempData.Keep();
try
{
SqlDataReader IDreader = cmd.ExecuteReader();
while (IDreader.Read())
{
IDataRecord myreader = (IDataRecord)IDreader;
JobSearchResult x = new JobSearchResult
{
JobID = (Guid)myreader[0],
CompID = (Guid)myreader[1],
JobName = myreader[2].ToString(),
JobDescription = myreader[3].ToString(),
City = myreader[4].ToString(),
State = myreader[5].ToString(),
CompanyName = myreader[6].ToString(),
Website = myreader[7].ToString(),
Applied = false
};
try
{
ApplicantJobApplicationPoco poco = _appliedLogic.GetAll().Where <ApplicantJobApplicationPoco>(T => (T.Applicant == (Guid)TempData["Applicant"] && T.Job == x.JobID) ? true : false).FirstOrDefault();
TempData.Keep();
x.Applied = (poco != null) ? true : false;
result.Add(x);
}
catch { }
finally {
TempData.Keep();
}
}
IDreader.Close();
conn.Close();
}
catch { }
finally { conn.Close(); }
}
conn.Close();
return(View(result));
}
/// <summary>
/// Reads the jobs from pages of data provided by the <see cref="IJobsDataProvider"/>
/// </summary>
/// <returns></returns>
public async Task <JobSearchResult> ReadJobs(JobSearchQuery query)
{
if (_jobResultsParser == null)
{
throw new InvalidOperationException("You must specify jobResultsParser when creating this instance to read jobs");
}
var jobs = new JobSearchResult()
{
Jobs = new List <Job>()
};
var currentPage = 1;
while (true)
{
Stream stream = null;
try
{
stream = await ReadJobsFromTalentLink(currentPage, query).ConfigureAwait(false);
if (_saveHtml)
{
stream = SaveHtml(query, currentPage, stream);
}
var parseResult = await _jobResultsParser.Parse(stream).ConfigureAwait(false);
if (parseResult.Jobs.Count > 0)
{
jobs.Jobs.AddRange(parseResult.Jobs);
}
if (parseResult.IsLastPage)
{
break;
}
else
{
currentPage++;
}
}
finally
{
stream?.Dispose();
}
}
return(jobs);
}
/// <summary>
/// Reads the jobs from pages of data provided by the <see cref="IJobsDataProvider"/>
/// </summary>
/// <returns></returns>
public async Task <JobSearchResult> ReadJobs(JobSearchQuery query)
{
if (_jobResultsParser == null)
{
throw new InvalidOperationException("You must specify jobResultsParser when creating this instance to read jobs");
}
var jobs = new JobSearchResult()
{
Jobs = new List <Job>()
};
foreach (var resultsUrl in _resultsUrls)
{
var stream = await ReadXml(resultsUrl, _proxy).ConfigureAwait(false);
jobs.Jobs.AddRange((await _jobResultsParser.Parse(stream)).Jobs);
}
return(jobs);
}
public JobSearchResult GetAllJobsFromByTerm(string searchedTerm, int page)
{
int count = this.usitData.Jobs.All
.Where(j => j.JobTitle.Contains(searchedTerm) || j.JobDescription.Contains(searchedTerm) || j.CompanyName.Contains(searchedTerm))
.Count();
int pageSize = 4;
if (count % pageSize > 0)
{
count = count / pageSize + 1;
}
else
{
count = count / pageSize;
}
int skip = page * pageSize;
if (page > 0)
{
page = (page - 1) * pageSize;
}
var jobs = this.usitData.Jobs.All
.Where(j => j.JobTitle.Contains(searchedTerm) || j.JobDescription.Contains(searchedTerm) || j.CompanyName.Contains(searchedTerm))
.OrderBy(j => j.JobTitle)
.Include(j => j.City)
.Skip(skip)
.Take(pageSize)
.ToList();
JobSearchResult result = new JobSearchResult()
{
Jobs = jobs,
Count = count
};
return(result);
}
/// <summary>
/// Gets the jobs matching the supplied query
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public Task <JobSearchResult> ReadJobs(JobSearchQuery query)
{
var examineQuery = _searcher.CreateSearchCriteria(BooleanOperation.And);
examineQuery.GroupedOr(new[] { "location" }, query.Locations.ToArray())
.And().GroupedOr(new[] { "contractType" }, query.ContractTypes.ToArray())
.And().GroupedOr(new[] { "salaryDisplay" }, query.PayGrades.ToArray())
.And().GroupedOr(new[] { "workPattern" }, query.WorkPatterns.ToArray())
.And().GroupedOr(new[] { "jobType" }, query.JobTypes.ToArray())
.And().GroupedOr(new[] { "department" }, query.Departments.ToArray())
.And().GroupedOr(new[] { "organisation" }, query.Organisations.ToArray());
// If any of the GroupedOr values are empty, Examine generates a Lucene query that requires no field set to no value: +()
// so we need to remove that and use the rest of the generated Lucene query
var generatedQuery = examineQuery.ToString();
generatedQuery = generatedQuery.Substring(34, generatedQuery.Length - 36);
var modifiedQuery = generatedQuery.Replace("+()", String.Empty);
if (_keywordsQueryBuilder != null)
{
// Search for title keywords by building up a clause that looks for any of the keywords to be present
// in the job title
modifiedQuery += _keywordsQueryBuilder.AnyOfTheseTermsInThisField(query.KeywordsInTitle ?? String.Empty, new SearchField()
{
FieldName = "title"
}, true);
// Search for keywords by building up a clause that looks for all of the keywords to be present
// in any one of the specified fields.
modifiedQuery += _keywordsQueryBuilder.AllOfTheseTermsInAnyOfTheseFields(query.Keywords ?? String.Empty, new[]
{
new SearchField()
{
FieldName = "reference"
},
new SearchField()
{
FieldName = "title", Boost = 2
},
new SearchField()
{
FieldName = "organisation"
},
new SearchField()
{
FieldName = "location"
},
new SearchField()
{
FieldName = "jobType"
},
new SearchField()
{
FieldName = "contractType"
},
new SearchField()
{
FieldName = "department"
},
new SearchField()
{
FieldName = "fullText", Boost = 0.5
}
}, true);
}
// For the salary ranges we need a structure that Examine's fluent API can't build, so build the raw Lucene query instead
if (_salaryQueryBuilder != null)
{
modifiedQuery += _salaryQueryBuilder.SalaryIsWithinAnyOfTheseRanges(query.SalaryRanges);
}
// Append a requirement that the job must not have closed
if (query.ClosingDateFrom.HasValue)
{
modifiedQuery += " +closingDate:[" + query.ClosingDateFrom.Value.ToString("yyyyMMdd000000000") + " TO 30000000000000000]";
}
var luceneQuery = _searcher.CreateSearchCriteria(BooleanOperation.And);
var sortField = String.Empty;
switch (query.SortBy)
{
case JobSearchQuery.JobsSortOrder.JobTitleAscending:
case JobSearchQuery.JobsSortOrder.JobTitleDescending:
sortField = "titleDisplay";
break;
case JobSearchQuery.JobsSortOrder.LocationAscending:
case JobSearchQuery.JobsSortOrder.LocationDescending:
sortField = "locationDisplay";
break;
case JobSearchQuery.JobsSortOrder.SalaryRangeAscending:
case JobSearchQuery.JobsSortOrder.SalaryRangeDescending:
sortField = "salarySort";
break;
case JobSearchQuery.JobsSortOrder.WorkPatternAscending:
case JobSearchQuery.JobsSortOrder.WorkPatternDescending:
sortField = "workPattern";
break;
case JobSearchQuery.JobsSortOrder.ClosingDateAscending:
case JobSearchQuery.JobsSortOrder.ClosingDateDescending:
sortField = "closingDate";
break;
}
if (String.IsNullOrWhiteSpace(modifiedQuery))
{
modifiedQuery = "__NodeId:[0 TO 999999]";
}
try
{
switch (query.SortBy)
{
case JobSearchQuery.JobsSortOrder.JobTitleAscending:
case JobSearchQuery.JobsSortOrder.LocationAscending:
case JobSearchQuery.JobsSortOrder.SalaryRangeAscending:
case JobSearchQuery.JobsSortOrder.WorkPatternAscending:
case JobSearchQuery.JobsSortOrder.ClosingDateAscending:
luceneQuery.RawQuery(modifiedQuery).OrderBy(sortField);
break;
case JobSearchQuery.JobsSortOrder.JobTitleDescending:
case JobSearchQuery.JobsSortOrder.LocationDescending:
case JobSearchQuery.JobsSortOrder.SalaryRangeDescending:
case JobSearchQuery.JobsSortOrder.WorkPatternDescending:
case JobSearchQuery.JobsSortOrder.ClosingDateDescending:
luceneQuery.RawQuery(modifiedQuery).OrderByDescending(sortField);
break;
default:
luceneQuery.RawQuery(modifiedQuery);
break;
}
var results = _searcher.Search(luceneQuery);
var searchResult = new JobSearchResult()
{
TotalJobs = results.Count()
};
IEnumerable <SearchResult> selectedResults;
if (query.PageSize.HasValue)
{
selectedResults = results.Skip((query.CurrentPage - 1) * query.PageSize.Value).Take(query.PageSize.Value);
}
else
{
selectedResults = results;
}
searchResult.Jobs = BuildJobsFromExamineResults(selectedResults);
return(Task.FromResult(searchResult));
}
catch (ParseException exception)
{
exception.Data.Add("Reference", query.JobReference);
exception.Data.Add("Job types", String.Join(",", query.JobTypes.ToArray()));
exception.Data.Add("Keywords in title", query.KeywordsInTitle);
exception.Data.Add("Keywords", query.Keywords);
exception.Data.Add("Locations", String.Join(",", query.Locations.ToArray()));
exception.Data.Add("Organisations", String.Join(",", query.Organisations.ToArray()));
exception.Data.Add("Salary ranges", String.Join(",", query.SalaryRanges.ToArray()));
exception.Data.Add("Contract types", String.Join(",", query.ContractTypes.ToArray()));
exception.Data.Add("Work patterns", String.Join(",", query.WorkPatterns.ToArray()));
exception.Data.Add("Sort", query.SortBy);
exception.Data.Add("Generated query", modifiedQuery);
exception.ToExceptionless().Submit();
var errorForLog = new StringBuilder($"Lucene.net could not parse {modifiedQuery} generated from parameters:").Append(Environment.NewLine)
.Append("Reference:").Append(query.JobReference).Append(Environment.NewLine)
.Append("Job types:").Append(String.Join(",", query.JobTypes.ToArray())).Append(Environment.NewLine)
.Append("Keywords in title:").Append(query.KeywordsInTitle).Append(Environment.NewLine)
.Append("Keywords:").Append(query.Keywords).Append(Environment.NewLine)
.Append("Locations:").Append(String.Join(",", query.Locations.ToArray())).Append(Environment.NewLine)
.Append("Organisations:").Append(String.Join(",", query.Organisations.ToArray())).Append(Environment.NewLine)
.Append("Salary ranges:").Append(String.Join(",", query.SalaryRanges.ToArray())).Append(Environment.NewLine)
.Append("Contract types:").Append(String.Join(",", query.ContractTypes.ToArray())).Append(Environment.NewLine)
.Append("Work patterns:").Append(String.Join(",", query.WorkPatterns.ToArray())).Append(Environment.NewLine)
.Append("Sort:").Append(query.SortBy).Append(Environment.NewLine);
_log.Error(errorForLog.ToString());
return(Task.FromResult(new JobSearchResult()));
}
}
