Implementare la ricerca basata sul tragitto giornaliero nell'interfaccia utente

Puoi integrare la ricerca sul tragitto giornaliero nella UI per consentire alle persone in cerca di lavoro di cercare offerte di lavoro all'interno di un'area geografica impostata in base ai tempi del tragitto giornaliero. Stime di ricerca basate sul tragitto giornaliero Tempo di percorrenza del tragitto giornaliero in base alla modalità di trasporto pubblico selezionata dall'utente e all'ora del giorno in cui hanno in programma di viaggiare.

Implementare la ricerca basata sul tragitto giornaliero

1. Prima di poter implementare la ricerca per tragitto giornaliero, Cloud Talent Solution deve essere collegato alla tua UI. Segui le guide di guida rapida per configurare Cloud Talent Solution.

2. La ricerca basata sul tragitto giornaliero utilizza i dati degli indirizzi che hai caricato con le tue offerte di lavoro durante Implementazione di CTS per calcolare i tempi di percorrenza del tragitto giornaliero. Per attivare questa funzione nell'interfaccia utente CTS esistente, invia jobs.search e includi un oggetto CommuteFilter nella JobQuery.commuteFilter. commuteMethod, travelDuration, startCoordinates e roadTraffic o departureTime sono campi obbligatori.

Go

Per informazioni su come installare e utilizzare la libreria client per CTS, consulta Librerie client di CTS. Per ulteriori informazioni, consulta API Go di CTS documentazione di riferimento.

Per eseguire l'autenticazione su CTS, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per scoprire come installare e utilizzare la libreria client per CTS, consulta Librerie client CTS. Per ulteriori informazioni, consulta API Java di CTS documentazione di riferimento.

Per eseguire l'autenticazione su CTS, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per scoprire come installare e utilizzare la libreria client per CTS, consulta Librerie client CTS. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API CTS Node.js.

Per eseguire l'autenticazione su CTS, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per scoprire come installare e utilizzare la libreria client per CTS, consulta Librerie client CTS. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API CTS Python.

Per autenticarti a CTS, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Suggerimenti per l'interfaccia utente

1. Cloud Talent Solution non consente di eseguire ricerche sia in base alla distanza (utilizzando il filtro di località CTS) sia in base al tempo di percorrenza nella stessa chiamata dell'API. Per consentire ai candidati di accedere a entrambe le opzioni, utilizza un approccio con due schede o simile.

2. Modifica il frontend dell'applicazione per assicurarti che il backend completi automaticamente le informazioni pertinenti di un candidato nel filtro per tragitto giornaliero. Il backend deve chiamare l'API come farebbe in una normale richiesta di ricerca.

3. Includi elementi nell'interfaccia utente:

   • Un'opzione per selezionare una ricerca per distanza o per tragitto giornaliero. Ad esempio, l'interfaccia utente della Ricerca potrebbe essere simile all'esempio riportato di seguito:

     

   • Un menu a discesa con le opzioni relative ai metodi di tragitto giornaliero.

   • Un'opzione per regolare le condizioni del traffico.

   • Il tempo di percorrenza totale (il tempo di percorrenza massimo supportato è di 60 minuti).

   • Ora di inizio del tragitto giornaliero.

4. Le informazioni sui tempi di percorrenza restituite dall'API vengono utilizzate per mostrare informazioni al candidato. Nell'elenco dei risultati vengono restituiti solo i lavori pertinenti che si trovano all'interno dell'area designata per il tempo di percorrenza. Consulta la documentazione relativa alle best practice di Ricerca di lavoro per una discussione sui modi per modificare l'ordine e il numero di annunci di lavoro restituiti in questa area.

5. I risultati di ricerca sul tragitto giornaliero si basano su dati storici e aggregati rispetto alle condizioni del traffico in tempo reale. Il traffico di departureTime vengono calcolate in base alle condizioni medie del traffico al in base all'ora del giorno. Le opzioni BUSY_HOUR/TRAFFIC_FREE in roadTraffic sono condizioni medie del traffico rispettivamente all'ora di punta e a mezzanotte. Gli utenti ricevono gli stessi risultati di ricerca relativi al tragitto giornaliero, a prescindere dall'ora quando inviano una query.

Generazione di una mappa con informazioni sul tragitto giornaliero (consigliato)

Puoi utilizzare Google Maps per generare una mappa in base ai tempi di percorrenza del tragitto giornaliero le informazioni restituite da CTS e le incorporano nei risultati. a chi è in cerca di lavoro. La suite API Maps offre diverse opzioni per la visualizzazione di una mappa. Alcune opzioni dell'API di Google Maps sono più efficaci di altre. Per Ad esempio, la visualizzazione della mappa termica JavaScript di Google Maps abbinato al clustering degli indicatori è un modo efficace per visualizzare i lavori pertinenti restituiti a chi cerca un impiego all'interno dell'area determinata dalle preferenze per il tragitto giornaliero impostate. Al contrario, la modalità Indicazioni non mostra tutti i job restituiti in una richiesta di ricerca e non è un'opzione consigliata.

Nota: le API di Google Maps prevedono varie strutture di prezzi. Questi prezzi NON sono coperti dall'utilizzo di Cloud Talent Solution. Solo l'utilizzo delle API Cloud Talent Solution per richiedere i lavori entro i tempi di percorrenza indicati è coperto dai prezzi di Cloud Talent Solution.

Per ulteriori informazioni sull'implementazione di una ricerca basata sul tragitto giornaliero, consulta le Guida illustrativa alla ricerca del tragitto giornaliero.