Implementa la búsqueda por viaje diario en tu interfaz de usuario (v3)

Puedes integrar la búsqueda por viaje diario en tu IU para permitir que los buscadores de trabajo busquen trabajos dentro de un área geográfica establecida por tiempo de viaje. La búsqueda por viaje diario estima el tiempo de viaje en función del modo de tránsito seleccionado por el usuario y la hora del día en que planea viajar.

  1. Antes de que puedas implementar la búsqueda por viaje diario, Cloud Talent Solution debe conectarse a tu IU. Sigue las guías de inicio rápido para configurar Cloud Talent Solution.

  2. la búsqueda por viaje diario usa los datos de dirección que cargaste con tus trabajos durante la implementación de CTS para calcular el tiempo de viaje. Para habilitar esta función en tu interfaz de usuario de CTS existente, envía una solicitud jobs.search e incluye un objeto CommuteFilter en el campo JobQuery.commuteFilter. commuteMethod, travelDuration y startCoordinates son campos obligatorios.

    Java

    Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un 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

    Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un 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)

    C#

    Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.

    
    public static void CommuteSearch(string companyName)
    {
        RequestMetadata requestMetadata = new RequestMetadata()
        {
            // Make sure to hash your userID
            UserId = "HashedUserId",
            // Make sure to hash the sessionID
            SessionId = "HashedSessionId",
            // Domain of the website where the search is conducted
            Domain = "www.google.com"
        };
    
        JobQuery jobQuery = new JobQuery()
        {
            CommuteFilter = new CommuteFilter()
            {
                RoadTraffic = "TRAFFIC_FREE",
                CommuteMethod = "TRANSIT",
                TravelDuration = "1000s",
                StartCoordinates = new LatLng()
                {
                    Latitude = 37.42208,
                    Longitude = -122.085609
                }
            }
        };
    
        if (companyName != null)
        {
            jobQuery.CompanyNames = new List<string>
            {
                companyName
            };
        }
    
        SearchJobsRequest searchJobRequest = new SearchJobsRequest()
        {
            RequestMetadata = requestMetadata,
            JobQuery = jobQuery,
            JobView = "JOB_VIEW_FULL",
            RequirePreciseResultSize = true
        };
    
        SearchJobsResponse searchJobsResponse = jobServiceClient.Projects.Jobs.Search(searchJobRequest, parent).Execute();
    
        Console.WriteLine("Jobs commute searched: " + ToJsonString(searchJobsResponse));
    }

    Go

    Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un 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: %v", err)
    	}
    	// Create the jobs service client.
    	service, err := talent.New(client)
    	if err != nil {
    		return nil, fmt.Errorf("talent.New: %v", 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: %v", err)
    	}
    	return resp, nil
    }
    

    Node.js

    Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.

    const commuteSearch = async (jobServiceClient, companyName) => {
      try {
        const requestMetadata = {
          userId: 'HashedUserId',
          sessionId: 'HashedSessionId',
          domain: 'www.google.com',
        };
    
        const startLocation = {
          latitude: 37.422408,
          longitude: -122.085609,
        };
    
        const commutePreference = {
          roadTraffic: 'TRAFFIC_FREE',
          commuteMethod: 'TRANSIT',
          travelDuration: '1000s',
          startCoordinates: startLocation,
        };
    
        const jobQuery = {
          commuteFilter: commutePreference,
        };
    
        if (companyName) {
          jobQuery.companyNames = [companyName];
        }
    
        const request = {
          parent: `projects/${PROJECT_ID}`,
          resource: {
            jobQuery: jobQuery,
            requestMetadata: requestMetadata,
            jobView: 'JOB_VIEW_FULL',
            requirePreciseResultSize: true,
          },
        };
    
        const result = await jobServiceClient.projects.jobs.search(request);
    
        console.log(JSON.stringify(result.data));
      } catch (e) {
        console.error(e);
        throw e;
      }
    };

    Ruby

    Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un 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 IU

  1. Cloud Talent Solution no permite la búsqueda por distancia (mediante el filtro de ubicación de CTS) Y por el tiempo de viaje. Para permitir que los solicitantes de empleo accedan a ambas opciones, use un enfoque de 2 pestañas o similar.

  2. Modifica el frontend de tu aplicación para que cuando un buscador de trabajo solicite una búsqueda por viaje, el backend complete la información relevante en el filtro de viaje y llame a la API como lo haría en una solicitud de búsqueda regular.

  3. Incluye estos elementos recién agregados en tu interfaz de usuario:

    • Una opción para elegir si se trata de una búsqueda de distancia o una búsqueda por viaje diario Por ejemplo, tu IU de búsqueda podría verse como el ejemplo que se muestra a continuación:

    • Un menú desplegable de opciones de método de viaje diario.

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

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

    • Hora de inicio del viaje.

  4. La información de tiempo de viaje que se muestra desde la API se usa para mostrarle información al buscador de trabajo. Solo los trabajos relevantes ubicados dentro del área designada de tiempo de viaje se muestran en la lista de resultados. Consulta la documentación de Prácticas recomendadas de Búsqueda de trabajo para obtener una discusión sobre las formas de ajustar el orden y la cantidad de trabajos que se muestran dentro de esta área.

Puedes aprovechar la API de Google Maps para generar un mapa basado en la información del tiempo de viaje que muestra la API de CTS e incorporarlo en los resultados que se le muestran a un buscador de trabajo. El paquete de la API de Google Maps tiene varias opciones para mostrar el mapa. Algunas opciones de la API de Google Maps son más efectivas que otras. Por ejemplo, la visualización de mapas de calor de JavaScript de Google Maps combinada con el agrupamiento en clústeres de marcadores es una excelente manera de visualizar los trabajos relevantes que se le muestran a un buscador de trabajo dentro del área determinada por sus preferencias de viaje establecidas. Por el contrario, el Modo de indicaciones no muestra todos los trabajos de una solicitud de búsqueda y no es una opción recomendada.

Para obtener más información sobre la implementación de una búsqueda basada en el viaje, consulta la guía práctica de la búsqueda por viaje diario.