Neste codelab, você aprenderá a melhorar a pesquisa de vagas e a aquisição de talentos para sua organização usando a API Cloud Talent Solution (CTS). Com o CTS, você pode adicionar o poder do machine learning à sua experiência de pesquisa de empregos.
O que você aprenderá
- Ativar o CTS em seu projeto do Google Cloud
- Criar entidades e vagas de emprego nessas empresas
O que é necessário
- Um projeto do Google Cloud com o faturamento já configurado. Se você ainda não tem um, crie um.
- Cerca de uma hora
Como você usará este tutorial?
Como você classificaria sua experiência anterior com o Google Cloud Platform?
Este tutorial é para ser executado no Google Cloud Platform. Não é necessário fazer downloads para a estação de trabalho.
- Se você ainda não tem uma Conta do Google, crie uma e faça login.
- Crie um novo projeto do GCP e ative o faturamento. A conclusão do codelab está bem abaixo do número de consultas sem custo financeiro recebidas por mês.
Ativar a API Cloud Talent Solutions
Abra seu aplicativo no Console do Cloud e clique no menu de hambúrguer no canto superior esquerdo. Navegue pelos menus até Talent Solution -> Visão geral.
Como este é um projeto novo, você será redirecionado para uma nova tela que solicitará a ativação da API. Clique em "Ativar" e aguarde alguns minutos para a API ser ativada neste projeto.
Ativar a geração de registros de dados
Volte para a página de visão geral anterior. Uma nova caixa de diálogo será exibida, pedindo que você ative a geração de registros de dados. Caso não a inicie, volte à página da caixa de diálogo. Isso é apenas para confirmar que você sabe que a API Job Search usa um modelo de machine learning que precisa de dados. Como parte da integração, você poderá enviar eventos de usuários que estão pesquisando para treinar melhor esses modelos. Quando isso é implementado por meio do código, você pode especificar quais informações são enviadas.
Veremos mais detalhes sobre esses eventos e como enviá-los posteriormente, mas os modelos pré-treinados funcionarão bem. Ative a geração de registros de dados e clique em "conexões de conta de serviço" na navegação à esquerda desta caixa de diálogo.
Configure uma conta de serviço.
Ao fazer solicitações de API, você precisará fazer isso em nome de uma conta autenticada. As práticas recomendadas do Google Cloud Platform recomendam configurar uma conta de serviço para isso. Pense nas contas de serviço como uma maneira fácil de configurar usuários autenticados que têm permissões limitadas. Isso ajudará você a criar um sistema independente e seguro.
Por exemplo, precisaremos de uma conta de serviço para usar a API Job Search. Vamos criar uma e conceder permissões de leitura/gravação usando o "Job Editor" na seção "Cloud Talent Solution" da navegação à esquerda. Também é possível configurar uma conta de serviço apenas com o "Job Viewer" para que ela tenha acesso somente leitura.
A próxima etapa perguntará se você quer conceder acesso a essa conta de serviço aos usuários. Você pode pular esta etapa, mas clique em "Criar chave", próximo à parte inferior. Selecione "JSON" para o tipo de chave e depois "Criar". Será feito o download automático de um novo arquivo de credencial JSON. Armazene esse arquivo no seu servidor. O código que você escrever em uma seção posterior o usará para autenticar.
Definir as variáveis de ambiente
Por conveniência, usaremos o shell do Google Cloud. Se você quiser fazer isso no seu próprio ambiente de desenvolvimento, ótimo! Instale o SDK do Google Cloud e as bibliotecas de cliente na linguagem que preferir. Este codelab usará o Python. O Cloud Shell já terá as bibliotecas de cliente da nuvem instaladas. Útil, certo?
Para executar o código usando as bibliotecas, verifique se duas variáveis de ambiente estão definidas: uma para especificar o ID de portabilidade e a outra para o arquivo da chave da sua conta de serviço. Vamos defini-las.
No seu projeto, clique no ícone "quot;>_"" no canto superior direito do console da Web para abrir um Cloud Shell. Adicione as variáveis de ambiente a seguir para especificar o ID do projeto e definir um caminho para o arquivo de chave JSON:
export GOOGLE_CLOUD_PROJECT="your-project-id" export GOOGLE_APPLICATION_CREDENTIALS="/path/to/key.json"
Para verificar se as variáveis foram definidas, use "echo".
echo $GOOGLE_CLOUD_PROJECT echo $GOOGLE_APPLICATION_CREDENTIALS
Abra o editor de código no Cloud Shell
No Console do Google Cloud, abra o Cloud Shell usando o ícone do Cloud Shell no canto superior direito.
Há vários ícones no canto superior direito do Cloud Shell. Clique em File -> Launch Code Editor, conforme mostrado aqui:
Criar uma empresa
Use File -> New File para criar um novo arquivo de origem e preencha-o com o conteúdo abaixo. Dê o nome create_company.py a ela.
create_company.py
import os
from googleapiclient.discovery import build
from googleapiclient.errors import Error
# Build the service object, passing in the api name and api version
client_service = build('jobs', 'v3')
project_id = 'projects/' + os.environ['GOOGLE_CLOUD_PROJECT']
# Specifying details for the company that's going to be created.
# These are the only two required fields.
# Optional fields are documented at
# http://googleapis.github.io/google-api-python-client/docs/dyn/jobs_v3.projects.companies.html#create
new_company = {
'display_name': "FooCorp",
'external_id': "foo_llc"
}
request = {'company': new_company}
try:
# This is the API call that actually creates the new company.
result = client_service.projects().companies().create(
parent=project_id, body=request).execute()
# You can easily just print the result as a string if you want
print('Company created: %s' % result)
# Or you can individual fields. The fields returned depend on what's specified
# in the "new_company" object. To see possible fields of the
# response, see the "create" documentation at:
# http://googleapis.github.io/google-api-python-client/docs/dyn/jobs_v3.projects.companies.html#create
print('%s: %s, %s' % (result.get('externalId'),
result.get('displayName'),
result.get('name')))
except Error as e:
print('Got exception while creating company')
raise eO que o código está fazendo? Vamos explorar. Há duas chamadas relevantes da biblioteca de cliente aqui:
client_service = build('jobs', 'v3')cria um objeto de serviço usando a biblioteca de cliente Python da API do Google.client_service.projects().companies().create(parent=project_id, body=request).execute()executa a chamada de API para criar a empresa. A resposta a essa chamada é um objeto que contém informações da empresa. O conteúdo do objeto de solicitação e do objeto de resposta é apresentado na documentação do método de criação .
Execute o arquivo no prompt de comando, que fica abaixo da janela do editor de código. Você verá algo parecido com o resultado abaixo.
> python create_company.py
Company created: {u'externalId': u'foo_llc', u'displayName': u'FooCorp', u'name': u'projects/[PROJECT_ID]/companies/1cd6ada9-e678-49cf-80da-aaaf8876feda'}
Foo_llc, FooCorp, projects/[PROJECT_ID]/companies/1cd6ada9-e678-49cf-80da-aaaf8876feda
O name é o identificador exclusivo gerado pela API Job Search, enquanto o external_id é o identificador que você fornece do seu próprio sistema de vagas. Toda vez que você fizer referência a um objeto na API, precisará usar name.
Atualizar empresa
Se você já tiver uma entidade corporativa no sistema e quiser adicionar ou alterar alguns campos, o processo será dividido nas seguintes etapas:
- Crie um objeto com os valores de campo atuais da empresa.
- Atualizar o objeto com os campos novos ou atualizados usando o campo "name" da empresa como chave para que a API saiba qual empresa deve ser atualizada.
- Envie o novo objeto usando o método "quoquo;patch"".
Esse processo exige que você tenha todos os valores existentes, porque eles substituem os valores da empresa de uma só vez, independentemente de quais você atualizou. Isso significa que precisamos recuperar as informações da empresa.
Crie um novo arquivo update_company.py no seu espaço de trabalho. Para começar, desative o método get_company mostrado abaixo.
update_company.py (link em inglês)
import os
from googleapiclient.discovery import build
from googleapiclient.errors import Error
# Build the service object, passing in the api name and api version
client_service = build('jobs', 'v3')
project_id = 'projects/' + os.environ['GOOGLE_CLOUD_PROJECT']
company_name = 'Your company name goes here'
def get_company(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
newCompany = get_company()Um ponto a ser observado é que a chamada de API é muito semelhante à criação de uma empresa. A biblioteca de cliente é gerada para corresponder a uma interface REST. Portanto, as operações CRUD que você executa nas empresas terão o formato client_service.projects().companies().theMethod(argName=argValue).execute()..
Agora que temos o conjunto de valores existentes, crie um objeto "patch" com os nomes dos campos que você quer atualizar e os novos valores. Use-o para atualizar o objeto da empresa com novos valores. O que é divertido fazer em Python: a biblioteca de cliente representa a empresa como um objeto de dicionário, o que significa que o método já está integrado. Sem a necessidade de um loop especial. Crie um objeto de dicionário logo abaixo do código que você já escreveu.
update_company.py (link em inglês)
...
patch = {
'displayName': "The New Bar",
'websiteUri': "http://www.example.com"
}
newCompany.update(patch)
print("Debug: New company info %s " % newCompany)
... Agora só falta criar um objeto de solicitação (consulte a documentação de patch para saber o que pode ser encontrado lá) e executar a chamada da API.
...
request = {'company': newCompany}
company_updated = client_service.projects().companies().patch(
name=company_name, body=request).execute()
print('Company updated: %s' % company_updated)
... Como alternativa, se você quiser fornecer apenas os campos que realmente quer alterar, inclua-os com uma máscara de atualização. Isso é útil quando você não tem uma configuração de objeto da empresa atualizada ou tem apenas um campo que quer atualizar e não quer enviar objetos desnecessariamente grandes. Mas como você usa uma máscara de atualização para perguntar? Onde está o código que demonstra essa maneira interessante e inovadora de atualizar informações da empresa?
Você lê nossas mentes, leitor! O snippet abaixo executa uma atualização de informações da empresa usando uma máscara de atualização em vez de uma substituição de entrada completa.
update_company.py (link em inglês)
...
# New set of fields, not the complete company object
companyFields = {'displayName': 'The New Bar',
'websiteUri': 'http://shouldNotUpdate.com',
'externalId': 'bar_llc'}
# Note that the mask only contains the display name, not the URL.
# This is entirely for demonstration purposes. This mask will tell the API
# to update the display name, but NOT the website uri.
mask = 'displayName'
request = {'company': companyFields,
'update_mask': mask}
company_updated = client_service.projects().companies().patch(
name=company_name,
body=request).execute()
print('Company updated!: %s' % company_updated)
... A chamada de API é a mesma. A diferença é que o objeto de solicitação agora tem dois campos (company e update_mask), em vez de apenas um (company). A máscara de atualização é uma lista de campos delimitada por vírgulas. Se quiséssemos incluir o campo "websiteUri" na máscara, o valor da máscara seria assim:
mask = 'displayName,websiteUri'Seja qual for a rota escolhida, execute-a no Cloud Shell e, se você deixou essas instruções, você verá a saída indicando os valores antigos e novos da sua empresa.
$ python update_company.py
Company existed: {u'externalId': u'bar_llc', u'displayName': u'The New Bar', u'name': u'projects/[PROJECT_ID]/companies/083495ad-acba-477f-a084-8be84f31692e', u'websiteUri': u'http://www.example.com'}
Company {u'externalId': u'bar_llc', u'displayName': u'The New Bar', u'name': u'projects/[PROJECT_ID]/companies/083495ad-acba-477f-a084-8be84f31692e', u'websiteUri': u'http://www.example.com'}
New company info {u'externalId': u'bar_llc', u'name': u'projects/[PROJECT_ID]/companies/083495ad-acba-477f-a084-8be84f31692e', u'displayName': 'The New Bar', u'websiteUri': 'http://www.example.com'}
Company updated: {u'externalId': u'bar_llc', u'displayName': u'The New Bar', u'name': u'projects/[PROJECT_ID]/companies/083495ad-acba-477f-a084-8be84f31692e', u'websiteUri': u'http://www.example.com'}
$
Não haveria muito motivo para criar uma solução de busca de emprego sem procurar empregos. Na última seção, falamos sobre a criação de empresas. Agora vamos falar sobre como criar vagas e práticas recomendadas para trabalhar com elas.
As vagas serão anexadas às empresas. Se você ainda não criou empresas com a API (ou se executou a chamada "delete" no final da seção e removeu sua única empresa), volte e crie uma empresa novamente. Em seguida, você estará pronto para criar jobs.
Criar um job
Vamos começar criando um job.
Para criar um job, você precisará dos seguintes dados:
- O nome da empresa. Não é a string "minha sofisticada empresa LLC&, mas a string "projects/[PROJECT_ID]/company/COMPANY_ID" muito mais longa.
- Um código do requisito da vaga. É semelhante ao external_id de uma empresa: ele representa seu identificador exclusivo da vaga para facilitar a manutenção da API Cloud Talent Solution em sincronia com a solução de vaga atual, por exemplo, senior_llama_wrangler.
- O título do cargo, que é o nome de exibição do job, por exemplo, "Ilamor sênior para Wrangler."
- A description do job. A descrição pode conter HTML incorporado para que você possa formatá-la corretamente. O conteúdo é autoexplicativo. "<p>Lidera a equipe de wranglers da lhama.</p><p> Precisa ter capacidade de liderança e experiência com llamas."</p>
- applicationInfo: mais informações sobre como se inscrever. Pode conter mais de 1 URI, 1+ endereços de e-mail ou uma string formatada em HTML com mais instruções. Você pode até incluir todos esses três itens. No entanto, é necessário incluir pelo menos um deles.
Portanto, se tivéssemos que criar um job para a corporação FooCorp criada anteriormente, estes seriam os campos:
name |
|
requiretion_id [código_de_solicitação] | senior__ama_wrangler |
title | Lranga sênior wrangler |
description | Para um cargo em tempo integral, é necessário ter experiência no Llama Wrangler. A capacidade de liderança é necessária, já que você cuidará de uma equipe de cuidadores de lhama que os treinará para escaladores completos.<p/>É necessário trabalhar bem com os animais e, de vez em quando, estar preparado para correr muito, muito rápido. Muito rápido. Estas são algumas lhamas rápidas. |
application_info | URIs: http://www.example.com/llama_wrangler_application/ E-mails: llama-apply@example.com |
Se você não tiver mais o nome da empresa, use o código "get_company" usado na etapa 3 para recuperá-lo.
O código para a criação de uma vaga de emprego será muito parecido com o da criação de uma empresa. As primeiras linhas devem ser familiares para você (importar blah blah blah, instanciar objeto de serviço de cliente). Depois crie um objeto dict (somente um conjunto aninhado de pares de chave-valor) representando sua solicitação e envie-o com a chamada de API "create"
Cole o snippet a seguir em um arquivo chamado create_job.py. Na verdade, você pode chamá-lo como quiser, mas este tutorial vai pressupor esse nome de arquivo.
create_job.py (em inglês).
import os
from googleapiclient.discovery import build
from googleapiclient.errors import Error
client_service = build('jobs', 'v3')
project_id = 'projects/' + os.environ['GOOGLE_CLOUD_PROJECT']
new_job = {
'company_name': 'projects/[PROJECT_ID]/companies/083495ad-acba-477f-a084-8be84f31692e',
'title': 'Senior Llama Wrangler',
'description':
"""Experienced Llama Wrangler required for full-time position.
Leadership ability required, as you will be taking a team of llama
caregivers and training them up to full-scale wranglers.
<p/>Must work well with animals and occasionally be prepared to run
really, like really really fast. Like REALLY fast.
These are quick llamas.""",
'requisition_id': 'senior_llama_wrangler',
'application_info': {
'uris': ['http://www.example.com/llama-wrangler-application'],
'emails': ['llama-apply@example.com']
}
}
try:
# Nest that Job object in a "job" object. Now it's an API request!
request = {'job': new_job}
# The actual API call happens here.
result = client_service.projects().jobs().create(
parent=project_id, body=request).execute()
print('Job created: %s' % result)
except Error as e:
print('Got exception while creating job')
raise eExecute isso no Cloud Shell. Você verá um grande blob do JSON com o job que acabou de criar.
$ python create_job.py
Job created: {u'languageCode': u'en', u'description': u'Experienced Llama Wrangler required for full-time position. Leadership ability required, as you will be taking a team of llama caregivers and training them up to full-scale wranglers.Must work well with animals and occasionally be prepared to run really, like really really fast. Like REALLY fast. These are some quick llamas.', u'applicationInfo': {u'emails': [u'llama-apply@example.com'], u'uris': [u'http://www.example.com/llama-wrangler-application']}, u'companyName': u'projects/[PROJECT_ID]/companies/083495ad-acba-477f-a084-8be84f31692e', u'requisitionId': u'senior_llama_wrangler', u'title': u'Senior Llama Wrangler', u'postingExpireTime': u'2019-09-11T16:04:48.546Z', u'visibility': u'ACCOUNT_ONLY', u'postingCreateTime': u'2019-08-12T16:04:48.546Z', u'companyDisplayName': u'Masked Panda Inc', u'postingUpdateTime': u'2019-08-12T16:04:48.611Z', u'postingPublishTime': u'2019-08-12T16:04:48.611Z', u'name': u'projects/[PROJECT_ID]/jobs/12345}
Se você receber algo parecido com o exemplo acima, isso significa que você criou um job.
Os jobs precisam ser exclusivos
Como experimento, execute o último script novamente e vamos ver o que acontece.
$ python create_job.py
Got exception while creating job
Traceback (most recent call last):
File "create_job.py", line 37, in <module>
raise e
googleapiclient.errors.HttpError: <HttpError 409 when requesting https://jobs.googleapis.com/v3/projects/[PROJECT_ID]/jobs?alt=json returned "Job projects/[PROJECT_ID]/jobs/103672929591403206 already exists. Request ID for tracking: ec94f4cb-70f1-48cf-bae6-b4dad056ac3f:APAb7ITRlgTTpVMONSSBCG4LnFzqR765Eg==. Related Job requisition ID: senior_llama_wrangler.">
O que aconteceu aqui? Você tentou inserir uma vaga de emprego duplicada. As vagas não expiradas precisam ser exclusivas no sistema.
A exclusividade é determinada pelos seguintes campos:
- Nome da empresa: não é obrigatório quando você cria uma vaga.
- Código da requisição - Obrigatório ao criar job e não atualizável
- Código do idioma: opcional, o padrão é en_us, atualizável.
Se um job que você tentar criar ou atualizar tiver esses três campos em comum com um job existente que não tenha expirado, ele será considerado duplicado e essa criação/atualização falha com a mensagem de erro que você vê acima.
Oba!
Parabéns! Agora você tem uma empresa E uma lista de vagas de emprego para ela no seu sistema. E tudo isso é feito em menos de uma hora. Você tem uma ideia de quanto tempo levou os melhores sites de vagas de emprego na Internet para chegar até esse ponto, leitor? Muito mais de uma hora. Como muito mais. Semanas. Meses. Reuniões de embarque. Provavelmente havia planilhas e declarações de missão envolvidas. Tenho certeza de que isso acabou mesmo. Sabe o que levou você? Um pouco menos de uma hora. Continue assim!
No entanto, tem mais! Vamos continuar.
Como atualizar um job
Assim como acontece com as empresas, podemos receber uma vaga para ver os detalhes dela e corrigir uma para atualizá-la.
Veja como acessar os detalhes do emprego. Se o snippet abaixo parece familiar, significamos que pegamos o método "get_company" da seção anterior e substituímos "company" por "job" e adicionamos na variável job_name. Vamos ver como conseguir as informações do job primeiro.
update_job.py (link em inglês)
import os
from googleapiclient.discovery import build
from googleapiclient.errors import Error
client_service = build('jobs', 'v3')
project_id = 'projects/' + os.environ['GOOGLE_CLOUD_PROJECT']
# The interesting bit
def get_job():
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
job_name = "projects/[PROJECT_ID]/jobs/12345"
job_info = get_job(job_name)
Para atualizar a vaga de emprego, você tem as mesmas opções de antes de atualizar a empresa: envie um objeto completo com valores atualizados para substituir o antigo ou envie um patch menor com uma máscara de campo separada por vírgulas.
update_job.py: é atualizado com substituição de objeto completo.
# First the full-replacement method. Update the complete job object with new field values.
job_patch = {
'title': "Rogue Llama Acquisition Engineer"
}
job_info.update(job_patch)
request = {"job": job_info}
job_updated = client_service.projects().jobs().patch(
name=job_name, body=request).execute()
print ("Updated job info : %s" % job_updated)update_job.py (apenas os novos valores de campo e uma máscara de atualização)
# Alternatively, if you know which fields have been updated, you can submit a patch with just the changes
# and an update mask. This time let's just re-use the same job patch, and create an update mask.
job_patch = {
'title': "Rogue Llama Acquisition Engineer"
}
update_mask = "title"
request = {"job": job_patch,
"updateMask": update_mask
}
job_updated = client_service.projects().jobs().patch(
name=job_name, body=request).execute()
print ("Updated job info : %s" % job_updated) Os dois snippets acima fazem exatamente o mesmo: eles atualizam um anúncio de emprego específico com o cargo "Rogue Llama Acquisition Engineer". A linha que faz a chamada da API é a mesma: a única diferença está no objeto da solicitação. Um deles tem um objeto de job completo que substituirá o objeto pelo nome do job. O outro é simplesmente um conjunto de campos a serem atualizados.
A saída que você escolher será a mesma. Vale a pena tentar!
$ python update_job
Updated job info : {u'languageCode': u'en', u'description': u'Experienced Llama Wrangler required for full-time position. Leadership ability required, as you will be taking a team of llama caregivers and training them up to full-scale wranglers.Must work well with animals and occasionally be prepared to run really, like really really fast. Like REALLY fast. These are some quick llamas.', u'applicationInfo': {u'emails': [u'llama-apply@example.com'], u'uris': [u'http://www.example.com/llama-wrangler-application']}, u'companyName': u'projects/[PROJECT_ID]/companies/083495ad-acba-477f-a084-8be84f31692e', u'derivedInfo': {u'jobCategories': [u'SCIENCE_AND_ENGINEERING']}, u'requisitionId': u'senior_llama_wrangler', u'title': u'Rogue Llama Acquisition Engineer', u'postingExpireTime': u'2019-09-11T16:04:48.546Z', u'visibility': u'ACCOUNT_ONLY', u'postingCreateTime': u'2019-08-12T16:04:48.546Z', u'companyDisplayName': u'Masked Panda Inc', u'postingUpdateTime': u'2019-08-12T19:28:41.850Z', u'postingPublishTime': u'2019-08-12T16:04:48.611Z', u'name': u'projects/[PROJECT_ID]/jobs/12345}
Que bom! Você concluiu a etapa 4.
Agora, vamos olhar para você. Nocauteando tudo como um monstro de produtividade. Até agora, você pode criar empresas, gerar empregos e atualizar ambos ao máximo. Mas talvez você tenha percebido algo curiosamente ausente dessas lições. A última operação que coloca o D em C.R.U.D. E se quisermos EXCLUÍ-los? Não se preocupe, leitor! A próxima seção aborda isso em detalhes.
Vamos começar com as empresas, porque isso fará sentido em até cinco minutos.
Excluir uma empresa
É muito fácil excluir uma empresa. Usando as mesmas instruções de importação que você fez ao criar ou atualizar uma empresa, basta chamar o método delete, transmitindo apenas o nome da empresa (sem necessidade de corpo de solicitação).
# Yup, that's the whole thing.
company_to_delete = "Insert company name here"
result = client_service.projects().companies().delete(
name=company_to_delete).execute()Para ajudar na limpeza enquanto você explora essa API, veja um script Python simples que usa o nome de uma empresa como um parâmetro de linha de comando e, como você sabe, exclui a empresa.
delete_company.py (em inglês)
from googleapiclient.discovery import build
from googleapiclient.errors import Error
client_service = build('jobs', 'v3')
# Name of the company to delete
company_to_delete = 'projects/[PROJECT_ID]/companies/123-abc-123'
try:
# Yup, that's the whole thing.
result_company = client_service.projects().companies().delete(
name=company_to_delete).execute()
print('Result of deleting company: %s' % result_company)
except Error as e:
print('Got exception while deleting company')
raise eChame-o e transmita o nome da empresa como o único argumento de linha de comando.
$ python delete_company.py projects/[PROJECT_ID]/companies/083495ad-acba-477f-a084-8be84f31692e
Got exception while deleting company
Traceback (most recent call last):
File "delete_company.py", line 29, in <module>
raise e
googleapiclient.errors.HttpError: <HttpError 400 when requesting https://jobs.googleapis.com/v3/projects/[PROJECT_ID]/companies/083495ad-acba-477f-a084-8be84f31692e?alt=json returned "Company with name projects/[PROJECT_ID]/companies/083495ad-acba-477f-a084-8be84f31692e still has open jobs. Request ID for tracking: 6b9fe1a0-50ae-48b0-b33d-1622d547c363:APAb7ISnO4taWI4poffoX/EqzRCPSwpEbQ==">
Pronto! Você precisa esperar. O que é isso? Ocorreu um erro? Ainda tem vagas em aberto?
Sim. Agora você já conhece a primeira regra de exclusão de empresas: ela falhará enquanto essa empresa ainda tiver empregos abertos. Como lidar com isso? Precisamos excluir todas as vagas abertas nessa empresa.
O que você pensa é: eu excluirei a vaga que acabei de criar e depois excluirei a empresa que ela usou. Faz sentido, leitor! Vamos fazer isso.
delete_company.py (em inglês)
from googleapiclient.discovery import build
from googleapiclient.errors import Error
client_service = build('jobs', 'v3')
# Replace with your actual company and job names.
company_to_delete = 'projects/[PROJECT_ID]/companies/123-abc-123'
job_to_delete = 'projects/[PROJECT_ID]/jobs/12345'
try:
result_job = client_service.projects().jobs().delete(
name=job_to_delete).execute()
result_company = client_service.projects().companies().delete(
name=company_to_delete).execute()
print('Result of deleting job: %s' % result_job)
print('Result of deleting company: %s' % result_company)
except Error as e:
print('Got exception while deleting company')
raise eAgora, execute-o novamente. Os valores retornados dessas chamadas de API devem estar vazios nas entradas "company" e "job", ou seja, devem estar vazias.
python delete_company.py
Result of deleting job: {}
Result of deleting company: {}
Ah, Muito bem!
Última pergunta. A solução acima funcionou muito bem, porque você, o leitor,
- Já tinha o nome da vaga de emprego para essa empresa.
- Não criou muitas funções para excluir manualmente as vagas de emprego dessa empresa.
Vamos fingir que não é
Há uma chamada de API, jobs.list(), que retornará as vagas correspondentes ao código do projeto especificado e à empresa controladora. É assim que você chama o método:
jobs_response = client_service.projects().jobs().list(
parent=project_id,
filter='companyName="' + company_name + '"').execute()
if jobs_response.get('jobs') is not None:
for job in jobs_response.get('jobs'):
print('- %s: %s' % (
job.get('title'),
job.get('name')))
Agora é possível criar e gerenciar vagas de emprego e empresas usando a API Job Search do Google Cloud Talent Solutions.
O que vimos
- Como criar e gerenciar empresas
- Criar e gerenciar anúncios de emprego para essas empresas
- Como configurar contas de serviço para interagir com a API em seu nome
Saiba mais
- Assista à série Canal do desenvolvedor sobre as soluções da Cloud Talent
- Veja o projeto do GitHub.
- Consulte a documentação da API.
- Poste perguntas e encontre respostas marcadas no Stack Overflow com a mensagem google-cloud-talent-solution