Implementar la búsqueda de desplazamiento en tu interfaz de usuario (v3)

Puedes integrar la búsqueda por ruta de desplazamiento en tu interfaz de usuario para que los candidatos puedan buscar empleos en una zona geográfica determinada por el tiempo de desplazamiento. Búsqueda por ruta de desplazamiento estima el tiempo de desplazamiento en función del medio de transporte que haya seleccionado el usuario y de la hora del día a la que tenga previsto viajar.

Implementar la búsqueda por ruta de desplazamiento

1. Para poder implementar Búsqueda de trayectos, Cloud Talent Solution debe estar conectado a tu interfaz de usuario. Sigue las guías de inicio rápido para configurar Cloud Talent Solution.

2. Búsqueda de trayectos usa los datos de dirección que has subido con tus trabajos durante la implementación de CTS para calcular el tiempo de trayecto. Para habilitar esta función en la interfaz de usuario de CTS, envíe una solicitud jobs.search e incluya un objeto CommuteFilter en el campo JobQuery.commuteFilter. commuteMethod, travelDuration y startCoordinates son campos obligatorios.

   Java

   Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de cliente de Cloud Talent Solution.

   
   public static void commuteSearch(String companyName) throws IOException, InterruptedException {
     // Make sure to set the requestMetadata the same as the associated search request
     RequestMetadata requestMetadata =
         new RequestMetadata()
             // Make sure to hash your userID
             .setUserId("HashedUserId")
             // Make sure to hash the sessionID
             .setSessionId("HashedSessionID")
             // Domain of the website where the search is conducted
             .setDomain("www.google.com");
     JobQuery jobQuery =
         new JobQuery()
             .setCommuteFilter(
                 new CommuteFilter()
                     .setRoadTraffic("TRAFFIC_FREE")
                     .setCommuteMethod("TRANSIT")
                     .setTravelDuration("1000s")
                     .setStartCoordinates(
                         new LatLng().setLatitude(37.422408).setLongitude(-122.085609)));
     if (companyName != null) {
       jobQuery.setCompanyNames(Arrays.asList(companyName));
     }
   
     SearchJobsRequest searchJobsRequest =
         new SearchJobsRequest()
             .setJobQuery(jobQuery)
             .setRequestMetadata(requestMetadata)
             .setJobView("JOB_VIEW_FULL")
             .setRequirePreciseResultSize(true);
     SearchJobsResponse response =
         talentSolutionClient
             .projects()
             .jobs()
             .search(DEFAULT_PROJECT_ID, searchJobsRequest)
             .execute();
     Thread.sleep(1000);
     System.out.printf("Search jobs for commute results: %s\n", response);
   }

   Python

   Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de cliente de Cloud Talent Solution.

   def commute_search(client_service, company_name):
       request_metadata = {
           "user_id": "HashedUserId",
           "session_id": "HashedSessionId",
           "domain": "www.google.com",
       }
       start_location = {"latitude": 37.422408, "longitude": -122.085609}
       commute_preference = {
           "road_traffic": "TRAFFIC_FREE",
           "commute_method": "TRANSIT",
           "travel_duration": "1000s",
           "start_coordinates": start_location,
       }
       job_query = {"commute_filter": commute_preference}
       if company_name is not None:
           job_query.update({"company_names": [company_name]})
       request = {
           "job_query": job_query,
           "request_metadata": request_metadata,
           "job_view": "JOB_VIEW_FULL",
           "require_precise_result_size": True,
       }
       response = (
           client_service.projects().jobs().search(parent=parent, body=request).execute()
       )
       print(response)
   
   

   Go

   Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de cliente de Cloud Talent Solution.

   
   // commuteSearch searches for jobs within commute filter.
   func commuteSearch(w io.Writer, projectID, companyName string) (*talent.SearchJobsResponse, 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)
   	}
   
   	jobQuery := &talent.JobQuery{
   		CommuteFilter: &talent.CommuteFilter{
   			RoadTraffic:    "TRAFFIC_FREE",
   			CommuteMethod:  "TRANSIT",
   			TravelDuration: "1000s",
   			StartCoordinates: &talent.LatLng{
   				Latitude:  37.422408,
   				Longitude: -122.085609,
   			},
   		},
   	}
   	if companyName != "" {
   		jobQuery.CompanyNames = []string{companyName}
   	}
   
   	parent := "projects/" + projectID
   	req := &talent.SearchJobsRequest{
   		// Make sure to set the RequestMetadata the same as the associated
   		// search request.
   		RequestMetadata: &talent.RequestMetadata{
   			// Make sure to hash your userID.
   			UserId: "HashedUsrId",
   			// Make sure to hash the sessionID.
   			SessionId: "HashedSessionId",
   			// Domain of the website where the search is conducted.
   			Domain: "www.googlesample.com",
   		},
   		// Set the actual search term as defined in the jobQuery.
   		JobQuery: jobQuery,
   		// Set the search mode to a regular search.
   		SearchMode:               "JOB_SEARCH",
   		RequirePreciseResultSize: true,
   	}
   	resp, err := service.Projects.Jobs.Search(parent, req).Do()
   	if err != nil {
   		return nil, fmt.Errorf("failed to search for jobs with commute filter: %w", err)
   	}
   	return resp, nil
   }
   

   Ruby

   Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de cliente de Cloud Talent Solution.

   # project_id              = "Id of the project"
   # commute_method          = "The method of transportation for which to calculate the commute time"
   # travel_duration         = "The maximum travel time in seconds"
   # start_coordinates       = "The latitude and longitude of the location from which to calculate the commute time"
   
   require "google/apis/jobs_v3"
   
   jobs = Google::Apis::JobsV3
   talent_solution_client = jobs::CloudTalentSolutionService.new
   # @see https://developers.google.com/identity/protocols/application-default-credentials#callingruby
   talent_solution_client.authorization = Google::Auth.get_application_default(
     "https://www.googleapis.com/auth/jobs"
   )
   
   # Make sure to set the request_metadata the same as the associated search request
   request_metadata = jobs::RequestMetadata.new user_id:    "HashedUserId",
                                                session_id: "HashedSessionId",
                                                domain:     "www.google.com"
   # Set location filter
   commute_filter = jobs::CommuteFilter.new road_traffic:      "TRAFFIC_FREE",
                                            commute_method:    commute_method,
                                            travel_duration:   travel_duration,
                                            start_coordinates: start_coordinates
   # Perform a search for analyst  related jobs
   search_jobs_request =
     jobs::SearchJobsRequest.new request_metadata:            request_metadata,
                                 job_query:                   (jobs::JobQuery.new commute_filter: commute_filter),
                                 job_view:                    "JOB_VIEW_FULL",
                                 require_precise_result_size: true
   search_jobs_response = talent_solution_client.search_jobs project_id, search_jobs_request
   puts search_jobs_response.to_json
   search_jobs_response

