Como implementar a pesquisa de deslocamento diário na sua IU

É possível integrar a pesquisa de deslocamento diário em sua IU para permitir que candidatos procurem vagas dentro de uma área geográfica definida pelo tempo de deslocamento. A pesquisa estima o tempo do deslocamento diário com base no meio de transporte selecionado pelo usuário e no horário em que ele planeja viajar.

Implementar pesquisa de deslocamento

1. Antes de implementar a pesquisa de deslocamento diário, o Cloud Talent Solution precisa estar conectado à sua IU. Siga as <atarget="_blank" class="external" l10n-attrs-original-order="href,target,class" l10n-encrypted-href="gMBmW1CJpUkqBwsc6X45vJFGBtNXMtSEozqMDCbrBLAVTmdE5Zm3DKcU3qbzRuF6frX41+aqUsjT+LI1UDeMrcClLjr70YAKyEYUijrkHsg=">orientações do guia de início rápido para configurar o Cloud Talent Solution</atarget="_blank">.

2. A pesquisa de deslocamento diário utiliza os dados de endereço carregados com suas vagas durante a implementação do CTS para calcular o tempo de deslocamento. Para ativar esse recurso na IU do CTS, envie uma solicitação jobs.search e inclua um objeto CommuteFilter no campo JobQuery.commuteFilter. commuteMethod, travelDuration, startCoordinates e roadTraffic ou departureTime são campos obrigatórios.

Go

Para saber como instalar e usar a biblioteca de cliente para o CTS, consulte Bibliotecas de cliente do CTS. Para mais informações, consulte a documentação de referência da API Go do CTS.

Para autenticar no CTS, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import (
	"context"
	"fmt"
	"io"

	talent "cloud.google.com/go/talent/apiv4beta1"
	"cloud.google.com/go/talent/apiv4beta1/talentpb"
	"github.com/golang/protobuf/ptypes/duration"
	"google.golang.org/genproto/googleapis/type/latlng"
)

// commuteSearch searches for jobs within commute filter.
func commuteSearch(w io.Writer, projectID, companyID string) error {
	ctx := context.Background()

	// Initialize a jobService client.
	c, err := talent.NewJobClient(ctx)
	if err != nil {
		return fmt.Errorf("talent.NewJobClient: %w", err)
	}
	defer c.Close()

	// Construct a jobQuery request with a commute filter.
	jobQuery := &talentpb.JobQuery{
		CommuteFilter: &talentpb.CommuteFilter{
			CommuteMethod:  talentpb.CommuteMethod_TRANSIT,
			TravelDuration: &duration.Duration{Seconds: 1800},
			StartCoordinates: &latlng.LatLng{
				Latitude:  37.422408,
				Longitude: -122.085609,
			},
		},
	}
	if companyID != "" {
		jobQuery.Companies = []string{fmt.Sprintf("projects/%s/companies/%s", projectID, companyID)}
	}

	// Construct a searchJobs request with a jobQuery.
	req := &talentpb.SearchJobsRequest{
		Parent: fmt.Sprintf("projects/%s", projectID),
		// Make sure to set the RequestMetadata the same as the associated
		// search request.
		RequestMetadata: &talentpb.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,
	}

	resp, err := c.SearchJobs(ctx, req)
	if err != nil {
		return fmt.Errorf("SearchJobs: %w", err)
	}

	for _, job := range resp.GetMatchingJobs() {
		fmt.Fprintf(w, "Matcing Job: %q\n", job.GetJob().GetName())
		fmt.Fprintf(w, "Job address: %v\n", job.GetCommuteInfo().GetJobLocation().GetPostalAddress().GetAddressLines())
	}

	return nil
}

Java

Para saber como instalar e usar a biblioteca de cliente para o CTS, consulte Bibliotecas de cliente do CTS. Para mais informações, consulte a documentação de referência da API Java do CTS.

Para autenticar no CTS, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import com.google.cloud.talent.v4.CommuteFilter;
import com.google.cloud.talent.v4.CommuteMethod;
import com.google.cloud.talent.v4.Job;
import com.google.cloud.talent.v4.JobQuery;
import com.google.cloud.talent.v4.JobServiceClient;
import com.google.cloud.talent.v4.RequestMetadata;
import com.google.cloud.talent.v4.SearchJobsRequest;
import com.google.cloud.talent.v4.SearchJobsResponse;
import com.google.cloud.talent.v4.TenantName;
import com.google.protobuf.Duration;
import com.google.type.LatLng;
import java.io.IOException;

public class CommuteSearchJobs {

