Crie uma empresa e um trabalho

Este tutorial foi concebido para começar a explorar e desenvolver aplicações com a Cloud Talent Solution. É pressuposto que tem conhecimentos básicos de programação, embora, mesmo sem muitos conhecimentos de programação, deva conseguir acompanhar. Depois de seguir este tutorial, deve conseguir usar a documentação de referência da Cloud Talent Solution para criar as suas próprias aplicações básicas.

Este tutorial explica passo a passo uma aplicação da Cloud Talent Solution através de código Java. O objetivo aqui não é explicar as bibliotecas cliente Java, mas sim explicar como fazer chamadas para a Cloud Talent Solution. As aplicações em Python e Node.js são essencialmente semelhantes. Contacte-nos se tiver alguma dúvida.

Antes de começar

Tem:

Crie uma empresa com empregos e pesquise esses empregos

Este tutorial explica uma aplicação básica da Cloud Talent Solution e ensina-o a criar um único trabalho que associa a uma empresa. O tutorial seguinte explica os passos para pesquisar empregos na empresa com base nos atributos dos empregos e na consulta de pesquisa. A API search tenta devolver trabalhos mais relevantes para a consulta de um candidato a emprego com base nos campos disponíveis num trabalho (nome da empresa, cargo, descrição do trabalho, categorias de trabalho, localização do trabalho, etc.).

Crie um serviço com as suas credenciais

Crie o serviço com o ficheiro de credenciais JSON que transferiu em Antes de começar:

Java

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


private static final JsonFactory JSON_FACTORY = new GsonFactory();
private static final NetHttpTransport NET_HTTP_TRANSPORT = new NetHttpTransport();
private static final String DEFAULT_PROJECT_ID =
    "projects/" + System.getenv("GOOGLE_CLOUD_PROJECT");

private static CloudTalentSolution talentSolutionClient =
    createTalentSolutionClient(generateCredential());

private static CloudTalentSolution createTalentSolutionClient(GoogleCredentials credential) {
  String url = "https://jobs.googleapis.com";

  HttpRequestInitializer requestInitializer =
      request -> {
        new HttpCredentialsAdapter(credential).initialize(request);
        request.setConnectTimeout(60000); // 1 minute connect timeout
        request.setReadTimeout(60000); // 1 minute read timeout
      };

  return new CloudTalentSolution.Builder(NET_HTTP_TRANSPORT, JSON_FACTORY, requestInitializer)
      .setApplicationName("JobServiceClientSamples")
      .setRootUrl(url)
      .build();
}

private static GoogleCredentials generateCredential() {
  try {
    // Credentials could be downloaded after creating service account
    // set the `GOOGLE_APPLICATION_CREDENTIALS` environment variable, for example:
    // export GOOGLE_APPLICATION_CREDENTIALS=/path/to/your/key.json
    return GoogleCredentials.getApplicationDefault()
        .createScoped(Collections.singleton(CloudTalentSolutionScopes.JOBS));
  } catch (Exception e) {
    System.out.println("Error in generating credential");
    throw new RuntimeException(e);
  }
}

public static CloudTalentSolution getTalentSolutionClient() {
  return talentSolutionClient;
}

public static void main(String... args) throws Exception {
  try {
    ListCompaniesResponse listCompaniesResponse =
        talentSolutionClient.projects().companies().list(DEFAULT_PROJECT_ID).execute();
    System.out.println("Request Id is " + listCompaniesResponse.getMetadata().getRequestId());
    if (listCompaniesResponse.getCompanies() != null) {
      for (Company company : listCompaniesResponse.getCompanies()) {
        System.out.println(company.getName());
      }
    }
  } catch (IOException e) {
    System.out.println("Got exception while listing companies");
    throw e;
  }
}

Python

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

import os

from googleapiclient.discovery import build
from googleapiclient.errors import Error

client_service = build("jobs", "v3")


def run_sample():
    try:
        project_id = "projects/" + os.environ["GOOGLE_CLOUD_PROJECT"]
        response = (
            client_service.projects().companies().list(parent=project_id).execute()
        )
        print("Request Id: %s" % response.get("metadata").get("requestId"))
        print("Companies:")
        if response.get("companies") is not None:
            for company in response.get("companies"):
                print("%s" % company.get("name"))
        print("")

    except Error as e:
        print("Got exception while listing companies")
        raise e


if __name__ == "__main__":
    run_sample()

Go

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


// Command quickstart is an example of using the Google Cloud Talent Solution API.
package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"golang.org/x/oauth2/google"
	talent "google.golang.org/api/jobs/v3"
)

