API de Job Search con Google Cloud

En este codelab, aprenderás a mejorar la búsqueda de empleo y la adquisición de talentos para tu organización con la API de Cloud Talent Solution (CTS). Con CTS, puedes agregar la potencia del aprendizaje automático a tu experiencia de búsqueda de empleo.

Qué aprenderás

  • Habilita CTS en tu proyecto de Google Cloud
  • Crear &entidades de la empresa y empresas en esas empresas

Requisitos

  • Ya existe un proyecto de Google Cloud con facturación (si no tienes uno, crea uno).
  • Aproximadamente una hora

¿Cómo usarás este instructivo?

Solo leerlo Leer y completar los ejercicios

¿Cómo calificarías tu experiencia anterior con Google Cloud Platform?

Principiante Intermedio Experto

Este instructivo se diseñó para ejecutarse completamente en Google Cloud Platform. No es necesario realizar descargas en tu estación de trabajo.

Habilitar la API de Cloud Talent Solutions

Abra su aplicación en Cloud Console y haga clic en el menú de opciones en la esquina superior izquierda. Explore los menús para Talent Solution -> Overview.

Como este es un proyecto nuevo, se te redireccionará a una pantalla nueva que te pedirá que habilites la API. Haz clic en Habilitar y espera unos minutos para que la API se active en este proyecto.

Habilitar el registro de datos

Ahora regrese a la página Resumen. Aparecerá un nuevo diálogo en el que se te solicitará que habilites el registro de datos (si es así, regresa a la página de diálogo anterior). Esto solo permite asegurarse de que la API de Job Search funciona con un modelo de aprendizaje automático que necesita datos. Como parte de la integración, realmente podrás enviar eventos de usuarios que busquen entrenar aún más esos modelos. Cuando se implementa mediante código, puede especificar qué información se envía.

Profundizaremos en cuáles son esos eventos y cómo enviarlos más adelante, pero los modelos previamente entrenados funcionarán bien. Habilita el registro de datos y, luego, haz clic en Conexiones de cuenta de servicio en el panel de navegación izquierdo de este diálogo.

Configure una cuenta de servicio

Cuando realices solicitudes a la API, deberás hacerlas en nombre de una cuenta autenticada real. En las prácticas recomendadas de Google Cloud Platform, se recomienda configurar una cuenta de servicio para esto. Piense en las cuentas de servicio como una manera fácil de configurar a los usuarios autenticados que tienen permisos limitados. Esto te ayudará a crear un sistema independiente y seguro.

Por ejemplo, necesitaremos una cuenta de servicio para usar la API de Job Search. Creemos una y le otorguemos permisos de lectura y escritura con el editor de trabajos en la sección Cloud Talent Solution del panel de navegación de la izquierda. También es posible configurar una cuenta de servicio con solo un "Visualizador de trabajos", de modo que solo tenga acceso de solo lectura.

En el siguiente paso, se te preguntará si deseas permitir que los usuarios accedan a esta cuenta de servicio. Puedes omitir este paso, pero asegúrate de hacer clic en "Crear clave&quot, cerca de la parte inferior. Selecciona &JSON; para el tipo de clave y, luego, Crear. Se descargará un archivo de credencial JSON nuevo de manera automática. Almacena este archivo en tu servidor, ya que el código que escribas en una sección posterior lo usará para autenticarse.

Configure las variables de entorno

Para mayor comodidad, usaremos la shell de Google Cloud. Si deseas hacerlo desde tu propio entorno de desarrollo, ¡fantástico! Asegúrate de instalar el SDK de Google Cloud y las bibliotecas cliente en el lenguaje que prefieras (en este codelab, se usará Python). Cloud Shell ya tendrá instaladas las bibliotecas cliente de Cloud. Práctico, ¿no?

Para ejecutar código con las bibliotecas, debes asegurarte de que dos variables de entorno estén configuradas: una para especificar tu ID de acceso y la otra para especificar tu archivo de claves de cuenta de servicio. Establezcamos eso.

En su proyecto, haga clic en el ícono de la parte superior derecha de su consola web para abrir Cloud Shell. Agrega las siguientes variables de entorno para especificar el ID de tu proyecto y establecer una ruta de acceso al archivo de claves JSON:

export GOOGLE_CLOUD_PROJECT="your-project-id"
export GOOGLE_APPLICATION_CREDENTIALS="/path/to/key.json"

Para verificar que se hayan establecido las variables, use eco.

echo $GOOGLE_CLOUD_PROJECT
echo $GOOGLE_APPLICATION_CREDENTIALS

Abra el editor de código en Cloud Shell

