Nozioni di base sul job (v4beta1)

Una risorsa Job rappresenta una singola offerta di lavoro (nota anche come "elenco di lavoro" o "richiesta di lavoro"). Un job appartiene a una risorsa Azienda che rappresenta l'entità che assume responsabile del lavoro.

Puoi accedere a un job utilizzando i metodi LIST e GET e manipolarlo con i metodi CREATE, UPDATE e DELETE. Potrebbero essere necessari diversi minuti prima che l'indice di Cloud Talent Solution rifletta le modifiche.

I job rientrano nell'ambito di un account di servizio. Solo le richieste di ricerca autenticate utilizzando le credenziali di un determinato account di servizio possono essere utilizzate per accedere ai contenuti di questi job.

Per semplificare la risoluzione dei problemi e la classificazione, sincronizza l'indice dei job di Cloud Talent Solution con il tuo indice di prestazioni e mantieni una relazione tra il name generato da Cloud Talent Solution e l'identificatore univoco del job nel tuo sistema. Man mano che i job cambiano o vengono introdotti nel sistema, la chiamata CRUD appropriata deve essere inviata al CTS in tempo reale per garantire che le modifiche vengano applicate immediatamente. L'indice CTS deve essere aggiunto alla pipeline di importazione dei job esistente.

Crea un job

Puoi creare un job utilizzando l'esempio di codice riportato di seguito. Consulta la Guida rapida: creazione di aziende e offerte di lavoro per ulteriori dettagli. Sono disponibili anche tutorial video e codelab interattivi.

Go

Per scoprire come installare e utilizzare la libreria client per CTS, consulta Librerie client CTS. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Go CTS.

Per eseguire l'autenticazione su CTS, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import (
	"context"
	"fmt"
	"io"

	talent "cloud.google.com/go/talent/apiv4beta1"
	talentpb "google.golang.org/genproto/googleapis/cloud/talent/v4beta1"
)

// createJob create a job as given.
func createJob(w io.Writer, projectID, companyID, requisitionID, title, URI, description, address1, address2, languageCode string) (*talentpb.Job, error) {
	ctx := context.Background()

	// Initialize a jobService client.
	c, err := talent.NewJobClient(ctx)
	if err != nil {
		fmt.Printf("talent.NewJobClient: %v\n", err)
		return nil, err
	}

	jobToCreate := &talentpb.Job{
		CompanyName:   fmt.Sprintf("projects/%s/companies/%s", projectID, companyID),
		RequisitionId: requisitionID,
		Title:         title,
		ApplicationInfo: &talentpb.Job_ApplicationInfo{
			Uris: []string{URI},
		},
		Description:  description,
		Addresses:    []string{address1, address2},
		LanguageCode: languageCode,
	}

	// Construct a createJob request.
	req := &talentpb.CreateJobRequest{
		Parent: fmt.Sprintf("projects/%s", projectID),
		Job:    jobToCreate,
	}

	resp, err := c.CreateJob(ctx, req)
	if err != nil {
		fmt.Printf("Failed to create job: %v\n", err)
		return nil, err
	}

	fmt.Printf("Created job: %q\n", resp.GetName())

	return resp, nil
}

Java

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di Cloud Talent Solution.

import com.google.cloud.talent.v4beta1.CreateJobRequest;
import com.google.cloud.talent.v4beta1.Job;
import com.google.cloud.talent.v4beta1.JobServiceClient;
import com.google.cloud.talent.v4beta1.TenantName;
import java.io.IOException;
import java.sql.Timestamp;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.Calendar;
import java.util.List;
import java.util.Locale;

public class JobSearchCreateJob {