func main() {
	projectID := os.Getenv("GOOGLE_CLOUD_PROJECT")
	parent := fmt.Sprintf("projects/%s", projectID)

	// Authorize the client using Application Default Credentials.
	// See https://g.co/dv/identity/protocols/application-default-credentials
	ctx := context.Background()
	client, err := google.DefaultClient(ctx, talent.CloudPlatformScope)
	if err != nil {
		log.Fatal(err)
	}

	// Create the jobs service client.
	ctsService, err := talent.New(client)
	if err != nil {
		log.Fatal(err)
	}

	// Make the RPC call.
	response, err := ctsService.Projects.Companies.List(parent).Do()
	if err != nil {
		log.Fatalf("Failed to list Companies: %v", err)
	}

	// Print the request id.
	fmt.Printf("Request ID: %q\n", response.Metadata.RequestId)

	// Print the returned companies.
	for _, company := range response.Companies {
		fmt.Printf("Company: %q\n", company.Name)
	}
}

Este código configura o serviço de cliente com as informações de credenciais da sua aplicação. O pedido de OAuth 2.0 é enviado quando é feita uma chamada de API. Normalmente, o token de autorização gerado através do processo acima tem uma data de validade de 1 hora, após a qual recebe um erro se tentar usá-lo. A biblioteca GoogleCredential encarrega-se de "atualizar" automaticamente o token, o que significa simplesmente obter um novo token de acesso.

Crie uma empresa

Uma empresa é uma entidade associada a um conjunto de ofertas de emprego. Tem de criar a empresa antes de poder publicar empregos no Cloud Talent Solution para essa empresa. Pode enviar qualquer string de forma livre como externalId quando cria a empresa. Isto significa que pode usar a chave principal da sua base de dados existente (se tiver uma) quando criar e fizer referência a uma empresa.

Java

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


/** Create a company. */
public static Company createCompany(Company companyToBeCreated) throws IOException {
  try {
    CreateCompanyRequest createCompanyRequest =
        new CreateCompanyRequest().setCompany(companyToBeCreated);
    Company companyCreated =
        talentSolutionClient
            .projects()
            .companies()
            .create(DEFAULT_PROJECT_ID, createCompanyRequest)
            .execute();
    System.out.println("Company created: " + companyCreated);
    return companyCreated;
  } catch (IOException e) {
    System.out.println("Got exception while creating company");
    throw e;
  }
}

Python

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

def create_company(client_service, company_to_be_created):
    try:
        request = {"company": company_to_be_created}
        company_created = (
            client_service.projects()
            .companies()
            .create(parent=parent, body=request)
            .execute()
        )
        print("Company created: %s" % company_created)
        return company_created
    except Error as e:
        print("Got exception while creating company")
        raise e

Go

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


// createCompany creates a company as given.
func createCompany(w io.Writer, projectID string, companyToCreate *talent.Company) (*talent.Company, error) {
	ctx := context.Background()

	client, err := google.DefaultClient(ctx, talent.CloudPlatformScope)
	if err != nil {
		return nil, fmt.Errorf("google.DefaultClient: %w", err)
	}
	// Create the jobs service client.
	service, err := talent.New(client)
	if err != nil {
		return nil, fmt.Errorf("talent.New: %w", err)
	}

	parent := "projects/" + projectID
	req := &talent.CreateCompanyRequest{
		Company: companyToCreate,
	}
	company, err := service.Projects.Companies.Create(parent, req).Do()
	if err != nil {
		return nil, fmt.Errorf("failed to create company %q: %w", companyToCreate.DisplayName, err)
	}

	return company, nil
}

Get company

Pode ler o estado atual de uma empresa enviando um pedido GET, juntamente com o name da empresa atribuído pelo nosso back-end.

Java

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


/** Get a company. */
public static Company getCompany(String companyName) throws IOException {
  try {
    Company companyExisted =
        talentSolutionClient.projects().companies().get(companyName).execute();
    System.out.println("Company existed: " + companyExisted);
    return companyExisted;
  } catch (IOException e) {
    System.out.println("Got exception while getting company");
    throw e;
  }
}

Python

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

def get_company(client_service, company_name):
    try:
        company_existed = (
            client_service.projects().companies().get(name=company_name).execute()
        )
        print("Company existed: %s" % company_existed)
        return company_existed
    except Error as e:
        print("Got exception while getting company")
        raise e

Go

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


