Attributs personnalisés

Cloud Talent Solution propose différents attributs d'emploi prédéfinis pour répondre aux besoins des différents clients. Pour bénéficier des meilleures performances de Cloud Talent Solution, il est vivement recommandé d'utiliser autant que possible les champs prédéfinis.

Par ailleurs, Cloud Talent Solution fournit des attributs personnalisés pour stocker des informations génériques. Les attributs personnalisés permettent d'offrir encore plus de flexibilité aux clients dans le cadre de leur logique métier. Les attributs personnalisés stockent une chaîne ou des informations numériques. Pour les filtrer dans les requêtes de recherche, vous devez définir les filtres appropriés.

Fonctionnalités des attributs personnalisés

• Définissez votre propre nom de champ personnalisé : définissez un nom pour un attribut d'emploi donné. Définissez cet attribut pour qu'il soit filtrable ou non filtrable suivant les besoins. Vous pouvez généralement utiliser un attribut customAttribute pour appliquer un filtre approprié si l'interface utilisateur a besoin d'un filtre qui n'est pas prédéfini dans Cloud Talent Solution.
• Recherche sensible/non sensible à la casse : vous pouvez spécifier pour chaque requête si la recherche de tous les attributs personnalisés est sensible à la casse ou non.
• Filtrage basé sur une plage : les filtres de recherche customAttribute permettent de filtrer les offres d'emploi dans une plage de valeurs numériques données. Par exemple, si vous utilisez un champ customAttribute pour enregistrer les exigences minimales d'un poste, le filtre de recherche customAttribute permet d'afficher les emplois dans une plage de moyennes minimales donnée, pour les moyennes supérieures ou inférieures à une valeur de moyenne minimale, etc.

• Filtrage de champs croisés : le filtre de recherche customAttribute permet également aux clients de Cloud Talent Solution de définir des expressions qui filtrent une combinaison d'attributs personnalisés. Par exemple, si la logique métier d'un client stipule qu'il ne recherche que des emplois parrainant l'obtention d'un visa ou des emplois en télétravail, le client enregistre ces deux champs dans un attribut customAttribute distinct. Il peut ensuite spécifier un filtre de recherche avec une expression qui définit la logique nécessaire. Seuls trois niveaux d'expressions imbriquées sont acceptés.

• Recherche spécifique par mot clé : définissez un attribut customAttribute dans la liste keywordSearchableCustomAttributes de l'entreprise associée pour garantir que les requêtes de recherche contenant une valeur pour un attribut customAttribute donné affichent bien les emplois présentant cette valeur dans l'attribut.

• Recherches SQL : l'attribut customAttribute vous permet de définir des expressions booléennes dans la requête de recherche. Cloud Talent Solution analyse automatiquement ces expressions, applique les filtres à la requête et renvoie les résultats en conséquence. Vous ne pouvez pas utiliser plus de trois niveaux d'imbrication et 2 000 caractères dans vos expressions booléennes.

• Définir des buckets d'histogrammes personnalisés : les attributs personnalisés permettent aux clients de Cloud Talent Solution de définir des buckets personnalisés pour calculer les histogrammes. Par exemple, vous pouvez définir un attribut customAttribute pour enregistrer des exigences de moyenne minimales, puis créer un histogramme sur ce champ. Vous pouvez également créer des buckets correspondant aux plages allant de 3,0 à 3,5, de 3,51 à 4,0, etc. pour regrouper toutes les moyennes minimales dans ces buckets.

Utiliser des attributs personnalisés

Créez une offre d'emploi avec le champ customAttribute (peut être utilisé avec des valeurs numériques ou de chaîne) :

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour CTS, consultez la section Bibliothèques clientes CTS. Pour en savoir plus, consultez la documentation de référence de l'API CTS Go.

Pour vous authentifier auprès de CTS, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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

Pour en savoir plus sur l'installation et la création d'un client Cloud Talent Solution, consultez la page Bibliothèques clientes 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

Pour en savoir plus sur l'installation et la création d'un client Cloud Talent Solution, consultez la page Bibliothèques clientes 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

Pour en savoir plus sur l'installation et la création d'un client Cloud Talent Solution, consultez la page Bibliothèques clientes 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

Remarque :Cloud Talent Solution permet de définir les attributs filterableCustomFields et personnalisés lors de la création d'une offre d'emploi. Toutefois, un seul des attributs filterableCustomFields ou personnalisés peut être défini dans une même requête de recherche.

Par défaut, les points de terminaison searchJobs et searchJobsForAlert n'effectuent des recherches que sur les champs prédéfinis. Si vous devez également effectuer une recherche sur les champs "customAttribute", utilisez le champ keywordSearchableJobCustomAttributes pour définir une liste d'attributs personnalisés à rechercher.

Par exemple, si un recruteur souhaite utiliser un champ customAttribute "customRequisitions" pour enregistrer les ID de demandes de recrutement propres à un employeur, définissez keywordSearchableJobCustomAttributes de manière à inclure ce champ. Ainsi, si un recruteur effectue une recherche classique sur "ABC123", toutes les offres d'emploi ayant un attribut customAttribute "customRequisitions" défini sur la valeur "ABC123" s'affichent.