Atributos personalizados

A Cloud Talent Solution dispõe de diversos atributos de vaga predefinidos para atender às necessidades de vários clientes. Use os campos predefinidos para o melhor desempenho do Cloud Talent Solution.

Além disso, o Cloud Talent Solution também inclui atributos personalizados para armazenar informações genéricas. Os atributos personalizados são usados para fornecer ainda mais flexibilidade a fim de permitir compatibilidade com a lógica de negócio dos clientes. Os atributos personalizados armazenam informações de string ou numéricas e podem ser filtrados nas consultas de pesquisa por meio da definição de filtros apropriados.

Recursos dos atributos personalizados

  • Definir o próprio nome do campo personalizado: defina um nome para um determinado atributo de uma vaga. Defina esse atributo para ser filtrável ou não filtrável, dependendo da necessidade. Normalmente, caso a IU precise de um atributo filtrável que não seja predefinido no Cloud Talent Solution, um customAttribute poderá ser usado para fornecer a filtragem certa.
  • Pesquisa (in)diferente a maiúsculas: cada solicitação de pesquisa pode especificar se a pesquisa em todos os atributos personalizados é indiferente a maiúsculas.
  • Filtragem baseada em intervalo: os filtros de pesquisa por customAttribute podem filtrar vagas em um intervalo de valores numéricos especificados. Por exemplo, se um campo customAttribute for usado para armazenar os requisitos mínimos de GPA de uma vaga, o filtro de pesquisa customAttribute poderá ser usado para retornar vagas dentro de um determinado intervalo mínimo de GPA, acima de um valor mínimo de GPA, abaixo de um valor mínimo de GPA etc.
  • Filtragem entre campos: customAttribute também capacitam os clientes do Cloud Talent Solution a definir expressões que filtram uma combinação de atributos personalizados. Por exemplo, um cliente tem uma lógica de negócios que afirma que ele quer apenas vagas que concedam vistos ou de trabalho remoto. O cliente armazena esses dois campos em um customAttribute diferente. O cliente pode especificar um filtro de pesquisa com uma expressão que defina a lógica necessária. Somente três níveis de expressões aninhadas são permitidos.

  • Pesquisa específica por palavra-chave: especifique um determinado customAttribute no keywordSearchableCustomAttributes da empresa associada para garantir que solicitações de pesquisa contendo um valor no customAttribute especificado retornem as vagas com esse valor no customAttribute.

  • Pesquisas baseadas em SQL: customAttribute permite definir expressões de estilo booleano na solicitação de pesquisa. O Cloud Talent Solution analisa automaticamente essas expressões, aplica os filtros à solicitação de pesquisa e retorna os resultados pertinentes. Somente três níveis de aninhamento das expressões booleanas e, no máximo, 2.000 caracteres são permitidos.

  • Definir buckets de histograma personalizados: os atributos personalizados permitem que os clientes do Cloud Talent Solution definam buckets personalizados para cálculo dos histogramas. Por exemplo, é possível usar um customAttribute para armazenar informações mínimas sobre o GPA e criar um histograma nesse campo. Você também pode criar buckets de 3.0 a 3.5, de 3.51 a 4.0 etc. para agrupar todos os GPAs mínimos nesses buckets.

Como usar atributos personalizados

Crie uma nova vaga com o campo customAttribute (numérico e string):

Go

import (
	"context"
	"fmt"
	"io"

	talent "cloud.google.com/go/talent/apiv4beta1"
	"github.com/gofrs/uuid"
	talentpb "google.golang.org/genproto/googleapis/cloud/talent/v4beta1"
	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: %v", 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: %v", 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

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do Cloud Talent Solution.


from google.cloud import talent
import six

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, six.binary_type):
        project_id = project_id.decode("utf-8")
    if isinstance(tenant_id, six.binary_type):
        tenant_id = tenant_id.decode("utf-8")
    if isinstance(company_id, six.binary_type):
        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

Por padrão, os endpoints searchJobs e searchJobsForAlert pesquisam apenas nos campos predefinidos. Caso você também precise pesquisar em campos customAttribute, use o campo keywordSearchableJobCustomAttributes para definir uma lista de atributos personalizados para pesquisa.

Por exemplo, caso um recrutador queira usar um customAttribute "customRequisitions" para armazenar os códigos de requisição de vagas pertinentes a um determinado empregador, ele deve definir keywordSearchableJobCustomAttributes para incluir esse campo. Dessa forma, ao pesquisar "ABC123" normalmente, serão retornadas todas as vagas que tenham o customAttribute "customRequisitions" com o valor "ABC123".