private void SetOtherActivitiesToSkip(RecommendationNotification recommendation)
{
foreach (RecommendationNotification notification in RecommendationList)
{
if (recommendation == notification ||
recommendation.State == RecommendationState.Recommended)
{
continue;
}
recommendation.State = RecommendationState.Skip;
}
}
private void OnCheckRecommendFlagSuccess(string json, BaseCardData baseCard)
{
if (json.Contains("false"))
{
RecommendationNotification recommendation = GetRecommendation(baseCard);
if (null == recommendation)
{
throw new NullReferenceException("RecommendationController.OnCheckRecommendFlagSuccess - can't get card: " +
baseCard.title);
}
recommendation.State = RecommendationState.NeedToShow;
}
}
public void OnDismissedCard(BaseCardData baseCard)
{
_currentlyShowing = false;
if (baseCard == null)
{
return;
}
RecommendationNotification recommendation = GetRecommendation(baseCard);
if (recommendation != null)
{
recommendation.State = RecommendationState.Skip;
}
}
public void OnRecommendButton(BaseCardData baseCard)
{
Debug.Log("RecommendationController.OnRecommendButton - OK");
RecommendationNotification recommendation = GetRecommendation(baseCard);
if (null == recommendation)
{
throw new NullReferenceException("RecommendationController.OnRecommendButton - can't get card: " +
baseCard.title);
}
recommendation.State = RecommendationState.Recommended;
_currentlyShowing = false;
ITTGoogleAnalytics.Instance.googleAnalytics.LogEvent(new EventHitBuilder()
.SetEventCategory("Notification - Recommendation")
.SetEventAction("Click - Recommend Button")
.SetEventLabel("User clicked recommend button for card id: " + baseCard.id + " " + baseCard.title));
ITTDataCache.Instance.RetrieveProfileActivityID((Int64)baseCard.id, OnRetrieveProfileActivitySuccess, OnRetrieveProfileActivityFailure);
}
private void OnCheckRecommendFlagSuccessFillData(string json, BaseCardData baseCard, int counter)
{
//Debug.Log("NotificationManager.OnCheckRecommendFlagSuccess - Activity: " + baseCard.nid + " name: " + baseCard.title);
if ("{\"result\":[]}" == json)
{
return;
}
RecommendationNotification recommendation = GetRecommendation(baseCard);
if (recommendation == null)
{
throw new NullReferenceException(
"RecommendationController.OnCheckRecommendFlagSuccessFillData - cann't find activities: " + baseCard.title);
}
if (json.Contains("false"))
{
if (recommendation.State != RecommendationState.Skip &&
recommendation.State != RecommendationState.NeedToShow)
{
recommendation.State = RecommendationState.NeedToShow;
}
}
else
{
recommendation.State = RecommendationState.Recommended;
}
int lastIndex = historyCardList.Count - 1;
if (baseCard.id == historyCardList[lastIndex].id)
{
GetCardAndShowIt();
}
}
private void CheckAndAddData(List <BaseCardData> baseCard)
{
Debug.Log("RecommendationController.CheckAndAddData - OK");
foreach (BaseCardData baseCardData in baseCard)
{
if (RecommendationList.Any(card => card.ActivitiesName == baseCardData.title && card.Nid == baseCardData.id))
{
continue;
}
RecommendationNotification recommendation =
new RecommendationNotification(baseCardData.title, (Int64)baseCardData.id,
RecommendationState.NeedToShow,
baseCardData.dateTime);
RecommendationList.Add(recommendation);
}
if (null != RecommendationList)
{
// Update data cache
ITTDataCache.Instance.Data.UpdateDataEntry((int)DataCacheIndices.RECOMMENDATIONS, RecommendationList.ToArray(), false);
}
}
private void GetCardAndShowIt()
{
//Debug.Log("RecommendationController.GetCardAndShowIt - trying to get neccesary card for reccomendation: ");
RecommendationNotification recommendation = null;
double minMinutes = double.MaxValue;
DateTime now = DateTime.UtcNow;
foreach (RecommendationNotification notification in RecommendationList)
{
//Debug.Log("RecommendationController.GetCardAndShowIt - min minutes:" + minMinutes);
string nState = Enum.GetName(typeof(RecommendationState), notification.State);
if (notification.Date < now && now.Subtract(notification.Date).TotalMinutes < minMinutes &&
notification.State == RecommendationState.NeedToShow)
{
minMinutes = now.Subtract(notification.Date).TotalMinutes;
recommendation = notification;
break;
//Debug.Log("RecommendationController.GetCardAndShowIt - recommendation" + recommendation);
}
}
if (recommendation != null)
{
//Debug.Log("RecommendationController.GetCardAndShowIt - card title:" + recommendation.ActivitiesName + " date:" +
// recommendation.Date);
AddRecommendationToView(GetBaseCardData(recommendation));
}
else
{
Debug.Log("RecommendationController.GetCardAndShowIt - Cann't find the card:");
}
}
private BaseCardData GetBaseCardData(RecommendationNotification notification)
{
return(historyCardList.FirstOrDefault(baseCard => baseCard.id == notification.Nid));
}
private void CheckAndAddData(List<BaseCardData> baseCard)
{
Debug.Log("RecommendationController.CheckAndAddData - OK");
foreach (BaseCardData baseCardData in baseCard)
{
if (RecommendationList.Any(card => card.ActivitiesName == baseCardData.title && card.Nid == baseCardData.id))
{
continue;
}
RecommendationNotification recommendation =
new RecommendationNotification(baseCardData.title, (Int64)baseCardData.id,
RecommendationState.NeedToShow,
baseCardData.dateTime);
RecommendationList.Add(recommendation);
}
if (null != RecommendationList)
{
// Update data cache
ITTDataCache.Instance.Data.UpdateDataEntry((int)DataCacheIndices.RECOMMENDATIONS, RecommendationList.ToArray(), false);
}
}
private BaseCardData GetBaseCardData(RecommendationNotification notification)
{
return historyCardList.FirstOrDefault(baseCard => baseCard.id == notification.Nid);
}
private void SetOtherActivitiesToSkip(RecommendationNotification recommendation)
{
foreach (RecommendationNotification notification in RecommendationList)
{
if (recommendation == notification ||
recommendation.State == RecommendationState.Recommended)
continue;
recommendation.State = RecommendationState.Skip;
}
}
public void Execute()
{
if (ApplicationDbContext.options != null && !isRunning)
{
isRunning = true;
ApplicationDbContext appDbContext = new ApplicationDbContext(ApplicationDbContext.options);
try
{
// Load relevant constants from Configration file (appSettings)
int minQuestionsRecommend = ConfigurationManager.Instance.GetValue("MIN_QUESTIONS_RECOMMEND", Consts.MIN_QUESTIONS_RECOMMEND);
double maxQuestionRank = ConfigurationManager.Instance.GetValue("MAX_QUESTION_RANK", Consts.MAX_QUESTION_RANK);
double minDaysAfterRejected = ConfigurationManager.Instance.GetValue("NUM_DAYS_AFTER_REJECTED", Consts.NUM_DAYS_AFTER_REJECTED);
// Load relevant candidates (which enabled to send their resume) and solved at least MIN_QUESTIONS_RECOMMEND
IEnumerable <CandidateUser> candidates = appDbContext.Set <CandidateUser>()
.Include("Questions.Question")
.Where(c => c.AllowSendResume &&
c.Questions.Where(q => q.IsDone).Count() >= minQuestionsRecommend);
// Load relevant recruiters (which enabled to receive notifications)
Dictionary <string, RecruiterUser> recruiters = appDbContext.Set <RecruiterUser>()
.Include(r => r.Identity)
.Where(r => r.ReceiveNotifications).ToDictionary(r => r.IdentityId, r => r);
// Load only OPEN positions which created by recruiters who enabled notifications
IEnumerable <Position> positions = appDbContext.Set <Position>()
.Include(p => p.PositionSkills)
.Where(p => p.Status == (int)PositionStatus.Opened && recruiters.ContainsKey(p.CreatedBy));
// Load recommendations which is relevant to filter users
/*
* It is uses in order to prevent from sending recommendations to recruiters
* about candidates which sent a recommendation already
*/
var recommendations = appDbContext.Set <RecommendationNotification>()
.Where(r => !(r.Approved == false && r.DateResponded.Value.AddDays(minDaysAfterRejected) < DateTime.Now))
.ToLookup(r => r.PositionId, r => r);
foreach (Position position in positions)
{
IEnumerable <PositionSkill> positionSkills = position.PositionSkills;
Dictionary <int, double> matchingNumbersOfCandidates = new Dictionary <int, double>();
foreach (CandidateUser candidate in candidates)
{
bool skipToNextCandidate = false;
//if(recommendations.Contains(position.Id))
//{
//}
foreach (RecommendationNotification recommendation in recommendations[position.Id])
{
if (recommendation.CandidateId == candidate.Id)
{
skipToNextCandidate = true;
break;
}
}
if (skipToNextCandidate)
{
continue;
}
double matchingNumber = 0;
foreach (PositionSkill positionSkill in positionSkills)
{
double skillGrade = 0;
double maxTotalRank = 0;
double totalRank = 0;
double sumQuestionsRank = 0;
// Load questions which done by the candidate, and has at least one skill of this position
var relevantQuestions = candidate.Questions.Where(cq => cq.IsDone && cq.Question.Rank > 0);
var questionsWithAtLeastOneRelevantSkill = new List <CandidateQuestion>();
foreach (CandidateQuestion cq in relevantQuestions)
{
if (Utils.ConvertStringIdsToList(cq.Question.TestedSkills).Contains(positionSkill.Id))
{
questionsWithAtLeastOneRelevantSkill.Add(cq);
}
}
relevantQuestions = questionsWithAtLeastOneRelevantSkill;
maxTotalRank = relevantQuestions.Count() * maxQuestionRank;
if (maxTotalRank > 0)
{
foreach (var relevantQuestion in relevantQuestions)
{
sumQuestionsRank += relevantQuestion.Question.Rank / maxQuestionRank;
totalRank += relevantQuestion.Question.Rank;
}
skillGrade = sumQuestionsRank * (totalRank / maxTotalRank) * positionSkill.SkillWeight;
matchingNumber += skillGrade;
}
}
if (matchingNumber > 0)
{
matchingNumbersOfCandidates.Add(candidate.Id, matchingNumber);
}
}
// Getting the recommended candidate which his matching number is the heighest
double max = 0;
int candidateId = -1;
foreach (var matchingNumber in matchingNumbersOfCandidates)
{
if (matchingNumber.Value > max)
{
max = matchingNumber.Value;
candidateId = matchingNumber.Key;
}
}
if (candidateId != -1 && recruiters.ContainsKey(position.CreatedBy))
{
RecruiterUser relevantRecruiter = recruiters[position.CreatedBy];
// Update recommentdation table
Notification notificiation = new Notification()
{
Type = (int)NotificationType.Recommendation,
DateCreated = DateTime.Now,
IsViewed = false,
Recipent = relevantRecruiter.IdentityId,
};
RecommendationNotification recommendation = new RecommendationNotification()
{
Approved = null,
Notification = notificiation,
CandidateId = candidateId,
PositionId = position.Id,
};
var otherDbContext = new ApplicationDbContext(ApplicationDbContext.options);
new RecommendationNotificationsRepository(otherDbContext).Add(recommendation);
otherDbContext.SaveChanges();
var genericNotificationToClient = new GenericNotification()
{
NotificationId = recommendation.Notification.Id,
Type = recommendation.Notification.Type,
DateCreated = recommendation.Notification.DateCreated,
IsViewed = recommendation.Notification.IsViewed,
Approved = recommendation.Approved,
CandidateId = recommendation.CandidateId,
};
// Send the recommendation
NotificationsHub.Notify(relevantRecruiter.Identity.Email, genericNotificationToClient);
}
//double maxMatchingNumber = matchingNumbersOfCandidates.Values.Max();
//int candidateId = matchingNumbersOfCandidates.Where((key, value) => value == maxMatchingNumber).First().Key;
}
}
catch (Exception)
{
// TODO: write to log
}
finally
{
isRunning = false;
}
}
}