// getCompany gets an existing company by name.
func getCompany(w io.Writer, name string) (*talent.Company, error) {
	ctx := context.Background()

	client, err := google.DefaultClient(ctx, talent.CloudPlatformScope)
	if err != nil {
		return nil, fmt.Errorf("google.DefaultClient: %w", err)
	}
	// Create the jobs service client.
	service, err := talent.New(client)
	if err != nil {
		return nil, fmt.Errorf("talent.New: %w", err)
	}

	company, err := service.Projects.Companies.Get(name).Do()
	if err != nil {
		return nil, fmt.Errorf("failed to get company %q: %w", name, err)
	}

	fmt.Fprintf(w, "Company: %q\n", company.Name)

	return company, nil
}

Criar trabalho

Para publicar um novo emprego, tem de fornecer todos os campos obrigatórios sobre o novo emprego, juntamente com o companyName da empresa à qual quer associar este emprego, que especificou quando criou o recurso da empresa.

O objeto de dados com os dados da oferta de emprego preenchidos é enviado para o ponto final da Cloud Talent Solution através de um pedido POST. Tenha em atenção que o campo name não deve ser definido no pedido inicial, uma vez que é um campo "apenas de saída" da API createJob e faz parte da resposta da API quando o servidor cria uma nova entidade de tarefa. O ponto final da API para interagir com o recurso de tarefas é especificado no documento das bibliotecas cliente da Cloud Talent Solution.

A resposta ao pedido é um objeto da nova publicação de emprego. Deve incluir um ID de emprego name que represente exclusivamente a publicação. O ID da tarefa name é usado quando a publicação tem de ser atualizada ou eliminada. Como prática recomendada, armazene este name e mapeie-o para o seu próprio ID exclusivo para a tarefa.

O servidor devolve um erro se tentar inserir uma tarefa quando já existe outra tarefa no sistema com o mesmo companyName, requisitionId e languageCode para a mesma empresa.

O código seguinte cria uma tarefa apenas com os campos obrigatórios para a empresa especificada no campo companyName.

Java

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

/** Create a job. */
public static Job createJob(Job jobToBeCreated) throws IOException {
  try {
    CreateJobRequest createJobRequest = new CreateJobRequest().setJob(jobToBeCreated);

    Job jobCreated =
        talentSolutionClient
            .projects()
            .jobs()
            .create(DEFAULT_PROJECT_ID, createJobRequest)
            .execute();
    System.out.println("Job created: " + jobCreated);
    return jobCreated;
  } catch (IOException e) {
    System.out.println("Got exception while creating job");
    throw e;
  }
}

Python

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

def create_job(client_service, job_to_be_created):
    try:
        request = {"job": job_to_be_created}
        job_created = (
            client_service.projects()
            .jobs()
            .create(parent=parent, body=request)
            .execute()
        )
        print("Job created: %s" % job_created)
        return job_created
    except Error as e:
        print("Got exception while creating job")
        raise e

Go

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


// createJob create a job as given.
func createJob(w io.Writer, projectID string, jobToCreate *talent.Job) (*talent.Job, error) {
	ctx := context.Background()

	client, err := google.DefaultClient(ctx, talent.CloudPlatformScope)
	if err != nil {
		return nil, fmt.Errorf("google.DefaultClient: %w", err)
	}
	// Create the jobs service client.
	service, err := talent.New(client)
	if err != nil {
		return nil, fmt.Errorf("talent.New: %w", err)
	}

	parent := "projects/" + projectID
	req := &talent.CreateJobRequest{
		Job: jobToCreate,
	}
	job, err := service.Projects.Jobs.Create(parent, req).Do()
	if err != nil {
		return nil, fmt.Errorf("Failed to create job %q, Err: %w", jobToCreate.RequisitionId, err)
	}
	return job, err
}

A Cloud Talent Solution também lhe permite criar empregos específicos de uma localização. Consulte locations para mais informações.

A Cloud Talent Solution tem vários campos associados a um trabalho que estão incorporados no esquema da API. No entanto, ainda pode ter alguns campos que não fazem parte dos campos predefinidos. Embora seja recomendado que todos os clientes da Cloud Talent Solution usem sempre os campos predefinidos sempre que possível, a Cloud Talent Solution também fornece alguns customAttributes para uma tarefa. Estas podem ser filtráveis ou não filtráveis. Consulte o artigo customAttributes para mais informações.

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

Java

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


