Recherche basée sur le temps de trajet (v3)

Les requêtes de recherche d'emploi peuvent inclure un filtre de temps de trajet qui limite les offres d'emploi renvoyées à celles correspondant au temps de trajet spécifié à partir d'un point de départ. Les résultats incluent le temps de trajet estimé en secondes pour les offres d'emploi correspondantes.

Pour afficher des offres d'emploi correspondant à un temps de trajet spécifique, envoyez une requête jobs.search en incluant un objet CommuteFilter dans le champ JobQuery.commuteFilter. Cloud Talent Solution utilise l'adresse de l'offre d'emploi pour calculer le temps de trajet correspondant. Si l'adresse complète n'est pas fournie, Cloud Talent Solution tente de localiser l'adresse postale de l'offre d'emploi.

Java

Pour en savoir plus sur l'installation et la création d'un client Cloud Talent Solution, consultez la page Bibliothèques clientes 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

Pour en savoir plus sur l'installation et la création d'un client Cloud Talent Solution, consultez la page Bibliothèques clientes 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)

C#

Pour en savoir plus sur l'installation et la création d'un client Cloud Talent Solution, consultez la page Bibliothèques clientes Cloud Talent Solution.


public static void CommuteSearch(string companyName)
{
    RequestMetadata requestMetadata = new RequestMetadata()
    {
        // Make sure to hash your userID
        UserId = "HashedUserId",
        // Make sure to hash the sessionID
        SessionId = "HashedSessionId",
        // Domain of the website where the search is conducted
        Domain = "www.google.com"
    };

    JobQuery jobQuery = new JobQuery()
    {
        CommuteFilter = new CommuteFilter()
        {
            RoadTraffic = "TRAFFIC_FREE",
            CommuteMethod = "TRANSIT",
            TravelDuration = "1000s",
            StartCoordinates = new LatLng()
            {
                Latitude = 37.42208,
                Longitude = -122.085609
            }
        }
    };

    if (companyName != null)
    {
        jobQuery.CompanyNames = new List<string>
        {
            companyName
        };
    }

    SearchJobsRequest searchJobRequest = new SearchJobsRequest()
    {
        RequestMetadata = requestMetadata,
        JobQuery = jobQuery,
        JobView = "JOB_VIEW_FULL",
        RequirePreciseResultSize = true
    };

    SearchJobsResponse searchJobsResponse = jobServiceClient.Projects.Jobs.Search(searchJobRequest, parent).Execute();

    Console.WriteLine("Jobs commute searched: " + ToJsonString(searchJobsResponse));
}

Go

Pour en savoir plus sur l'installation et la création d'un client Cloud Talent Solution, consultez la page Bibliothèques clientes 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: %v", err)
	}
	// Create the jobs service client.
	service, err := talent.New(client)
	if err != nil {
		return nil, fmt.Errorf("talent.New: %v", 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: %v", err)
	}
	return resp, nil
}

Node.js

Pour en savoir plus sur l'installation et la création d'un client Cloud Talent Solution, consultez la page Bibliothèques clientes Cloud Talent Solution.

const commuteSearch = async (jobServiceClient, companyName) => {
  try {
    const requestMetadata = {
      userId: 'HashedUserId',
      sessionId: 'HashedSessionId',
      domain: 'www.google.com',
    };

    const startLocation = {
      latitude: 37.422408,
      longitude: -122.085609,
    };

    const commutePreference = {
      roadTraffic: 'TRAFFIC_FREE',
      commuteMethod: 'TRANSIT',
      travelDuration: '1000s',
      startCoordinates: startLocation,
    };

    const jobQuery = {
      commuteFilter: commutePreference,
    };

    if (companyName) {
      jobQuery.companyNames = [companyName];
    }

    const request = {
      parent: `projects/${PROJECT_ID}`,
      resource: {
        jobQuery: jobQuery,
        requestMetadata: requestMetadata,
        jobView: 'JOB_VIEW_FULL',
        requirePreciseResultSize: true,
      },
    };

    const result = await jobServiceClient.projects.jobs.search(request);

    console.log(JSON.stringify(result.data));
  } catch (e) {
    console.error(e);
    throw e;
  }
};

Ruby

Pour en savoir plus sur l'installation et la création d'un client Cloud Talent Solution, consultez la page Bibliothèques clientes 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

Champs obligatoires

  • commuteMethod : moyen de transport pour lequel calculer le temps de trajet. Les options sont DRIVING et TRANSIT. Toutes les versions depuis V3p1beta1 comprendront également les moyens de transport WALKING et CYCLING. Les itinéraires pédestres et cyclables peuvent ne pas refléter les conditions réelles, par exemple les zones de construction ou les chemins piétons ou cyclables non dégagés. Ces réponses incluent des warnings dans le résultat renvoyé, que vous devez afficher à vos utilisateurs.

  • travelDuration : durée maximale du trajet en secondes. La valeur maximale autorisée est 3600s (une heure). Le format correspond à 123s.

  • startCoordinates : latitude et longitude du lieu à partir duquel calculer le temps de trajet. Accepte un objet LatLng.

Champs facultatifs

  • allowImpreciseAddresses : les adresses "précises" sont définies en tant qu'adresses (nom de rue) ou en tant que coordonnées GPS. Si allowImpreciseAddresses est défini sur true, les offres d'emploi avec des adresses "imprécises" (ville, État ou pays uniquement) peuvent également être renvoyées. Pour les villes ou les localisations plus larges, la correspondance textuelle est utilisée. Si ce champ est défini sur false ou n'est pas spécifié, seules les offres d'emploi qui incluent des adresses précises sont renvoyées par la recherche par temps de trajet.
  • roadTraffic : spécifie la densité du trafic à utiliser pour le calcul du temps de trajet. Les options sont TRAFFIC_FREE ou BUSY_HOUR. Ce champ est absent si departureHourLocal est spécifié.

  • departureTime : heure de départ à utiliser pour calculer l'impact du trafic. Accepte un entier compris entre 0 et 23, qui représente l'heure dans le fuseau horaire de startLocation. Ce champ est absent si roadTraffic est spécifié.