Esta página foi traduzida pela API Cloud Translation.

Atributos personalizados (v4beta1)

A Cloud Talent Solution oferece vários atributos de tarefas diferentes prontos a usar para suportar as necessidades de vários clientes. Para obter o melhor desempenho da Cloud Talent Solution, recomendamos vivamente que use os campos predefinidos o mais possível.

Além disso, a Cloud Talent Solution também fornece atributos personalizados para armazenar informações genéricas. Os atributos personalizados são usados para oferecer ainda mais flexibilidade e permitir que os clientes suportem a respetiva lógica empresarial. Os atributos personalizados armazenam uma string ou informações numéricas e podem ser filtrados em consultas de pesquisa através da definição de filtros adequados.

Funcionalidades de atributos personalizados

Defina o seu próprio nome de campo personalizado: defina um nome para um atributo específico de um trabalho. Defina este atributo como filtrável ou não filtrável, consoante as suas necessidades. Normalmente, se a IU precisar de uma faceta filtrável que não seja fornecida pronta a usar pela Cloud Talent Solution, pode usar customAttribute para fornecer a filtragem correta.
Pesquisa sensível a maiúsculas e minúsculas: cada pedido de pesquisa pode especificar se a pesquisa em todos os atributos personalizados é sensível a maiúsculas e minúsculas ou não.
Filtragem baseada em intervalos: os filtros de pesquisa customAttribute podem filtrar trabalhos entre um intervalo de valores numéricos especificados. Por exemplo, se um determinado campo customAttribute for usado para armazenar os requisitos mínimos de média de um emprego, o filtro de pesquisa customAttribute pode ser usado para devolver empregos dentro de um determinado intervalo mínimo de média, superior a um valor mínimo de média, inferior a um valor mínimo de média, etc.
Filtragem entre campos: customAttribute também oferece aos clientes da Cloud Talent Solution a capacidade de definir expressões que filtram uma combinação de atributos personalizados. Por exemplo, um cliente tem uma lógica empresarial que indica que só quer trabalhos que patrocinem vistos ou trabalhos de teletrabalho. O cliente armazena ambos os campos num formato customAttribute diferente. Em seguida, o cliente pode especificar um filtro de pesquisa com uma expressão que define a lógica necessária. Apenas são suportados 3 níveis de expressões aninhadas.
Pesquisa específica de palavras-chave: especifique um determinado customAttribute no keywordSearchableCustomAttributes da empresa associada para garantir que as solicitações de pesquisa que contêm um valor no customAttribute especificado devolvem os trabalhos que contêm este valor nesse customAttribute.
Pesquisas baseadas em SQL: customAttribute permite-lhe definir expressões de estilo booleano nos pedidos de pesquisa. A Cloud Talent Solution analisa automaticamente estas expressões, aplica os filtros ao pedido de pesquisa e devolve os resultados em conformidade. Só são permitidos 3 níveis de aninhamento das expressões booleanas e, no máximo, 2000 carateres.
Defina intervalos de histogramas personalizados: os atributos personalizados permitem que os clientes da Cloud Talent Solution definam intervalos personalizados pelos quais os histogramas podem ser calculados. Por exemplo, pode usar um customAttribute para armazenar informações de média mínima e, em seguida, criar um histograma neste campo. Pode criar ainda mais intervalos de 3,0 a 3,5, 3,51 a 4,0, etc., para agrupar todas as médias mínimas dentro destes intervalos.

Usar atributos personalizados

Crie uma nova tarefa com o campo customAttribute (pode ser usado com valores numéricos ou de string):

Go

Para saber como instalar e usar a biblioteca cliente para o CTS, consulte o artigo Bibliotecas cliente do CTS. Para mais informações, consulte a documentação de referência da API Go CTS.

Para se autenticar no CTS, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento 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

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


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

Python

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

Por predefinição, os pontos finais searchJobs e searchJobsForAlert pesquisam apenas campos predefinidos. Se também precisar de pesquisar campos customAttribute, use o campo keywordSearchableJobCustomAttributes para definir uma lista de atributos personalizados a pesquisar.

Por exemplo, se um recrutador quiser usar um customAttribute "customRequisitions" para armazenar os IDs de requisições de empregos específicos de um determinado empregador, ao definir keywordSearchableJobCustomAttributes para incluir este campo, uma pesquisa normal realizada por um recrutador para "ABC123" devolve todos os empregos que têm o customAttribute "customRequisitions" com um valor de "ABC123".