En Google Cloud Console, abra Cloud Shell con el ícono de Cloud Shell que se encuentra en la parte superior derecha.

En la parte superior derecha de Cloud Shell, verá una serie de íconos. Haz clic en File -> Launch Code Editor, como se muestra a continuación:

Cómo crear una empresa

Usa File -> New File para crear un archivo de origen nuevo y completarlo con el contenido que se indica a continuación. Asígnale el nombre create_company.py.

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 e

¿Qué hace este código? Exploremos. Aquí hay dos llamadas de biblioteca cliente relevantes:

  • client_service = build('jobs', 'v3') crea un objeto de servicio mediante la biblioteca cliente de Python de la API de Google.
  • client_service.projects().companies().create(parent=project_id, body=request).execute() ejecuta la llamada a la API para crear la empresa. La respuesta a esta llamada es un objeto que contiene información de la empresa. El contenido del objeto de solicitud y del objeto de respuesta se presenta en la documentación del método create.

Ejecuta el archivo desde el símbolo del sistema (que aparece justo debajo de la ventana del editor de código) y verás un resultado similar al siguiente.

> 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

El name es el identificador único que genera la API de Job Search, mientras que el external_id es el identificador que proporciona desde su propio sistema de trabajos. Cada vez que hagas referencia a un objeto a través de la API, deberás usar el nombre.

Empresa de actualización

Si ya tienes una entidad de empresa en el sistema y quieres agregar o cambiar algunos campos, el proceso se desglosa en los siguientes pasos:

  • Crear un objeto con los valores de campo actuales para la empresa
  • Actualizar ese objeto con los campos nuevos o actualizados, mediante el campo Company &name; como clave para que la API sepa qué empresa actualizar
  • Envía el objeto nuevo mediante el método "patch&quot.

Ten en cuenta que este proceso requiere que tengas todos los valores existentes, ya que reemplaza los valores de la empresa de una sola vez, independientemente de los que hayas actualizado. Esto significa que, antes de actualizar la información de la empresa, debemos recuperarla.

Cree un archivo nuevo, update_company.py en su lugar de trabajo. Primero, agrega el método get_company que se muestra a continuación si quieres desactivarlo.

update_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']
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()

Algo que notarás en este punto es que la llamada a la API es muy similar a crear una empresa. La biblioteca cliente se genera para que coincida con una interfaz REST, de modo que las operaciones de CRUD que realizas en empresas tendrán el formato client_service.projects().companies().theMethod(argName=argValue).execute()..

Ahora que tenemos el conjunto de valores existentes, cree un objeto "patch" con los nombres de campo que desee actualizar y sus valores nuevos, y úselo para actualizar el objeto de su empresa con valores nuevos. Esto es lo divertido de hacer esto en Python: la biblioteca cliente representa a la empresa como un objeto de diccionario, lo que significa que el método ya está integrado. No es necesario repetir indefinidamente. Crea un objeto de diccionario justo debajo del código que ya escribiste.

update_company.py

...  
    patch = {
       'displayName': "The New Bar",
       'websiteUri': "http://www.example.com"
    }
    newCompany.update(patch)
    print("Debug: New company info %s " % newCompany)
...

Ahora, lo único que queda por hacer es crear un objeto de solicitud (consulta la documentación de parches para obtener detalles sobre lo que puede incluir allí) y ejecutar la llamada a la 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, si solo deseas proporcionar los campos que realmente deseas cambiar, puedes incluir los campos junto con una máscara de actualización. Esto resulta útil en situaciones en las que ya no tiene un objeto de empresa actualizado configurado o solo tiene un campo que desea actualizar y no desea intercambiar objetos innecesariamente grandes. Pero ¿cómo se usa una máscara de actualización? ¿Dónde está el código que demuestra esta forma innovadora y emocionante de actualizar la información de la empresa?

¡Leíste nuestras mentes, lector! El siguiente fragmento ejecuta una actualización de información de la empresa con una máscara de actualización en lugar de un reemplazo de entrada completo.

update_company.py

... 
   # 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)
...

Ten en cuenta que la llamada a la API es la misma. La diferencia es que el objeto de la solicitud ahora tiene dos campos (company y update_mask), en lugar de solo uno (company). La máscara de actualización es una lista de campos delimitados por comas. Si quisiéramos incluir el campo "websiteUri" en la máscara, el valor de la máscara se vería así:

   mask = 'displayName,websiteUri'

Independientemente de la ruta que elija, ejecútela desde Cloud Shell y (suponiendo que haya dejado esas instrucciones de impresión) debería ver un resultado con los valores antiguos y nuevos de su 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'}
$

