Implementar a pesquisa de trajeto na sua IU (v4beta1)

Pode integrar a pesquisa de trajeto na sua IU para permitir que os candidatos a emprego pesquisem empregos numa área geográfica definida pelo tempo de trajeto. As estimativas de pesquisa de trajeto para o trabalho estimam o tempo de trajeto com base no modo de transporte público selecionado por um utilizador e na hora do dia em que planeia viajar.

Implemente a pesquisa de trajeto

1. Antes de poder implementar a pesquisa de trajeto, a Cloud Talent Solution tem de estar associada à sua IU. Siga os guias de início rápido para configurar a Cloud Talent Solution.

2. A pesquisa de trajeto usa os dados de morada que carregou com os seus trabalhos durante a implementação do CTS para calcular o tempo de trajeto. Para ativar esta funcionalidade na IU do CTS existente, envie um pedido 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 cliente para o CTS, consulte o artigo Bibliotecas cliente do CTS. Para mais informações, consulte a documentação de referência da API Go CTS.

Para se autenticar no CTS, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 mais informações sobre a instalação e a criação de um cliente da Cloud Talent Solution, consulte o artigo Bibliotecas de cliente da Cloud Talent Solution.

import com.google.cloud.talent.v4beta1.CommuteFilter;
import com.google.cloud.talent.v4beta1.CommuteMethod;
import com.google.cloud.talent.v4beta1.Job;
import com.google.cloud.talent.v4beta1.JobQuery;
import com.google.cloud.talent.v4beta1.JobServiceClient;
import com.google.cloud.talent.v4beta1.RequestMetadata;
import com.google.cloud.talent.v4beta1.SearchJobsRequest;
import com.google.cloud.talent.v4beta1.SearchJobsResponse;
import com.google.cloud.talent.v4beta1.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).iterateAll()) {
        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());
      }
    }
  }
}

Python

Para mais informações sobre a instalação e a criação de um cliente da Cloud Talent Solution, consulte o artigo Bibliotecas de cliente da Cloud Talent Solution.

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. A Cloud Talent Solution não permite a pesquisa por distância (através do filtro de localização da CTS) e tempo de trajeto no mesmo pedido API. Para permitir que os candidatos acedam a ambas as opções, use uma abordagem de 2 separadores ou semelhante.

2. Modifique o frontend da sua aplicação para garantir que o backend preenche automaticamente as informações relevantes de um candidato a emprego no filtro de trajeto. O back-end deve chamar a API como faria num pedido de pesquisa normal.

3. Inclua itens na IU:

   • Uma opção para selecionar uma pesquisa por distância ou uma pesquisa de trajeto. Por exemplo, a IU de pesquisa pode ter o aspeto do exemplo abaixo:

     

   • Um menu pendente de opções de método de trajeto.

   • Uma opção para ajustar as condições de trânsito.

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

   • Hora de início da viagem regular.

4. As informações sobre o tempo de trajeto devolvidas pela API são usadas para apresentar informações ao candidato a emprego. Apenas são devolvidos na lista de resultados os empregos relevantes localizados na área de tempo de trajeto designada. Consulte a documentação de práticas recomendadas de pesquisa de emprego para ver uma discussão sobre formas de ajustar a ordem e o número de empregos devolvidos nesta área.

5. Os resultados da pesquisa de trajeto baseiam-se em dados históricos e agregados, em vez de condições de trânsito em tempo real. As departureTimecondições de trânsito são calculadas a partir das condições de trânsito médias na hora do dia especificada. As opções BUSY_HOUR/TRAFFIC_FREE em roadTraffic representam, respetivamente, as condições de trânsito médias na hora de ponta da manhã e à meia-noite. Os utilizadores recebem os mesmos resultados de pesquisa de trajeto, independentemente da hora do dia em que enviam uma consulta.

Gerar um mapa com informações de viagens regulares (recomendado)

Pode tirar partido do Google Maps para gerar um mapa com base nas informações de tempo de trajeto de deslocação devolvidas pelo CTS e incorporá-lo nos resultados devolvidos a um candidato a emprego. O conjunto de APIs Google Maps tem várias opções para apresentar um mapa. Algumas opções da API Maps são mais eficazes do que outras. Por exemplo, a visualização do mapa de calor do JavaScript do Google Maps, quando combinada com a agrupamento de marcadores, é uma forma eficaz de visualizar os trabalhos relevantes devolvidos a um candidato a emprego na área determinada pelas suas preferências de deslocação definidas. Por outro lado, o modo de direções não mostra todas as ofertas de emprego devolvidas num pedido de pesquisa e não é uma opção recomendada.

Nota: as APIs Google Maps têm várias estruturas de preços diferentes. Estes preços NÃO são abrangidos pela utilização da Cloud Talent Solution. Apenas a utilização das APIs Cloud Talent Solution para pedir os trabalhos dentro dos tempos de trajeto especificados é abrangida como parte dos preços da Cloud Talent Solution.

Para mais informações sobre a implementação de uma pesquisa baseada em deslocações, consulte o guia de instruções da pesquisa de deslocações.