Nozioni di base sul job (v3)

Una risorsa Job rappresenta un'offerta di lavoro (nota anche come "offerta di lavoro" o "richiesta di lavoro"). Un'offerta di lavoro appartiene a un'azienda che è l'entità di assunzione responsabile dell'offerta di lavoro.

Un job può essere manipolato utilizzando i metodi di creazione, aggiornamento ed eliminazione e vi si accede utilizzando i metodi di elenco e recupero. Potrebbero essere necessari fino a 5 minuti prima che l'indice di Cloud Talent Solution rifletta le modifiche.

I job sono contenuti nell'ambito di un account di servizio. Solo le richieste di ricerca autenticate utilizzando le credenziali di un determinato account di servizio possono essere utilizzate per accedere ai contenuti di questi job.

Per semplificare la risoluzione dei problemi e la valutazione, sincronizza l'indice dei lavori di Cloud Talent Solution con il tuo indice dei lavori e mantieni una relazione tra name generato da Cloud Talent Solution e l'identificatore univoco del lavoro nel tuo sistema. Man mano che i lavori cambiano o vengono introdotti nel tuo sistema, la chiamata CRUD appropriata deve essere inviata a Cloud Talent Solution in tempo reale per garantire che queste modifiche vengano riflesse immediatamente. L'indice Cloud Talent Solution deve essere aggiunto alla pipeline di importazione dei job esistente.

Crea un job

Per creare un job, consulta la guida rapida: crea aziende e job per maggiori dettagli.

/** 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;
  }
}

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

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

Campi obbligatori

I seguenti campi sono obbligatori durante la creazione e l'aggiornamento del job:

• companyName: il nome della risorsa dell'azienda che pubblica l'offerta di lavoro, ad esempio projects/[PROJECT_ID]/companies/[COMPANY_ID].

• requisitionId: l'ID richiesta, chiamato anche ID annuncio, assegnato dal cliente per identificare un lavoro. Questo campo è destinato all'utilizzo da parte dei clienti per l'identificazione dei clienti e il monitoraggio delle richieste. Il numero massimo di caratteri consentiti è 225.

  L'unicità di un'offerta di lavoro è determinata utilizzando una combinazione di requisitionID, companyName e delle impostazioni internazionali del lavoro. Se un job viene creato con una chiave specifica di questi attributi, questa chiave viene archiviata nell'indice di Cloud Talent Solution e non è possibile creare altri job con questi stessi campi finché il job non viene eliminato.

• title: il titolo della posizione lavorativa, ad esempio "Ingegnere informatico". Il numero massimo di caratteri consentiti è 500.

  Per risolvere il problema dei risultati di ricerca mancanti a causa di titoli di lavoro non standard, Cloud Talent Solution sfrutta tutti i campi forniti nel job per comprendere il contesto del lavoro e memorizzare internamente un titolo "pulito". Quando una richiesta di ricerca viene inviata al servizio, viene pulita anche la query di ricerca e le ontologie vengono utilizzate per mappare la query pulita ai job di pulizia pertinenti.

• description: la descrizione del lavoro, che in genere include una descrizione dell'azienda e informazioni correlate in più paragrafi. Nel campo dell'oggetto Lavoro sono disponibili campi separati per responsabilità, qualifiche e altre caratteristiche del lavoro. Ti consigliamo di utilizzare questi campi separati per i job.

  Questo campo accetta e pulisce l'input HTML e accetta i tag di markup per grassetto, corsivo, elenco ordinato ed elenco non ordinato. Il numero massimo di caratteri consentiti è 100.000.

Il valore sarà uno dei seguenti:

• applicationInfo.uris[]: gli URL delle pagine dell'applicazione.

• applicationInfo.emails[]: indirizzo o indirizzi email a cui devono essere inviati i curriculum o le candidature.

• applicationInfo.instruction: istruzioni per la richiesta, ad esempio "Invia la tua richiesta a…". Questo campo accetta e pulisce l'input HTML e accetta i tag di markup per grassetto, corsivo, elenchi ordinati ed elenchi non ordinati. Il numero massimo di caratteri consentiti è 3000.

Campi utilizzati di frequente

• postingExpireTime: l'ora, in base al timestamp, in cui scade l'offerta di lavoro. Una volta trascorso il tempo, il job viene contrassegnato come scaduto e non viene visualizzato nei risultati di ricerca. Questa data deve essere precedente al 31/12/2100 nel fuso orario UTC. Le date non valide (ad esempio quelle passate) vengono ignorate. La data predefinita di scadenza del job è 30 giorni dopo l'ora di creazione del job nel fuso orario UTC.

  Il contenuto delle offerte di lavoro scadute può comunque essere recuperato fino a 60 giorni dopo la scadenza utilizzando l'operatore GET. Dopo questa scadenza di 60 giorni, il job non verrà restituito tramite un'operazione GET.

• addresses[]: la o le sedi in cui si assume personale per il lavoro. Per ottenere risultati migliori dall'API, inclusi i risultati di ricerca di lavoro in base al tempo di percorrenza, è consigliabile fornire l'indirizzo o gli indirizzi completi della sede di assunzione. Il numero massimo di caratteri consentiti è 500. Per saperne di più su addresses[], consulta la sezione Best practice di seguito.

• promotionValue: un valore maggiore di 0 definisce questo lavoro come "lavoro in evidenza" che viene restituito solo nelle ricerche di lavoro di tipo FEATURED_JOBS. I valori più elevati vengono restituiti più in alto nei risultati di ricerca in primo piano. Per ulteriori informazioni, consulta la sezione Offerte di lavoro in evidenza.

Campi personalizzati

• customAttributes: questo campo memorizza fino a 100 attributi personalizzati utilizzati per memorizzare dati personalizzati sul lavoro. Questi campi possono essere filtrati utilizzando una richiesta di ricerca che specifica il campo jobQuery di una richiesta di ricerca di lavoro. Inoltre, uno qualsiasi di questi campi può essere impostato nell'attributo keywordSearchableJobCustomAttributes dell'azienda, quindi un termine di ricerca che ha una corrispondenza esatta in uno qualsiasi dei campi in keywordSearchableJobCustomAttributes restituisce qualsiasi offerta di lavoro che include la corrispondenza.

Aggiornare un job

Aggiorna job senza fieldMask

/** Update a job. */
public static Job updateJob(String jobName, Job jobToBeUpdated) throws IOException {
  try {
    UpdateJobRequest updateJobRequest = new UpdateJobRequest().setJob(jobToBeUpdated);
    Job jobUpdated =
        talentSolutionClient.projects().jobs().patch(jobName, updateJobRequest).execute();
    System.out.println("Job updated: " + jobUpdated);
    return jobUpdated;
  } catch (IOException e) {
    System.out.println("Got exception while updating job");
    throw e;
  }
}

