Attributi personalizzati

Cloud Talent Solution fornisce diversi attributi di lavoro predefiniti per soddisfare le esigenze di vari clienti. Per ottenere le migliori prestazioni 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 di business. Gli attributi personalizzati memorizzano informazioni numeriche o stringhe e possono essere filtrati nelle query di ricerca impostando i filtri appropriati.

Funzionalità degli attributi personalizzati

  • Definisci il nome del campo personalizzato: definisci un nome per un determinato attributo di un'offerta di lavoro. Imposta questo attributo come filtrabile o non filtrabile a seconda delle tue esigenze. In genere, se l'interfaccia utente ha bisogno di una sfaccettatura filtrabile non fornita predefinita da Cloud Talent Solution, è possibile utilizzare un customAttribute per fornire il filtro corretto.
  • Ricerca con distinzione tra maiuscole e minuscole: ogni richiesta di ricerca può specificare se la ricerca in tutti gli attributi personalizzati fa distinzione tra maiuscole e minuscole.
  • Filtro basato su intervallo: customAttribute i filtri di ricerca possono filtrare le offerte di lavoro in base a un intervallo di valori numerici specificati. Ad esempio, se un determinato campo customAttribute viene utilizzato per memorizzare i requisiti minimi di GPA di un'offerta di lavoro, il filtro di ricerca customAttribute può essere utilizzato per restituire le offerte di lavoro all'interno di un determinato intervallo di GPA minimo, maggiore di un valore di GPA minimo, inferiore a un valore di GPA minimo e così via.

  • Filtro tra campi: customAttribute offre ai clienti di Cloud Talent Solution anche la possibilità di definire espressioni che filtrano una combinazione di attributi personalizzati. Ad esempio, un cliente ha una logica di business che prevede di visualizzare solo le offerte di lavoro che sponsorizzano i visti o le offerte di lavoro in telelavoro. Il cliente memorizza entrambi questi 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 della società associata per assicurarti che le richieste di ricerca che contengono un valore nell'attributo personalizzato specificato restituiscano le offerte di lavoro contenenti questo valore in quell'attributo personalizzato.

  • Ricerche basate su SQL: customAttribute 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 al massimo 2000 caratteri.

  • Definisci 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 GPA minimo e poi creare un istogramma su questo campo. Puoi anche creare bucket da 3.0 a 3.5, da 3.51 a 4.0 e così via, per raggruppare tutti i GPA minimi all'interno di questi bucket.

Utilizzo di attributi personalizzati

Crea una nuova offerta di lavoro con il campo customAttribute (può essere utilizzato con valori numerici o stringhe):

Go

Per scoprire come installare e utilizzare la libreria client per CTS, consulta la sezione Librerie client CTS. Per saperne di più, consulta la documentazione di riferimento dell'API CTS Go.

Per eseguire l'autenticazione in CTS, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 la ricerca solo nei campi predefiniti. Se devi eseguire la ricerca anche nei campi customAttribute, utilizza il campo keywordSearchableJobCustomAttributes per definire un elenco di attributi personalizzati da cercare.

Ad esempio, se un recruiter vuole utilizzare un customAttribute "customRequisitions" per memorizzare gli ID delle richieste di offerte di lavoro specifiche per un determinato datore di lavoro, impostando keywordSearchableJobCustomAttributes in modo da includere questo campo, una normale ricerca eseguita da un recruiter per "ABC123" restituisce tutte le offerte di lavoro che hanno l'attributo customAttribute "customRequisitions" con il valore "ABC123".