Pesquisa por deslocamento diário (v3)

É possível incluir nas solicitações de pesquisa de vagas um filtro de tempo de deslocamento diário. Com ele, os resultados retornados se limitam às vagas que correspondem a um tempo de viagem específico saindo de um determinado ponto de partida. Os resultados incluem o tempo de deslocamento diário estimado em segundos para as vagas que correspondem à pesquisa.

Para retornar vagas com um tempo específico de deslocamento, envie uma solicitação jobs.search e inclua um objeto CommuteFilter no campo JobQuery.commuteFilter. O Cloud Talent Solution usa o endereço da vaga para calcular o tempo de deslocamento diário dela. Quando um endereço detalhado não é fornecido, o Cloud Talent Solution tenta inferir o endereço real da vaga.

Java

Para mais informações sobre a instalação e criação de um cliente do Cloud Talent Solution, consulte Bibliotecas de cliente do 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.println(response);
}

Python

Para mais informações sobre a instalação e criação de um cliente do Cloud Talent Solution, consulte Bibliotecas de cliente do 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#

Para mais informações sobre a instalação e criação de um cliente do Cloud Talent Solution, consulte Bibliotecas de cliente do 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

Para mais informações sobre a instalação e criação de um cliente do Cloud Talent Solution, consulte Bibliotecas de cliente do 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

Para mais informações sobre a instalação e criação de um cliente do Cloud Talent Solution, consulte Bibliotecas de cliente do 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

Para mais informações sobre a instalação e criação de um cliente do Cloud Talent Solution, consulte Bibliotecas de clientes do 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

Campos obrigatórios

  • commuteMethod: o modo de transporte para o cálculo do tempo de deslocamento. As opções são DRIVING e TRANSIT. Todas as versões desde a V3p1beta1 também incluirão os modos de transporte WALKING e CYCLING. As rotas a pé e de bicicleta podem não refletir as condições do mundo real, como obras, ou conter caminhos desobstruídos para caminhada ou ciclismo. Essas respostas terão warnings incluídos no resultado retornado que será exibido aos usuários.

  • travelDuration: o tempo máximo de deslocamento em segundos. O valor máximo permitido é 3600s (uma hora). O formato é 123s.

  • startCoordinates: a latitude e a longitude do local de onde o tempo de deslocamento diário será calculado. Aceita um objeto LatLng.

Campos opcionais

  • allowImpreciseAddresses: endereços "precisos" são definidos como endereços no nível de rua ou coordenadas de GPS. Se allowImpreciseAddresses estiver definido como true, as vagas com endereços "imprecisos" (somente cidade, estado ou país) também poderão ser retornadas. Para endereços no nível de cidade e mais imprecisos, é usada a correspondência de texto. Se este campo for definido como false ou não for especificado, somente as vagas que incluírem endereços precisos serão retornadas pela pesquisa por deslocamento diário.
  • roadTraffic: especifica a intensidade do trânsito a ser usada no cálculo do tempo de deslocamento diário. As opções são TRAFFIC_FREE ou BUSY_HOUR. Não precisa estar presente se departureHourLocal for especificado.

  • departureTime: a hora de partida a ser usada para calcular o impacto do trânsito. Aceita um número inteiro entre 0 e 23, representando a hora no fuso horário de startLocation. Não precisa estar presente se roadTraffic for especificado.