  public static void createJob() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String tenantId = "your-tenant-id";
    String companyId = "your-company-id";
    String requisitionId = "your-unique-req-id";
    String jobApplicationUrl = "your-job-url";
    createJob(projectId, tenantId, companyId, requisitionId, jobApplicationUrl);
  }

  // Create a job.
  public static void createJob(
      String projectId,
      String tenantId,
      String companyId,
      String requisitionId,
      String jobApplicationUrl)
      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);
      Job.ApplicationInfo applicationInfo =
          Job.ApplicationInfo.newBuilder().addUris(jobApplicationUrl).build();

      List<String> addresses =
          Arrays.asList(
              "1600 Amphitheatre Parkway, Mountain View, CA 94043",
              "111 8th Avenue, New York, NY 10011");

      // By default, job will expire in 30 days.
      // https://cloud.google.com/talent-solution/job-search/docs/jobs
      Job job =
          Job.newBuilder()
              .setCompany(companyId)
              .setRequisitionId(requisitionId)
              .setTitle("Software Developer")
              .setDescription("Develop, maintain the software solutions.")
              .setApplicationInfo(applicationInfo)
              .addAllAddresses(addresses)
              .setLanguageCode("en-US")
              .build();

      CreateJobRequest request =
          CreateJobRequest.newBuilder().setParent(parent.toString()).setJob(job).build();

      Job response = jobServiceClient.createJob(request);
      System.out.format("Created job: %s%n", response.getName());
    }
  }
}

Python

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di Cloud Talent Solution.

from google.cloud import talent

def create_job(
    project_id,
    tenant_id,
    company_id,
    requisition_id,
    job_application_url,
):
    """Create Job"""

    client = talent.JobServiceClient()

    # project_id = 'Your Google Cloud Project ID'
    # tenant_id = 'Your Tenant ID (using tenancy is optional)'
    # company_id = 'Company name, e.g. projects/your-project/companies/company-id'
    # requisition_id = 'Job requisition ID, aka Posting ID. Unique per job.'
    # title = 'Software Engineer'
    # description = 'This is a description of this <i>wonderful</i> job!'
    # job_application_url = 'https://www.example.org/job-posting/123'
    # address_one = '1600 Amphitheatre Parkway, Mountain View, CA 94043'
    # address_two = '111 8th Avenue, New York, NY 10011'
    # language_code = 'en-US'

    if isinstance(project_id, bytes):
        project_id = project_id.decode("utf-8")
    if isinstance(tenant_id, bytes):
        tenant_id = tenant_id.decode("utf-8")
    if isinstance(company_id, bytes):
        company_id = company_id.decode("utf-8")
    if isinstance(requisition_id, bytes):
        requisition_id = requisition_id.decode("utf-8")
    if isinstance(job_application_url, bytes):
        job_application_url = job_application_url.decode("utf-8")
    parent = f"projects/{project_id}/tenants/{tenant_id}"
    uris = [job_application_url]
    application_info = {"uris": uris}
    addresses = [
        "1600 Amphitheatre Parkway, Mountain View, CA 94043",
        "111 8th Avenue, New York, NY 10011",
    ]
    job = {
        "company": company_id,
        "requisition_id": requisition_id,
        "title": "Software Developer",
        "description": "Develop, maintain the software solutions.",
        "application_info": application_info,
        "addresses": addresses,
        "language_code": "en-US",
    }

    response = client.create_job(parent=parent, job=job)
    print(f"Created job: {response.name}")
    return response.name

Campi obbligatori

I seguenti campi sono obbligatori durante la creazione e l'aggiornamento del job:

• companyName: il nome della risorsa dell'azienda proprietaria del lavoro, ad esempio companyName=\"projects/{ProjectId}/companies/{CompanyId}\".

• requisitionId: l'ID richiesta, chiamato anche ID pubblicazione, è un valore che assegni per identificare un lavoro. Puoi utilizzare questo campo per il monitoraggio dell'identificazione del cliente e delle richieste. Il numero massimo di caratteri consentiti è 225.

  L'unicità di un'offerta di lavoro viene determinata utilizzando una combinazione di requisitionID, companyName e località. Se un job viene creato con una chiave specifica di questi attributi, la chiave viene archiviata nell'indice di Cloud Talent Solution e non è possibile creare altri job con gli stessi campi finché il job non viene eliminato.

