Esta página foi traduzida pela API Cloud Translation.

Noções básicas do emprego (v4beta1)

Um recurso Job representa uma única publicação de emprego (também denominada "oferta de emprego" ou "requisição de emprego"). Um trabalho pertence a um recurso de empresa que representa a entidade de contratação responsável pelo trabalho.

Pode aceder a uma tarefa através dos métodos LIST e GET, e manipulá-la através dos métodos CREATE, UPDATE e DELETE. O índice do Cloud Talent Solution pode demorar vários minutos a refletir as alterações.

Os trabalhos estão contidos no âmbito de uma conta de serviço. Apenas os pedidos de pesquisa autenticados através das credenciais de uma determinada conta de serviço podem ser usados para aceder ao conteúdo destas tarefas.

Para uma resolução de problemas e uma triagem fáceis, sincronize o índice de tarefas da Cloud Talent Solution com o seu próprio índice de tarefas e mantenha uma relação entre o name gerado pela Cloud Talent Solution e o identificador de tarefas único no seu sistema. À medida que os trabalhos mudam ou são introduzidos no seu sistema, a chamada CRUD adequada deve ser enviada para o CTS em tempo real para garantir que estas alterações são refletidas imediatamente. O índice CTS tem de ser adicionado ao pipeline de carregamento de tarefas existente.

Crie um trabalho

Pode criar uma tarefa com o exemplo de código abaixo. Consulte o artigo Início rápido: crie empresas e trabalhos para ver mais detalhes. Os tutoriais em vídeo e os codelabs interativos também estão disponíveis.

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"
	talentpb "google.golang.org/genproto/googleapis/cloud/talent/v4beta1"
)

// createJob create a job as given.
func createJob(w io.Writer, projectID, companyID, requisitionID, title, URI, description, address1, address2, languageCode string) (*talentpb.Job, error) {
	ctx := context.Background()

	// Initialize a jobService client.
	c, err := talent.NewJobClient(ctx)
	if err != nil {
		fmt.Printf("talent.NewJobClient: %v\n", err)
		return nil, err
	}

	jobToCreate := &talentpb.Job{
		CompanyName:   fmt.Sprintf("projects/%s/companies/%s", projectID, companyID),
		RequisitionId: requisitionID,
		Title:         title,
		ApplicationInfo: &talentpb.Job_ApplicationInfo{
			Uris: []string{URI},
		},
		Description:  description,
		Addresses:    []string{address1, address2},
		LanguageCode: languageCode,
	}

	// Construct a createJob request.
	req := &talentpb.CreateJobRequest{
		Parent: fmt.Sprintf("projects/%s", projectID),
		Job:    jobToCreate,
	}

	resp, err := c.CreateJob(ctx, req)
	if err != nil {
		fmt.Printf("Failed to create job: %v\n", err)
		return nil, err
	}

	fmt.Printf("Created job: %q\n", resp.GetName())

	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.Job;
import com.google.cloud.talent.v4beta1.JobServiceClient;
import com.google.cloud.talent.v4beta1.TenantName;
import java.io.IOException;
import java.sql.Timestamp;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.Calendar;
import java.util.List;
import java.util.Locale;

public class JobSearchCreateJob {

  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";
    String jobApplicationUrl = "your-job-url";
    createJob(projectId, tenantId, companyId, requisitionId, jobApplicationUrl);
  }

  // Create a job.
  public static void createJob(
      String projectId,
      String tenantId,
      String companyId,
      String requisitionId,
      String jobApplicationUrl)
      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);
      Job.ApplicationInfo applicationInfo =
          Job.ApplicationInfo.newBuilder().addUris(jobApplicationUrl).build();

      List<String> addresses =
          Arrays.asList(
              "1600 Amphitheatre Parkway, Mountain View, CA 94043",
              "111 8th Avenue, New York, NY 10011");

      // By default, job will expire in 30 days.
      // https://cloud.google.com/talent-solution/job-search/docs/jobs
      Job job =
          Job.newBuilder()
              .setCompany(companyId)
              .setRequisitionId(requisitionId)
              .setTitle("Software Developer")
              .setDescription("Develop, maintain the software solutions.")
              .setApplicationInfo(applicationInfo)
              .addAllAddresses(addresses)
              .setLanguageCode("en-US")
              .build();

      CreateJobRequest request =
          CreateJobRequest.newBuilder().setParent(parent.toString()).setJob(job).build();

      Job response = jobServiceClient.createJob(request);
      System.out.format("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,
    job_application_url,
):
    """Create Job"""

    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.'
    # title = 'Software Engineer'
    # description = 'This is a description of this <i>wonderful</i> job!'
    # job_application_url = 'https://www.example.org/job-posting/123'
    # address_one = '1600 Amphitheatre Parkway, Mountain View, CA 94043'
    # address_two = '111 8th Avenue, New York, NY 10011'
    # 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")
    if isinstance(requisition_id, bytes):
        requisition_id = requisition_id.decode("utf-8")
    if isinstance(job_application_url, bytes):
        job_application_url = job_application_url.decode("utf-8")
    parent = f"projects/{project_id}/tenants/{tenant_id}"
    uris = [job_application_url]
    application_info = {"uris": uris}
    addresses = [
        "1600 Amphitheatre Parkway, Mountain View, CA 94043",
        "111 8th Avenue, New York, NY 10011",
    ]
    job = {
        "company": company_id,
        "requisition_id": requisition_id,
        "title": "Software Developer",
        "description": "Develop, maintain the software solutions.",
        "application_info": application_info,
        "addresses": addresses,
        "language_code": "en-US",
    }

    response = client.create_job(parent=parent, job=job)
    print(f"Created job: {response.name}")
    return response.name

