Questa pagina è stata tradotta dall'API Cloud Translation.

Attributi personalizzati

Cloud Talent Solution fornisce diversi attributi di lavoro pronti all'uso per supportare le esigenze di vari clienti. Per ottenere il massimo rendimento da Cloud Talent Solution, ti consigliamo vivamente di utilizzare il più possibile i campi predefiniti.

Inoltre, Cloud Talent Solution fornisce anche attributi personalizzati per archiviare informazioni generiche. Gli attributi personalizzati vengono utilizzati per offrire ancora più flessibilità e consentire ai clienti di supportare la propria logica aziendale. Gli attributi personalizzati memorizzano una stringa o informazioni numeriche e possono essere filtrati nelle query di ricerca impostando filtri appropriati.

Funzionalità degli attributi personalizzati

Definisci il tuo nome di campo personalizzato: definisci un nome per un determinato attributo di un job. Imposta questo attributo come filtrabile o non filtrabile a seconda delle tue esigenze. In genere, se l'interfaccia utente ha bisogno di un'estrazione filtrabile non fornita immediatamente da Cloud Talent Solution, è possibile utilizzare un'customAttribute per fornire il filtro corretto.
Ricerca sensibile (o meno) alle maiuscole: ogni richiesta di ricerca può specificare se la ricerca in base a tutti gli attributi personalizzati è sensibile alle maiuscole o meno.
Filtro basato su intervallo: i filtri di ricerca customAttribute possono filtrare i job tra un intervallo di valori numerici specificati. Ad esempio, se un determinato campo customAttribute viene utilizzato per memorizzare i requisiti minimi del voto di laurea di un lavoro, il filtro di ricerca customAttribute può essere utilizzato per restituire i lavori all'interno di un determinato intervallo di voto di laurea minimo, maggiore di un valore minimo del voto di laurea, minore di un valore minimo del voto di laurea e così via.
Filtro tra campi: customAttribute offre inoltre ai clienti di Cloud Talent Solution la possibilità di definire espressioni che filtrano una combinazione di attributi personalizzati. Ad esempio, un cliente ha una logica di business che indica che vuole solo offerte di lavoro che sponsorizzano visti o che prevedono il telelavoro. Il cliente memorizza entrambi i campi in un customAttribute diverso. Il cliente può quindi specificare un filtro di ricerca con un'espressione che definisce la logica necessaria. Sono supportati solo 3 livelli di espressioni nidificate.
Ricerca specifica per parole chiave: specifica un determinato customAttribute in keywordSearchableCustomAttributes dell'azienda associata per assicurarti che le richieste di ricerca che contengono un valore nell'attributo personalizzato specificato restituiscano le offerte di lavoro contenenti questo valore nell'attributo personalizzato.
Ricerche basate su SQL: customAttribute ti consente di definire espressioni di tipo booleano nella richiesta di ricerca. Cloud Talent Solution analizza automaticamente queste espressioni, applica i filtri alla richiesta di ricerca e restituisce i risultati di conseguenza. Sono consentiti solo 3 livelli di nidificazione delle espressioni booleane e massimo 2000 caratteri.
Definire bucket di istogrammi personalizzati:gli attributi personalizzati consentono ai clienti di Cloud Talent Solution di impostare bucket personalizzati in base ai quali è possibile calcolare gli istogrammi. Ad esempio, puoi utilizzare un customAttribute per memorizzare le informazioni sul voto medio minimo e poi creare un'istogramma in questo campo. Puoi creare ulteriormente bucket da 3,0 a 3,5, da 3,51 a 4,0 e così via per raggruppare tutti i voti minimi all'interno di questi bucket.

Utilizzo di attributi personalizzati

Crea un nuovo job con il campo customAttribute (può essere utilizzato con valori numerici o di stringa):

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 saperne di più sull'installazione e sulla creazione di un client Cloud Talent Solution, consulta Librerie client Cloud Talent Solution.


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 saperne di più sull'installazione e sulla creazione di un client Cloud Talent Solution, consulta Librerie client Cloud Talent Solution.


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 saperne di più sull'installazione e sulla creazione di un client Cloud Talent Solution, consulta Librerie client 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

Per impostazione predefinita, gli endpoint searchJobs e searchJobsForAlert eseguono ricerche solo nei campi predefiniti. Se devi eseguire ricerche anche in base ai campi customAttribute, utilizza il campo keywordSearchableJobCustomAttributes per definire un elenco di attributi personalizzati da cercare.

Ad esempio, se un recruiter vuole utilizzare un campo customAttribute "customRequisitions" per memorizzare gli ID richiesta di offerte specifiche per un datore di lavoro specifico, impostando keywordSearchableJobCustomAttributes per includere questo campo, una ricerca normale effettuata da un recruiter per "ABC123" restituisce tutte le offerte che hanno il campo customAttribute "customRequisitions" con un valore di "ABC123".