• title: la qualifica, ad esempio "Ingegnere informatico". Il numero massimo di caratteri consentiti è 500.

  Per risolvere il problema della perdita di risultati di ricerca a causa di qualifiche non standard, Cloud Talent Solution sfrutta tutti i campi di prestazioni per comprendere il contesto del lavoro e archiviare internamente una qualifica "pulita". Quando una richiesta di ricerca viene inviata al servizio, viene cancellata anche la query di ricerca e le ontologie vengono utilizzate per mappare la query ripulita ai job clean pertinenti.

• description: la descrizione del lavoro, che in genere include una descrizione in più paragrafi dell'azienda e delle informazioni correlate. Nell'oggetto Job vengono forniti campi separati per responsabilità, qualifiche e altre caratteristiche del lavoro. Si consiglia di utilizzare questi campi separati.

  Questo campo accetta e sanitizza l'input HTML e accetta tag di markup in grassetto, corsivo, elenchi ordinati ed elenchi non ordinati. Il numero massimo di caratteri consentiti è 100.000.

Il valore sarà uno dei seguenti:

• applicationInfo.uris: l'URL o gli URL delle pagine dell'applicazione.

• applicationInfo.emails: indirizzi email a cui inviare i curricula o le domande di partecipazione.

• applicationInfo.instruction: istruzioni per l'applicazione, ad esempio "Invia la tua applicazione a ...". Questo campo accetta e sanitizza l'input HTML e accetta grassetto, corsivo, tag di elenco ordinati ed elenchi non ordinati. Il numero massimo di caratteri consentiti è 3000.

Campi di uso comune

• postingExpireTime: il momento in cui scade l'offerta di lavoro, in base al timestamp. Trascorso questo periodo, il job viene contrassegnato come scaduto e non viene visualizzato nei risultati di ricerca. Questa data deve essere precedente al 31/12/2100 nel fuso orario UTC. Le date non valide, ad esempio quelle passate, vengono ignorate. La data predefinita di scadenza del job è 30 giorni dopo l'ora di creazione del job nel fuso orario UTC.

  Il contenuto dei job scaduti può essere comunque recuperato fino a 60 giorni dopo la scadenza del job utilizzando l'operatore GET. Dopo questa scadenza, il job non verrà restituito tramite un'operazione GET.

  Nota: il limite di 60 giorni è configurabile dall'assistenza clienti. Presenta un ticket al team di assistenza se hai bisogno di estendere l'accesso.

• addresses: località del lavoro. Ti consigliamo di fornire gli indirizzi completi della sede in cui si trova la sede in cui si trova l'offerta di lavoro per ottenere risultati di ricerca di lavoro migliori, incluse le ricerche in base alla durata del tragitto giornaliero. Il numero massimo di caratteri consentiti è 500. Ulteriori informazioni su addresses sono disponibili nella sezione Best practice di seguito.

• promotionValue: un valore maggiore di 0 definisce questo job come "job in primo piano", che viene restituito solo nelle ricerche di tipo FEATURED_JOBS. I valori più alti vengono restituiti più in alto nei risultati di ricerca in primo piano. Consulta Job in primo piano per ulteriori informazioni.

Utilizzo dei campi personalizzati del job

Cloud Talent Solution include diversi campi di job integrati nei suoi schemi API. Tuttavia, potrebbero essere necessari campi aggiuntivi che non sono presenti nelle opzioni predefinite. Anche se consigliamo di utilizzare i campi pronti all'uso ove possibile, Cloud Talent Solution fornisce anche alcuni campi customAttributes per un job. Possono essere filtrabili o non filtrabili. Per saperne di più, consulta la documentazione di customAttributes.

• customAttributes: questo campo memorizza fino a 100 attributi personalizzati utilizzati per archiviare i dati personalizzati relativi al job. Questi campi possono essere filtrati in base a una richiesta di ricerca che specifichi il campo jobQuery. Inoltre, uno qualsiasi di questi campi può essere impostato nell'attributo keywordSearchableJobCustomAttributes di company, quindi un termine di ricerca con una corrispondenza esatta in uno qualsiasi dei campi di keywordSearchableJobCustomAttributes restituirà qualsiasi job che include la corrispondenza.

