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 integrieren, 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.

  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. Wenn Sie diese Funktion in Ihrer vorhandenen CTS-UI aktivieren möchten, senden Sie eine jobs.search-Anfrage und fügen Sie ein CommuteFilter-Objekt in das Feld JobQuery.commuteFilter ein. commuteMethod, travelDuration und startCoordinates sind Pflichtfelder.

Go

import (
	"context"
	"fmt"
	"io"

	talent "cloud.google.com/go/talent/apiv4beta1"
	"github.com/golang/protobuf/ptypes/duration"
	"google.golang.org/api/iterator"
	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)
	}

	// 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,
	}

	it := c.SearchJobs(ctx, req)

	for {
		resp, err := it.Next()
		if err == iterator.Done {
			return nil
		}
		if err != nil {
			return fmt.Errorf("it.Next: %v", err)
		}
		fmt.Fprintf(w, "Matcing job: %q\n", resp.GetJob().GetName())
		fmt.Fprintf(w, "Job address: %v\n", resp.GetCommuteInfo().GetJobLocation().GetPostalAddress().GetAddressLines())
	}
}

Java

Weitere Informationen zum Installieren und Erstellen eines Cloud Talent Solution-Clients finden Sie unter Cloud Talent Solution-Clientbibliotheken.

/*
 * Please include the following imports to run this sample.
 *
 * 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.MatchingJob;
 * import com.google.cloud.talent.v4beta1.TenantName;
 * import com.google.cloud.talent.v4beta1.TenantOrProjectName;
 * import com.google.protobuf.Duration;
 * import com.google.type.LatLng;
 */

/** Search Jobs using commute distance */
public static void sampleSearchJobs(String projectId, String tenantId) {
  try (JobServiceClient jobServiceClient = JobServiceClient.create()) {
    // projectId = "Your Google Cloud Project ID";
    // tenantId = "Your Tenant ID (using tenancy is optional)";
    TenantOrProjectName 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.TRANSIT;
    long seconds = 1800L;
    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.printf("Job summary: %s\n", responseItem.getJobSummary());
      System.out.printf("Job title snippet: %s\n", responseItem.getJobTitleSnippet());
      Job job = responseItem.getJob();
      System.out.printf("Job name: %s\n", job.getName());
      System.out.printf("Job title: %s\n", job.getTitle());
    }
  } catch (Exception exception) {
    System.err.println("Failed to create the client due to: " + exception);
  }
}

Node.js

Weitere Informationen zum Installieren und Erstellen eines Cloud Talent Solution-Clients finden Sie unter Cloud Talent Solution-Clientbibliotheken.

const talent = require('@google-cloud/talent').v4beta1;

/** 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);
    });
}

PHP

Weitere Informationen zum Installieren und Erstellen eines Cloud Talent Solution-Clients finden Sie unter Cloud Talent Solution-Clientbibliotheken.

require __DIR__ . '/vendor/autoload.php';

use Google\Cloud\Talent\V4beta1\JobServiceClient;
use Google\Cloud\Talent\V4beta1\CommuteFilter;
use Google\Cloud\Talent\V4beta1\CommuteMethod;
use Google\Cloud\Talent\V4beta1\JobQuery;
use Google\Cloud\Talent\V4beta1\RequestMetadata;
use Google\Protobuf\Duration;
use Google\Type\LatLng;

/** Search Jobs using commute distance */
function sampleSearchJobs($projectId, $tenantId)
{

    $jobServiceClient = new JobServiceClient();

    // $projectId = 'Your Google Cloud Project ID';
    // $tenantId = 'Your Tenant ID (using tenancy is optional)';
    $formattedParent = $jobServiceClient->tenantName($projectId, $tenantId);
    $domain = 'www.example.com';
    $sessionId = 'Hashed session identifier';
    $userId = 'Hashed user identifier';
    $requestMetadata = new RequestMetadata();
    $requestMetadata->setDomain($domain);
    $requestMetadata->setSessionId($sessionId);
    $requestMetadata->setUserId($userId);
    $commuteMethod = CommuteMethod::TRANSIT;
    $seconds = 1800;
    $travelDuration = new Duration();
    $travelDuration->setSeconds($seconds);
    $latitude = 37.422408;
    $longitude = 122.084068;
    $startCoordinates = new LatLng();
    $startCoordinates->setLatitude($latitude);
    $startCoordinates->setLongitude($longitude);
    $commuteFilter = new CommuteFilter();
    $commuteFilter->setCommuteMethod($commuteMethod);
    $commuteFilter->setTravelDuration($travelDuration);
    $commuteFilter->setStartCoordinates($startCoordinates);
    $jobQuery = new JobQuery();
    $jobQuery->setCommuteFilter($commuteFilter);

    try {
        // Iterate through all elements
        $pagedResponse = $jobServiceClient->searchJobs($formattedParent, $requestMetadata, ['customRankingInfo' => $customRankingInfo, 'orderBy' => $orderBy]);
        foreach ($pagedResponse->iterateAllElements() as $responseItem) {
            printf('Job summary: %s'.PHP_EOL, $responseItem->getJobSummary());
            printf('Job title snippet: %s'.PHP_EOL, $responseItem->getJobTitleSnippet());
            $job = $responseItem->getJob();
            printf('Job name: %s'.PHP_EOL, $job->getName());
            printf('Job title: %s'.PHP_EOL, $job->getTitle());
        }
    } finally {
        $jobServiceClient->close();
    }

}