Campos obrigatórios

Os seguintes campos são obrigatórios durante a criação e a atualização de tarefas:

companyName: o nome do recurso da empresa proprietária da tarefa, como companyName=\"projects/{ProjectId}/companies/{CompanyId}\".
requisitionId: o ID do pedido, também denominado ID da publicação, é um valor que atribui para identificar um emprego. Pode usar este campo para identificação do cliente e acompanhamento de requisições. O número máximo de carateres permitidos é 225.

A unicidade de uma publicação de emprego é determinada através de uma combinação do requisitionID, do companyName e da localização. Se uma tarefa for criada com uma chave específica destes atributos, esta chave é armazenada no índice da Cloud Talent Solution e não é possível criar outras tarefas com estes mesmos campos até que a tarefa seja eliminada.
title: O cargo, por exemplo, "Engenheiro de software". O número máximo de carateres permitidos é 500.

Para corrigir o problema dos resultados de pesquisa perdidos devido a cargos não padrão, a Cloud Talent Solution tira partido de todos os campos de emprego para compreender o contexto do emprego e armazenar internamente um cargo "limpo". Quando um pedido de pesquisa é enviado para o serviço, a consulta de pesquisa também é limpa, e as ontologias são usadas para mapear a consulta limpa para tarefas limpas relevantes.
description: a descrição do trabalho, que normalmente inclui uma descrição de vários parágrafos da empresa e informações relacionadas. São fornecidos campos separados no objeto Job para responsabilidades, qualificações e outras caraterísticas do trabalho. Recomendamos a utilização destes campos separados.

Este campo aceita e limpa a entrada HTML, e aceita etiquetas de marcação em negrito, itálico, lista ordenada e lista não ordenada. O número máximo de carateres permitidos é 100 000.

Uma das seguintes opções:

applicationInfo.uris: os URLs das páginas da aplicação.
applicationInfo.emails: endereços de email para os quais devem ser enviados currículos ou candidaturas.
applicationInfo.instruction: instruções de candidatura, como "Envie a sua candidatura por correio para …". Este campo aceita e limpa a entrada de HTML, e aceita etiquetas de marcação em negrito, itálico, lista ordenada e lista não ordenada. O número máximo de carateres permitidos é 3000.