Il seguente esempio di codice mostra come creare un job con un customAttribute:

Go

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di Cloud Talent Solution.

import (
	"context"
	"fmt"
	"io"

	talent "cloud.google.com/go/talent/apiv4beta1"
	"cloud.google.com/go/talent/apiv4beta1/talentpb"
	"github.com/gofrs/uuid"
	money "google.golang.org/genproto/googleapis/type/money"
)

// createJobWithCustomAttributes creates a job with custom attributes.
func createJobWithCustomAttributes(w io.Writer, projectID, companyID, jobTitle string) (*talentpb.Job, error) {
	ctx := context.Background()

	// Initialize a job service client.
	c, err := talent.NewJobClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("talent.NewJobClient: %w", err)
	}
	defer c.Close()

	// requisitionID shoud be the unique ID in your system
	requisitionID := fmt.Sprintf("job-with-custom-attribute-%s", uuid.Must(uuid.NewV4()).String())
	jobToCreate := &talentpb.Job{
		Company:       fmt.Sprintf("projects/%s/companies/%s", projectID, companyID),
		RequisitionId: requisitionID,
		Title:         jobTitle,
		ApplicationInfo: &talentpb.Job_ApplicationInfo{
			Uris: []string{"https://googlesample.com/career"},
		},
		Description:     "Design, devolop, test, deploy, maintain and improve software.",
		LanguageCode:    "en-US",
		PromotionValue:  2,
		EmploymentTypes: []talentpb.EmploymentType{talentpb.EmploymentType_FULL_TIME},
		Addresses:       []string{"Mountain View, CA"},
		CustomAttributes: map[string]*talentpb.CustomAttribute{
			"someFieldString": {
				Filterable:   true,
				StringValues: []string{"someStrVal"},
			},
			"someFieldLong": {
				Filterable: true,
				LongValues: []int64{900},
			},
		},
		CompensationInfo: &talentpb.CompensationInfo{
			Entries: []*talentpb.CompensationInfo_CompensationEntry{
				{
					Type: talentpb.CompensationInfo_BASE,
					Unit: talentpb.CompensationInfo_HOURLY,
					CompensationAmount: &talentpb.CompensationInfo_CompensationEntry_Amount{
						Amount: &money.Money{
							CurrencyCode: "USD",
							Units:        1,
						},
					},
				},
			},
		},
	}

	// Construct a createJob request.
	req := &talentpb.CreateJobRequest{
		Parent: fmt.Sprintf("projects/%s", projectID),
		Job:    jobToCreate,
	}

	resp, err := c.CreateJob(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("CreateJob: %w", err)
	}

	fmt.Fprintf(w, "Created job with custom attributres: %q\n", resp.GetName())
	fmt.Fprintf(w, "Custom long field has value: %v\n", resp.GetCustomAttributes()["someFieldLong"].GetLongValues())

	return resp, nil
}

Java

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di Cloud Talent Solution.

import com.google.cloud.talent.v4beta1.CreateJobRequest;
import com.google.cloud.talent.v4beta1.CustomAttribute;
import com.google.cloud.talent.v4beta1.Job;
import com.google.cloud.talent.v4beta1.JobServiceClient;
import com.google.cloud.talent.v4beta1.TenantName;
import java.io.IOException;

public class JobSearchCreateJobCustomAttributes {

  public static void createJob() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String tenantId = "your-tenant-id";
    String companyId = "your-company-id";
    String requisitionId = "your-unique-req-id";
    createJob(projectId, tenantId, companyId, requisitionId);
  }

  // Create Job with Custom Attributes.
  public static void createJob(
          String projectId,
          String tenantId,
          String companyId,
          String requisitionId)
          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);

      // Custom attribute can be string or numeric value, and can be filtered in search queries.
      // https://cloud.google.com/talent-solution/job-search/docs/custom-attributes
      CustomAttribute customAttribute = CustomAttribute.newBuilder()
              .addStringValues("Internship")
              .addStringValues("Apprenticeship")
              .setFilterable(true)
              .build();

      Job job =
              Job.newBuilder()
                      .setCompany(companyId)
                      .setTitle("Software Developer I")
                      .setDescription("This is a description of this <i>wonderful</i> job!")
                      .putCustomAttributes("FOR_STUDENTS", customAttribute)
                      .setRequisitionId(requisitionId)
                      .setLanguageCode("en-US")
                      .build();

      CreateJobRequest request =
              CreateJobRequest.newBuilder().setParent(parent.toString()).setJob(job).build();
      Job response = jobServiceClient.createJob(request);
      System.out.printf("Created job: %s\n", response.getName());
    }
  }
}