No tendría sentido buscar una solución de búsqueda de empleo sin empleos que buscar. En la última sección, hablamos sobre cómo crear empresas. Ahora hablemos sobre cómo crear trabajos y prácticas recomendadas para trabajar con ellos.

Ten en cuenta que los trabajos se adjuntarán a las empresas. Si todavía no creaste ninguna empresa con la API (o si ejecutaste correctamente la llamada de eliminación al final de la sección y quitaste tu única empresa), vuelve y crea una empresa nuevamente. Luego, estarás listo para crear trabajos.

Crea un trabajo

Para comenzar, crea un trabajo.

Para crear un trabajo, necesitarás los siguientes datos:

  • Es el nombre de la empresa. No es una string legible de mi empresa, pero es una string mucho más extensa (projects. [ID_PROYECTO]/empresas/ID_DE_EMPRESA).
  • Un ID de requerimiento para el trabajo. Es similar al atributo external_id de una empresa, ya que representa su propio identificador único para el trabajo a fin de que sea más fácil mantener la API de Cloud Talent Solution sincronizada con su solución de trabajo actual. p. ej., sénior_llama_wrangler
  • El cargo del trabajo, que es el nombre visible del trabajo, p.ej., “Grand Wrangler” o
  • La descripción del trabajo. Tenga en cuenta que la descripción puede incluir código HTML incorporado para que pueda darle el formato adecuado. El contenido es bastante evidente. &tt;<p>Liderará al equipo de administradores de llamas.</p><p> Debe tener capacidad de liderazgo y experiencia con llamas.</p>
  • applicationInfo: Más información sobre cómo solicitar la certificación. Puede ser uno o más URI, más de una dirección de correo electrónico o una string con formato HTML y más instrucciones. Incluso puedes incluir los tres. Pero debes incluir al menos 1.

Entonces, si tuviéramos que crear un trabajo para nuestra corporación FooCorp, así se verían los campos:

nombre

projects/[PROJECT_ID]/companies/0123-Big-Hex-String-AABB0

requisition_id

jubilado_superior

title

Wrangler sénior

description

Este lugar necesita de una experiencia laboral integral. Se requiere la capacidad de liderazgo, ya que tomarás un equipo de cuidadores de llamas y los entrenarás para administradores de gran escala. <lt;>Debe funcionar bien con los animales y, a veces, estar preparado para correr de verdad, de verdad. MUY rápido. Estas son algunas llamas rápidas.

aplicación_información

URI: http://www.example.com/llama_wrangler_application/

Correos electrónicos: llama-apply@example.com

Si ya no tienes el nombre de la empresa, puedes usar el código que usaste en el paso 3 para recuperarlo.

El código para crear un trabajo será muy similar al código para crear una empresa. Deberían conocer las primeras líneas (importe bla bla, bla, crea una instancia del objeto de servicio del cliente). Luego, creas un objeto dict (solo un conjunto anidado de pares clave-valor) que representa tu solicitud y lo envías junto con la llamada a la API "create"

Pega el siguiente fragmento en un archivo llamado create_job.py. Puedes llamarlo como quieras, pero, en este instructivo, se usa ese nombre de archivo.

create_job.py

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 e

Ejecuta eso desde Cloud Shell y deberías obtener una gran BLOB de JSON con el trabajo que acabas de crear.

$ 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}

Si vuelves a algo como lo anterior, creaste un trabajo correctamente.

Los trabajos deben ser únicos

A modo de experimento, vuelva a ejecutar esa última secuencia de comandos y veamos lo que sucede.

$ 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.">

¿Qué pasó aquí? Intentaste ingresar una ficha de trabajo duplicada. Los trabajos sin vencer deben ser únicos en el sistema.

La exclusividad se determina mediante los siguientes campos:

  • Nombre de la empresa: Es obligatorio cuando se crea el trabajo; no se puede actualizar
  • ID de solicitud: obligatorio cuando se crea el trabajo, no se puede actualizar
  • Código de idioma: Opcional, predeterminado en en_us, actualizable

Si un trabajo que intentas crear o actualizar tiene estos 3 campos en común con un trabajo existente que no se venció, se considera un duplicado y la creación o actualización de un error falla, como se muestra más arriba.

¡Hip, hip, hurra!

¡Felicitaciones! Ahora tiene una empresa y una ficha de trabajo en su sistema. Completaste todas estas tareas en menos de una hora. ¿Sabes cuánto tiempo tardó el mejor sitio de avisos laborales en Internet para llegar hasta este punto? Más de una hora. Como mucho más. Semanas. Meses. Reuniones de la junta. Es probable que haya hojas de cálculo y declaraciones de misión involucradas. Estoy seguro de que se volvió bastante real en esas oficinas. ¿Sabes lo que te llevó? Un poco menos de una hora. ¡Bravo!

