def searchAndScore():

    callStartTime = datetime.now().isoformat()

    reqId = request.GET.get('requisition_id', '').strip()
    minScore = request.GET.get('min_score', '').strip()

    #print("[searchAndScore]  reqId [" + reqId + "] minScore [" + minScore + "]")

    msg = ("[SearchAndScore]  CallStartTime [" + callStartTime + "]  reqId [" + reqId + "]  minScore [" + minScore +"]")
    logger.log(msg)

    if minScore is '':
        minScore = 0

    try:
        summary=zcSearchAndScore.getSearchAndScore(int(reqId), int(minScore))
        print(summary)
        return (summary)
    except Exception as e:
        DebugException(e)
        response.status = 500
        #return ("Internal Error: %s" % e)
        msg = ("Internal Error: %s" % e)
        summaryObj = ZcSummaryObj(-1, False, msg)
        return (summaryObj.toJson())
Exemple #2
0
def writeScoresToAudit(db, zScoreList, zSummary, inputParamObj, startTime):

   try:
      ### First, save the cadidate score list
      inputObj = inputParamObj.toJson()
      zSummaryAudit = zSummary
      zSummaryAudit["start_time"] = startTime
      zSummaryAudit["end_time"] = datetime.now().isoformat()
      zSummaryAudit["input_parameters"] = inputObj
      db.candidate_zindex_score_audit.insert_many( zScoreList )
      db.candidate_zindex_score_summary_audit.insert_one( zSummaryAudit )
      summaryObj = ZcSummaryObj(0, True, "Write to Audit collection successful")
      return summaryObj.toJson()
   except Exception as e:
      DebugException(e)
      summaryObj = ZcSummaryObj(-1, False, e)
      return(summaryObj.toJson())
      raise
def isServiceAlive():
    callStartTime = datetime.now().isoformat()
    msg = "[isServiceAlive] Call start time [" + callStartTime + "]"
    logger.log(msg)
    successStatus = False
    try:
        resp=checkService.getServiceStatus()
        msg = "Service status returned [" + str(resp) + "]"
        if( resp == 1):
            successStatus = True
        else:
            successStatus = False
        summaryObj = ZcSummaryObj(resp, successStatus, msg)
        return (summaryObj.toJson())
    except Exception as e:
        DebugException(e)
        response.status = 500
        msg = ("Internal Error: %s" % e)
        return(msg) 
Exemple #4
0
def writeScoresToDb(db, zScoreList, zSummary):

   try:
      ### First, save the cadidate score list
      for zScore in zScoreList:
         reqId = zScore["requisition_id"]
         candId = zScore["candidate_id"]
         db.candidate_zindex_score.replace_one({'requisition_id': reqId, 'candidate_id': candId }, zScore, True)

      ### Now, save the summary for the request   
      db.candidate_zindex_score_summary.replace_one( {"requisition_id" : reqId}, zSummary, True )
      summaryDoc = db.candidate_zindex_score_summary.find_one( {"requisition_id" : reqId}, { "_id" : 1} )
      summaryDocId = str((summaryDoc["_id"]))
      summaryObj = ZcSummaryObj(summaryDocId, True, "Search request completed successfully")
      return summaryObj.toJson()
   except Exception as e:
      DebugException(e)
      summaryObj = ZcSummaryObj(-1, False, e)
      print(summaryObj.toJson())
      return(summaryObj.toJson())
      raise
def candidateScore():
    #qryDict = parse_qs(request.query_string)
    callStartTime = datetime.now().isoformat()

    reqId = request.GET.get('requisition_id', '').strip()
    isSubmitted = request.GET.get('issubmitted', '').strip()
    masterSupplierId = request.GET.get('master_supplier_id', '').strip()
    minScore = request.GET.get('min_score', '').strip()
    
    print("[candidateScore]  reqId [" + reqId + "]  isSubmitted [" + isSubmitted + "]   masterSupplierId [" + masterSupplierId + "]  minScore [" + minScore +"]")
    msg = ("[candidateScore]  CallStartTime [" + callStartTime + "]  reqId [" + reqId + "]  isSubmitted [" + isSubmitted + "]   masterSupplierId [" + masterSupplierId + "]  minScore [" + minScore +"]")

    logger.log(msg)
    try:
        summary=zcCandidateScore.getCandidateScore(int(reqId), int(isSubmitted), int(masterSupplierId), int(minScore))
        return (summary)
    except Exception as e:
        DebugException(e)
        response.status = 500
        #return("Internal Error: %s" % e)
        msg = ("Internal Error: %s" % e)
        summaryObj = ZcSummaryObj(-1, False, msg)
        return (summaryObj.toJson())