Python

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di Cloud Talent Solution.

from google.cloud import talent

def create_job(project_id, tenant_id, company_id, requisition_id):
    """Create Job with Custom Attributes"""

    client = talent.JobServiceClient()

    # project_id = 'Your Google Cloud Project ID'
    # tenant_id = 'Your Tenant ID (using tenancy is optional)'
    # company_id = 'Company name, e.g. projects/your-project/companies/company-id'
    # requisition_id = 'Job requisition ID, aka Posting ID. Unique per job.'
    # language_code = 'en-US'

    if isinstance(project_id, bytes):
        project_id = project_id.decode("utf-8")
    if isinstance(tenant_id, bytes):
        tenant_id = tenant_id.decode("utf-8")
    if isinstance(company_id, bytes):
        company_id = company_id.decode("utf-8")

    # Custom attribute can be string or numeric value,
    # and can be filtered in search queries.
    # https://cloud.google.com/talent-solution/job-search/docs/custom-attributes
    custom_attribute = talent.CustomAttribute()
    custom_attribute.filterable = True
    custom_attribute.string_values.append("Intern")
    custom_attribute.string_values.append("Apprenticeship")

    parent = f"projects/{project_id}/tenants/{tenant_id}"

    job = talent.Job(
        company=company_id,
        title="Software Engineer",
        requisition_id=requisition_id,
        description="This is a description of this job",
        language_code="en-us",
        custom_attributes={"FOR_STUDENTS": custom_attribute},
    )

    response = client.create_job(parent=parent, job=job)
    print(f"Created job: {response.name}")
    return response.name

Recupera un job

Go

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di Cloud Talent Solution.

import (
	"context"
	"fmt"
	"io"

	talent "cloud.google.com/go/talent/apiv4beta1"
	talentpb "google.golang.org/genproto/googleapis/cloud/talent/v4beta1"
)

// getJob gets an existing job by its resource name.
func getJob(w io.Writer, projectID, jobID string) (*talentpb.Job, error) {
	ctx := context.Background()

	// Initialize a jobService client.
	c, err := talent.NewJobClient(ctx)
	if err != nil {
		fmt.Printf("talent.NewJobClient: %v\n", err)
		return nil, err
	}

	// Construct a getJob request.
	jobName := fmt.Sprintf("projects/%s/jobs/%s", projectID, jobID)
	req := &talentpb.GetJobRequest{
		// The resource name of the job to retrieve.
		// The format is "projects/{project_id}/jobs/{job_id}".
		Name: jobName,
	}

	resp, err := c.GetJob(ctx, req)
	if err != nil {
		fmt.Printf("Failed to get job %s: %v\n", jobName, err)
		return nil, err
	}

	fmt.Fprintf(w, "Job: %q\n", resp.GetName())
	fmt.Fprintf(w, "Job title: %v\n", resp.GetTitle())

	return resp, err
}

Java

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di Cloud Talent Solution.

import com.google.cloud.talent.v4beta1.GetJobRequest;
import com.google.cloud.talent.v4beta1.Job;
import com.google.cloud.talent.v4beta1.JobName;
import com.google.cloud.talent.v4beta1.JobServiceClient;
import java.io.IOException;

public class JobSearchGetJob {

