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 le risposte restituite a quelli all'interno del tempo di percorrenza specificato da un punto di partenza. I risultati includono il tempo di tragitto giornaliero stimato in secondi per le offerte di lavoro corrispondenti.

Ricerca di un orario di tragitto giornaliero specifico

Per restituire i job entro un tempo di percorrenza specifico, 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 necessario per raggiungere quel lavoro. Quando non viene fornito un indirizzo dettagliato, Cloud Talent Solution tenta di dedurre l'indirizzo stradale effettivo della posizione di lavoro.

Java

Per saperne di più sull'installazione e sulla 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 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 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 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 metodo di trasporto per cui calcolare il dei tragitti giornalieri. Le opzioni sono DRIVING e TRANSIT. Tutte le versioni a partire dalla versione V3p1beta1 includeranno anche le modalità di trasporto pubblico WALKING e CYCLING. I percorsi a piedi e in bicicletta potrebbero non riflettere le condizioni reali, ad esempio la presenza di cantieri, o includere percorsi pedonali o ciclabili chiari. Queste risposte includeranno warnings nel risultato restituito che devi mostrare agli utenti.

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

• startCoordinates: la latitudine e la longitudine della posizione da cui calcolare il tempo di percorrenza. Accetta un LatLng.

Campi facoltativi

• allowImpreciseAddresses: "Esatta" gli indirizzi sono definiti come indirizzi o coordinate GPS. Se allowImpreciseAddresses è impostato su true, i job con "impreciso" (solo città, provincia o paese). Per gli indirizzi a livello di città e a livello approssimativo, viene utilizzata la corrispondenza del testo. Se questo campo è impostato su false o non è specificato, la ricerca per tragitto giornaliero restituisce solo i lavori che includono indirizzi precisi.

Nota: se allowImpreciseAddresses è impostato su true, la ricerca basata sul tragitto giornaliero non è in grado di calcolare tempi di percorrenza precisi per raggiungere le offerte di lavoro con informazioni a livello di città e indirizzi più approssimativi. Job con gli indirizzi imprecisi restituiscono un tempo travelDuration pari a 0 indipendentemente dalla distanza chi cerca lavoro.

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

• 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 roadTraffic è specificato.