Nozioni di base sul job

Una risorsa Job rappresenta una singola offerta di lavoro (indicata anche come "Elenco offerte di lavoro" o "Richiesta di lavoro"). Un job appartiene a una risorsa Azienda che rappresenta la persona giuridica di assunzione responsabile del job.

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

I job sono contenuti 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 una facile risoluzione dei problemi e una classificazione, sincronizza l'indice dei job di Cloud Talent Solution con il tuo indice dei job e mantieni una relazione tra 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 a CTS in tempo reale per garantire che queste 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 il esempio di codice riportato di seguito. Per ulteriori dettagli, consulta la guida rapida: crea aziende e offerte di lavoro. Sono inoltre disponibili tutorial video e codelab interattivi.

Go

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

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori 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 scoprire come installare e utilizzare la libreria client per CTS, consulta Librerie client CTS. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API CTS Java.

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import com.google.cloud.talent.v4.CreateJobRequest;
import com.google.cloud.talent.v4.Job;
import com.google.cloud.talent.v4.JobServiceClient;
import com.google.cloud.talent.v4.TenantName;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;

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";
    // String projectId = "me-qa-1";
    // String tenantId = "8ed97629-27ee-4215-909b-18cfe3b7e8e3";
    // String companyId = "05317758-b30e-4b26-a57d-d9e54e4cccd8";
    // String requisitionId = "test-requisitionid-1";
    // String jobApplicationUrl = "http://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());
    }
  }
}

Node.js

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

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

/**
 * Create Job
 *
 * @param projectId {string} Your Google Cloud Project ID
 * @param tenantId {string} Identifier of the Tenant
 */
function sampleCreateJob(
  projectId,
  tenantId,
  companyName,
  requisitionId,
  title,
  description,
  jobApplicationUrl,
  addressOne,
  addressTwo,
  languageCode
) {
  const client = new talent.JobServiceClient();
  // const projectId = 'Your Google Cloud Project ID';
  // const tenantId = 'Your Tenant ID (using tenancy is optional)';
  // const companyName = 'Company name, e.g. projects/your-project/companies/company-id';
  // const requisitionId = 'Job requisition ID, aka Posting ID. Unique per job.';
  // const title = 'Software Engineer';
  // const description = 'This is a description of this <i>wonderful</i> job!';
  // const jobApplicationUrl = 'https://www.example.org/job-posting/123';
  // const addressOne = '1600 Amphitheatre Parkway, Mountain View, CA 94043';
  // const addressTwo = '111 8th Avenue, New York, NY 10011';
  // const languageCode = 'en-US';
  const formattedParent = client.tenantPath(projectId, tenantId);
  const uris = [jobApplicationUrl];
  const applicationInfo = {
    uris: uris,
  };
  const addresses = [addressOne, addressTwo];
  const job = {
    company: companyName,
    requisitionId: requisitionId,
    title: title,
    description: description,
    applicationInfo: applicationInfo,
    addresses: addresses,
    languageCode: languageCode,
  };
  const request = {
    parent: formattedParent,
    job: job,
  };
  client
    .createJob(request)
    .then(responses => {
      const response = responses[0];
      console.log(`Created job: ${response.name}`);
    })
    .catch(err => {
      console.error(err);
    });
}

Python

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

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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 job, ad esempio companyName=\"projects/{ProjectId}/companies/{CompanyId}\".

• requisitionId: l'ID richiesta, noto anche come ID pubblicazione, è un valore che assegni per identificare un lavoro. Puoi utilizzare questo campo per l'identificazione del cliente e il monitoraggio 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, questa chiave viene archiviata nell'indice Cloud Talent Solution e non è possibile creare altri job con gli stessi campi fino a quando il job non viene eliminato.

• title: il titolo del lavoro, ad esempio "Ingegnere informatico". Il numero massimo di caratteri consentiti è 500.

  Per risolvere il problema dei risultati di ricerca mancanti a causa di titoli professionali non standard, Cloud Talent Solution sfrutta tutti i campi delle offerte di lavoro per comprendere il contesto della posizione e memorizzare internamente un titolo professionale "pulito". Quando una richiesta di ricerca viene inviata al servizio, viene pulita anche la query di ricerca e le ontologie vengono utilizzate per mappare la query pulita ai job di pulizia pertinenti.