  public static void getJob() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String tenantId = "your-tenant-id";
    String jobId = "your-job-id";
    getJob(projectId, tenantId, jobId);
  }

  // Get Job.
  public static void getJob(String projectId, String tenantId, String jobId) 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()) {
      JobName name = JobName.ofProjectTenantJobName(projectId, tenantId, jobId);

      GetJobRequest request = GetJobRequest.newBuilder().setName(name.toString()).build();

      Job response = jobServiceClient.getJob(request);
      System.out.format("Job name: %s%n", response.getName());
      System.out.format("Requisition ID: %s%n", response.getRequisitionId());
      System.out.format("Title: %s%n", response.getTitle());
      System.out.format("Description: %s%n", response.getDescription());
      System.out.format("Posting language: %s%n", response.getLanguageCode());
      for (String address : response.getAddressesList()) {
        System.out.format("Address: %s%n", address);
      }
      for (String email : response.getApplicationInfo().getEmailsList()) {
        System.out.format("Email: %s%n", email);
      }
      for (String websiteUri : response.getApplicationInfo().getUrisList()) {
        System.out.format("Website: %s%n", websiteUri);
      }
    }
  }
}

Python

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di Cloud Talent Solution.

from google.cloud import talent

def get_job(project_id, tenant_id, job_id):
    """Get Job"""

    client = talent.JobServiceClient()

    # project_id = 'Your Google Cloud Project ID'
    # tenant_id = 'Your Tenant ID (using tenancy is optional)'
    # job_id = 'Job ID'

    if isinstance(project_id, bytes):
        project_id = project_id.decode("utf-8")
    if isinstance(tenant_id, bytes):
        tenant_id = tenant_id.decode("utf-8")
    if isinstance(job_id, bytes):
        job_id = job_id.decode("utf-8")
    name = client.job_path(project_id, tenant_id, job_id)

    response = client.get_job(name=name)
    print(f"Job name: {response.name}")
    print(f"Requisition ID: {response.requisition_id}")
    print(f"Title: {response.title}")
    print(f"Description: {response.description}")
    print(f"Posting language: {response.language_code}")
    for address in response.addresses:
        print(f"Address: {address}")
    for email in response.application_info.emails:
        print(f"Email: {email}")
    for website_uri in response.application_info.uris:
        print(f"Website: {website_uri}")

Elenco job

Go

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di Cloud Talent Solution.

import (
	"context"
	"fmt"
	"io"

	talent "cloud.google.com/go/talent/apiv4beta1"
	"google.golang.org/api/iterator"
	talentpb "google.golang.org/genproto/googleapis/cloud/talent/v4beta1"
)

// listJobs lists jobs with a filter, for example
// `companyName="projects/my-project/companies/123"`.
func listJobs(w io.Writer, projectID, companyID string) error {
	ctx := context.Background()

	// Initialize a jobService client.
	c, err := talent.NewJobClient(ctx)
	if err != nil {
		fmt.Printf("talent.NewJobClient: %v\n", err)
		return err
	}

	// Construct a listJobs request.
	companyName := fmt.Sprintf("projects/%s/companies/%s", projectID, companyID)
	req := &talentpb.ListJobsRequest{
		Parent: "projects/" + projectID,
		Filter: fmt.Sprintf("companyName=%q", companyName),
	}

	it := c.ListJobs(ctx, req)

	for {
		resp, err := it.Next()
		if err == iterator.Done {
			return nil
		}
		if err != nil {
			fmt.Printf("it.Next: %v\n", err)
			return err
		}
		fmt.Fprintf(w, "Listing job: %v\n", resp.GetName())
		fmt.Fprintf(w, "Job title: %v\n", resp.GetTitle())
	}
}

Java

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di Cloud Talent Solution.

import com.google.cloud.talent.v4beta1.Job;
import com.google.cloud.talent.v4beta1.JobServiceClient;
import com.google.cloud.talent.v4beta1.ListJobsRequest;
import com.google.cloud.talent.v4beta1.TenantName;
import java.io.IOException;

public class JobSearchListJobs {

