Cette page a été traduite par l'API Cloud Translation.

Recherche de rémunération (v3)

Recherchez des offres d'emploi par plage de rémunération.

En savoir plus

Pour obtenir une documentation détaillée incluant cet exemple de code, consultez les articles suivants :

Filtres de recherche (v3)

Exemple de code

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour CTS, consultez la page Bibliothèques clientes CTS. Pour en savoir plus, consultez les API CTS Go documentation de référence.

Pour vous authentifier auprès de CTS, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.


// compensationSearch searches for job on compensation.
func compensationSearch(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: %w", err)
	}
	// Create the jobs service client.
	service, err := talent.New(client)
	if err != nil {
		return nil, fmt.Errorf("talent.New: %w", err)
	}

	jobQuery := &talent.JobQuery{
		CompensationFilter: &talent.CompensationFilter{
			Type:  "UNIT_AND_AMOUNT",
			Units: []string{"HOURLY"},
			Range: &talent.CompensationRange{
				MaxCompensation: &talent.Money{
					Units:        15,
					CurrencyCode: "USD",
				},
				MinCompensation: &talent.Money{
					Units:        10,
					CurrencyCode: "USD",
					Nanos:        500000000,
				},
			},
		},
	}
	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",
	}
	resp, err := service.Projects.Jobs.Search(parent, req).Do()
	if err != nil {
		return nil, fmt.Errorf("failed to search for jobs with compensation: %w", err)
	}

	fmt.Fprintln(w, "Jobs:")
	for _, j := range resp.MatchingJobs {
		fmt.Fprintf(w, "\t%q\n", j.Job.Name)
	}

	return resp, nil
}

Java

Pour savoir comment installer et utiliser la bibliothèque cliente pour CTS, consultez la page Bibliothèques clientes CTS. Pour en savoir plus, consultez les API CTS Java documentation de référence.


/** Search on compensation. */
public static void compensationSearch(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");

  // Search jobs that pay between 10.50 and 15 USD per hour
  JobQuery jobQuery =
      new JobQuery()
          .setCompensationFilter(
              new CompensationFilter()
                  .setType("UNIT_AND_AMOUNT")
                  .setUnits(Arrays.asList("HOURLY"))
                  .setRange(
                      new CompensationRange()
                          .setMaxCompensation(new Money().setCurrencyCode("USD").setUnits(15L))
                          .setMinCompensation(
                              new Money()
                                  .setCurrencyCode("USD")
                                  .setUnits(10L)
                                  .setNanos(500000000))));
  if (companyName != null) {
    jobQuery.setCompanyNames(Arrays.asList(companyName));
  }

  SearchJobsRequest searchJobsRequest =
      new SearchJobsRequest()
          .setRequestMetadata(requestMetadata)
          .setJobQuery(jobQuery) // Set the actual search term as defined in the jobQurey
          .setSearchMode("JOB_SEARCH"); // Set the search mode to a regular search

  SearchJobsResponse searchJobsResponse =
      talentSolutionClient
          .projects()
          .jobs()
          .search(DEFAULT_PROJECT_ID, searchJobsRequest)
          .execute();
  Thread.sleep(1000);

  System.out.printf("Search results by compensation: %s\n", searchJobsResponse);
}

Python

Pour savoir comment installer et utiliser la bibliothèque cliente pour CTS, consultez Bibliothèques clientes CTS. Pour en savoir plus, consultez la documentation de référence de l'API CTS Python.

def compensation_search(client_service, company_name):
    request_metadata = {
        "user_id": "HashedUserId",
        "session_id": "HashedSessionId",
        "domain": "www.google.com",
    }
    compensation_range = {
        "max_compensation": {"currency_code": "USD", "units": 15},
        "min_compensation": {"currency_code": "USD", "units": 10, "nanos": 500000000},
    }
    compensation_filter = {
        "type": "UNIT_AND_AMOUNT",
        "units": ["HOURLY"],
        "range": compensation_range,
    }
    job_query = {"compensation_filter": compensation_filter}
    if company_name is not None:
        job_query.update({"company_names": [company_name]})
    request = {
        "search_mode": "JOB_SEARCH",
        "request_metadata": request_metadata,
        "job_query": job_query,
    }

    response = (
        client_service.projects().jobs().search(parent=parent, body=request).execute()
    )
    print(response)

Ruby

Pour savoir comment installer et utiliser la bibliothèque cliente pour CTS, consultez Bibliothèques clientes CTS.

Pour vous authentifier auprès de CTS, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

# project_id        = "Id of the project"
# company_name      = "The resource name of the company listing the job. The format is "projects/{project_id}/companies/{company_id}""
# min_unit          = "Min value of the compensation range we want to search on"
# max_unit          = "Max value of the compensation range we want to search on"

require "google/apis/jobs_v3"
# Instantiate the client
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:     "http://careers.google.com"
# Search jobs that pay between min_unit and max_unit (USD/hour)
compensation_range = jobs::CompensationRange.new max_compensation: (
                                                   jobs::Money.new currency_code: "USD",
                                                                   units:         max_unit,
                                                                   nanos:         500_000_000
                                                 ),
                                                 min_compensation: (
                                                   jobs::Money.new currency_code: "USD",
                                                                   units:         min_unit,
                                                                   nanos:         0
                                                 )
compensation_filter = jobs::CompensationFilter.new type:  "UNIT_AND_AMOUNT",
                                                   units: ["HOURLY"],
                                                   range: compensation_range
# Perform a search for analyst  related jobs
job_query = jobs::JobQuery.new compensation_filter: compensation_filter,
                               company_names:       [company_name]

search_jobs_request = jobs::SearchJobsRequest.new request_metadata: request_metadata,
                                                  job_query:        job_query,
                                                  search_mode:      "JOB_SEARCH"
search_jobs_response = talent_solution_client.search_jobs project_id, search_jobs_request

puts search_jobs_response.to_json
search_jobs_response

Étapes suivantes

Pour rechercher et filtrer des exemples de code pour d'autres produits Google Cloud, consultez l'explorateur d'exemples Google Cloud.