def update_job(client_service, job_name, job_to_be_updated):
    try:
        request = {"job": job_to_be_updated}
        job_updated = (
            client_service.projects()
            .jobs()
            .patch(name=job_name, body=request)
            .execute()
        )
        print("Job updated: %s" % job_updated)
        return job_updated
    except Error as e:
        print("Got exception while updating job")
        raise e

// updateJob update a job with all fields except name.
func updateJob(w io.Writer, jobName string, jobToUpdate *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)
	}

	req := &talent.UpdateJobRequest{
		Job: jobToUpdate,
	}
	job, err := service.Projects.Jobs.Patch(jobName, req).Do()
	if err != nil {
		return nil, fmt.Errorf("Failed to update job %s: %w", jobName, err)
	}

	return job, err
}

Aggiorna job con fieldMask

/** Update a job. */
public static Job updateJobWithFieldMask(String jobName, String fieldMask, Job jobToBeUpdated)
    throws IOException {
  try {
    UpdateJobRequest updateJobRequest =
        new UpdateJobRequest().setUpdateMask(fieldMask).setJob(jobToBeUpdated);
    Job jobUpdated =
        talentSolutionClient.projects().jobs().patch(jobName, updateJobRequest).execute();
    System.out.println("Job updated: " + jobUpdated);
    return jobUpdated;
  } catch (IOException e) {
    System.out.println("Got exception while updating job");
    throw e;
  }
}

def update_job_with_field_mask(client_service, job_name, job_to_be_updated, field_mask):
    try:
        request = {"job": job_to_be_updated, "update_mask": field_mask}
        job_updated = (
            client_service.projects()
            .jobs()
            .patch(name=job_name, body=request)
            .execute()
        )
        print("Job updated: %s" % job_updated)
        return job_updated
    except Error as e:
        print("Got exception while updating job with field mask")
        raise e

