Implementazione della ricerca per tragitto giornaliero nell'interfaccia utente (v4beta1)

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

Implementare la ricerca basata sul tragitto giornaliero

1. Prima di poter implementare la ricerca basata sul tragitto giornaliero, è necessario collegare Cloud Talent Solution a l'UI. Segui le guida rapida guide per la configurazione di 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 funzionalità nell'interfaccia utente 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 ulteriori informazioni, consulta API Go di CTS documentazione di riferimento.

Per autenticarti a CTS, configura le 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 saperne di più sull'installazione e sulla creazione di un client Cloud Talent Solution, consulta Librerie client 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

Per saperne di più sull'installazione e sulla creazione di un client Cloud Talent Solution, consulta Librerie client 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

Suggerimenti sull'interfaccia utente

1. Cloud Talent Solution non consente la ricerca per entrambe le ricerche a distanza (utilizzando filtro località CTS) tempo di tragitto giornaliero nella stessa API chiamata. Per consentire a chi cerca lavoro di accedere a entrambe le opzioni, utilizza un approccio a due schede oppure simili.

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 di distanza o una ricerca basata sul tragitto giornaliero. Ad esempio, l'interfaccia utente della Ricerca potrebbe essere simile all'esempio riportato di seguito:

     

   • Un menu a discesa con le opzioni per il metodo 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 sul tempo di percorrenza del tragitto giornaliero restituite dall'API vengono utilizzate per visualizzare le informazioni a chi cerca lavoro. Nell'elenco dei risultati vengono restituiti solo i lavori pertinenti che si trovano all'interno dell'area designata per il tempo di percorrenza. Scopri il job Best practice per la rete di ricerca documentazione per una discussione su come modificare l'ordine e il numero lavori restituiti in quest'area.

5. I risultati di ricerca relativi ai percorsi giornalieri si basano su dati storici e aggregati anziché sulle condizioni del traffico in tempo reale. Le condizioni di traffico departureTime vengono calcolate in base alle condizioni di traffico medie all'ora del giorno specificata. 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 alle informazioni sul tempo di percorrenza riportate da CTS e incorporarla nei risultati riportati a un cercatore di lavoro. La suite API Maps offre diverse opzioni per la visualizzazione di una mappa. Alcune opzioni dell'API 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 Maps hanno una serie di strutture di prezzo diverse. Questi prezzi sono NON coperto dall'utilizzo di Cloud Talent Solution. Solo l'utilizzo di Cloud Talent Solution Le API per richiedere i lavori entro i tempi del tragitto giornaliero specificati vengono considerate come fanno parte dei prezzi di Cloud Talent Solution.

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