Implementare la ricerca in base al tragitto giornaliero nell'interfaccia utente (v3)

Puoi integrare la ricerca basata sul tragitto giornaliero nella tua UI per consentire ai candidati di cercare lavoro in un'area geografica definita in base al tempo di percorrenza. La ricerca basata sul tragitto giornaliero stima il tempo di percorrenza in base alla modalità di trasporto selezionata dall'utente e all'ora del giorno in cui prevede di viaggiare.

Implementare la ricerca basata sul tragitto giornaliero

1. Prima di poter implementare la ricerca basata sul tragitto giornaliero, Cloud Talent Solution deve essere collegato alla tua UI. Segui le guide rapide per configurare Cloud Talent Solution.

2. La ricerca basata sul tragitto giornaliero utilizza i dati degli indirizzi che hai caricato con i tuoi annunci di lavoro durante l'implementazione di CTS per calcolare il tempo di percorrenza. Per attivare questa funzionalità nella UI CTS esistente, invia una richiesta jobs.search e includi un oggetto CommuteFilter nel campo JobQuery.commuteFilter. commuteMethod, travelDuration e startCoordinates sono campi obbligatori.

   Java

   Per saperne di più sull'installazione e la creazione di un client Cloud Talent Solution, consulta Librerie client di Cloud Talent Solution.

   
   public static void commuteSearch(String companyName) throws IOException, InterruptedException {
     // Make sure to set the requestMetadata the same as the associated search request
     RequestMetadata requestMetadata =
         new RequestMetadata()
             // Make sure to hash your userID
             .setUserId("HashedUserId")
             // Make sure to hash the sessionID
             .setSessionId("HashedSessionID")
             // Domain of the website where the search is conducted
             .setDomain("www.google.com");
     JobQuery jobQuery =
         new JobQuery()
             .setCommuteFilter(
                 new CommuteFilter()
                     .setRoadTraffic("TRAFFIC_FREE")
                     .setCommuteMethod("TRANSIT")
                     .setTravelDuration("1000s")
                     .setStartCoordinates(
                         new LatLng().setLatitude(37.422408).setLongitude(-122.085609)));
     if (companyName != null) {
       jobQuery.setCompanyNames(Arrays.asList(companyName));
     }
   
     SearchJobsRequest searchJobsRequest =
         new SearchJobsRequest()
             .setJobQuery(jobQuery)
             .setRequestMetadata(requestMetadata)
             .setJobView("JOB_VIEW_FULL")
             .setRequirePreciseResultSize(true);
     SearchJobsResponse response =
         talentSolutionClient
             .projects()
             .jobs()
             .search(DEFAULT_PROJECT_ID, searchJobsRequest)
             .execute();
     Thread.sleep(1000);
     System.out.printf("Search jobs for commute results: %s\n", response);
   }

   Python

   Per saperne di più sull'installazione e la creazione di un client Cloud Talent Solution, consulta Librerie client di Cloud Talent Solution.

   def commute_search(client_service, company_name):
       request_metadata = {
           "user_id": "HashedUserId",
           "session_id": "HashedSessionId",
           "domain": "www.google.com",
       }
       start_location = {"latitude": 37.422408, "longitude": -122.085609}
       commute_preference = {
           "road_traffic": "TRAFFIC_FREE",
           "commute_method": "TRANSIT",
           "travel_duration": "1000s",
           "start_coordinates": start_location,
       }
       job_query = {"commute_filter": commute_preference}
       if company_name is not None:
           job_query.update({"company_names": [company_name]})
       request = {
           "job_query": job_query,
           "request_metadata": request_metadata,
           "job_view": "JOB_VIEW_FULL",
           "require_precise_result_size": True,
       }
       response = (
           client_service.projects().jobs().search(parent=parent, body=request).execute()
       )
       print(response)
   
   

   Go

   Per saperne di più sull'installazione e la creazione di un client Cloud Talent Solution, consulta Librerie client di Cloud Talent Solution.

   
   // commuteSearch searches for jobs within commute filter.
   func commuteSearch(w io.Writer, projectID, companyName string) (*talent.SearchJobsResponse, error) {
   	ctx := context.Background()
   
   	client, err := google.DefaultClient(ctx, talent.CloudPlatformScope)
   	if err != nil {
   		return nil, fmt.Errorf("google.DefaultClient: %w", err)
   	}
   	// Create the jobs service client.
   	service, err := talent.New(client)
   	if err != nil {
   		return nil, fmt.Errorf("talent.New: %w", err)
   	}
   
   	jobQuery := &talent.JobQuery{
   		CommuteFilter: &talent.CommuteFilter{
   			RoadTraffic:    "TRAFFIC_FREE",
   			CommuteMethod:  "TRANSIT",
   			TravelDuration: "1000s",
   			StartCoordinates: &talent.LatLng{
   				Latitude:  37.422408,
   				Longitude: -122.085609,
   			},
   		},
   	}
   	if companyName != "" {
   		jobQuery.CompanyNames = []string{companyName}
   	}
   
   	parent := "projects/" + projectID
   	req := &talent.SearchJobsRequest{
   		// Make sure to set the RequestMetadata the same as the associated
   		// search request.
   		RequestMetadata: &talent.RequestMetadata{
   			// Make sure to hash your userID.
   			UserId: "HashedUsrId",
   			// Make sure to hash the sessionID.
   			SessionId: "HashedSessionId",
   			// Domain of the website where the search is conducted.
   			Domain: "www.googlesample.com",
   		},
   		// Set the actual search term as defined in the jobQuery.
   		JobQuery: jobQuery,
   		// Set the search mode to a regular search.
   		SearchMode:               "JOB_SEARCH",
   		RequirePreciseResultSize: true,
   	}
   	resp, err := service.Projects.Jobs.Search(parent, req).Do()
   	if err != nil {
   		return nil, fmt.Errorf("failed to search for jobs with commute filter: %w", err)
   	}
   	return resp, nil
   }
   

   Ruby

   Per saperne di più sull'installazione e la creazione di un client Cloud Talent Solution, consulta Librerie client di Cloud Talent Solution.

   # project_id              = "Id of the project"
   # commute_method          = "The method of transportation for which to calculate the commute time"
   # travel_duration         = "The maximum travel time in seconds"
   # start_coordinates       = "The latitude and longitude of the location from which to calculate the commute time"
   
   require "google/apis/jobs_v3"
   
   jobs = Google::Apis::JobsV3
   talent_solution_client = jobs::CloudTalentSolutionService.new
   # @see https://developers.google.com/identity/protocols/application-default-credentials#callingruby
   talent_solution_client.authorization = Google::Auth.get_application_default(
     "https://www.googleapis.com/auth/jobs"
   )
   
   # Make sure to set the request_metadata the same as the associated search request
   request_metadata = jobs::RequestMetadata.new user_id:    "HashedUserId",
                                                session_id: "HashedSessionId",
                                                domain:     "www.google.com"
   # Set location filter
   commute_filter = jobs::CommuteFilter.new road_traffic:      "TRAFFIC_FREE",
                                            commute_method:    commute_method,
                                            travel_duration:   travel_duration,
                                            start_coordinates: start_coordinates
   # Perform a search for analyst  related jobs
   search_jobs_request =
     jobs::SearchJobsRequest.new request_metadata:            request_metadata,
                                 job_query:                   (jobs::JobQuery.new commute_filter: commute_filter),
                                 job_view:                    "JOB_VIEW_FULL",
                                 require_precise_result_size: true
   search_jobs_response = talent_solution_client.search_jobs project_id, search_jobs_request
   puts search_jobs_response.to_json
   search_jobs_response

