Se usó la API de Cloud Translation para traducir esta página.

Atributos personalizados

Cloud Talent Solution incluye varios atributos de trabajo integrados para atender las necesidades de diversos clientes. Para que Cloud Talent Solution tenga el mejor rendimiento, te recomendamos usar los campos integrados lo más posible.

Además, Cloud Talent Solution también cuenta con atributos personalizados para almacenar información genérica, que brindan más flexibilidad y permiten que los clientes respalden su lógica empresarial. Los atributos personalizados pueden almacenar una string o información numérica y también se pueden filtrar en las búsquedas si configuras los filtros adecuados.

Funciones de los atributos personalizados

Definir un nombre de campo personalizado: Define el nombre de un atributo específico de un trabajo. Determina si este atributo se puede filtrar o no según tus necesidades. Por lo general, si la interfaz de usuario necesita una faceta filtrable que Cloud Talent Solution no proporciona de manera inmediata, se puede usar un customAttribute para proporcionar el filtrado correcto.
Búsqueda con (o sin) distinción de mayúsculas y minúsculas: En cada solicitud de búsqueda, se puede especificar si la búsqueda de todos los atributos personalizados distingue o no mayúsculas y minúsculas.
Filtrado basado en rango: Los filtros de búsqueda customAttribute pueden filtrar trabajos entre un rango de valores numéricos especificados. Por ejemplo, si se usa un campo customAttribute determinado para almacenar los requisitos mínimos de GPA de un trabajo, el filtro de búsqueda customAttribute se puede usar para mostrar trabajos dentro de un cierto rango de GPA mínimo, mayor que un valor mínimo de GPA, menor que un valor mínimo de GPA, etcétera.
Filtro de campos combinados: customAttribute también proporciona a los clientes de Cloud Talent Solution la capacidad de definir expresiones que filtran una combinación de atributos personalizados. Por ejemplo, la lógica empresarial de un cliente indica que solo necesita trabajos desde casa o con patrocinio de visa. El cliente almacena estos dos campos en un customAttribute diferente. Luego, puede especificar un filtro de búsqueda con una expresión que defina la lógica necesaria. Solo se admiten 3 niveles de expresiones anidadas.
Búsqueda específica de palabras clave: Especifica un determinado customAttribute en los keywordSearchableCustomAttributes de la empresa asociada para garantizar que las solicitudes de búsqueda que contienen un valor en el customAttribute especificado muestren los trabajos que contienen este valor en ese customAttribute.
Búsquedas basadas en SQL: customAttribute te permite definir expresiones de estilo booleano en la solicitud de búsqueda. Cloud Talent Solution analiza automáticamente estas expresiones, aplica los filtros a la solicitud de búsqueda y muestra los resultados correspondientes. Solo se admiten 3 niveles de expresiones booleanas anidadas y con un máximo de 2,000 caracteres.
Definir intervalos de histograma personalizados: Los atributos personalizados permiten que los clientes de Cloud Talent Solution puedan definir intervalos personalizados para calcular los histogramas. Por ejemplo, puedes usar un customAttribute para almacenar información mínima de GPA y, luego, crear un histograma en este campo. Puedes crear más intervalos, como de 3.0 a 3.5, de 3.51 a 4.0, etc., para agrupar todos los GPA mínimos en ellos.

Usa atributos personalizados

Crea un nuevo trabajo con el campo customAttribute (puede usarse con valores numéricos o de string):

Go

Para obtener información sobre cómo instalar y usar la biblioteca cliente de CTS, consulta las bibliotecas cliente de CTS. Para obtener más información, consulta la documentación de referencia de la API de Go de CTS.

Para autenticarte en CTS, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de 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

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de 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

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de 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

De forma predeterminada, los extremos searchJobs y searchJobsForAlert solo buscan en los campos listos para usar. Si también necesitas buscar en los campos de customAttribute, usa el campo keywordSearchableJobCustomAttributes para definir una lista de atributos personalizados que quieras incluir en la búsqueda.

Por ejemplo, si un reclutador desea usar un customAttribute "customRequisitions" para almacenar los ID de solicitud de trabajos particulares para un empleador específico, si se configura keywordSearchableJobCustomAttributes para incluir este campo, una búsqueda regular realizada por un reclutador para "ABC123" muestra todos los trabajos que tienen las "customRequisitions" customAttribute con un valor de "ABC123".