Python

Weitere Informationen zum Installieren und Erstellen eines Cloud Talent Solution-Clients finden Sie unter Cloud Talent Solution-Clientbibliotheken.

from google.cloud import talent_v4beta1
from google.cloud.talent_v4beta1 import enums
import six

def sample_search_jobs(project_id, tenant_id):
    """Search Jobs using commute distance"""

    client = talent_v4beta1.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 = client.tenant_path(project_id, tenant_id)
    domain = 'www.example.com'
    session_id = 'Hashed session identifier'
    user_id = 'Hashed user identifier'
    request_metadata = {
        'domain': domain,
        'session_id': session_id,
        'user_id': user_id
    }
    commute_method = enums.CommuteMethod.TRANSIT
    seconds = 1800
    travel_duration = {'seconds': seconds}
    latitude = 37.422408
    longitude = 122.084068
    start_coordinates = {'latitude': latitude, 'longitude': longitude}
    commute_filter = {
        'commute_method': commute_method,
        'travel_duration': travel_duration,
        'start_coordinates': start_coordinates
    }
    job_query = {'commute_filter': commute_filter}

    # Iterate over all results
    for response_item in client.search_jobs(parent,
                                            request_metadata,
                                            job_query=job_query):
        print('Job summary: {}'.format(response_item.job_summary))
        print('Job title snippet: {}'.format(response_item.job_title_snippet))
        job = response_item.job
        print('Job name: {}'.format(job.name))
        print('Job title: {}'.format(job.title))

Ruby

Weitere Informationen zum Installieren und Erstellen eines Cloud Talent Solution-Clients finden Sie unter Cloud Talent Solution-Clientbibliotheken.

# Search Jobs using commute distance
def sample_search_jobs(project_id, tenant_id)
  # Instantiate a client
  job_client = Google::Cloud::Talent::JobService.new version: :v4beta1

  # project_id = "Your Google Cloud Project ID"
  # tenant_id = "Your Tenant ID (using tenancy is optional)"
  formatted_parent = job_client.class.tenant_path(project_id, tenant_id)
  domain = "www.example.com"
  session_id = "Hashed session identifier"
  user_id = "Hashed user identifier"
  request_metadata = {
    domain: domain,
    session_id: session_id,
    user_id: user_id
  }
  commute_method = :TRANSIT
  seconds = 1800
  travel_duration = { seconds: seconds }
  latitude = 37.422408
  longitude = 122.084068
  start_coordinates = { latitude: latitude, longitude: longitude }
  commute_filter = {
    commute_method: commute_method,
    travel_duration: travel_duration,
    start_coordinates: start_coordinates
  }
  job_query = { commute_filter: commute_filter }

  # Iterate over all results.
  job_client.search_jobs(formatted_parent, request_metadata, custom_ranking_info: custom_ranking_info, order_by: order_by).each do |element|
    puts "Job summary: #{element.job_summary}"
    puts "Job title snippet: #{element.job_title_snippet}"
    job = element.job
    puts "Job name: #{job.name}"
    puts "Job title: #{job.title}"
  end

end

Empfehlungen für Ihre UI

  1. Mit Cloud Talent Solution kann nicht gleichzeitig nach Entfernung (mithilfe des CTS-Standortfilters) UND nach Anfahrtszeit gesucht werden. Damit Jobsuchende Zugriff auf beide Optionen erhalten, verwenden Sie einen Ansatz mit zwei Tabs oder Ähnliches.

  2. Ändern Sie das Front-End Ihrer Anwendung so, dass das Back-End den Anfahrtszeitfilter mit den relevanten Informationen füllt und die API wie in einer regulären Suchanfrage aufruft, wenn ein Jobsuchender eine Suche nach der Anfahrtszeit durchführt.

  3. Fügen Sie diese neu hinzugefügten Elemente in Ihre UI ein:

    • Option zum Auswählen der Entfernungssuche oder der Anfahrtszeitsuche. 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 Anfahrtszeitinformationen werden dann 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.

Sie können die Google Maps API nutzen, um eine Karte basierend auf den von der CTS API zurückgegebenen Anfahrtszeitinformationen zu generieren und in die Ergebnisse einzubetten, die an einen Jobsuchenden zurückgegeben werden. Die Google Maps API-Suite bietet mehrere Optionen zum Anzeigen der Karte. Einige Google Maps API-Optionen sind wirkungsvoller als andere. Mit der JavaScript-Heatmap-Visualisierung für Google Maps in Kombination mit einem Markierungsclustering können Sie beispielsweise die relevanten Jobs visualisieren, die an einen Jobsuchenden zurückgegeben werden, und zwar innerhalb des Gebiets, das durch die angegebenen bevorzugten Anfahrtszeiten festgelegt wird. Dagegen werden im Wegbeschreibungsmodus nicht alle in einer Suchanfrage zurückgegebenen Jobs angezeigt. Deshalb ist er keine empfohlene Option.

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