Mettre en œuvre la recherche d'emploi basée sur le temps de trajet dans votre interface utilisateur

En intégrant la recherche d'emploi basée sur le temps de trajet dans votre interface utilisateur, vous donnez aux demandeurs d'emploi la possibilité de restreindre leurs recherches à une zone géographique définie par leur temps de trajet domicile-travail. La recherche basée sur le temps de trajet évalue le temps de trajet domicile-travail en fonction du mode de transport choisi par l'utilisateur et du moment de la journée auquel il compte effectuer ses trajets.

Mettre en œuvre la recherche d'emploi basée sur le temps de trajet domicile-travail

1. Avant de pouvoir implémenter la recherche basée sur le temps de trajet, vous devez avoir connecté Cloud Talent Solution à votre interface utilisateur. Suivez les guides de démarrage rapide pour configurer Cloud Talent Solution.

2. La recherche basée sur le temps de trajet s'appuie sur les données d'adresse que vous avez téléchargées avec vos offres d'emploi lors de la mise en œuvre de CTS pour calculer le temps de trajet. Pour activer cette fonctionnalité dans votre interface utilisateur CTS existante, envoyez une requête jobs.search et incluez un objet CommuteFilter dans le champ JobQuery.commuteFilter. commuteMethod, travelDuration, startCoordinates et roadTraffic ou departureTime sont des champs obligatoires.

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour CTS, consultez la page Bibliothèques clientes CTS. Pour en savoir plus, consultez les API CTS Go documentation de référence.

Pour vous authentifier auprès de CTS, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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

Pour savoir comment installer et utiliser la bibliothèque cliente pour CTS, consultez Bibliothèques clientes CTS. Pour en savoir plus, consultez les API CTS Java documentation de référence.

Pour vous authentifier auprès de CTS, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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

Pour savoir comment installer et utiliser la bibliothèque cliente pour CTS, consultez Bibliothèques clientes CTS. Pour en savoir plus, consultez la documentation de référence de l'API CTS Node.js.

Pour vous authentifier auprès de CTS, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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

Pour savoir comment installer et utiliser la bibliothèque cliente pour CTS, consultez Bibliothèques clientes CTS. Pour en savoir plus, consultez la documentation de référence de l'API CTS Python.

Pour vous authentifier auprès de CTS, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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

Recommandations relatives à l'interface utilisateur

1. Cloud Talent Solution ne permet pas de faire porter une recherche à la fois sur la distance (via un filtre de lieu CTS) ET sur le temps de trajet dans le même appel d'API. Pour permettre aux chercheurs d'emploi d'accéder aux deux options, vous devez recourir à deux onglets ou à une approche équivalente.

2. Modifiez l'interface de votre application pour vous assurer que le serveur backend insère automatiquement les informations pertinentes d'un demandeur d'emploi dans le filtre de temps de trajet. Le backend doit appeler l'API comme il le ferait dans une requête de recherche normale.

3. Incluez des éléments dans votre interface utilisateur :

   • Une option permettant d'indiquer si la recherche doit être basée sur la distance ou sur le temps de trajet. Par exemple, votre interface de recherche pourrait se présenter comme suit :

     

   • un menu déroulant proposant les différents modes de transport ;

   • une option permettant d'ajuster les conditions de circulation ;

   • la durée totale du trajet (la durée maximale de trajet autorisée est de 60 minutes) ;

   • l'heure de début du trajet.

4. Les informations relatives au temps de trajet renvoyées par l'API sont ensuite utilisées pour présenter des informations au demandeur d'emploi. Seules les offres d'emploi pertinentes situées dans la zone géographique correspondant au temps de trajet indiqué sont renvoyées dans la liste des résultats. Reportez-vous à la documentation Meilleures pratiques en matière de recherche d'emploi pour voir comment ajuster l'ordre et le nombre d'offres d'emploi renvoyées pour cette zone.

5. Les résultats de la recherche de temps de trajet sont basés sur des données historiques et agrégées plutôt que sur les conditions de circulation en direct. Les conditions de circulation departureTime sont calculées à partir des conditions de circulation moyennes à l'heure spécifiée de la journée. Les options BUSY_HOUR/TRAFFIC_FREE sous roadTraffic sont des conditions de circulation moyennes aux heures de pointe le matin et à minuit, respectivement. Les utilisateurs reçoivent les mêmes résultats de recherche de temps de trajet, quelle que soit l'heure à laquelle ils envoient une requête.

Générer une carte à l'aide des informations sur le temps de trajet (recommandé)

Vous pouvez utiliser Google Maps pour générer une carte basée sur les informations de temps de trajet renvoyées par CTS et l'intégrer dans les résultats renvoyés à un demandeur d'emploi. La suite API Maps propose différentes options pour afficher une carte. Certaines options de l'API Google Maps sont plus efficaces que d'autres. Par exemple, la visualisation des cartes de densité JavaScript Google Maps associée au regroupement de marqueurs constitue un moyen efficace d'afficher les offres d'emploi pertinentes qui sont renvoyées à un demandeur d'emploi en fonction d'une zone déterminée par ses préférences de trajet domicile-travail. En revanche, le mode Itinéraire n'affiche pas la totalité des offres d'emploi renvoyées dans le cadre d'une requête de recherche et ne constitue donc pas une option recommandée.

Remarque : les API Maps présentent plusieurs grilles tarifaires distinctes. Ces prix ne sont PAS compris dans l'utilisation de Cloud Talent Solution. Seule l'utilisation des API Cloud Talent Solution pour demander les offres d'emploi correspondant aux temps de trajet spécifiés est comprise dans la tarification de Cloud Talent Solution.

Pour plus d'informations sur la mise en œuvre d'une recherche basée sur le temps de trajet domicile-travail, consultez le Guide d'utilisation de la recherche d'emploi basée sur le temps de trajet.