  public static void listJobs() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String tenantId = "your-tenant-id";
    String query = "count(base_compensation, [bucket(12, 20)])";
    listJobs(projectId, tenantId, query);
  }

  // Search Jobs with histogram queries.
  public static void listJobs(String projectId, String tenantId, String filter) 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);
      ListJobsRequest request =
          ListJobsRequest.newBuilder().setParent(parent.toString()).setFilter(filter).build();
      for (Job responseItem : jobServiceClient.listJobs(request).iterateAll()) {
        System.out.format("Job name: %s%n", responseItem.getName());
        System.out.format("Job requisition ID: %s%n", responseItem.getRequisitionId());
        System.out.format("Job title: %s%n", responseItem.getTitle());
        System.out.format("Job description: %s%n", responseItem.getDescription());
      }
    }
  }
}

Python

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di Cloud Talent Solution.

from google.cloud import talent

def list_jobs(project_id, tenant_id, filter_):
    """List Jobs"""

    client = talent.JobServiceClient()

    # project_id = 'Your Google Cloud Project ID'
    # tenant_id = 'Your Tenant ID (using tenancy is optional)'
    # filter_ = 'companyName=projects/my-project/companies/company-id'

    if isinstance(project_id, bytes):
        project_id = project_id.decode("utf-8")
    if isinstance(tenant_id, bytes):
        tenant_id = tenant_id.decode("utf-8")
    if isinstance(filter_, bytes):
        filter_ = filter_.decode("utf-8")
    parent = f"projects/{project_id}/tenants/{tenant_id}"

    # Iterate over all results
    results = []
    for job in client.list_jobs(parent=parent, filter=filter_):
        results.append(job.name)
        print("Job name: {job.name}")
        print("Job requisition ID: {job.requisition_id}")
        print("Job title: {job.title}")
        print("Job description: {job.description}")
    return results

Eliminazione di un job

Go

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di Cloud Talent Solution.

import (
	"context"
	"fmt"
	"io"

	talent "cloud.google.com/go/talent/apiv4beta1"
	talentpb "google.golang.org/genproto/googleapis/cloud/talent/v4beta1"
)

// deleteJob deletes an existing job by its resource name.
func deleteJob(w io.Writer, projectID, jobID string) error {
	ctx := context.Background()

	// Initialize a jobService client.
	c, err := talent.NewJobClient(ctx)
	if err != nil {
		fmt.Printf("talent.NewJobClient: %v\n", err)
		return err
	}

	// Construct a deleteJob request.
	jobName := fmt.Sprintf("projects/%s/jobs/%s", projectID, jobID)
	req := &talentpb.DeleteJobRequest{
		// The resource name of the job to be deleted.
		// The format is "projects/{project_id}/jobs/{job_id}".
		Name: jobName,
	}

	if err := c.DeleteJob(ctx, req); err != nil {
		fmt.Printf("Delete(%s): %v\n", jobName, err)
		return err
	}

	fmt.Printf("Deleted job: %q\n", jobName)

	return err
}

Java

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di Cloud Talent Solution.

import com.google.cloud.talent.v4beta1.DeleteJobRequest;
import com.google.cloud.talent.v4beta1.JobName;
import com.google.cloud.talent.v4beta1.JobServiceClient;
import java.io.IOException;

public class JobSearchDeleteJob {

  public static void deleteJob() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String tenantId = "your-tenant-id";
    String jobId = "your-job-id";
    deleteJob(projectId, tenantId, jobId);
  }

  // Delete Job.
  public static void deleteJob(String projectId, String tenantId, String jobId) 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()) {
      JobName name = JobName.ofProjectTenantJobName(projectId, tenantId, jobId);

      DeleteJobRequest request = DeleteJobRequest.newBuilder().setName(name.toString()).build();

      jobServiceClient.deleteJob(request);
      System.out.println("Deleted job.");
    }
  }
}

Python

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di Cloud Talent Solution.

from google.cloud import talent

def delete_job(project_id, tenant_id, job_id):
    """Delete Job"""

    client = talent.JobServiceClient()

    # project_id = 'Your Google Cloud Project ID'
    # tenant_id = 'Your Tenant ID (using tenancy is optional)'
    # job_id = 'Company ID'

    if isinstance(project_id, bytes):
        project_id = project_id.decode("utf-8")
    if isinstance(tenant_id, bytes):
        tenant_id = tenant_id.decode("utf-8")
    if isinstance(job_id, bytes):
        job_id = job_id.decode("utf-8")
    name = client.job_path(project_id, tenant_id, job_id)

    client.delete_job(name=name)
    print("Deleted job.")