Campos usados frequentemente

postingExpireTime: a hora, com base na data/hora, em que a oferta de emprego expira. Após este período, a tarefa é marcada como expirada e não aparece nos resultados da pesquisa. Esta data deve ser anterior a 31/12/2100 no fuso horário UTC. As datas inválidas (como datas no passado) são ignoradas. A data predefinida em que a tarefa expira é 30 dias após a hora de criação da tarefa no fuso horário UTC.

O conteúdo de trabalhos expirados ainda pode ser obtido até 60 dias após a expiração do trabalho através do operador GET. Após este prazo de 60 dias, a tarefa não é devolvida através de uma operação GET.

Nota: o limite de 60 dias é configurável pelo apoio técnico. Apresente um pedido à equipa de apoio técnico se precisar de prolongar o acesso.
addresses: localizações de trabalho. Recomendamos que indique as moradas completas do local de recrutamento para permitir melhores resultados da pesquisa de emprego, incluindo pesquisas por tempo de trajeto. O número máximo de carateres permitido é 500. Estão disponíveis mais informações sobre addresses na secção Práticas recomendadas abaixo.
promotionValue: um valor superior a 0 define esta oferta de emprego como uma "oferta de emprego em destaque", que só é devolvida em pesquisas do tipo FEATURED_JOBS. Os valores mais elevados são devolvidos em posições mais altas nos resultados da pesquisa em destaque. Consulte o artigo Anúncios de emprego em destaque para mais informações.

Usar campos de tarefas personalizados

A Cloud Talent Solution inclui vários campos de tarefas incorporados nos respetivos esquemas de API. No entanto, pode precisar de campos adicionais que não estão presentes nas opções predefinidas. Embora recomendemos que use os campos prontos a usar sempre que possível, a Cloud Talent Solution também fornece alguns campos customAttributes para um trabalho. Podem ser filtráveis ou não filtráveis. Consulte a customAttributes documentação para mais informações.

customAttributes: este campo armazena até 100 atributos personalizados usados para armazenar dados personalizados sobre a tarefa. Estes campos podem ser filtrados através de um pedido de pesquisa que especifique o campo jobQuery. Além disso, qualquer um destes campos pode ser definido no keywordSearchableJobCustomAttributes atributo do company, pelo que um termo de pesquisa que tenha uma correspondência exata em qualquer um dos campos em keywordSearchableJobCustomAttributes devolve qualquer trabalho que inclua a correspondência.

O exemplo de código seguinte mostra como criar uma tarefa com um customAttribute:

