Ricerca in base al tragitto giornaliero (v3)

Le richieste di ricerca di lavoro possono includere un filtro relativo alla durata del tragitto giornaliero che limita gli impieghi restituiti a quelli compresi nel tempo di percorrenza specificato da un determinato punto di partenza. I risultati includono la durata stimata del tragitto giornaliero in secondi per gli impieghi corrispondenti.

Per restituire gli impieghi entro una durata specifica del tragitto giornaliero, invia una jobs.search richiesta e includi un CommuteFilter oggetto nel JobQuery.commuteFilter campo. Cloud Talent Solution utilizza l'indirizzo dell'impiego per calcolare la durata del tragitto giornaliero per raggiungere l'impiego. Se non viene fornito un indirizzo dettagliato, Cloud Talent Solution tenta di dedurre l'indirizzo stradale effettivo dell'impiego.

Java

Per saperne di più sull'installazione e sulla 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 sulla 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 sulla 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 sulla 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

Campi obbligatori

  • commuteMethod: il mezzo di trasporto per il quale calcolare la durata del tragitto giornaliero. Le opzioni sono DRIVING e TRANSIT. Tutte le versioni successive alla V3p1beta1 includeranno anche le modalità di trasporto WALKING e CYCLING. I percorsi a piedi e in bicicletta potrebbero non riflettere le condizioni reali, ad esempio la presenza di lavori in corso, o includere percorsi a piedi o in bicicletta chiari. Queste risposte includeranno warnings in nel risultato restituito, che devi mostrare agli utenti.

  • travelDuration: il tempo di percorrenza massimo in secondi. Il valore massimo consentito è 3600s (un'ora). Il formato è 123s.

  • startCoordinates: la latitudine e la longitudine della località da cui calcolare la durata del tragitto giornaliero. Accetta un LatLng oggetto.

Campi facoltativi

  • allowImpreciseAddresses: gli indirizzi "precisi" sono definiti come indirizzi a livello di strada o coordinate GPS. Se allowImpreciseAddresses è impostato su true, potrebbero essere restituiti anche gli impieghi con indirizzi "imprecisi" (solo città, stato o paese). Per gli indirizzi a livello città e a livello più grossolano, viene utilizzata la corrispondenza del testo. Se questo campo è impostato su false o non è specificato, la ricerca del tragitto giornaliero restituisce solo gli impieghi che includono indirizzi precisi.

  • roadTraffic: specifica la densità del traffico da utilizzare per calcolare la durata del tragitto giornaliero. Le opzioni sono TRAFFIC_FREE o BUSY_HOUR. Non deve essere presente se è specificato departureHourLocal.

  • departureTime: l'ora di partenza da utilizzare per calcolare l'impatto del traffico. Accetta un numero intero compreso tra 0 e 23, che rappresenta l'ora nel fuso orario di startLocation. Non deve essere presente se è specificato roadTraffic.