Consigli per la tua UI

1. Cloud Talent Solution non consente di eseguire ricerche sia per distanza (utilizzando il filtro di località CTS) sia per tempo di percorrenza. Per consentire ai candidati di accedere a entrambe le opzioni, utilizza un approccio a due schede o simile.

2. Modifica il front-end dell'applicazione in modo che, quando un candidato richiede una ricerca basata sul tragitto giornaliero, il back-end inserisca le informazioni pertinenti nel filtro del tragitto giornaliero e chiami l'API come farebbe in una normale richiesta di ricerca.

3. Includi questi elementi appena aggiunti nella tua UI:

   • Un'opzione per scegliere se si tratta di una ricerca per distanza o di una ricerca basata sul tragitto giornaliero. Ad esempio, la UI di ricerca potrebbe essere simile a quella dell'esempio seguente:

     

   • Un menu a discesa di opzioni per la modalità di trasporto.

   • Un'opzione per regolare le condizioni del traffico.

   • Il tempo di percorrenza totale (il tempo di percorrenza massimo supportato è di 60 minuti).

   • Ora di inizio del tragitto giornaliero.

4. Le informazioni sul tempo di percorrenza restituite dall'API vengono quindi utilizzate per mostrare le informazioni al candidato. Nell'elenco dei risultati vengono restituiti solo gli annunci di lavoro pertinenti che si trovano nell'area di tempo di percorrenza designata. Per una discussione sui modi per regolare l'ordine e il numero di annunci di lavoro restituiti in quest'area, consulta la documentazione relativa alle best practice per la ricerca di lavoro.

Generare una mappa con le informazioni sul tragitto giornaliero (consigliato)

Puoi utilizzare l'API Maps per generare una mappa in base alle informazioni sul tempo di percorrenza restituite dall'API CTS e incorporarla nei risultati restituiti a un candidato. La suite API Maps offre diverse opzioni per visualizzare la mappa. Alcune opzioni dell'API Maps sono più efficaci di altre. Ad esempio, la visualizzazione della mappa termica di Google Maps JavaScript abbinata al clustering degli indicatori è un ottimo modo per visualizzare gli annunci di lavoro pertinenti restituiti a un candidato all'interno dell'area determinata dalle preferenze di tragitto giornaliero impostate. Al contrario, la modalità Indicazioni stradali non mostra tutti gli annunci di lavoro restituiti in una richiesta di ricerca e non è un'opzione consigliata.

Nota: l'API Maps ha diverse strutture dei prezzi. Questi prezzi NON sono inclusi nell'utilizzo di Cloud Talent Solution. Solo l'utilizzo delle API Cloud Talent Solution per richiedere gli annunci di lavoro entro i tempi di percorrenza specificati è incluso nei prezzi di Cloud Talent Solution.

Per saperne di più sull'implementazione di una ricerca basata sul tragitto giornaliero, consulta la guida pratica alla ricerca basata sul tragitto giornaliero.