Questa pagina è stata tradotta dall'API Cloud Translation.

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 il tempo di percorrenza stimato in secondi per le offerte di lavoro corrispondenti.

Ricerca di un tempo di percorrenza specifico

Per restituire i job entro un determinato tempo di percorrenza, invia una richiesta jobs.search e includi un oggetto CommuteFilter nel campo JobQuery.commuteFilter. Cloud Talent Solution utilizza l'indirizzo del lavoro per calcolare il tempo di percorrenza per raggiungere il luogo di lavoro. Quando non viene fornito un indirizzo dettagliato, Cloud Talent Solution tenta di dedurre l'indirizzo stradale effettivo del lavoro.

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

Campi obbligatori

commuteMethod: il mezzo di trasporto per cui calcolare il tempo di spostamento. 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 corrispondere alle condizioni reali, ad esempio lavori in corso o includere sentieri a piedi o in bicicletta ben definiti. Queste risposte includeranno warnings nel risultato restituito, che devi mostrare ai tuoi 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 posizione da cui calcolare il tempo di percorrenza. Accetta un oggetto LatLng.

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 lavori con indirizzi "imprecisi" (solo città, stato o paese). Per gli indirizzi a livello di città e più generici, viene utilizzata la corrispondenza del testo. Se questo campo è impostato su false o non è specificato, la ricerca del tragitto giornaliero restituisce solo i lavori che includono indirizzi precisi.

roadTraffic: specifica la densità del traffico da utilizzare per calcolare il tempo di percorrenza. 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.

Ricerca in base al tragitto giornaliero (v3) Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Ricerca di un tempo di percorrenza specifico

Java

Python

Go

Ruby

Campi obbligatori

Campi facoltativi

Ricerca in base al tragitto giornaliero (v3)