Go

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 (
	"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

Obtenha um trabalho

Go

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 (
	"context"
	"fmt"
	"io"

	talent "cloud.google.com/go/talent/apiv4beta1"
	talentpb "google.golang.org/genproto/googleapis/cloud/talent/v4beta1"
)

// getJob gets an existing job by its resource name.
func getJob(w io.Writer, projectID, jobID string) (*talentpb.Job, error) {
	ctx := context.Background()

	// Initialize a jobService client.
	c, err := talent.NewJobClient(ctx)
	if err != nil {
		fmt.Printf("talent.NewJobClient: %v\n", err)
		return nil, err
	}

	// Construct a getJob request.
	jobName := fmt.Sprintf("projects/%s/jobs/%s", projectID, jobID)
	req := &talentpb.GetJobRequest{
		// The resource name of the job to retrieve.
		// The format is "projects/{project_id}/jobs/{job_id}".
		Name: jobName,
	}

	resp, err := c.GetJob(ctx, req)
	if err != nil {
		fmt.Printf("Failed to get job %s: %v\n", jobName, err)
		return nil, err
	}

	fmt.Fprintf(w, "Job: %q\n", resp.GetName())
	fmt.Fprintf(w, "Job title: %v\n", resp.GetTitle())

	return resp, err
}

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.GetJobRequest;
import com.google.cloud.talent.v4beta1.Job;
import com.google.cloud.talent.v4beta1.JobName;
import com.google.cloud.talent.v4beta1.JobServiceClient;
import java.io.IOException;

public class JobSearchGetJob {

  public static void getJob() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String tenantId = "your-tenant-id";
    String jobId = "your-job-id";
    getJob(projectId, tenantId, jobId);
  }

  // Get Job.
  public static void getJob(String projectId, String tenantId, String jobId) 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()) {
      JobName name = JobName.ofProjectTenantJobName(projectId, tenantId, jobId);

      GetJobRequest request = GetJobRequest.newBuilder().setName(name.toString()).build();

      Job response = jobServiceClient.getJob(request);
      System.out.format("Job name: %s%n", response.getName());
      System.out.format("Requisition ID: %s%n", response.getRequisitionId());
      System.out.format("Title: %s%n", response.getTitle());
      System.out.format("Description: %s%n", response.getDescription());
      System.out.format("Posting language: %s%n", response.getLanguageCode());
      for (String address : response.getAddressesList()) {
        System.out.format("Address: %s%n", address);
      }
      for (String email : response.getApplicationInfo().getEmailsList()) {
        System.out.format("Email: %s%n", email);
      }
      for (String websiteUri : response.getApplicationInfo().getUrisList()) {
        System.out.format("Website: %s%n", websiteUri);
      }
    }
  }
}

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 get_job(project_id, tenant_id, job_id):
    """Get Job"""

    client = talent.JobServiceClient()

    # project_id = 'Your Google Cloud Project ID'
    # tenant_id = 'Your Tenant ID (using tenancy is optional)'
    # job_id = 'Job ID'

    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(job_id, bytes):
        job_id = job_id.decode("utf-8")
    name = client.job_path(project_id, tenant_id, job_id)

    response = client.get_job(name=name)
    print(f"Job name: {response.name}")
    print(f"Requisition ID: {response.requisition_id}")
    print(f"Title: {response.title}")
    print(f"Description: {response.description}")
    print(f"Posting language: {response.language_code}")
    for address in response.addresses:
        print(f"Address: {address}")
    for email in response.application_info.emails:
        print(f"Email: {email}")
    for website_uri in response.application_info.uris:
        print(f"Website: {website_uri}")

Anuncie empregos

Go

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 (
	"context"
	"fmt"
	"io"

	talent "cloud.google.com/go/talent/apiv4beta1"
	"google.golang.org/api/iterator"
	talentpb "google.golang.org/genproto/googleapis/cloud/talent/v4beta1"
)

// listJobs lists jobs with a filter, for example
// `companyName="projects/my-project/companies/123"`.
func listJobs(w io.Writer, projectID, companyID string) error {
	ctx := context.Background()

	// Initialize a jobService client.
	c, err := talent.NewJobClient(ctx)
	if err != nil {
		fmt.Printf("talent.NewJobClient: %v\n", err)
		return err
	}

	// Construct a listJobs request.
	companyName := fmt.Sprintf("projects/%s/companies/%s", projectID, companyID)
	req := &talentpb.ListJobsRequest{
		Parent: "projects/" + projectID,
		Filter: fmt.Sprintf("companyName=%q", companyName),
	}

	it := c.ListJobs(ctx, req)

	for {
		resp, err := it.Next()
		if err == iterator.Done {
			return nil
		}
		if err != nil {
			fmt.Printf("it.Next: %v\n", err)
			return err
		}
		fmt.Fprintf(w, "Listing job: %v\n", resp.GetName())
		fmt.Fprintf(w, "Job title: %v\n", resp.GetTitle())
	}
}

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.Job;
import com.google.cloud.talent.v4beta1.JobServiceClient;
import com.google.cloud.talent.v4beta1.ListJobsRequest;
import com.google.cloud.talent.v4beta1.TenantName;
import java.io.IOException;

public class JobSearchListJobs {