Recomendaciones para tu interfaz de usuario

1. Cloud Talent Solution no permite buscar por distancia (con el filtro de ubicación de CTS) y por tiempo de trayecto. Para que los candidatos puedan acceder a ambas opciones, utiliza un enfoque de dos pestañas o similar.

2. Modifica el frontend de tu aplicación para que, cuando un candidato solicite una búsqueda por ruta de desplazamiento, el backend rellene la información pertinente en el filtro de ruta de desplazamiento y llame a la API como lo haría en una solicitud de búsqueda normal.

3. Incluye estos elementos recién añadidos en tu interfaz de usuario:

   • Una opción para elegir si se trata de una búsqueda por distancia o por trayecto. Por ejemplo, la interfaz de búsqueda podría tener el siguiente aspecto:

     

   • Un menú desplegable con opciones de método de desplazamiento.

   • Una opción para ajustar las condiciones del tráfico.

   • El tiempo total de viaje (el tiempo máximo de viaje admitido es de 60 minutos).

   • Hora de inicio del trayecto.

4. La información sobre el tiempo de desplazamiento que devuelve la API se usa para mostrar información a la persona que busca empleo. En la lista de resultados solo se muestran los empleos relevantes que se encuentran en la zona de tiempo de desplazamiento designada. Consulta las prácticas recomendadas de la búsqueda de empleo para ver cómo ajustar el orden y el número de empleos devueltos en esta zona.

Generar un mapa con información sobre el trayecto habitual (opción recomendada)

Puedes usar la API Maps para generar un mapa basado en la información del tiempo de trayecto que devuelve la API CTS e insertarlo en los resultados que se devuelven a un candidato. El paquete de APIs de Maps ofrece varias opciones para mostrar el mapa. Algunas opciones de las APIs de Maps son más eficaces que otras. Por ejemplo, la visualización de mapa de calor de JavaScript de Google Maps combinada con el agrupamiento de marcadores es una forma estupenda de visualizar los trabajos relevantes que se le ofrecen a un candidato dentro de la zona determinada por sus preferencias de trayecto. Por el contrario, el modo de ruta no muestra todos los trabajos devueltos en una solicitud de búsqueda y no es una opción recomendada.

Nota: La API Maps tiene varias estructuras de precios diferentes. Estos precios NO se incluyen en el uso de Cloud Talent Solution. Solo se incluye en los precios de Cloud Talent Solution el uso de las APIs de Cloud Talent Solution para solicitar los empleos que se encuentren dentro de los tiempos de desplazamiento especificados.

Para obtener más información sobre cómo implementar una búsqueda por distancia al trabajo, consulta la guía práctica sobre la búsqueda por distancia al trabajo.