def getCandidateScore(reqId, isSubmitted, masterSupplierId, minScore):
   try:
      start_time = datetime.now()
      beginTime = datetime.now().isoformat()

      inputObj = InputParamsObj(reqId, isSubmitted, masterSupplierId, minScore)
      req = db.requisition.find_one( { "requisition_id" : int(reqId) } )
      if req is None:
         summaryObj = ZcSummaryObj(-1, False, "Invalid Requisition Id")
         return(summaryObj.toJson())


      ### Search for all submitted candidates
      if (int(reqId) > 0 and isSubmitted and int(masterSupplierId) <= 0):
          query_dict = {
                          "requisition_id" : int(reqId),
                          "dnr_flag" : False
                       }
          candidateList = db.requisition_candidate.find( query_dict, { "loaded_date" : 0, "updated_date" : 0, "dnr_flag" : 0, "is_hired" : 0, "etl_process_flag" :0, "_id" : 0 } )
          appendReq = False
          mspFlag = False
          
      ### Search submitted candidates with the provided master supplier id
      elif int(reqId) > 0 and isSubmitted and int(masterSupplierId) > 0:
          query_dict = {
              "requisition_id" : int(reqId),
              "dnr_flag" : False,
              "master_supplier_id" : int(masterSupplierId)
          }
          candidateList = db.requisition_candidate.find( query_dict, { "loaded_date" : 0, "updated_date" : 0, "dnr_flag" : 0, "is_hired" : 0, "etl_process_flag" :0, "_id" : 0 } )
          appendReq = False
          mspFlag = False

      #print(reqId, isSubmitted, masterSupplierId, minScore)

      ### Search all candidates with the provided master supplier id whether submitted or not.
      elif int(reqId) > 0 and (not isSubmitted) and int(masterSupplierId) > 0:
         print(reqId, isSubmitted, masterSupplierId, minScore)
         clientId = req["client_id"]
         exclude_list = {
                "_id": 0,
                "address1": 0,
                "address2": 0,
                "allow_talent_cloud_search_for_all_division": 0,
                "opt_in_talent_search": 0,
                "unique_resource_id": 0,
                "candidate_divisions": 0,
                "update_date" : 0,
                "dnrs": 0,
                "job_skill_names.job_skill_id" : 0,
                "job_skill_names.competency_years_experience" : 0,
                "job_skill_names.competency_level" : 0,
                "job_certificate_names.job_certification_id" : 0,
                "etl_process_flag" : 0
         }
         candidateList = db.candidate.find( { "dnrs.client_id" : {"$ne" : clientId}, "master_supplier_id" : int(masterSupplierId) }, exclude_list )
         appendReq = True
         mspFlag = True

      else:
         summaryObj = ZcSummaryObj(0, True, "Invalid search parameters received")
         candidateList = None

      #logger.log(candidateList)
      cnt = 0 
      if (candidateList is not None):
         for c in candidateList:
            cnt += 1
      ### Now, if we have a condidate list, then process them with scoring
      if (cnt > 0):
         zindexScores = list(candidateScorer.scoreCandidates(req, candidateList, appendReq, score_collection_name, mspFlag, searchAndScoreFlag))
         #logger.log(str(zindexScores))
         ### Now, remove from the list who scored below minScore specified
         if minScore is not None and minScore is not "":
            zindexScoresMinScore = []
            for candidate in zindexScores:
               if candidate["zindex_score"] >=  int(minScore):
                  zindexScoresMinScore.append(candidate)
            zindexScores = zindexScoresMinScore

         ### Now, get the summary for requisition search
         summary = getZindexSummary(db, reqId, zindexScores, searchAndScoreFlag)
         
         ### Add input parameters to the results
         for zindex in zindexScores:
            zindex["input_is_submitted"] = int(isSubmitted) 
            zindex["input_master_supplier_id"] = int(masterSupplierId)
            zindex["input_min_score"] = int(minScore)

         summary["input_is_submitted"] = int(isSubmitted) 
         summary["input_master_supplier_id"] = int(masterSupplierId)
         summary["input_min_score"] = int(minScore)

         ### Finally write the results to the DB
         clean_zindex_scores = cleanScores(zindexScores)
         summaryDocId = writeCandidateScoreToSqlServer(int(reqId), int(isSubmitted), int(masterSupplierId), clean_zindex_scores, summary)
         if summaryDocId > 0:
            summaryObj = ZcSummaryObj(summaryDocId, True, "Search request completed successfully")
         else:
            summaryObj = ZcSummaryObj(summaryDocId, False, "Error in SQL Server write function")

         auditWriteResult = writeScoresToAudit(db, zindexScores, summary, inputObj, start_time)
      else:
         summaryObj = ZcSummaryObj(0, True, "No candidates found with the specified search criteria")
      
      print("%s" % summaryObj.toJson())

   except Exception as e:
      DebugException(e)
      summaryObj = ZcSummaryObj(-1, False, e)
      print("%s" % summaryObj.toJson())
      raise

   elapsed = datetime.now() - start_time
   endTime = datetime.now().isoformat()
   logger.log("[DebugInfo] -- [CandidateScore] Process Start [" + beginTime + "]  End [" + endTime + "]   Elapsed [" + str(elapsed) + "] seconds")

   return (summaryObj.toJson())