  public static void listJobs() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String tenantId = "your-tenant-id";
    String query = "count(base_compensation, [bucket(12, 20)])";
    listJobs(projectId, tenantId, query);
  }

  // Search Jobs with histogram queries.
  public static void listJobs(String projectId, String tenantId, String filter) 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);
      ListJobsRequest request =
          ListJobsRequest.newBuilder().setParent(parent.toString()).setFilter(filter).build();
      for (Job responseItem : jobServiceClient.listJobs(request).iterateAll()) {
        System.out.format("Job name: %s%n", responseItem.getName());
        System.out.format("Job requisition ID: %s%n", responseItem.getRequisitionId());
        System.out.format("Job title: %s%n", responseItem.getTitle());
        System.out.format("Job description: %s%n", responseItem.getDescription());
      }
    }
  }
}

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 list_jobs(project_id, tenant_id, filter_):
    """List Jobs"""

    client = talent.JobServiceClient()

    # project_id = 'Your Google Cloud Project ID'
    # tenant_id = 'Your Tenant ID (using tenancy is optional)'
    # filter_ = 'companyName=projects/my-project/companies/company-id'

    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(filter_, bytes):
        filter_ = filter_.decode("utf-8")
    parent = f"projects/{project_id}/tenants/{tenant_id}"

    # Iterate over all results
    results = []
    for job in client.list_jobs(parent=parent, filter=filter_):
        results.append(job.name)
        print("Job name: {job.name}")
        print("Job requisition ID: {job.requisition_id}")
        print("Job title: {job.title}")
        print("Job description: {job.description}")
    return results

Elimine uma tarefa

Go

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 (
	"context"
	"fmt"
	"io"

	talent "cloud.google.com/go/talent/apiv4beta1"
	talentpb "google.golang.org/genproto/googleapis/cloud/talent/v4beta1"
)

// deleteJob deletes an existing job by its resource name.
func deleteJob(w io.Writer, projectID, jobID string) error {
	ctx := context.Background()

	// Initialize a jobService client.
	c, err := talent.NewJobClient(ctx)
	if err != nil {
		fmt.Printf("talent.NewJobClient: %v\n", err)
		return err
	}

	// Construct a deleteJob request.
	jobName := fmt.Sprintf("projects/%s/jobs/%s", projectID, jobID)
	req := &talentpb.DeleteJobRequest{
		// The resource name of the job to be deleted.
		// The format is "projects/{project_id}/jobs/{job_id}".
		Name: jobName,
	}

	if err := c.DeleteJob(ctx, req); err != nil {
		fmt.Printf("Delete(%s): %v\n", jobName, err)
		return err
	}

	fmt.Printf("Deleted job: %q\n", jobName)

	return err
}

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.DeleteJobRequest;
import com.google.cloud.talent.v4beta1.JobName;
import com.google.cloud.talent.v4beta1.JobServiceClient;
import java.io.IOException;

public class JobSearchDeleteJob {

  public static void deleteJob() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String tenantId = "your-tenant-id";
    String jobId = "your-job-id";
    deleteJob(projectId, tenantId, jobId);
  }

  // Delete Job.
  public static void deleteJob(String projectId, String tenantId, String jobId) 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()) {
      JobName name = JobName.ofProjectTenantJobName(projectId, tenantId, jobId);

      DeleteJobRequest request = DeleteJobRequest.newBuilder().setName(name.toString()).build();

      jobServiceClient.deleteJob(request);
      System.out.println("Deleted job.");
    }
  }
}

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 delete_job(project_id, tenant_id, job_id):
    """Delete Job"""

    client = talent.JobServiceClient()

    # project_id = 'Your Google Cloud Project ID'
    # tenant_id = 'Your Tenant ID (using tenancy is optional)'
    # job_id = 'Company ID'

    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(job_id, bytes):
        job_id = job_id.decode("utf-8")
    name = client.job_path(project_id, tenant_id, job_id)

    client.delete_job(name=name)
    print("Deleted job.")

Práticas recomendadas

Campos de localização

