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 lavori all'interno di un'area geografica impostata 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.

Implementazione della ricerca basata sul tragitto giornaliero

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

2. La ricerca del tragitto casa-lavoro utilizza i dati degli indirizzi che hai caricato con le tue offerte di lavoro durante l'implementazione di CTS per calcolare il tempo di percorrenza. Per attivare questa funzionalità nell'interfaccia utente 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 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 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 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 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 la ricerca in base sia alla distanza (utilizzando il filtro della posizione CTS) sia al 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 della tua applicazione in modo che, quando un candidato richiede una ricerca basata sul tragitto giornaliero, il back-end compili le informazioni pertinenti nel filtro per il tragitto giornaliero e chiami l'API come farebbe in una normale richiesta di ricerca.

3. Includi questi elementi appena aggiunti nell'interfaccia utente:

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

     

   • Un menu a discesa con le opzioni per il metodo di spostamento.

   • 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 poi utilizzate per mostrare le informazioni al candidato. Nell'elenco dei risultati vengono restituiti solo i lavori pertinenti che si trovano all'interno dell'area del tempo di percorrenza designato. Consulta la documentazione relativa alle best practice per la ricerca di lavoro per una discussione sui modi per modificare l'ordine e il numero di lavori restituiti in questa area.

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

Puoi sfruttare 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 di API Maps offre diverse opzioni per la visualizzazione della mappa. Alcune opzioni dell'API Maps sono più efficaci di altre. Ad esempio, la visualizzazione della mappa di intensità JavaScript di Google Maps abbinata al raggruppamento dei marcatori è un ottimo modo per visualizzare i lavori pertinenti restituiti a un candidato all'interno dell'area determinata dalle sue preferenze di spostamento. Al contrario, la modalità Indicazioni non mostra tutti i job restituiti in una richiesta di ricerca e non è un'opzione consigliata.

Nota: l'API Maps ha diverse strutture di prezzi. Questi prezzi NON sono coperti dall'utilizzo di Cloud Talent Solution. Solo l'utilizzo delle API Cloud Talent Solution per richiedere i lavori entro i tempi di trasferimento specificati è coperto dai prezzi di Cloud Talent Solution.

Per ulteriori informazioni sull'implementazione di una ricerca basata sul tragitto giornaliero, consulta la guida alle istruzioni per la ricerca del tragitto giornaliero.