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 i lavori restituiti a quelli entro un tempo di percorrenza specificato da un punto di partenza. I risultati includono il tempo di percorrenza stimato in secondi per le offerte di lavoro corrispondenti.

Ricerca di tempi specifici per tragitto giornaliero

Per restituire i job entro un periodo di tempo specifico di un tragitto giornaliero, 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 il lavoro. Quando non viene fornito un indirizzo dettagliato, Cloud Talent Solution tenta di dedurre l'indirizzo effettivo del job.

Java

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

Campi obbligatori

• commuteMethod: il metodo di trasporto per cui calcolare il tempo del tragitto giornaliero. Le opzioni sono DRIVING e TRANSIT. Tutte le versioni a partire da V3p1beta1 includeranno anche le modalità di trasporto pubblico WALKING e CYCLING. I percorsi a piedi e in bicicletta potrebbero non riflettere le condizioni reali come i lavori in corso o includere percorsi pedonali o ciclabili visibili. Queste risposte includeranno warnings 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 posizione da cui calcolare i tempi di percorrenza del tragitto giornaliero. Accetta un oggetto LatLng.

Campi facoltativi

• allowImpreciseAddresses: gli indirizzi "esatti" sono definiti come indirizzi a livello stradale o coordinate GPS. Se allowImpreciseAddresses è impostato su true, possono essere restituite anche i lavori con indirizzi "imprecisi" (solo città, provincia o paese). Per gli indirizzi a livello di città e a livello più approssimativo, viene utilizzata la corrispondenza del testo. Se questo campo è impostato su false o non viene specificato, solo le offerte di lavoro che includono indirizzi precisi vengono restituite dalla ricerca per tragitto giornaliero.

Nota: se allowImpreciseAddresses è impostato su true, Ricerca tragitto giornaliero non è in grado di calcolare tempi accurati per il tragitto giornaliero verso le offerte di lavoro con informazioni a livello di città e sull'indirizzo più approssimativo. I job con indirizzi imprecisi restituiscono travelDuration volta pari a 0, indipendentemente dalla distanza da chi cerca il lavoro.

• roadTraffic: specifica la densità del traffico da utilizzare per il calcolo del 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 sul 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.