Suche in Abhängigkeit von der Anfahrtszeit

Jobsuchanfragen können einen Anfahrtszeitfilter enthalten, der die zurückgegebenen Jobs auf eine angegebene Fahrtzeit vom Startpunkt aus begrenzt. Die Ergebnisse enthalten die geschätzte Anfahrtszeit in Sekunden für übereinstimmende Jobs.

Senden Sie eine Anfrage vom Typ jobs.search und fügen Sie ein Objekt vom Typ CommuteFilter in das Feld JobQuery.commuteFilter ein, um Jobs innerhalb einer bestimmten Anfahrtszeit zurückzugeben. Cloud Talent Solution verwendet die Adresse des Jobs, um die Anfahrtszeit für diesen Job zu berechnen. Wenn keine detaillierte Adresse angegeben ist, versucht Cloud Talent Solution, die tatsächliche Adresse des Jobs abzuleiten.

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 {
  // 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();
  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

Pflichtfelder

  • commuteMethod: Die Beförderungsart, für die die Anfahrtszeit berechnet wird. Optionen sind DRIVING und TRANSIT. Alle Versionen seit V3p1beta1 enthalten auch die Bewegungsarten WALKING und CYCLING. Wander- und Radrouten spiegeln möglicherweise nicht die Gegebenheiten in der realen Welt wider (z. B. Baustellen) oder umfassen keine eindeutigen Wander- oder Radwege. Diese Antworten enthalten warnings im zurückgegebenen Ergebnis, die Sie Ihren Nutzern anzeigen müssen.

  • travelDuration: Die maximale Anfahrtszeit in Sekunden. Der maximal zulässige Wert ist 3600s (eine Stunde). Das Format ist 123s.

  • startCoordinates: Der Breiten- und Längengrad des Ortes, der als Ausgangspunkt für die Berechnung der Anfahrtszeit dient. Akzeptiert ein Objekt vom Typ LatLng.

Optionale Felder

  • allowImpreciseAddresses: "Präzise" Adressen werden entweder als vollständige Adressen oder als GPS-Koordinaten definiert. Wenn allowImpreciseAddresses auf true gesetzt ist, können auch Jobs mit "ungenauen" Adressen (nur Stadt, Bundesland oder Land) zurückgegeben werden. Für Adressen auf Stadtebene und höherer Ebene wird ein Textabgleich verwendet. Ist der Wert für dieses Feld auf false gesetzt oder nicht angegeben, werden bei der Suche in Abhängigkeit von der Anfahrtszeit nur vollständige Adressen zurückgegeben.
  • roadTraffic: Gibt die zu verwendende Verkehrsdichte bei der Berechnung der Anfahrtszeit an. Optionen sind TRAFFIC_FREE oder BUSY_HOUR. Muss nicht vorhanden sein, wenn departureHourLocal angegeben ist.

  • departureTime: Die Abfahrtszeit zur Berechnung der Auswirkungen durch das Verkehrsaufkommen. Akzeptiert eine Ganzzahl zwischen 0 und 23, die für die Stunde in der Zeitzone der startLocation steht. Muss nicht vorhanden sein, wenn roadTraffic angegeben ist.