/** Generate a job with a custom attribute. */
@SuppressWarnings("checkstyle:AbbreviationAsWordInName")
public static Job generateJobWithACustomAttribute(String companyName) {
  // requisition id should be a unique Id in your system.
  String requisitionId = "jobWithACustomAttribute:" + String.valueOf(new Random().nextLong());
  ApplicationInfo applicationInfo =
      new ApplicationInfo().setUris(Arrays.asList("http://careers.google.com"));

  // Constructs custom attributes map
  Map<String, CustomAttribute> customAttributes = new HashMap<>();
  customAttributes.put(
      "someFieldName1",
      new CustomAttribute().setStringValues(Arrays.asList("value1")).setFilterable(Boolean.TRUE));
  customAttributes.put(
      "someFieldName2",
      new CustomAttribute().setLongValues(Arrays.asList(256L)).setFilterable(true));

  // Creates job with custom attributes
  Job job =
      new Job()
          .setCompanyName(companyName)
          .setRequisitionId(requisitionId)
          .setTitle("Software Engineer")
          .setApplicationInfo(applicationInfo)
          .setDescription("Design, develop, test, deploy, maintain and improve software.")
          .setCustomAttributes(customAttributes);
  System.out.println("Job generated: " + job);
  return job;
}

Python

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

def generate_job_with_custom_attributes(company_name):
    # Requisition id should be a unique Id in your system.
    requisition_id = "job_with_custom_attributes:" + "".join(
        random.choice(string.ascii_uppercase + string.digits) for _ in range(16)
    )

    job_title = "Software Engineer"
    application_urls = ["http://careers.google.com"]
    description = "Design, develop, test, deploy, maintain and improve " "software."

    custom_attributes = {
        "someFieldName1": {"string_values": ["value1"], "filterable": True},
        "someFieldName2": {"long_values": [256], "filterable": True},
    }

    job = {
        "company_name": company_name,
        "requisition_id": requisition_id,
        "title": job_title,
        "application_info": {"uris": application_urls},
        "description": description,
        "custom_attributes": custom_attributes,
    }
    print("Job generated: %s" % job)
    return job

Go

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


// constructJobWithCustomAttributes constructs a job with custom attributes.
func constructJobWithCustomAttributes(companyName string, jobTitle string) *talent.Job {
	// requisitionID shoud be the unique ID in your system
	requisitionID := fmt.Sprintf("job-with-custom-attribute-%d", time.Now().UnixNano())

	job := &talent.Job{
		RequisitionId: requisitionID,
		Title:         jobTitle,
		CompanyName:   companyName,
		ApplicationInfo: &talent.ApplicationInfo{
			Uris: []string{"https://googlesample.com/career"},
		},
		Description: "Design, devolop, test, deploy, maintain and improve software.",
		CustomAttributes: map[string]talent.CustomAttribute{
			"someFieldString": {
				Filterable:   true,
				StringValues: []string{"someStrVal"},
			},
			"someFieldLong": {
				Filterable: true,
				LongValues: []int64{900},
			},
		},
	}
	return job
}

Obter tarefa

Pode confirmar que a tarefa foi criada através da operação GET para obter os detalhes da tarefa. Tenha em atenção que a tarefa pode demorar alguns minutos a ficar disponível, com base no volume atual de tarefas que estão a ser criadas na Cloud Talent Solution.

Pode obter os detalhes de uma tarefa inserida anteriormente enviando um pedido GET para a Cloud Talent Solution. O URI deve incluir a tarefa name inserida anteriormente devolvida pelo pedido de criação original como um parâmetro de URL.

O exemplo seguinte usa uma operação GET para obter os detalhes de uma tarefa com um name específico:

Java

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

/** Get a job. */
public static Job getJob(String jobName) throws IOException {
  try {
    Job jobExisted = talentSolutionClient.projects().jobs().get(jobName).execute();
    System.out.println("Job existed: " + jobExisted);
    return jobExisted;
  } catch (IOException e) {
    System.out.println("Got exception while getting job");
    throw e;
  }
}

Python

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

def get_job(client_service, job_name):
    try:
        job_existed = client_service.projects().jobs().get(name=job_name).execute()
        print("Job existed: %s" % job_existed)
        return job_existed
    except Error as e:
        print("Got exception while getting job")
        raise e

Go

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


// getJob gets a job by name.
func getJob(w io.Writer, jobName string) (*talent.Job, error) {
	ctx := context.Background()

	client, err := google.DefaultClient(ctx, talent.CloudPlatformScope)
	if err != nil {
		return nil, fmt.Errorf("google.DefaultClient: %w", err)
	}
	// Create the jobs service client.
	service, err := talent.New(client)
	if err != nil {
		return nil, fmt.Errorf("talent.New: %w", err)
	}

	job, err := service.Projects.Jobs.Get(jobName).Do()
	if err != nil {
		return nil, fmt.Errorf("Failed to get job %s: %w", jobName, err)
	}

	fmt.Fprintf(w, "Job: %q", job.Name)

	return job, err
}

Pesquise empregos

Criou a sua primeira empresa e emprego com a Cloud Talent Solution! Já pode pesquisar para realizar uma pesquisa nestes trabalhos.

O que se segue?