  public static void searchJobs() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String tenantId = "your-tenant-id";
    searchJobs(projectId, tenantId);
  }

  // Search Jobs with histogram queries.
  public static void searchJobs(String projectId, String tenantId) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (JobServiceClient jobServiceClient = JobServiceClient.create()) {
      TenantName parent = TenantName.of(projectId, tenantId);
      String domain = "www.example.com";
      String sessionId = "Hashed session identifier";
      String userId = "Hashed user identifier";
      RequestMetadata requestMetadata =
          RequestMetadata.newBuilder()
              .setDomain(domain)
              .setSessionId(sessionId)
              .setUserId(userId)
              .build();

      CommuteMethod commuteMethod = CommuteMethod.DRIVING;
      long seconds = 3600L;
      Duration travelDuration = Duration.newBuilder().setSeconds(seconds).build();

      double latitude = 37.422408;
      double longitude = -122.084068;
      LatLng startCoordinates =
          LatLng.newBuilder().setLatitude(latitude).setLongitude(longitude).build();

      CommuteFilter commuteFilter =
          CommuteFilter.newBuilder()
              .setCommuteMethod(commuteMethod)
              .setTravelDuration(travelDuration)
              .setStartCoordinates(startCoordinates)
              .build();

      JobQuery jobQuery = JobQuery.newBuilder().setCommuteFilter(commuteFilter).build();
      SearchJobsRequest request =
          SearchJobsRequest.newBuilder()
              .setParent(parent.toString())
              .setRequestMetadata(requestMetadata)
              .setJobQuery(jobQuery)
              .build();

      for (SearchJobsResponse.MatchingJob responseItem :
          jobServiceClient.searchJobs(request).getMatchingJobsList()) {
        System.out.format("Job summary: %s%n", responseItem.getJobSummary());
        System.out.format("Job title snippet: %s%n", responseItem.getJobTitleSnippet());
        Job job = responseItem.getJob();
        System.out.format("Job name: %s%n", job.getName());
        System.out.format("Job title: %s%n", job.getTitle());
      }
    }
  }
}

Node.js

Para saber como instalar e usar a biblioteca de cliente para o CTS, consulte Bibliotecas de cliente do CTS. Para mais informações, consulte a documentação de referência da API Node.js do CTS.

Para autenticar no CTS, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

const talent = require('@google-cloud/talent').v4;

/** Search Jobs using commute distance */
function sampleSearchJobs(projectId, tenantId) {
  const client = new talent.JobServiceClient();
  // Iterate over all elements.
  // const projectId = 'Your Google Cloud Project ID';
  // const tenantId = 'Your Tenant ID (using tenancy is optional)';
  const formattedParent = client.tenantPath(projectId, tenantId);
  const domain = 'www.example.com';
  const sessionId = 'Hashed session identifier';
  const userId = 'Hashed user identifier';
  const requestMetadata = {
    domain: domain,
    sessionId: sessionId,
    userId: userId,
  };
  const commuteMethod = 'TRANSIT';
  const seconds = 1800;
  const travelDuration = {
    seconds: seconds,
  };
  const latitude = 37.422408;
  const longitude = 122.084068;
  const startCoordinates = {
    latitude: latitude,
    longitude: longitude,
  };
  const commuteFilter = {
    commuteMethod: commuteMethod,
    travelDuration: travelDuration,
    startCoordinates: startCoordinates,
  };
  const jobQuery = {
    commuteFilter: commuteFilter,
  };
  const request = {
    parent: formattedParent,
    requestMetadata: requestMetadata,
    jobQuery: jobQuery,
  };

  client
    .searchJobs(request)
    .then(responses => {
      const resources = responses[0];
      for (const resource of resources) {
        console.log(`Job summary: ${resource.jobSummary}`);
        console.log(`Job title snippet: ${resource.jobTitleSnippet}`);
        const job = resource.job;
        console.log(`Job name: ${job.name}`);
        console.log(`Job title: ${job.title}`);
      }
    })
    .catch(err => {
      console.error(err);
    });
}

Python

Para saber como instalar e usar a biblioteca de cliente para o CTS, consulte Bibliotecas de cliente do CTS. Para mais informações, consulte a documentação de referência da API Python do CTS.

Para autenticar no CTS, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

from google.cloud import talent