Sempre que possível, recomendamos que indique a morada da rua de um emprego no campo addresses. Isto ajuda na deteção de localização e na relevância. Quando não estiver disponível uma morada ao nível da rua, introduza o máximo de informações possível. Os endereços são suportados até ao nível do país. As designações de regiões (como "Noroeste Pacífico") não são suportadas.

A Cloud Talent Solution usa os dados no campo addresses para preencher o campo (apenas saída) derivedInfo.locations. Quando não é fornecida uma morada completa, o serviço usa outros sinais, como o nome da empresa, para determinar se é possível inferir uma morada mais completa para a publicação de emprego.

Por exemplo, se a localização de um cargo de software for especificada como Mountain View e a empresa à qual o cargo está associado for Google, o serviço procura o objeto company para ver se é fornecida uma morada mais precisa no campo headquartersAddress e se essa morada está na mesma cidade que a publicação de emprego. Se for o caso, o serviço compreende que o emprego está "provavelmente" localizado nessa morada e preenche o campo derivedInfo.locations adequadamente.

Se os dados da morada da empresa não estiverem disponíveis, o serviço usa uma combinação de conhecimentos proprietários e informações de emprego/empresa para preencher o campo derivedInfo.locations.

Uma vez que o valor derivedInfo.locations é uma estimativa, recomendamos que use os dados derivedInfo.locations ou o campo addresses quando apresentar a morada do trabalho.

Uma publicação de emprego não pode ter mais de 50 localizações associadas. Se uma tarefa tiver mais localizações, pode dividi-la em várias tarefas, cada uma com um requisitionId único (por exemplo, "ReqA", "ReqA-1", "ReqA-2" e assim sucessivamente). Não é permitido ter vários trabalhos com o mesmo requisitionId, companyName e languageCode. Se o requisitionId original tiver de ser preservado, deve usar um CustomAttribute para armazenamento. Recomendamos que agrupe as localizações mais próximas entre si no mesmo trabalho para uma melhor experiência de pesquisa.

Moradas suportadas

Qualquer morada reconhecida pela API Google Maps Geocoding (no campo formattedAddress) é aceite pela Cloud Talent Solution. O serviço devolve um erro 400 se tentar criar uma tarefa ou executar uma pesquisa usando um endereço não reconhecido.

Se a morada de uma empresa estiver incorretamente indicada na API Google Maps Geocoding, apresente um erro para que seja corrigido. As correções podem demorar até 5 dias a entrar em vigor.

Conclusão automática de moradas

A Cloud Talent Solution não oferece sugestões de preenchimento automático para localizações. Use a API Google Maps Places ou outros serviços de localização semelhantes para preencher sugestões de preenchimento automático.

Empregos em todo o estado, em todo o país e de teletrabalho

Os trabalhos podem ser especificados como ao nível do estado, nacional ou em regime de teletrabalho através do campo postingRegion.

ADMINISTRATIVE_AREA e NATION são devolvidos empregos para qualquer pesquisa com uma localização especificada no estado/país da publicação de emprego. Por exemplo, se um ADMINISTRATIVE_AREA emprego tiver a localização "WA, EUA", é devolvido para pesquisas com LocationFilter que especifiquem "Seattle".
TELECOMMUTE Os empregos são devolvidos em qualquer pesquisa relacionada com a localização, mas são tratados como menos relevantes. Podem ser segmentados numa pesquisa definindo o flag telecommutePreference como TELECOMMUTE_ALLOWED no LocationFilter da pesquisa.

Noções básicas do emprego (v4beta1) Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Crie um trabalho

Go

Java

Python

Campos obrigatórios

Campos usados frequentemente

Usar campos de tarefas personalizados

Go

Java

Python

Obtenha um trabalho

Go

Java

Python

Anuncie empregos

Go

Java

Python

Elimine uma tarefa

Go

Java

Python

Práticas recomendadas

Campos de localização

Moradas suportadas

Conclusão automática de moradas

Empregos em todo o estado, em todo o país e de teletrabalho

Noções básicas do emprego (v4beta1)