Mettre en œuvre la recherche basée sur le temps de trajet dans votre interface utilisateur (v4beta1)

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.

  1. Avant de pouvoir mettre en œuvre la recherche basée sur le temps de trajet, vous devez avoir connecté Cloud Talent Solution à votre interface utilisateur. Suivez la <atarget="_blank" class="external" l10n-attrs-original-order="href,target,class" l10n-encrypted-href="I2bjjCb1CfjxAHi33R1uSZFGBtNXMtKHzbcHzHybZHbRhZHzDYHwbDhbHzhybhzhBHbhbbbbbbhbHNHbwhby guides de configuration de Cloud Talent Solution.</atarget="_blank">

  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

import (
	"context"
	"fmt"
	"io"

	talent "cloud.google.com/go/talent/apiv4beta1"
	"github.com/golang/protobuf/ptypes/duration"
	talentpb "google.golang.org/genproto/googleapis/cloud/talent/v4beta1"
	"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: %v", 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: %v", 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 en savoir plus sur l'installation et la création d'un client Cloud Talent Solution, consultez la page Bibliothèques clientes 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

Pour en savoir plus sur l'installation et la création d'un client Cloud Talent Solution, consultez la page Bibliothèques clientes Cloud Talent Solution.


from google.cloud import talent
import six

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, six.binary_type):
        project_id = project_id.decode("utf-8")
    if isinstance(tenant_id, six.binary_type):
        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.

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.

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.