• description: la descrizione del lavoro, che in genere include una descrizione in più paragrafi dell'azienda e informazioni correlate. Nell'oggetto Job sono disponibili campi distinti per responsabilità, qualifiche e altre caratteristiche del lavoro. Ti consigliamo di utilizzare questi campi separati.

  Questo campo accetta e convalida l'input HTML e i tag di markup in grassetto, corsivo, elenco ordinato ed elenco non ordinato. Il numero massimo di caratteri consentiti è 100.000.

Il valore sarà uno dei seguenti:

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

• applicationInfo.emails: indirizzi email a cui devono essere inviati i curriculum o le domande di candidatura.

• applicationInfo.instruction: istruzioni per la richiesta, ad esempio "Invia la tua richiesta all'indirizzo ...". Questo campo accetta e convalida l'input HTML e i tag markup in grassetto, corsivo, elenco ordinato ed elenco non ordinato. Il numero massimo di caratteri consentiti è 3000.

Campi di uso comune

• postingExpireTime: l'ora di scadenza dell'annuncio di lavoro in base al timestamp. Dopo questo periodo di tempo, 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 es. quelle passate) vengono ignorate. La data predefinita di scadenza del job è 30 giorni dopo l'ora di creazione del job nel fuso orario UTC.

  I contenuti dei job scaduti possono essere recuperati fino a 90 giorni dopo la scadenza utilizzando l'operatore GET. Dopo questa scadenza di 90 giorni, il job non verrà restituito tramite un'operazione GET.

  Nota: il limite di 90 giorni è configurabile dall'assistenza clienti. Se hai bisogno di estendere l'accesso, invia un ticket al team di assistenza.

• addresses: località del lavoro. Ti consigliamo di fornire gli indirizzi stradali completi della sede di assunzione per ottenere risultati migliori nella Ricerca di lavoro, incluse le ricerche per tempo di 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 evidenza", che viene restituito solo nelle ricerche di tipo FEATURED_JOBS. I valori più elevati vengono visualizzati più in alto nei risultati di ricerca in primo piano. Per ulteriori informazioni, consulta la sezione Posti di lavoro in primo piano.

Utilizzo di campi di job personalizzati

Cloud Talent Solution include diversi campi di lavoro integrati negli schemi della sua API. Tuttavia, potresti aver bisogno di campi aggiuntivi non presenti nelle opzioni predefinite. Sebbene ti consigliamo di utilizzare i campi predefiniti ove possibile, Cloud Talent Solution fornisce anche alcuni campi customAttributes per un job. Possono essere filtrabili o non filtrabili. Per ulteriori informazioni, consulta la documentazione di customAttributes.

• customAttributes: questo campo memorizza fino a 100 attributi personalizzati utilizzati per memorizzare dati personalizzati sul job. Questi campi possono essere filtrati utilizzando una richiesta di ricerca che specifica il campo jobQuery. Inoltre, qualsiasi di questi campi può essere impostato nell'attributo keywordSearchableJobCustomAttributes della proprietà company, pertanto un termine di ricerca che ha una corrispondenza esatta in uno dei campi in keywordSearchableJobCustomAttributes restituisce qualsiasi annuncio di lavoro che include la corrispondenza.

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

Go

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

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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 scoprire come installare e utilizzare la libreria client per CTS, consulta Librerie client CTS. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API CTS Java.

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import com.google.cloud.talent.v4.CreateJobRequest;
import com.google.cloud.talent.v4.CustomAttribute;
import com.google.cloud.talent.v4.Job;
import com.google.cloud.talent.v4.JobServiceClient;
import com.google.cloud.talent.v4.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());
    }
  }
}

Node.js

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

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