Sin embargo, hay más. Sigamos adelante.

Actualiza un objeto Job

Al igual que con las empresas, podemos obtener un trabajo para ver los detalles y parcharlo a fin de actualizarlo.

A continuación, te mostramos cómo obtener los detalles del trabajo. Si el siguiente fragmento le parece conocido, es porque tomamos el método "get_company" de la sección anterior y reemplazamos "company" por "job" y lo agregamos en la variable job_name. Veamos cómo obtener la información del trabajo primero.

update_job.py.

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)

A fin de actualizar el trabajo, tiene las mismas opciones que antes de actualizar la empresa: envíe un objeto completo con valores actualizados para reemplazar el anterior o envíe un parche más pequeño con una máscara de campo separada por comas.

update_job.py (actualización con el reemplazo completo de objetos)

   # 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 (solo con los valores de campo nuevos y una máscara de actualización)

   # 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)

Los dos fragmentos anteriores hacen exactamente lo mismo: actualizan una ficha de trabajo específica con el nombre de ingeniero de adquisición de llamas llamas. Además, ten en cuenta que la línea que realiza la llamada a la API es la misma: la única diferencia está en el objeto de la solicitud. Uno tiene un objeto de trabajo completo que reemplazará al que tiene ese nombre de trabajo. El otro es simplemente un conjunto de campos para actualizar.

Independientemente de la opción que elija ejecutar, el resultado será el mismo. Inténtelo.

$ 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}

¡Genial! Completaste el paso 4.

Ahora, veamos. Todo se trata de un monstruo de productividad. Hasta ahora, puedes crear empresas, crear trabajos y actualizar ambos a la vez. Es posible que hayas notado algo extraño en estas lecciones. Esa operación final que dice D en C.R.U.D.. ¿Qué ocurre si queremos BORRARlos? No te preocupes, lector. En la siguiente sección, se trata en detalle.

Comencemos por las empresas, por motivos que tendrían sentido narrativo en unos 5 minutos a partir de ahora.

Cómo borrar una empresa

Borrar una empresa es bastante fácil. Con las mismas declaraciones de importación que creó cuando creó o actualizó la empresa, simplemente llame al método delete y pase solo el nombre de ella (no es necesario un cuerpo de solicitud).

   # 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 ayudarte con la limpieza mientras exploras esta API, esta es una secuencia de comandos de Python simple que toma el nombre de una empresa como parámetro de línea de comandos y, como ya adivinaste, borra la empresa.

borrar_empresa.py

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 e

Llámelo y pase el nombre de la empresa como único argumento de la línea de comandos.

$ 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==">

Lo logró. Esperas un segundo. ¿Qué es eso? ¿Se produjo un error? ¿Aún tienes trabajos disponibles?

Sí. Ahora conoce la primera regla para borrar empresas: Fallará siempre y cuando esa empresa aún tenga trabajos disponibles. ¿Cómo lo solucionamos? Debemos borrar todos los trabajos disponibles asociados a esa empresa.

Ahora, lo absolutamente razonable que piensan es que borraré el trabajo que acabo de crear y ENTONCES borrar la empresa a la que venían. Eso tiene sentido, lector. Hagamos eso.

borrar_empresa.py

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 e

Ahora, prueba volver a ejecutarlo. Los valores mostrados de esas llamadas a la API deben ser las entradas actuales de "empresa" y "trabajo", es decir, deben estar vacías.

python delete_company.py
Result of deleting job: {}
Result of deleting company: {}

Ah. ¡Bien hecho!

Una última cosa. La solución anterior funcionó de manera óptima, ya que usted, el lector,

  • Ya tenía el nombre del trabajo para todos los trabajos existentes de esta empresa a mano.
  • No se crearon demasiados para eliminar de forma manual los trabajos de esa empresa.

Supongamos que ese no es el caso.

Hay una llamada a la API, jobs.list(), que mostrará trabajos que coincidan con un ID de proyecto y una empresa principal especificados. Así es como llamarás al 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')))

Ahora puedes crear y administrar fichas de empresas y trabajos con la API de búsqueda de empleo de Google Cloud Talent Solutions.

Temas abordados

  • Crear y administrar empresas
  • Crear y administrar fichas de trabajo para esas empresas
  • Configurar cuentas de servicio para interactuar con la API en tu nombre

Más información