best practice

Campi relativi alla località

Se possibile, ti consigliamo di fornire la via di un lavoro nel campo addresses. Ciò favorisce il rilevamento della posizione e la pertinenza. Quando un indirizzo a livello stradale non è disponibile, inserisci il maggior numero possibile di informazioni. Gli indirizzi sono supportati fino a livello di paese. Le designazioni delle regioni (come "Pacifico nord-ovest") non sono supportate.

Cloud Talent Solution utilizza i dati del campo addresses per compilare il campo derivedInfo.locations (solo output). Quando non viene fornito un indirizzo completo, il servizio utilizza altri indicatori, come il nome dell'azienda, per determinare se è possibile dedurre un indirizzo più completo per l'offerta di lavoro.

Ad esempio, se la posizione di una posizione software è specificata come Mountain View e l'azienda a cui è associata l'offerta di lavoro è Google, il servizio cerca l'oggetto company per verificare se nel campo headquartersAddress è presente un indirizzo migliore e se questo indirizzo si trova nella stessa città dell'offerta di lavoro. In tal caso, il servizio comprende che il lavoro "probabilmente" si trova in quell'indirizzo e compila il campo derivedInfo.locations in modo appropriato.

Se i dati sugli indirizzi dell'azienda non sono disponibili, il servizio utilizza una combinazione di conoscenze proprietarie e informazioni sul lavoro/azienda per fornire informazioni al campo derivedInfo.locations.

Poiché il valore derivedInfo.locations è una stima ottimale, ti consigliamo di utilizzare i dati derivedInfo.locations o il campo addresses quando mostri l'indirizzo del lavoro.

A un'offerta di lavoro non possono essere associate più di 50 sedi. Se un job ha più località, puoi suddividerlo in più job, ciascuno con un ID requisito univoco (ad esempio "ReqA", "ReqA-1", "ReqA-2" e così via). Non è consentito avere più job con gli stessi requisitionId, , companyName e languageCode. Se è necessario conservare il valore requisitionId originale, è necessario utilizzare un CustomAttribute per l'archiviazione. Ti consigliamo di raggruppare le sedi più vicine tra loro nello stesso lavoro per migliorare l'esperienza di ricerca.

Indirizzi supportati

Tutti gli indirizzi riconosciuti dall'API Google Maps Geocoding (nel campo formattedAddress) sono accettati da Cloud Talent Solution. Il servizio restituisce un errore 400 se tenti di creare un job o di eseguire una ricerca utilizzando un indirizzo non riconosciuto.

Se l'indirizzo di un'attività non è indicato correttamente nell'API Google Maps Geocoding, segnala un bug per risolverlo. L'applicazione delle correzioni può richiedere fino a 5 giorni.

Completamento automatico degli indirizzi

Cloud Talent Solution non fornisce suggerimenti di completamento automatico per le località. Utilizza l'API Google Maps Places o altri servizi di geolocalizzazione simili per completare i suggerimenti di completamento automatico.

Offerte di lavoro a livello statale, nazionale e di telelavoro

I lavori possono essere specificati come a livello di stato, nazionale o telelavoro utilizzando il campo postingRegion.

• I lavori ADMINISTRATIVE_AREA e NATION vengono restituiti per qualsiasi ricerca con una località specificata all'interno della provincia/del paese dell'offerta di lavoro. Ad esempio, se un job ADMINISTRATIVE_AREA ha "WA, USA" viene restituito per le ricerche in cui LocationFilter specifica "Seattle".

• TELECOMMUTE I lavori vengono restituiti per qualsiasi ricerca correlata alla località, ma vengono trattati come meno pertinenti. Possono essere scelti come target in una ricerca impostando il flag telecommutePreference su TELECOMMUTE_ALLOWED nella LocationFilter della ricerca.