/**
 * Create Job with Custom Attributes
 *
 * @param projectId {string} Your Google Cloud Project ID
 * @param tenantId {string} Identifier of the Tenantd
 */
function sampleCreateJob(
  projectId,
  tenantId,
  companyName,
  requisitionId,
  languageCode
) {
  const client = new talent.JobServiceClient();
  // const projectId = 'Your Google Cloud Project ID';
  // const tenantId = 'Your Tenant ID (using tenancy is optional)';
  // const companyName = 'Company name, e.g. projects/your-project/companies/company-id';
  // const requisitionId = 'Job requisition ID, aka Posting ID. Unique per job.';
  // const languageCode = 'en-US';
  const formattedParent = client.tenantPath(projectId, tenantId);
  const job = {
    company: companyName,
    requisitionId: requisitionId,
    languageCode: languageCode,
  };
  const request = {
    parent: formattedParent,
    job: job,
  };
  client
    .createJob(request)
    .then(responses => {
      const response = responses[0];
      console.log(`Created job: ${response.name}`);
    })
    .catch(err => {
      console.error(err);
    });
}

Python

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

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Recuperare un job

Go

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

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori 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"
)

// 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 scoprire come installare e utilizzare la libreria client per CTS, consulta Librerie client CTS. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API CTS Java.

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import com.google.cloud.talent.v4.GetJobRequest;
import com.google.cloud.talent.v4.Job;
import com.google.cloud.talent.v4.JobName;
import com.google.cloud.talent.v4.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.of(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);
      }
    }
  }
}

Node.js

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

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

/** Get Job */
function sampleGetJob(projectId, tenantId, jobId) {
  const client = new talent.JobServiceClient();
  // const projectId = 'Your Google Cloud Project ID';
  // const tenantId = 'Your Tenant ID (using tenancy is optional)';
  // const jobId = 'Job ID';
  const formattedName = client.jobPath(projectId, tenantId, jobId);
  client
    .getJob({name: formattedName})
    .then(responses => {
      const response = responses[0];
      console.log(`Job name: ${response.name}`);
      console.log(`Requisition ID: ${response.requisitionId}`);
      console.log(`Title: ${response.title}`);
      console.log(`Description: ${response.description}`);
      console.log(`Posting language: ${response.languageCode}`);
      for (const address of response.addresses) {
        console.log(`Address: ${address}`);
      }
      for (const email of response.applicationInfo.emails) {
        console.log(`Email: ${email}`);
      }
      for (const websiteUri of response.applicationInfo.uris) {
        console.log(`Website: ${websiteUri}`);
      }
    })
    .catch(err => {
      console.error(err);
    });
}

Python

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

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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}")

Elenca job

Go

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

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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 scoprire come installare e utilizzare la libreria client per CTS, consulta Librerie client CTS. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API CTS Java.

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import com.google.cloud.talent.v4.Job;
import com.google.cloud.talent.v4.JobServiceClient;
import com.google.cloud.talent.v4.ListJobsRequest;
import com.google.cloud.talent.v4.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());
      }
    }
  }
}

Node.js

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

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

/**
 * List Jobs
 *
 * @param projectId {string} Your Google Cloud Project ID
 * @param tenantId {string} Identifier of the Tenant
 */
function sampleListJobs(projectId, tenantId, filter) {
  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 filter = 'companyName=projects/my-project/companies/company-id';
  const formattedParent = client.tenantPath(projectId, tenantId);
  const request = {
    parent: formattedParent,
    filter: filter,
  };

  client
    .listJobs(request)
    .then(responses => {
      const resources = responses[0];
      for (const resource of resources) {
        console.log(`Job name: ${resource.name}`);
        console.log(`Job requisition ID: ${resource.requisitionId}`);
        console.log(`Job title: ${resource.title}`);
        console.log(`Job description: ${resource.description}`);
      }
    })
    .catch(err => {
      console.error(err);
    });
}

Python

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

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Elimina un job

Go

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

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori 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"
)

