Suche in Abhängigkeit von der Anfahrtszeit in Ihrer UI implementieren

Sie können die Suche in Abhängigkeit von der Anfahrtszeit in Ihre UI einbinden, um Jobsuchenden die Suche nach Jobs in einem geografischen Gebiet zu ermöglichen, das über die Anfahrtszeit festgelegt wird. Bei der Suche in Abhängigkeit von der Anfahrtszeit wird die Anfahrtszeit basierend auf dem ausgewählten Verkehrsmittel des Nutzers und der Tageszeit, zu der er unterwegs sein wird, geschätzt.

Pendelsuche implementieren

1. Bevor Sie die Suche in Abhängigkeit von der Anfahrtszeit implementieren können, muss Cloud Talent Solution in Ihre UI integriert werden. Folgen Sie den Schnellstartanleitungen, um Cloud Talent Solution einzurichten.

2. Bei der Suche in Abhängigkeit von der Anfahrtszeit werden die Adressdaten, die Sie während der CTS-Implementierung mit Ihren Jobs hochgeladen haben, zur Berechnung der Anfahrtszeit verwendet. Um diese Funktion in Ihrer vorhandenen CTS-Benutzeroberfläche zu aktivieren, senden Sie eine jobs.search -Anfrage und fügen Sie ein CommuteFilter - Objekt in das Feld JobQuery.commuteFilter ein. commuteMethod, travelDuration, startCoordinates und roadTraffic oder departureTime sind Pflichtfelder.

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für CTS finden Sie unter CTS-Clientbibliotheken. Weitere Informationen finden Sie in der CTS Go-API Referenzdokumentation.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei CTS zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Informationen zum Installieren und Verwenden der Clientbibliothek für CTS finden Sie unter CTS-Clientbibliotheken Weitere Informationen finden Sie in der CTS Java-API Referenzdokumentation.

Richten Sie zur Authentifizierung bei CTS die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Informationen zum Installieren und Verwenden der Clientbibliothek für CTS finden Sie unter CTS-Clientbibliotheken Weitere Informationen finden Sie in der CTS Node.js-API Referenzdokumentation.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei CTS zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Informationen zum Installieren und Verwenden der Clientbibliothek für CTS finden Sie unter CTS-Clientbibliotheken Weitere Informationen finden Sie in der Referenzdokumentation zur CTS Python API.

Richten Sie zur Authentifizierung bei CTS die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

UI-Empfehlungen

1. Cloud Talent Solution lässt die Suche nach beiden Entfernungen (mit dem CTS-Standortfilter) im selben API-Aufruf nicht zu. Damit Jobsuchende Zugriff auf beide Optionen erhalten, verwenden Sie einen Ansatz mit zwei Tabs oder Ähnliches.

2. Ändern Sie das Frontend Ihrer Anwendung, um sicherzustellen, dass das Backend die relevanten Informationen eines Jobsuchenden automatisch in den Filter "Pendelstrecke" einfügt. Das Back-End sollte die API wie bei einer normalen Suchanfrage aufrufen.

3. Elemente in die Benutzeroberfläche einschließen:

   • Eine Option zur Auswahl einer Entfernungssuche oder einer Pendelstrecke. Ihre Such-UI könnte beispielsweise so aussehen:

     

   • Drop-down-Menü mit Optionen für die Anfahrtszeitmethode.

   • Option zum Anpassen der Verkehrsbedingungen.

   • Gesamtfahrzeit (die maximal unterstützte Fahrzeit beträgt 60 Minuten).

   • Anfahrtsstartzeit.

4. Die von der API zurückgegebenen Informationen zur Anfahrtszeit werden verwendet, um Informationen für den Jobsuchenden anzuzeigen. In der Ergebnisliste werden nur relevante Jobs zurückgegeben, die sich innerhalb des festgelegten Anfahrtszeitgebiets befinden. In der Dokumentation zu Best Practices für die Jobsuche finden Sie Informationen dazu, wie Sie die Reihenfolge und Anzahl der in diesem Gebiet zurückgegebenen Jobs anpassen können.

5. Die Ergebnisse der Pendelsuche basieren eher auf historischen und aggregierten Daten als auf Live-Verkehrsbedingungen. Die departureTime Verkehrsbedingungen werden aus den durchschnittlichen Verkehrsbedingungen zur angegebenen Tageszeit berechnet. Die Optionen BUSY_HOUR/TRAFFIC_FREE unter roadTraffic sind durchschnittliche Verkehrsbedingungen zur Hauptverkehrszeit am Morgen bzw. um Mitternacht. Nutzer erhalten unabhängig von der Tageszeit, zu der sie eine Anfrage senden, dieselben Ergebnisse für den Pendelverkehr.

Karte mit Anfahrtszeitinformationen erstellen (empfohlen)

Sie können mit Google Maps eine Karte erstellen, die auf den von CTS zurückgegebenen Informationen zur Anfahrtszeit basiert, und sie in die Ergebnisse einbetten, die an einen Jobsuchenden zurückgegeben werden. Die Maps API-Suite bietet mehrere Optionen zum Anzeigen einer Karte. Einige Google Maps API-Optionen sind wirkungsvoller als andere. Die JavaScript-Heatmap-Visualisierung von Google Maps in Verbindung mit Marker-Clustering ist beispielsweise eine effektive Möglichkeit, die relevanten Jobs zu visualisieren, die an einen Jobsuchenden in dem Gebiet zurückgegeben werden, das durch die festgelegten Pendelstrecken bestimmt wird. Dagegen werden im Wegbeschreibungsmodus nicht alle in einer Suchanfrage zurückgegebenen Jobs angezeigt. Deshalb ist er keine empfohlene Option.

Hinweis: Google Maps-APIs haben verschiedene Preisstrukturen. Diese Preise sind NICHT durch die Nutzung von Cloud Talent Solution abgedeckt. Nur die Nutzung der Cloud Talent Solution APIs zum Anfragen von Jobs innerhalb der angegebenen Anfahrtszeiten ist in den Cloud Talent Solution-Preisen inbegriffen.

Weitere Informationen zur Implementierung einer auf der Anfahrtszeit basierenden Suche finden Sie in der Anleitung zur Suche in Abhängigkeit von der Anfahrtszeit.