// updateJobWithMask updates a job by name with specific fields.
// mask is a comma separated list top-level fields of talent.Job.
func updateJobWithMask(w io.Writer, jobName string, mask string, jobToUpdate *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)
	}

	req := &talent.UpdateJobRequest{
		Job:        jobToUpdate,
		UpdateMask: mask,
	}
	job, err := service.Projects.Jobs.Patch(jobName, req).Do()
	if err != nil {
		log.Fatalf("Failed to update job %s with field mask %s, Err: %v", jobName, mask, err)
	}

	return job, err
}

Best practice

Campi relativi alla località

Se possibile, ti consigliamo di fornire l'indirizzo della via di un job nel campo addresses[]. Ciò contribuisce al rilevamento e alla pertinenza della posizione. Quando non è disponibile un indirizzo a livello stradale, inserisci il maggior numero possibile di informazioni. Gli indirizzi sono supportati fino al livello di paese. Le designazioni di regioni (ad esempio "Pacifico nord-occidentale") non sono supportate.

Cloud Talent Solution utilizza i dati nel campo addresses[] per compilare il campo (solo output) derivedInfo.locations[]. Quando non viene fornito un indirizzo completo, il servizio utilizza altri indicatori, come il nome dell'azienda, per determinare se è possibile dedurre un indirizzo più completo per l'offerta di lavoro.

Ad esempio, se la sede di un lavoro nel settore del software è specificata come Mountain View e l'azienda a cui è associato il lavoro è Google, il servizio cerca l'oggetto azienda per vedere se è fornito un indirizzo stradale migliore nel campo headquartersAddress e se questo indirizzo stradale si trova nella stessa città dell'offerta di lavoro. In questo caso, il servizio comprende che il lavoro è "probabile" a quell'indirizzo e compila il campo derivedInfo.locations[] in modo appropriato.

Se i dati dell'indirizzo dell'azienda non sono disponibili, il servizio utilizza una combinazione di conoscenze proprietarie e informazioni su lavoro/azienda per compilare il campo derivedInfo.locations[].

Poiché il valore derivedInfo.locations[] è una stima approssimativa, ti consigliamo di utilizzare i dati derivedInfo.locations[] o il campo addresses quando visualizzi l'indirizzo del lavoro.

A un annuncio di lavoro possono essere associate al massimo 50 sedi. Se un lavoro ha più sedi, puoi suddividerlo in più lavori, ognuno con un requisitionId univoco (ad es. "ReqA", "ReqA-1", "ReqA-2" e così via), poiché non è consentito avere più lavori con lo stesso requisitionId, companyName e languageCode. Se l'requisitionId originale deve essere conservato, per l'archiviazione deve essere utilizzato un CustomAttribute. Per una migliore esperienza di ricerca, ti consigliamo di raggruppare le posizioni più vicine tra loro nello stesso lavoro.

Indirizzi supportati

Qualsiasi indirizzo riconosciuto dall'API Geocoding di Google Maps (nel campo formattedAddress) è accettato da Cloud Talent Solution. Il servizio restituisce un errore 400 se tenti di creare un job o eseguire una ricerca utilizzando un indirizzo non riconosciuto.

Se un indirizzo dell'attività è elencato in modo errato nell'API Google Maps Geocoding, segnala un bug per farlo correggere. L'applicazione delle correzioni può richiedere fino a 5 giorni.

Completamento automatico dell'indirizzo

Cloud Talent Solution non fornisce suggerimenti di completamento automatico per le località. Utilizza l'API Google Maps Places o altri servizi di localizzazione simili per compilare i suggerimenti di completamento automatico.

Lavori statali, nazionali e di telelavoro

I lavori possono essere specificati come statali, nazionali o di telelavoro utilizzando il campo postingRegion della risorsa Job.

• I job ADMINISTRATIVE_AREA e NATION vengono restituiti per qualsiasi ricerca la cui località si trova all'interno dello stato/paese dell'offerta di lavoro. Ad esempio, se un'offerta di lavoro ADMINISTRATIVE_AREA ha la sede "WA, USA", viene restituita per le ricerche il cui LocationFilter specifica "Seattle".

• TELECOMMUTE vengono restituiti in qualsiasi ricerca correlata alla posizione, ma sono considerati meno pertinenti. Possono essere presi di mira in una ricerca impostando il flag telecommutePreference su TELECOMMUTE_ALLOWED in LocationFilter della ricerca.