// 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 scoprire come installare e utilizzare la libreria client per CTS, consulta Librerie client CTS. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API CTS Java.

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import com.google.cloud.talent.v4.DeleteJobRequest;
import com.google.cloud.talent.v4.JobName;
import com.google.cloud.talent.v4.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.of(projectId, tenantId, jobId);

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

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

Node.js

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

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

/** Delete Job */
function sampleDeleteJob(projectId, tenantId, jobId) {
  const client = new talent.JobServiceClient();
  // const projectId = 'Your Google Cloud Project ID';
  // const tenantId = 'Your Tenant ID (using tenancy is optional)';
  // const jobId = 'Company ID';
  const formattedName = client.jobPath(projectId, tenantId, jobId);
  client.deleteJob({name: formattedName}).catch(err => {
    console.error(err);
  });
  console.log('Deleted job.');
}

Python

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

Per autenticarti a CTS, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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 posizione

Se possibile, ti consigliamo di fornire l'indirizzo di un job nel addresses campo. Ciò contribuisce al rilevamento della posizione e alla pertinenza. Se non è disponibile un indirizzo al piano terra, inserisci quante più informazioni possibili. Gli indirizzi sono supportati fino al livello di paese. Le denominazioni delle regioni (ad es. "Nordovest Pacifico") non sono supportate.

Cloud Talent Solution utilizza i dati nel campo addresses per compilare il campo (solo output) derivedInfo.locations. 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 la scheda di lavoro.

Ad esempio, se la posizione di una posizione software è specificata come Mountain View e l'azienda a cui è associato il lavoro è Google, il servizio cerca l'oggetto company per verificare se è fornito un indirizzo migliore nel campo headquartersAddress e se questo indirizzo si trova nella stessa città della pubblicazione di lavoro. In questo caso, il servizio comprende che il lavoro è "probabilmente" situato all'indirizzo stradale specificato e compila il campo derivedInfo.locations di conseguenza.

Se i dati dell'indirizzo dell'azienda non sono disponibili, il servizio utilizza una combinazione di conoscenze proprietarie e informazioni su lavoro/azienda per compilare il campo derivedInfo.locations.

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

A un annuncio di lavoro non possono essere associate più di 50 località. Se un lavoro ha più sedi, puoi suddividerlo in più job, ciascuno con un valore requisitionId univoco (ad esempio "ReqA", "ReqA-1", "ReqA-2" e così via). Non è consentito avere più job con gli stessi valori requisitionId, companyName e languageCode. Se il requisitionId originale deve essere conservato, per l'archiviazione deve essere utilizzato un CustomAttribute. Per una migliore esperienza di ricerca, ti consigliamo di raggruppare le sedi più vicine tra loro nello stesso job.

Indirizzi supportati

Qualsiasi indirizzo riconosciuto dall'API Geocoding di Google Maps (nel formattedAddress campo) è accettato da Cloud Talent Solution. Il servizio restituisce un errore 400 se provi a creare un job o a eseguire una ricerca utilizzando un indirizzo non riconosciuto.

Se l'indirizzo di un'attività è elencato in modo errato nell'API Geocoding di Google Maps, segnala un bug perché venga corretto. L'applicazione delle correzioni può richiedere fino a 5 giorni.

Completamento automatico dell'indirizzo

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 compilare i suggerimenti di completamento automatico.

Lavori a livello statale, nazionale e con possibilità di telelavoro

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

• Le offerte di lavoro ADMINISTRATIVE_AREA e NATION vengono restituite per qualsiasi ricerca con una località specificata all'interno dello stato/del paese dell'annuncio di lavoro. Ad esempio, se un job ADMINISTRATIVE_AREA ha la località "WA, USA", viene visualizzato per le ricerche con ADMINISTRATIVE_AREA che specifica "Seattle".LocationFilter

• TELECOMMUTE Le offerte di lavoro vengono restituite in qualsiasi ricerca relativa alla località, ma vengono considerate meno pertinenti. Possono essere scelti come target in una ricerca impostando il flag telecommutePreference su TELECOMMUTE_ALLOWED in LocationFilter della ricerca.