def getSearchAndScore(reqId, minScore):
	start_time = datetime.now()
	beginTime = datetime.now().isoformat()

	inputObj = InputParamsObj(int(reqId), None, None, int(minScore))

	scored_candidate_list = []
	relevant_vendor_ids = []
	try:
		reqObj = getRequisitionObject(int(reqId))
		if reqObj is None:
			summaryObj = ZcSummaryObj(-1, False, "Invalid Requisition Id")
			return(summaryObj.toJson())

		client_id = reqObj["client_id"]
		category_id = reqObj["new_global_job_category_id"]
		relevant_candidate_ids = getRelevantCandidates(category_id)

		#if relevant_candidate_ids is None or len(relevant_candidate_ids) == 0:
			#summaryObj = ZcSummaryObj(0, True, "No candidates found under relevant job classification")
			#return(summaryObj.toJson())	

		#queryParams = QueryParams(client_id)
		#relevant_vendor_ids = getRelevantVendorIds(queryParams)
		#candidate_list = getCandidateList(queryParams, relevant_vendor_ids, category_id, relevant_candidate_ids)

		### Get prefiltered candidates from SQL Server
		#preFilterCandidateList = getPreFilterCandidateList(client_id)
		preFilterCandidateList = mongoPreFilter(client_id)

		### Get submitted candidates list from requisition_candidate collection
		submittedCandidateList = getSubmittedCandidates(reqId)

		### Convert the candidate lists into sets
		relevantCandidateSet = set(relevant_candidate_ids)
		preFilterCandidateSet = set(preFilterCandidateList)

		### get the intersection list of the two lists
		filteredCandidateList = list(preFilterCandidateSet.intersection(relevantCandidateSet) )

		### Finally, add the submitted candidate list to the filtered list
		finalCandidateList = filteredCandidateList + submittedCandidateList

		### Get the candidates info from candidate collection using the finalCandidateList
		candidate_list = getCandidateList2(finalCandidateList)

		if candidate_list is None:
			summaryObj = ZcSummaryObj(0, True, "No candidates found with the specified search criteria")
			return(summaryObj.toJson())	

		scored_candidate_list = candidateScorer.scoreCandidates(reqObj, candidate_list, True, score_collection_name, mspFlag, searchAndScoreFlag)

		if scored_candidate_list is not None and minScore is not None and minScore is not "":
			scored_list_minScore = []
			for candidate in scored_candidate_list:
				if candidate["zindex_score"] >= int(minScore):
					scored_list_minScore.append(candidate)
			scored_candidate_list = scored_list_minScore

		if scored_candidate_list is not None:
			summary = getZindexSummary(db, int(reqId), scored_candidate_list, searchAndScoreFlag)
			db.candidate_zindex_score.delete_many({"requisition_id": int(reqId)})
			db.candidate_zindex_score.insert_many(scored_candidate_list)

			db.candidate_zindex_score_summary.replace_one( {"requisition_id" : int(reqId)}, summary, True )
			summaryDoc = db.candidate_zindex_score_summary.find_one( {"requisition_id" : int(reqId)}, { "_id" : 1} )
			summaryDocId = str((summaryDoc["_id"]))
			summaryObj = ZcSummaryObj(summaryDocId, True, "Search request completed successfully")
			auditWriteResult = writeScoresToAudit(db, scored_candidate_list, summary, inputObj, start_time)
		else:
			summaryObj = ZcSummaryObj(0, True, "No candidates found with the specified search criteria")
			return(summaryObj.toJson())	

	except Exception as e:
		DebugException(e)
		summaryObj = ZcSummaryObj(-1, False, e)
		raise

	elapsed = datetime.now() - start_time
	endTime = datetime.now().isoformat()
	print("---Total Time: %s seconds ---" % (datetime.now() - start_time))
	logger.log("[DebugInfo] -- [SearchAndScore] RequisitionId [" + str(reqId) + "]   Process Start [" + beginTime + "]  End [" + endTime + "]   Elapsed [" + str(elapsed) + "] seconds")
	return (summaryObj.toJson())