Implementazione della ricerca per tragitto giornaliero nell'interfaccia utente

Puoi integrare la ricerca relativa al tragitto giornaliero nella tua UI per consentire a chi cerca lavoro di cercare offerte di lavoro all'interno di un'area geografica impostata in base ai tempi di percorrenza del tragitto giornaliero. La ricerca basata sul tragitto giornaliero stima il tempo di percorrenza del tragitto giornaliero in base alla modalità di trasporto pubblico selezionata dall'utente e all'ora del giorno in cui prevede di viaggiare.

Implementare la ricerca per tragitto giornaliero

1. Prima di poter implementare la ricerca basata sul tragitto giornaliero, Cloud Talent Solution deve essere collegato alla tua UI. Segui <atarget="_blank" class="external" l10n-attrs-original-order="href,target,class" l10n-encrypted-href="gMBmW1CJpUkqBwsc6X45vJFGBtNXMtSEozqMDCbrBLAVTmdE5Zm3DKcU3qbzRuF6qLED1Accelerat&aq=it&sjid=3 eDeeck/?l=it</a>

2. La ricerca basata sul tragitto giornaliero utilizza i dati degli indirizzi che hai caricato con i tuoi job durante l'implementazione della CTS per calcolare il tempo di percorrenza del tragitto giornaliero. Per abilitare questa funzionalità nella tua UI di CTS esistente, invia una richiesta jobs.search e includi un oggetto CommuteFilter nel campo JobQuery.commuteFilter. commuteMethod, travelDuration, startCoordinates e roadTraffic o departureTime sono campi obbligatori.

Go

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

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 maggiori informazioni, consulta la documentazione di riferimento dell'API Java CTS.

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 maggiori informazioni, consulta la documentazione di riferimento dell'API Node.js CTS.

Per eseguire l'autenticazione su CTS, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare 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 maggiori informazioni, consulta la documentazione di riferimento dell'API Python CTS.

Per eseguire l'autenticazione su CTS, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare 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 dell'interfaccia utente

1. Cloud Talent Solution non consente la ricerca per entrambe le distanze (utilizzando il filtro località CTS) del tragitto giornaliero nella stessa chiamata API. Per consentire a chi cerca lavoro di accedere a entrambe le opzioni, utilizza un approccio basato su due schede o un approccio simile.

2. Modifica il frontend dell'applicazione per assicurarti che il backend compili automaticamente le informazioni pertinenti di una persona che cerca un job nel filtro del tragitto giornaliero. Il backend deve chiamare l'API come 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 al seguente:

     

   • 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 del tragitto giornaliero restituite dall'API vengono utilizzate per mostrare le informazioni a chi cerca un impiego. Nell'elenco dei risultati vengono restituite solo le offerte di lavoro pertinenti che si trovano nell'area di tempo del tragitto giornaliero designata. Consulta la documentazione sulle best practice per la ricerca di job per una spiegazione dei modi per modificare l'ordine e il numero di job restituiti in quest'area.

5. I risultati di ricerca relativi al tragitto giornaliero sono basati su dati storici e aggregati anziché sulle condizioni del traffico in tempo reale. Le condizioni del traffico departureTime vengono calcolate in base alle condizioni medie del traffico nell'ora del giorno specificata. Le opzioni BUSY_HOUR/TRAFFIC_FREE in roadTraffic corrispondono alle condizioni medie del traffico rispettivamente all'ora di punta del mattino e a mezzanotte. Gli utenti ricevono i risultati di ricerca relativi al tragitto giornaliero, a prescindere dall'ora del giorno in cui inviano una query.

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

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

Nota: le API di Google Maps presentano diverse strutture di prezzi. Questi prezzi NON sono coperti dall'utilizzo di Cloud Talent Solution. Solo l'utilizzo delle API Cloud Talent Solution per richiedere le offerte di lavoro nei tempi di percorrenza specificati è coperto come parte dei prezzi di Cloud Talent Solution.

Per ulteriori informazioni sull'implementazione di una ricerca basata sul tragitto giornaliero, consulta la guida illustrativa a Ricerca tragitto giornaliero.