def search_jobs(project_id, tenant_id):
    """Search Jobs using commute distance"""

    client = talent.JobServiceClient()

    # project_id = 'Your Google Cloud Project ID'
    # tenant_id = 'Your Tenant ID (using tenancy is optional)'

    if isinstance(project_id, bytes):
        project_id = project_id.decode("utf-8")
    if isinstance(tenant_id, bytes):
        tenant_id = tenant_id.decode("utf-8")
    parent = f"projects/{project_id}/tenants/{tenant_id}"
    domain = "www.example.com"
    session_id = "Hashed session identifier"
    user_id = "Hashed user identifier"
    request_metadata = talent.RequestMetadata(
        domain=domain, session_id=session_id, user_id=user_id
    )
    commute_method = talent.CommuteMethod.TRANSIT
    seconds = 1800
    travel_duration = {"seconds": seconds}
    latitude = 37.422408
    longitude = -122.084068
    start_coordinates = {"latitude": latitude, "longitude": longitude}
    commute_filter = talent.CommuteFilter(
        commute_method=commute_method,
        travel_duration=travel_duration,
        start_coordinates=start_coordinates,
    )
    job_query = talent.JobQuery(commute_filter=commute_filter)

    # Iterate over all results
    results = []
    request = talent.SearchJobsRequest(
        parent=parent,
        request_metadata=request_metadata,
        job_query=job_query,
    )
    for response_item in client.search_jobs(request=request).matching_jobs:
        print(f"Job summary: {response_item.job_summary}")
        print(f"Job title snippet: {response_item.job_title_snippet}")
        job = response_item.job
        results.append(job.name)
        print(f"Job name: {job.name}")
        print(f"Job title: {job.title}")
    return results

Recomendações de IU

1. O Cloud Talent Solution não permite a pesquisa por distância (que usa o filtro de local do CTS) e pelo tempo de deslocamento diário na mesma chamada de API. Use 2 guias, ou abordagem semelhante, para permitir que os candidatos acessem as duas opções.

2. Modifique o front-end do seu aplicativo para garantir que o back-end preencha automaticamente as informações relevantes de um candidato a emprego no filtro de deslocamento diário. O back-end deve chamar a API como faria em uma solicitação de pesquisa comum.

3. Inclua itens na sua IU:

   • Uma opção para selecionar uma pesquisa de distância ou deslocamento diário. Por exemplo, sua IU de pesquisa pode ter a seguinte aparência:

     

   • Um menu suspenso das opções de método de deslocamento.

   • Uma opção para ajustar as condições de tráfego.

   • O tempo total de viagem (60 minutos é o tempo máximo de viagem permitido).

   • Início do deslocamento.

4. As informações de tempo de deslocamento retornadas da API são usadas para exibir informações ao candidato. Apenas as vagas relevantes, localizadas dentro da área de tempo de deslocamento designado, são mostradas na lista de resultados. Consulte a documentação das Práticas recomendadas de pesquisa de vagas para uma discussão sobre as formas de ajustar a ordem e o número de vagas retornadas nessa área.

5. Os resultados da pesquisa de deslocamento diário são baseados em dados históricos e agregados, e não em condições de trânsito ao vivo. As condições de trânsito departureTime são calculadas das médias das condições de trânsito na hora do dia especificada. As opções BUSY_HOUR/TRAFFIC_FREE em roadTraffic são condições médias de trânsito no horário de pico matinal e à meia-noite, respectivamente. Os usuários recebem os mesmos resultados de pesquisa de deslocamento diário, independentemente do horário em que enviam uma consulta.

Como gerar um mapa com informações de deslocamento diário (recomendado)

Aproveite o Google Maps para gerar um mapa baseado nas informações de tempo de deslocamento diário retornadas do CTS e incorporá-lo nos resultados retornados a um candidato a emprego. O pacote da API Maps tem várias opções de exibição de mapa. Algumas opções da API do Google Maps são mais eficazes que outras. Por exemplo, a visualização do mapa de calor JavaScript do Google Maps combinada com o clustering de marcadores é uma maneira eficiente de ver as vagas relevantes que aparecem para um candidato dentro da região determinada pelas preferências de deslocamento diário dele. O modo de rotas, ao contrário, não mostra todas as vagas retornadas em uma solicitação de pesquisa, portanto, não é uma opção recomendada.

Observação: as APIs Maps têm várias estruturas de preços. Esses preços NÃO são cobertos pelo uso do Cloud Talent Solution. Somente o uso de APIs do Cloud Talent Solution para solicitar as vagas dentro dos horários de deslocamento especificados é coberto como parte do sistema de preços do Cloud Talent Solution.

Para mais informações sobre a implementação de uma pesquisa baseada no deslocamento diário, consulte o guia de instruções de pesquisa de deslocamento diário.