Suche in Abhängigkeit von der Anfahrtszeit in Ihrer UI implementieren (v3)

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.

  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 auf Ihrer vorhandenen CTS-Benutzeroberfläche zu aktivieren, senden Sie eine jobs.search -Anforderung und fügen Sie ein CommuteFilter -Objekt in das Feld JobQuery.commuteFilter ein. commuteMethod, travelDuration und startCoordinates sind Pflichtfelder.

    Java

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

    
    public static void commuteSearch(String companyName) throws IOException, InterruptedException {
      // Make sure to set the requestMetadata the same as the associated search request
      RequestMetadata requestMetadata =
          new RequestMetadata()
              // Make sure to hash your userID
              .setUserId("HashedUserId")
              // Make sure to hash the sessionID
              .setSessionId("HashedSessionID")
              // Domain of the website where the search is conducted
              .setDomain("www.google.com");
      JobQuery jobQuery =
          new JobQuery()
              .setCommuteFilter(
                  new CommuteFilter()
                      .setRoadTraffic("TRAFFIC_FREE")
                      .setCommuteMethod("TRANSIT")
                      .setTravelDuration("1000s")
                      .setStartCoordinates(
                          new LatLng().setLatitude(37.422408)
                              .setLongitude(-122.085609)));
      if (companyName != null) {
        jobQuery.setCompanyNames(Arrays.asList(companyName));
      }
    
      SearchJobsRequest searchJobsRequest =
          new SearchJobsRequest()
              .setJobQuery(jobQuery)
              .setRequestMetadata(requestMetadata)
              .setJobView("JOB_VIEW_FULL")
              .setRequirePreciseResultSize(true);
      SearchJobsResponse response =
          talentSolutionClient.projects().jobs().search(DEFAULT_PROJECT_ID, searchJobsRequest)
              .execute();
      Thread.sleep(1000);
      System.out.println(response);
    }

    Python

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

    def commute_search(client_service, company_name):
        request_metadata = {
            'user_id': 'HashedUserId',
            'session_id': 'HashedSessionId',
            'domain': 'www.google.com'
        }
        start_location = {'latitude': 37.422408, 'longitude': -122.085609}
        commute_preference = {
            'road_traffic': 'TRAFFIC_FREE',
            'commute_method': 'TRANSIT',
            'travel_duration': '1000s',
            'start_coordinates': start_location
        }
        job_query = {'commute_filter': commute_preference}
        if company_name is not None:
            job_query.update({'company_names': [company_name]})
        request = {
            'job_query': job_query,
            'request_metadata': request_metadata,
            'job_view': 'JOB_VIEW_FULL',
            'require_precise_result_size': True
        }
        response = client_service.projects().jobs().search(
            parent=parent, body=request).execute()
        print(response)

    C#

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

    
    public static void CommuteSearch(string companyName)
    {
        RequestMetadata requestMetadata = new RequestMetadata()
        {
            // Make sure to hash your userID
            UserId = "HashedUserId",
            // Make sure to hash the sessionID
            SessionId = "HashedSessionId",
            // Domain of the website where the search is conducted
            Domain = "www.google.com"
        };
    
        JobQuery jobQuery = new JobQuery()
        {
            CommuteFilter = new CommuteFilter()
            {
                RoadTraffic = "TRAFFIC_FREE",
                CommuteMethod = "TRANSIT",
                TravelDuration = "1000s",
                StartCoordinates = new LatLng()
                {
                    Latitude = 37.42208,
                    Longitude = -122.085609
                }
            }
        };
    
        if (companyName != null)
        {
            jobQuery.CompanyNames = new List<string>
            {
                companyName
            };
        }
    
        SearchJobsRequest searchJobRequest = new SearchJobsRequest()
        {
            RequestMetadata = requestMetadata,
            JobQuery = jobQuery,
            JobView = "JOB_VIEW_FULL",
            RequirePreciseResultSize = true
        };
    
        SearchJobsResponse searchJobsResponse = jobServiceClient.Projects.Jobs.Search(searchJobRequest, parent).Execute();
    
        Console.WriteLine("Jobs commute searched: " + ToJsonString(searchJobsResponse));
    }

    Go

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

    
    // commuteSearch searches for jobs within commute filter.
    func commuteSearch(w io.Writer, projectID, companyName string) (*talent.SearchJobsResponse, error) {
    	ctx := context.Background()
    
    	client, err := google.DefaultClient(ctx, talent.CloudPlatformScope)
    	if err != nil {
    		return nil, fmt.Errorf("google.DefaultClient: %v", err)
    	}
    	// Create the jobs service client.
    	service, err := talent.New(client)
    	if err != nil {
    		return nil, fmt.Errorf("talent.New: %v", err)
    	}
    
    	jobQuery := &talent.JobQuery{
    		CommuteFilter: &talent.CommuteFilter{
    			RoadTraffic:    "TRAFFIC_FREE",
    			CommuteMethod:  "TRANSIT",
    			TravelDuration: "1000s",
    			StartCoordinates: &talent.LatLng{
    				Latitude:  37.422408,
    				Longitude: -122.085609,
    			},
    		},
    	}
    	if companyName != "" {
    		jobQuery.CompanyNames = []string{companyName}
    	}
    
    	parent := "projects/" + projectID
    	req := &talent.SearchJobsRequest{
    		// Make sure to set the RequestMetadata the same as the associated
    		// search request.
    		RequestMetadata: &talent.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,
    		// Set the search mode to a regular search.
    		SearchMode:               "JOB_SEARCH",
    		RequirePreciseResultSize: true,
    	}
    	resp, err := service.Projects.Jobs.Search(parent, req).Do()
    	if err != nil {
    		return nil, fmt.Errorf("failed to search for jobs with commute filter: %v", err)
    	}
    	return resp, nil
    }
    

    Node.js

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

    const commuteSearch = async (jobServiceClient, companyName) => {
      try {
        const requestMetadata = {
          userId: 'HashedUserId',
          sessionId: 'HashedSessionId',
          domain: 'www.google.com',
        };
    
        const startLocation = {
          latitude: 37.422408,
          longitude: -122.085609,
        };
    
        const commutePreference = {
          roadTraffic: 'TRAFFIC_FREE',
          commuteMethod: 'TRANSIT',
          travelDuration: '1000s',
          startCoordinates: startLocation,
        };
    
        const jobQuery = {
          commuteFilter: commutePreference,
        };
    
        if (companyName) {
          jobQuery.companyNames = [companyName];
        }
    
        const request = {
          parent: `projects/${PROJECT_ID}`,
          resource: {
            jobQuery: jobQuery,
            requestMetadata: requestMetadata,
            jobView: 'JOB_VIEW_FULL',
            requirePreciseResultSize: true,
          },
        };
    
        const result = await jobServiceClient.projects.jobs.search(request);
    
        console.log(JSON.stringify(result.data));
      } catch (e) {
        console.error(e);
        throw e;
      }
    };

    Ruby

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

    # project_id              = "Id of the project"
    # commute_method          = "The method of transportation for which to calculate the commute time"
    # travel_duration         = "The maximum travel time in seconds"
    # start_coordinates       = "The latitude and longitude of the location from which to calculate the commute time"
    
    require "google/apis/jobs_v3"
    
    jobs = Google::Apis::JobsV3
    talent_solution_client = jobs::CloudTalentSolutionService.new
    # @see https://developers.google.com/identity/protocols/application-default-credentials#callingruby
    talent_solution_client.authorization = Google::Auth.get_application_default(
      "https://www.googleapis.com/auth/jobs"
    )
    
    # Make sure to set the request_metadata the same as the associated search request
    request_metadata = jobs::RequestMetadata.new user_id:    "HashedUserId",
                                                 session_id: "HashedSessionId",
                                                 domain:     "www.google.com"
    # Set location filter
    commute_filter = jobs::CommuteFilter.new road_traffic:      "TRAFFIC_FREE",
                                             commute_method:    commute_method,
                                             travel_duration:   travel_duration,
                                             start_coordinates: start_coordinates
    # Perform a search for analyst  related jobs
    search_jobs_request =
      jobs::SearchJobsRequest.new request_metadata:            request_metadata,
                                  job_query:                   (jobs::JobQuery.new commute_filter: commute_filter),
                                  job_view:                    "JOB_VIEW_FULL",
                                  require_precise_result_size: true
    search_jobs_response = talent_solution_client.search_jobs project_id, search_jobs_request
    puts search_jobs_response.to_json
    search_jobs_response

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.