peoplegroup-connectors 1.0.5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71281e48df14d934fff4a9f440e44a53aa416082080afa02735e7675de8359a7
-  data.tar.gz: e8dec527298a0a87e8e7c2f0524ecd9c691a944c610c7ac66dd3fe638fbeb6ab
+  metadata.gz: 561d0cf562f003fd466dd9b9bec4494308228b046ea7e6d1af0a65f44c296acb
+  data.tar.gz: c1faf7bfa314dfb8bbbfe36aad665140aa6f357e97efa01a8e378d68e8ef6be8
 SHA512:
-  metadata.gz: ec8af3c1b8606214ac38b402eaa60d2467f8201fb3b27ada5a0d4e6e574ca43b8169b807b0d4ced02b9e57d8fb6ce0a4dd194b91b8791cbbfc4b8cd6a7f410f7
-  data.tar.gz: 65c30b6577487e88dd7a6eb78bfd88bf4528db9eb660a1cd1f54cdf00e9a00176e77d5cbebc9c150dead33cafe7b593b378d238c1ebe354e6e5ecc3f7abebbd8
+  metadata.gz: ba0f3f958eabdc082033844c7e3341298606d901333bdd46f6e452e04195ccde1809bc8b388453c4400b60b41febb1ab7e2763ab57c3208ba16b14b86a404fdf
+  data.tar.gz: 331d056805178a2335b47a9b4768295da89c4ff403c019edaf5c3bea452cbf6aa5d415a5701350401ff5dacdd0b5057b66ed0ac6d2260461e589092accdccec0

data/README.md

@@ -37,6 +37,16 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 For local development and manual testing, copy the contents of the `.env.example` file to a new file called `.env` and fill-in the environment variable values. You will then be able to run a REPL by running `bundle exec bin/console` from the root of the repository.
 
+### Documentation
+
+To view documentation for the current release. You can navigate to https://gemdocs.org/gems/peoplegroup-connectors/latest to view the latest documentation or https://gemdocs.org/gems/peoplegroup-connectors to select documentation for particular tags.
+
+If you are developing locally, you can preview documentation changes by starting a yard server in the background:
+
+```console
+yard server --reload
+```
+
 ## Contributing and Code of Conduct
 
 Bug reports and pull requests are welcome on GitLab at <https://gitlab.com/gitlab-com/people-group/peopleops-eng/connectors-gem>. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

data/lib/peoplegroup/connectors/gitlab.rb

@@ -5,18 +5,28 @@ require 'gitlab'
 module PeopleGroup
   module Connectors
     class GitLab
+      # The Gitlab.client instance we wrap around.
       attr_accessor :client
 
+      # The GitLab instance API url.
       API_URL = ENV['GITLAB_API_V4_URL'] || 'https://gitlab.com/api/v4'
 
+      # Create a new client instance with the provided token for authentication.
+      # @param token [String] The personal access token to use for authentication.
       def initialize(token: ENV['GITLAB_API_TOKEN'])
         @client = Gitlab.client(endpoint: API_URL, private_token: token)
       end
 
+      # Serach for a GitLab user under the gitlab-com group.
       def find_gitlabber(field, query)
         find_gitlabber_on(field, query, 'gitlab-com')
       end
 
+      # Finds a GitLab user by the field.
+      # @param field [Symbol] The field to search for.
+      # @param query [String] The query to search for.
+      # @param group [String|Integer] The group to search in.
+      # @return [Gitlab::ObjectifiedHash] The found GitLab user if any.
       def find_gitlabber_on(field, query, group)
         return if !query || query.empty?
 
@@ -28,55 +38,117 @@ module PeopleGroup
         end
       end
 
+      # Creates a GitLab group.
+      # @param name [String] The name of the group.
+      # @param path [String] The path of the group.
+      # @param options [Hash] The options to create the group with.
+      # @return [Gitlab::ObjectifiedHash] The created group.
+      # @see https://docs.gitlab.com/ee/api/groups.html#create-a-group
       def create_group(name, path, options = {})
         retry_on_error { @client.create_group(name, path, options) }
       end
 
+      # Get subgroups of a group.
+      # @param group_id [Integer|String] the id of the group to get the subgroups of.
+      # @param options [Hash] the options to get the subgroups with.
+      # @return [Array<Gitlab::ObjectifiedHash>] the subgroups of the group.
+      # @see https://docs.gitlab.com/ee/api/groups.html#list-subgroups
       def get_subgroups(group_id, options = {})
         retry_on_error { @client.group_subgroups(group_id, options).auto_paginate }
       end
 
+      # Get members of a group.
+      # @param group_id [Integer|String] the id of the group to get the members of.
+      # @param options [Hash] the options to get the members with.
+      # @return [Array<Gitlab::ObjectifiedHash>] the members of the group.
+      # @see https://docs.gitlab.com/ee/api/groups.html#list-users
       def get_group_members(group_id, options = {})
         retry_on_error { @client.group_members(group_id, options).auto_paginate }
       end
 
+      # Add a group member with a set access level.
+      # @param group_id [Integer|String] the id of the group to add the member to.
+      # @param user_id [Integer|String] the id of the user to add to the group.
+      # @param access_level [Integer] the access level to add the user with.
+      # @return [Gitlab::ObjectifiedHash] the created group member.
+      # @see https://docs.gitlab.com/ee/api/members.html#add-a-member-to-a-group-or-project
       def add_group_member(group_id, user_id, access_level)
         retry_on_error { @client.add_group_member(group_id, user_id, access_level) }
       end
 
+      # Remove a group member
+      # @param group_id [Integer|String] the id of the group to remove the member from.
+      # @param user_id [Integer|String] the id of the user to remove from the group.
       def remove_group_member(group_id, user_id)
         retry_on_error { @client.remove_group_member(group_id, user_id) }
       end
 
+      # Get a list of a groups user ids
+      # @param group_id [Integer|String] the id of the group to get the members of.
+      # @return [Array<Integer>] the user ids of the members of the group.
       def group_member_ids(group_id)
         members = retry_on_error { @client.group_members(group_id) }
         members.map(&:id)
       end
 
-      def create_issue(project, title, options = {})
+      # Create a new issue.
+      # @param project [Integer|String] the id of the project to create the issue in.
+      # @param title [String] the title of the issue.
+      # @param options [Hash] the options to create the issue with.
+      # @return [Gitlab::ObjectifiedHash] the created issue.
+      # @see https://docs.gitlab.com/ee/api/issues.html#new-issue
+      # @example
+      #   gitlab = PeopleGroup::Connectors::GitLab.new
+      #   options = { description: 'This is a new issue', labels: ['bug'] }
+      #   gitlab.create_issue(123, 'New issue', options)
+      def create_issue(project, title, options)
         retry_on_error { @client.create_issue(project, title, options) }
       end
 
+      # Create a note on an issue
+      # @param project [Integer|String] the id of the project to create the note in.
+      # @param id [Integer|String] the id of the issue to create the note on.
+      # @param text [String] the text of the note.
+      # @return [Gitlab::ObjectifiedHash] the created issue note.
+      # @example
+      #   gitlab = PeopleGroup::Connectors::GitLab.new
+      #   gitlab.create_issue_note(123, 456, 'This is a new note')
       def create_issue_note(project, id, text)
         retry_on_error { @client.create_issue_note(project, id, text) }
       end
 
+      # List notes on an issue.
+      # @param project [Integer|String] the id of the project to list the notes from.
+      # @param id [Integer|String] the id of the issue to list the notes from.
+      # @param options [Hash] the options to list the notes with.
+      # @return [Array<Gitlab::ObjectifiedHash>] a list of notes associated to the issue.
       def issue_notes(project, id, options = {})
         retry_on_error { @client.issue_notes(project, id, options) }
       end
 
+      # Edit an issue.
+      # @param project [Integer|String] the id of the project to edit the issue in.
+      # @param id [Integer|String] the id of the issue to edit.
+      # @param options [Hash] the options to edit the issue with.
+      # @return [Gitlab::ObjectifiedHash] the updated issue.
       def edit_issue(project, id, options)
         retry_on_error { @client.edit_issue(project, id, options) }
       end
 
-      def get_onboarding_issues(project, args)
-        retry_on_error { @client.issues(project, args).auto_paginate }
-      end
-
+      # Get a list of issues from a project.
+      # @param project [Integer|String] the id of the project to search for the issue in.
+      # @param args [Hash] the options to search for the issue with.
+      # @return [Array<Gitlab::ObjectifiedHash>] the list of issues matching the search criteria.
+      # @see https://docs.gitlab.com/ee/api/issues.html#list-project-issues
       def get_issues(project, args)
         retry_on_error { @client.issues(project, args).auto_paginate }
       end
+      alias_method :get_onboarding_issues, :get_issues
 
+      # Gets an issue from the associated project.
+      # @param project [Integer|String] the id of the project to search for the issue in.
+      # @param issue_id [Integer|String] the id of the issue to get.
+      # @return [Gitlab::ObjectifiedHash] the issue object.
       def get_issue(project, issue_id)
         retry_on_error { @client.issue(project, issue_id) }
       end
@@ -85,6 +157,11 @@ module PeopleGroup
         retry_on_error { @client.update_variable(project, key, value, **opts) }
       end
 
+      # Find or create an epic by title.
+      # @param group_id [Integer|String] the id of the group to search for the epic in.
+      # @param title [String] the title of the epic.
+      # @param options [Hash] the options to create the epic with.
+      # @return [Gitlab::ObjectifiedHash] the created or found epic.
       def find_or_create_epic(group_id, title, options = {})
         epic = find_epic(group_id, title)
         reopen_epic(epic) if epic && epic.state == 'closed'
@@ -216,28 +293,75 @@ module PeopleGroup
         create_merge_request(project_id, commit_message, options)
       end
 
+      # Create an epic for a group.
+      # @param group_id [Integer|String] the id of the group to create the epic for.
+      # @param title [String] the title of the epic.
+      # @param options [Hash] the options to create the epic with.
+      # @return [Gitlab::ObjectifiedHash] the created epic.
+      # @see https://docs.gitlab.com/ee/api/epics.html#new-epic
       def create_epic(group_id, title, options)
         retry_on_error { @client.create_epic(group_id, title, options) }
       end
 
+      # Create a note on an epic.
+      # @param group_id [Integer|String] the id of the group to search for the epic in.
+      # @param epic_id [Integer|String] the id of the epic to create the note for.
+      # @param text [String] the text of the note.
       def create_epic_note(group_id, epic_id, text)
         retry_on_error { @client.create_epic_note(group_id, epic_id, text) }
       end
 
+      # Get all epics of a specific group.
+      # @param group_id [Integer|String] the id of the group to search for the epics in.
+      # @param  options [Hash] the options to search for the epics with.
+      # @return [Array<Gitlab::ObjectifiedHash>] the list of epics associated
+      # @see https://docs.gitlab.com/ee/api/epics.html#list-epics-for-a-group
       def get_epics(group_id, options = {})
         retry_on_error { @client.epics(group_id, options).auto_paginate }
       end
 
+      # Get the the issues for a specific epic.
+      # @param group_id [Integer|String] the id of the group to search for the epic in.
+      # @param epic_iid [Integer|String] the iid of the epic to search for the issues of.
+      # @return [Array<Gitlab::ObjectifiedHash>] the list of issues associated with the epic.
+      # @see https://docs.gitlab.com/ee/api/epics.html#get-a-list-of-epic-issues
       def get_issue_epics(group_id, epic_iid)
         retry_on_error { @client.epic_issues(group_id, epic_iid) }
       end
 
+      # Get the file at a specific path in a specific project.
+      # @param project_id [Integer|String] the id of the project to search for the file in.
+      # @param file_path [String] the files path relative to the project root.
+      # @param ref [String] the branch or tag name, or the commit SHA, to retrieve the file from.
+      # @return [Gitlab::ObjectifiedHash] The get repository file response.
+      # @see https://docs.gitlab.com/ee/api/repository_files.html#get-file-from-repository
+      # @example
+      #  client = PeopleGroup::Connectors::GitLab.new
+      #  client.get_file(00000, 'path/to/file.txt')
+      def get_file(project_id, file_path, ref = 'main')
+        retry_on_error { @client.get_file(project_id, file_path, ref) }
+      end
+
+      # Get the contents of the specified file at a specific path in a project.
+      # @param project_id [Integer|String] the id of the project to search for the file in.
+      # @param file_path [String] the file path relative to the project root.
+      # @param ref [String] the branch or tag name, or the commit SHA, to retrieve the file from.
+      # @return [String] The contents of the file.
+      # @example
+      #  client = PeopleGroup::Connectors::GitLab.new
+      #  client.get_file_contents(00000, 'path/to/file.txt')
+      def get_file_contents(project_id, file_path, ref = 'main')
+        response = get_file(project_id, file_path, ref)
+        Base64.decode64(response&.content)
+      end
+
       private
 
       def retry_on_error(&block)
         Utils.retry_on_error(errors: retry_errors, delay: 3, &block)
       end
 
+      # Common errors that we can retry.
       def retry_errors
         [Gitlab::Error::InternalServerError, Gitlab::Error::BadGateway, Gitlab::Error::ServiceUnavailable]
       end

data/lib/peoplegroup/connectors/google_sheets.rb

@@ -5,10 +5,17 @@ require 'google_drive'
 module PeopleGroup
   module Connectors
     class GoogleSheets
+      # Find a spreadsheet by title.
+      # @param title [String] the title of the spreadsheet, must be exact and shared with the service account.
+      # @return [GoogleDrive::Spreadsheet|nil] the found spreadsheet or nil if no matches were found.
       def spreadsheet(title)
         retry_on_error { session.spreadsheet_by_title(title) }
       end
 
+      # Find a worksheet by title within a given spreadsheet.
+      # @param spreadsheet_title [String] the title of the spreadsheet, must be exact and shared with the service account.
+      # @param worksheet_title [String] the title of the worksheet inside the spreadsheet, must be an exact match.
+      # @return [GoogleDrive::Worksheet|nil] the found worksheet or nil if no matches were found.
       def worksheet(spreadsheet_title, worksheet_title)
         worksheets = retry_on_error { spreadsheet(spreadsheet_title).worksheets }
         worksheets.find { |worksheet| worksheet.title == worksheet_title }

data/lib/peoplegroup/connectors/greenhouse.rb

@@ -5,28 +5,60 @@ require 'greenhouse_io'
 module PeopleGroup
   module Connectors
     class Greenhouse
+      # Maximum amount of retries for requests.
       MAX_RETRIES = 3
 
+      # Error to retry on.
+      RETRY_ERRORS = [
+        GreenhouseIo::Error,
+        Net::OpenTimeout,
+        RestClient::InternalServerError
+      ].freeze
+
+      # Time to delay inbetween retries.
+      RETRY_DELAY = 3
+
+      # Create a new Greenhouse client instance.
+      # @param use_users_api_key [Boolean] Whether to use the users API key or the default one.
+      # @return [PeopleGroup::Connectors::Greenhouse]
+      # @example
+      #   client = PeopleGroup::Connectors::Greenhouse.new
       def initialize(use_users_api_key: false)
         api_key = use_users_api_key ? ENV['GREENHOUSE_API_KEY_USERS'] : ENV['GREENHOUSE_API_KEY']
         @client = GreenhouseIo::Client.new(api_key)
       end
 
+      # List all offers for an application.
+      # @param application_id [Integer|String] The id of the application to get the offers for.
+      # @return [Array<Hash>] The offers for the application.
+      # @see https://developers.greenhouse.io/harvest.html#get-list-offers-for-application
       def offer_for_application(application_id)
-        @client.offers_for_application(application_id)
+        retry_on_error { @client.offers_for_application(application_id) }
       end
-
+      alias_method :offers_for_application, :offer_for_application
+
+      # Get the current offer of an application.
+      # @param application_id [Integer|String] The id of the application to get the offer for.
+      # @return [Hash] The current offer for the application.
+      # @example
+      #   client = PeopleGroup::Connectors::Greenhouse.new
+      #   client.current_offer_for_application(123)
+      #   #=> { "id" => 123, "status" => "accepted", "application_id" => 456, ... }
+      # @see https://developers.greenhouse.io/harvest.html#get-retrieve-current-offer-for-application
       def current_offer_for_application(application_id)
         @client.current_offer_for_application(application_id)
       end
 
+      # Check for hired candidates based on when they have been updated.
+      # @param updated_since [String|DateTime] YYYY-MM-DD format with optional time stamp.
+      # @return [Array<Hash>] The hired candidates.
+      # @see PeopleGroup::Connectors::Greenhouse#hired_non_active
       def hired_candidates(updated_since)
         page = 1
         candidates = []
-        on_error = -> { p [updated_since, page] }
 
         loop do
-          results = Utils.retry_on_error(errors: [GreenhouseIo::Error, RestClient::InternalServerError], on_error: on_error) do
+          results = Utils.retry_on_error(on_error: -> { p [updated_since, page] }) do
             @client.candidates(nil, updated_after: updated_since, page: page)
           end
 
@@ -42,25 +74,43 @@ module PeopleGroup
         candidates
       end
 
+      # Search for a canidate by their candidate id.
+      # @param candidate_id [String|Integer] the candidates id.
+      # @return [Hash] the candidates details.
+      # @see https://developers.greenhouse.io/harvest.html#get-retrieve-candidate
       def candidate(candidate_id)
-        @client.candidates(candidate_id)
+        retry_on_error { @client.candidates(candidate_id) }
       end
 
+      # Add a note to the candidates profile in Greenhouse.
+      # @param candidate_id [String|Integer] the candidates ID that is being synced.
+      # @return [Boolean] whether or not the request was successful.
       def add_sync_note_to_candidate(candidate_id)
         note = {
           user_id: ENV['GREENHOUSE_AUTHOR_ID'],
           body: "This person was synced at #{Time.now} by the Employee Bot",
           visibility: 'public'
         }
-        @client.create_candidate_note(candidate_id, note, ENV['GREENHOUSE_AUTHOR_ID'])
+
+        retry_on_error { @client.create_candidate_note(candidate_id, note, ENV['GREENHOUSE_AUTHOR_ID']) }
       end
 
+      # List candidates by the specified options.
+      # @param id [String|Integer] The ID of the candidate to fetch.
+      # @param options [Hash] The options to filter the candidates by.
+      # @return [Array<Hash>] candidates matching the specified filter.
+      # @example
+      #   greenhouse = PeopleGroup::Connectors::Greenhouse.new
+      #   greenhouse.candidates(nil, { email: 'john@example.com' })
+      #   greenhouse.candiates(12345)
+      # @see https://developers.greenhouse.io/harvest.html#get-list-candidates
       def candidates(id = nil, options = {})
-        Utils.retry_on_error(errors: [GreenhouseIo::Error, Net::OpenTimeout]) do
-          @client.candidates(id, options)
-        end
+        retry_on_error { @client.candidates(id, options) }
       end
 
+      # Paginate through a list of users in Greenhouse.
+      # @return [Array<Hash>] The users in Greenhouse.
+      # @see https://developers.greenhouse.io/harvest.html#get-list-users
       def users
         page = 1
         users = []
@@ -76,18 +126,40 @@ module PeopleGroup
         users
       end
 
+      # Find an application by id.
+      # @param application_id [String|Integer] The ID of the application to fetch.
+      # @return [Hash] The application data.
+      # @see https://developers.greenhouse.io/harvest.html#get-retrieve-application
+      # @example
+      #   greenhouse = PeopleGroup::Connectors::Greenhouse.new
+      #   greenhouse.application(12345)
       def application(application_id)
-        @client.applications(application_id)
+        retry_on_error { @client.applications(application_id) }
       end
 
+      # Check if the individual has any active applications.
+      # @param work_email [String] the individuals email address.
+      # @return [Boolean] true if the individual has any active applications, false if not.
       def has_active_application?(work_email)
-        candidates(nil, { email: work_email })&.[]('applications')&.any? { |application| application['status'] == 'active' }
+        # Find the canidate by email.
+        candidate = candidates(nil, { email: work_email })
+
+        # Return false unless they could be found or have no applications.
+        return false unless candidate && candidate['applications'].size.positive?
+
+        # Check all applications for any with a status of 'active'
+        candidate['applications'].any? { |application| application['status'] == 'active' }
       rescue RestClient::NotFound
-        nil # return nil if candidate could not be found
+        false # return false if candidate could not be found
       end
 
       private
 
+      # Check if the candidate is hired and inactive.
+      # - The candidate has any application that is active, we don't sync.
+      # - Check if candidate is hired for at least one of their applications
+      # @param candidate [Hash] The candidate data.
+      # @return [Boolean] whether or not the candidate is hired but not active.
       def hired_non_active?(candidate)
         # If the candidate has any application that is active, we don't sync.
         return false if candidate['applications'].any? { |application| application['status'] == 'active' }
@@ -95,6 +167,10 @@ module PeopleGroup
         # Check if candidate is hired for at least one of their applications
         candidate['applications'].any? { |application| application['status'] == 'hired' }
       end
+
+      def retry_on_error(on_error: -> {}, &block)
+        Utils.retry_on_error(errors: RETRY_ERRORS, delay: RETRY_DELAY, max_attempts: MAX_RETRIES, on_error: on_error, &block)
+      end
     end
   end
 end

data/lib/peoplegroup/connectors/hris.rb

@@ -8,9 +8,13 @@ module PeopleGroup
 
       def initialize
         @workday = Workday::Client.new unless ENV.fetch('WORKDAY_SERVICE_URL', nil).nil?
-        @bamboo = Bamboo.new
       end
 
+      # List all team members from the WORKDAY_WORKERS_REPORT.
+      # @return [Array<Hash>]
+      #   hris = PeopleGroup::Connectors::Hris.new
+      #   hris.team_members
+      #   #=> [{ "workEmail"=>"tanuki@gitlab.com" }, ...]
       def employees
         @employees ||= Workday::Report.call(
           url: ENV.fetch('WORKDAY_WORKERS_REPORT', nil),
@@ -19,11 +23,15 @@ module PeopleGroup
       end
       alias_method :team_members, :employees
 
+      # List team members with the satus of 'Active'.
+      # @return [Array<Hash] team members with a status of 'Active'.
       def active_employees
         employees.select { |employee| employee['status'] == 'Active' }
       end
       alias_method :active_team_members, :active_employees
 
+      # List team members with the satus of 'Active' and a hireDate that is less than or equal to today.
+      # @return [Array<Hash>] team members with a status of 'Active' and a hireDate that is less than or equal to today.
       def active_and_current_employees
         today = Date.current
         employees.select do |employee|
@@ -32,11 +40,22 @@ module PeopleGroup
       end
       alias_method :active_and_current_team_members, :active_and_current_employees
 
+      # Get the details of a team member from the WORKDAY_WORKERS_REPORT.
+      # @param employee_number [String|Integer] the team member's employee number.
+      # @return [Hash] the team member's details.
+      # @example
+      #   hris = PeopleGroup::Connectors::Hris.new
+      #   hris.get_employee_details(12345)
+      #   #=> { "workEmail"=>"tanuki@gitlab.com", ... }
       def get_employee_details(employee_number)
         employees.find { |emp| emp['employeeNumber'] == employee_number.to_s }
       end
       alias_method :get_team_member_details, :get_employee_details
 
+      # Get the details of a team member from the WORKDAY_WORKERS_REPORT.
+      # @param employee_number [String|Integer]
+      # @raise [EmployeeNotFoundError] if the team member could not be found.
+      # @see [PeopleGroup::Connectors::Hris#get_employee_details]
       def get_employee_details!(employee_number)
         employee_details = get_employee_details(employee_number)
         raise EmployeeNotFoundError, "No team member found with employee number #{employee_number}" if employee_details.nil?
@@ -45,6 +64,12 @@ module PeopleGroup
       end
       alias_method :get_team_member_details!, :get_employee_details!
 
+      # Search a team member by name.
+      # @param name [String] the team member's name.
+      # @return [Hash|nil] the team member's details if found or nil.
+      # @example
+      #   hris = PeopleGroup::Connectors::Hris.new
+      #   hris.search_employee('Jane Doe')
       def search_employee(name)
         return if name.empty?
 
@@ -61,6 +86,10 @@ module PeopleGroup
       end
       alias_method :search_team_member, :search_employee
 
+      # Search team member by name.
+      # @param name [String] the team member's name or display name.
+      # @raise [EmployeeNotFoundError] if the team member could not be found.
+      # @see [PeopleGroup::Connectors::Hris#search_employee]
       def search_employee!(name)
         employee = search_employee(name)
         raise EmployeeNotFoundError, "No employee found with name #{name}" if employee.nil?
@@ -69,11 +98,24 @@ module PeopleGroup
       end
       alias_method :search_team_member!, :search_employee!
 
+      # Search a team meber by field.
+      # @param field [String] the field to search on.
+      # @param value [String|Integer] the value to search for.
+      # @return [Hash|nil] the team member's details if found or nil.
+      # @example
+      #   hris = PeopleGroup::Connectors::Hris.new
+      #   hris.search_employee_by_field('workEmail', 'tanuki@gitlab.com')
+      #    #=> { "workEmail"=>"tanuki@gitlab.com", ... }
       def search_employee_by_field(field:, value:)
         employees.find { |employee| employee[field] == value.to_s }
       end
       alias_method :search_team_member_by_field, :search_employee_by_field
 
+      # Search a team member by field, and raise error if not found.
+      # @param field [String] the field to search on.
+      # @param value [String|Integer] the value to search for.
+      # @raise [EmployeeNotFoundError] if the team member could not be found.
+      # @see [PeopleGroup::Connectors::Hris#search_employee_by_field]
       def search_employee_by_field!(field:, value:)
         employee = search_employee_by_field(field: field, value: value)
         raise EmployeeNotFoundError, "No employee found with #{field}: #{value}" if employee.nil?
@@ -83,6 +125,11 @@ module PeopleGroup
       alias_method :search_team_member_by_field!, :search_employee_by_field!
 
       # Find the associated team member without checking case on their e-mail fields.
+      # 1. Look for a match on their workEmail field.
+      # 2. Look for a match on their bestEmail field.
+      # 3. Look for a match on their homeEmail field.
+      # @param email [String] the team member's e-mail address.
+      # @return [Hash|nil] the team member's details if found or nil.
       def search_team_member_by_email(email)
         return nil unless email
 
@@ -94,6 +141,8 @@ module PeopleGroup
       alias_method :slack_email_lookup_with_fallback, :search_team_member_by_email
 
       # Find the team member by email and raise error if not found.
+      # @param email [String] the team members e-mail address.
+      # @see [PeopleGroup::Connectors::Hris#search_team_member_by_email]
       def search_team_member_by_email!(email)
         team_member = search_team_member_by_email(email)
 
@@ -103,18 +152,38 @@ module PeopleGroup
       end
       alias_method :slack_email_lookup_with_fallback!, :search_team_member_by_email!
 
+      # Team members filtered by department
+      # @param department [String] the department name.
+      # @return [Array<Hash>] the team members that belong to that department
+      # @example
+      #   hris = PeopleGroup::Connectors::Hris.new
+      #   hris.team_members_by_department('People Operations')
+      #   #=> [{ "workEmail"=>"tanuki@gitlab.com", ... }, ...]
       def team_members_by_department(department)
         active_and_current_team_members.select { |team_member| team_member['department'] == department }
       end
 
+      # Team members filtered by division
+      # @param division [String] the division name.
+      # @return [Array<Hash>] the team members that belong to that division
+      # @example
+      #   hris = PeopleGroup::Connectors::Hris.new
+      #   hris.team_members_by_division('People Group')
       def team_members_by_division(division)
         active_and_current_team_members.select { |team_member| team_member['division'] == division }
       end
 
+      # Find the manager of a team member.
+      # @param team_member [Hash] the team member's details.
+      # @return [Hash|nil] the manager's details
       def fetch_manager(team_member)
         active_team_members.find { |tm| tm['employeeNumber'] == team_member['supervisorId'] }
       end
 
+      # Find the manager of a team member and raise error if not found.
+      # @param team_member [Hash] the team member's details.
+      # @raise [EmployeeNotFoundError] if the manager could not be found.
+      # @see [PeopleGroup::Connectors::Hris#fetch_manager]
       def fetch_manager!(team_member)
         manager = fetch_manager(team_member)
         raise EmployeeNotFoundError, "Manager not found for employee #{team_member['employeeNumber']}" if manager.nil?
@@ -122,10 +191,20 @@ module PeopleGroup
         manager
       end
 
+      # Find the second level manager of a team member.
+      # 1. Find the team member's manager.
+      # 2. Find the manager's manager.
+      # @param team_member [Hash] the team member's details.
+      # @return [Hash|nil] the second level manager's details or nil.
       def fetch_second_level_manager(team_member)
         fetch_manager(fetch_manager(team_member))
       end
 
+      # Find the second level manager of a team member, raise error if not found.
+      # @param team_member [Hash] the team member's details.
+      # @return [Hash|nil] the second level manager's details or nil.
+      # @raise [EmployeeNotFoundError] if the second level manager could not be found.
+      # @see [PeopleGroup::Connectors::Hris#fetch_second_level_manager]
       def fetch_second_level_manager!(team_member)
         manager = fetch_second_level_manager(team_member)
         raise EmployeeNotFoundError, "No second level manager found for employee #{team_member['employeeNumber']}" if manager.nil?
@@ -133,37 +212,12 @@ module PeopleGroup
         manager
       end
 
-      def create_employee(employee_details_hash)
-        @bamboo.create_employee(employee_details_hash)
-      end
-      alias_method :create_team_member, :create_employee
-
-      def update_employee(employee_number, employee_details_hash)
-        # Only used in activate_team_members.rb, which is not needed in Workday
-        @bamboo.update_employee(employee_number, employee_details_hash)
-      end
-      alias_method :update_team_member, :update_employee
-
+      # List entities from Workday.
+      # @return [Array<Hash>] list of entities from Workday.
       def locations
         @workday.locations
       end
 
-      def add_stock_options(employee_number, data)
-        @bamboo.add_stock_options(employee_number, data)
-      end
-
-      def add_job_details(employee_number, data)
-        @bamboo.add_job_details(employee_number, data)
-      end
-
-      def update_job_details(employee_number, data)
-        @bamboo.update_job_details(employee_number, data)
-      end
-
-      def add_compensation_details(employee_number, data)
-        @bamboo.add_compensation_details(employee_number, data)
-      end
-
       def employment_statuses(employee_number)
         # Terminated/Active in one field already. Those are the statuses we need to care about
         # Look for a hire date that is after the start date (not original hire date) to account for rehires
@@ -181,98 +235,26 @@ module PeopleGroup
         raise NotImplementedError
       end
 
-      def time_off_type(name)
-        # Staying in bamboo for workday first release
-        # Will need to have talks with pto by roots admin
-        @bamboo.time_off_type(name)
-      end
-
-      def time_off_adjustment(employee_number, options)
-        # Staying in bamboo for workday first release
-        # Will need to have talks with pto by roots admin
-        @bamboo.time_off_adjustment(employee_number, options)
-      end
-
-      def accrued_days(employee_number)
-        # Staying in bamboo for workday first release
-        # Will need to have talks with pto by roots admin
-        @bamboo.accrued_days(employee_number)
-      end
-
-      def time_off_policies
-        @bamboo.time_off_policies
-      end
-
-      def employee_time_off_policies(employee_number)
-        @bamboo.employee_time_off_policies(employee_number)
-      end
-      alias_method :team_member_time_off_policies, :employee_time_off_policies
-
-      def add_time_off_policy(employee_number, time_off_policy_id, accrual_start_date)
-        @bamboo.add_time_off_policy(employee_number, time_off_policy_id, accrual_start_date)
-      end
-
-      def remove_time_off_policy(employee_number, time_off_policy_id)
-        @bamboo.remove_time_off_policy(employee_number, time_off_policy_id)
-      end
-
       def job_details(employee_number)
         warn '[DEPRECATED] PeopleGroup::Connectors::Hris#job_details, use a custom workday report instead.'
         Workday::Report.call(url: ENV.fetch('WORKDAY_MANAGER_REPORT', nil))
       end
 
-      def resumes_folder_id(employee_number)
-        @bamboo.resumes_folder_id(employee_number)
-      end
-
-      def contract_folder_id(employee_number)
-        @bamboo.contract_folder_id(employee_number)
-      end
-
-      def add_file(employee_number, file_name, file, folder_id)
-        @bamboo.add_file(employee_number, file_name, file, folder_id)
-      end
-
-      def add_employment_status(employee_number, data)
-        # Only used in parental_pto_to_bamboo.rb
-        # That integration adds the following statuses: Parental Leave, End of Parental Leave, Active
-        # Asked what to do about this one on Slack: https://gitlab.slack.com/archives/C02FHJ9BYTZ/p1650666853127429
-
-        raise NotImplementedError
-      end
-
-      def add_currency_conversion(employee_number, data)
-        @bamboo.add_currency_conversion(employee_number, data)
-      end
-
-      def add_on_target_earnings(employee_number, data)
-        @bamboo.add_on_target_earnings(employee_number, data)
-      end
-
-      def add_signing_bonus(employee_number, data)
-        @bamboo.add_signing_bonus(employee_number, data)
-      end
-
-      def add_family_member(employee_number, data)
-        @bamboo.add_family_member(employee_number, data)
-      end
-
-      def add_additional_data(employee_number, data)
-        @bamboo.add_additional_data(employee_number, data)
-      end
-
-      def additional_data(employee_number)
-        @bamboo.additional_data(employee_number)
-      end
-
       def add_bonus(employee_number, comment)
         @workday.add_bonus(employee_number, comment)
       end
 
+      # List active departments from Workday.
+      # @return [Array<Hash>] list of departments from Workday.
       def departments
         @workday.departments
       end
 
+      # Check team member eligibility status based on salary ranges.
+      # @param eid [String|Integer] the team members employee number
+      # @param salary_min [Integer] the minimum salary.
+      # @param salary_max [Integer] the maximum salary.
+      # @return [Hash] details regarding their eligibility status.
       def eligibility_status(eid, salary_min, salary_max)
         @workday.eligibility_status(eid, salary_min, salary_max)
       end

data/lib/peoplegroup/connectors/version.rb

@@ -2,6 +2,6 @@
 
 module PeopleGroup
   module Connectors
-    VERSION = '1.0.5'
+    VERSION = '2.0.0'
   end
 end

data/lib/peoplegroup/connectors/workday/xml/request_one_time_payment.rb

@@ -20,9 +20,9 @@ module PeopleGroup
           # Adds a bonus to the team members
           # @param employee_number [Integer] The Employee Number of the team member receiving the bonus.
           # @param comment [String] The comment to leave on the business process.
-          def add_bonus(employee_number, comment)
+          def add_bonus(employee_number, comment: '', auto_complete: false)
             options = {
-              **business_process_params(comment),
+              **business_process_params(comment: comment, auto_complete: auto_complete),
               **one_time_payment_data(employee_number, comment)
             }
 
@@ -38,7 +38,7 @@ module PeopleGroup
           # @param auto_complete: [Boolean] Defaults to true to apply this bonus without needing approval.
           #
           # @return [Hash] The <wd:Business_Process_Parameters> for this request.
-          def business_process_params(comment, run_now: true, auto_complete: true)
+          def business_process_params(comment:, run_now: true, auto_complete: true)
             {
               'Business_Process_Parameters' => {
                 'Auto_Complete' => auto_complete,

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: peoplegroup-connectors
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 2.0.0
 platform: ruby
 authors:
 - lien van den steen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-19 00:00:00.000000000 Z
+date: 2025-01-17 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bamboozled-gitlab
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.2.14
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.2.14
 - !ruby/object:Gem::Dependency
   name: gitlab
   requirement: !ruby/object:Gem::Requirement
@@ -122,7 +108,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
-description: Avoid repeating methods in different projects for our connectos.
+description: Avoid repeating methods in different projects for our connectors.
 email:
 - lvandensteen@gitlab.com
 executables: []
@@ -132,7 +118,6 @@ files:
 - LICENSE.txt
 - README.md
 - lib/peoplegroup/connectors.rb
-- lib/peoplegroup/connectors/bamboo.rb
 - lib/peoplegroup/connectors/gitlab.rb
 - lib/peoplegroup/connectors/google_sheets.rb
 - lib/peoplegroup/connectors/greenhouse.rb
@@ -171,7 +156,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.23
 signing_key:
 specification_version: 4
 summary: Library for our shared connectors.

data/lib/peoplegroup/connectors/bamboo.rb

@@ -1,355 +0,0 @@
-# frozen_string_literal: true
-
-require 'bamboozled'
-
-module PeopleGroup
-  module Connectors
-    class Bamboo
-      attr_accessor :client
-
-      EmployeeNotFoundError = Class.new(StandardError)
-
-      def initialize(use_report: false)
-        @use_report = use_report
-        @client = Bamboozled.client(subdomain: 'gitlab', api_key: ENV['BAMBOO_API_KEY'])
-      end
-
-      def get_employee_details(id)
-        employees.find { |emp| emp['employeeNumber'] == id.to_s }
-      end
-      alias_method :get_team_member_details, :get_employee_details
-
-      def get_employee_details!(id)
-        employee_details = get_employee_details(id)
-        raise EmployeeNotFoundError, "No team member found with employee number #{id}" if employee_details.nil?
-
-        employee_details
-      end
-      alias_method :get_team_member_details!, :get_employee_details!
-
-      def bamboo_id!(employee_number)
-        get_team_member_details!(employee_number)['id']
-      end
-
-      def search_employee(name)
-        return if name.empty?
-
-        employees.find do |emp|
-          [
-            emp['displayName']&.downcase,
-            "#{emp['firstName']&.downcase} #{emp['lastName']&.downcase}",
-            "#{emp['preferredName']&.downcase} #{emp['lastName']&.downcase}",
-            "#{emp['firstName']&.downcase} #{emp['customPreferredLastName']&.downcase}",
-            "#{emp['preferredName']&.downcase} #{emp['customPreferredLastName']&.downcase}",
-            emp['fullName5']&.downcase # this is firstName middleName lastName
-          ].include?(name.downcase)
-        end
-      end
-      alias_method :search_team_member, :search_employee
-
-      def search_employee!(name)
-        employee = search_employee(name)
-        raise EmployeeNotFoundError, "No employee found with name #{name}" if employee.nil?
-
-        employee
-      end
-      alias_method :search_team_member!, :search_employee!
-
-      def search_employee_by_field(field:, value:)
-        employees.find { |employee| employee[field] == value.to_s }
-      end
-      alias_method :search_team_member_by_field, :search_employee_by_field
-
-      def search_employee_by_field!(field:, value:)
-        employee = search_employee_by_field(field: field, value: value)
-        raise EmployeeNotFoundError, "No employee found with #{field}: #{value}" if employee.nil?
-
-        employee
-      end
-      alias_method :search_team_member_by_field!, :search_employee_by_field!
-
-      # Find the associated team member without checking case on the 'workEmail' field.
-      def search_team_member_by_email(email)
-        team_members.find { |team_member| team_member['workEmail']&.downcase == email&.downcase }
-      end
-      alias_method :slack_email_lookup_with_fallback, :search_team_member_by_email
-
-      def search_team_member_by_email!(email)
-        team_member = search_team_member_by_email(email)
-        raise EmployeeNotFoundError, "No team member found with email #{email}." unless team_member
-
-        team_member
-      end
-      alias_method :slack_email_lookup_with_fallback!, :search_team_member_by_email!
-
-      def team_members_by_department(department)
-        active_and_current_team_members.select { |team_member| team_member['department'] == department }
-      end
-
-      def team_members_by_division(division)
-        active_and_current_team_members.select { |team_member| team_member['division'] == division }
-      end
-
-      def fetch_manager(team_member)
-        active_team_members.find { |tm| tm['employeeNumber'] == team_member['supervisorId'] }
-      end
-
-      def fetch_manager!(team_member)
-        manager = fetch_manager(team_member)
-        raise EmployeeNotFoundError, "Manager not found for employee #{team_member['employeeNumber']}" if manager.nil?
-
-        manager
-      end
-
-      def fetch_second_level_manager(team_member)
-        fetch_manager(fetch_manager(team_member))
-      end
-
-      def fetch_second_level_manager!(team_member)
-        manager = fetch_second_level_manager(team_member)
-        raise EmployeeNotFoundError, "No second level manager found for employee #{team_member['employeeNumber']}" if manager.nil?
-
-        manager
-      end
-
-      def create_employee(employee_details_hash)
-        invalidate_cache
-        retry_on_error { @client.employee.add(employee_details_hash) }
-      end
-      alias_method :create_team_member, :create_employee
-
-      def update_employee(employee_number, employee_details_hash)
-        id = bamboo_id!(employee_number)
-        invalidate_cache
-        retry_on_error { @client.employee.update(id, employee_details_hash) }
-      end
-      alias_method :update_team_member, :update_employee
-
-      def locations
-        meta_fields.detect { |res| res['name'] == 'Location' }['options'].each_with_object([]) { |option, array| array << option['name'] if option['archived'] == 'no' } || []
-      end
-
-      def employees
-        return @employees unless @employees.nil?
-
-        report = retry_on_error do
-          if @use_report
-            @client.report.find(@use_report, 'JSON', true)
-          else
-            @client.report.custom(fields, 'JSON')
-          end
-        end
-
-        filtered = report.reject { |team_member| team_member['lastName'] == 'Test-Gitlab' }
-        @employees = filtered.map { |team_member| format_team_member(team_member) }
-      end
-      alias_method :team_members, :employees
-
-      def active_employees
-        employees.select { |employee| employee['status'] == 'Active' }
-      end
-      alias_method :active_team_members, :active_employees
-
-      def active_and_current_employees
-        today = Date.current
-        employees.select do |employee|
-          employee['status'] == 'Active' && Date.parse(employee['hireDate']) <= today
-        end
-      end
-      alias_method :active_and_current_team_members, :active_and_current_employees
-
-      def add_stock_options(employee_number, data)
-        id = bamboo_id!(employee_number)
-        retry_on_error { @client.employee.add_table_row(id, 'customEquity', data) }
-      end
-
-      def add_job_details(employee_number, data)
-        id = bamboo_id!(employee_number)
-        retry_on_error { @client.employee.add_table_row(id, 'jobInfo', data) }
-      end
-
-      def update_job_details(employee_number, data)
-        id = bamboo_id!(employee_number)
-        current_data = job_details(employee_number) # it should only be one row as we just created this user
-        row_id = current_data.first['id']
-        retry_on_error { @client.employee.update_table_row(id, 'jobInfo', row_id, data) }
-      end
-
-      def add_compensation_details(employee_number, data)
-        id = bamboo_id!(employee_number)
-        retry_on_error { @client.employee.add_table_row(id, 'compensation', data) }
-      end
-
-      def employment_statuses(employee_number)
-        id = bamboo_id!(employee_number)
-        retry_on_error { @client.employee.table_data(id, 'employmentStatus') }
-      end
-
-      def time_off_type(name)
-        time_off_types['timeOffTypes'].find { |type| type['name'] == name }
-      end
-
-      def time_off_adjustment(employee_number, options)
-        id = bamboo_id!(employee_number)
-        retry_on_error { @client.employee.time_off_balance_adjustment(id, options) }
-      end
-
-      def accrued_days(employee_number)
-        employee_accruals_type = time_off_type('Employee Accruals')
-        total_accruals = time_off_estimate(employee_number).find { |type| type['timeOffType'] == employee_accruals_type['id'] }
-
-        total_accruals['balance'].to_f
-      end
-
-      def time_off_policies
-        @time_off_policies ||= retry_on_error { @client.meta.time_off_policies }
-      end
-
-      def employee_time_off_policies(employee_number)
-        id = bamboo_id!(employee_number)
-        retry_on_error { @client.employee.time_off_policies(id) }
-      end
-      alias_method :team_member_time_off_policies, :employee_time_off_policies
-
-      def add_time_off_policy(employee_number, time_off_policy_id, accrual_start_date)
-        policies = [{ timeOffPolicyId: time_off_policy_id, accrualStartDate: accrual_start_date }]
-        id = bamboo_id!(employee_number)
-
-        retry_on_error { @client.employee.add_time_off_policies(id, policies) }
-      end
-
-      def remove_time_off_policy(employee_number, time_off_policy_id)
-        # A nil accrual start date removes a policy assignment
-        # Reference: https://documentation.bamboohr.com/reference#time-off-assign-time-off-policies-for-an-employee
-        add_time_off_policy(employee_number, time_off_policy_id, nil)
-      end
-
-      def job_details(employee_number)
-        id = bamboo_id!(employee_number)
-        retry_on_error { @client.employee.table_data(id, 'jobInfo') }
-      end
-
-      def resumes_folder_id(employee_number)
-        @resumes_folder_id ||= files(employee_number)['categories'].find { |folder| folder['name'] == 'Resumes and Applications' }['id']
-      end
-
-      def contract_folder_id(employee_number)
-        @contract_folder_id ||= files(employee_number)['categories'].find { |folder| folder['name'] == 'Contracts & Changes' }['id']
-      end
-
-      def add_file(employee_number, file_name, file, folder_id)
-        id = bamboo_id!(employee_number)
-
-        options = {
-          category: folder_id,
-          fileName: file_name,
-          share: 'yes',
-          file: file
-        }
-        retry_on_error { @client.employee.add_file(id, options) }
-      end
-
-      def add_employment_status(employee_number, data)
-        id = bamboo_id!(employee_number)
-        retry_on_error { @client.employee.add_table_row(id, 'employmentStatus', data) }
-      end
-
-      def add_currency_conversion(employee_number, data)
-        id = bamboo_id!(employee_number)
-        retry_on_error { @client.employee.add_table_row(id, 'customCurrencyConversion', data) }
-      end
-
-      def add_on_target_earnings(employee_number, data)
-        id = bamboo_id!(employee_number)
-        retry_on_error { @client.employee.add_table_row(id, 'customOnTargetEarnings', data) }
-      end
-
-      def add_signing_bonus(employee_number, data)
-        id = bamboo_id!(employee_number)
-        retry_on_error { @client.employee.add_table_row(id, 'customBonus', data) }
-      end
-
-      def add_family_member(employee_number, data)
-        id = bamboo_id!(employee_number)
-        retry_on_error { @client.employee.add_table_row(id, 'customFamilyMember', data) }
-      end
-
-      def add_additional_data(employee_number, data)
-        id = bamboo_id!(employee_number)
-        retry_on_error { @client.employee.add_table_row(id, 'customAdditionalInformation1', data) }
-      end
-
-      def additional_data(employee_number)
-        id = bamboo_id!(employee_number)
-        retry_on_error { @client.employee.table_data(id, 'employmentStatus') }
-      end
-
-      def add_bonus(employee_number, comment)
-        team_member = search_employee_by_field(field: 'employeeNumber', value: employee_number)
-        data = {
-          customBonusdate: Date.today.to_s,
-          customBonusamount: { value: 1_000, currency: 'USD' },
-          customBonustype: 'Discretionary Bonus',
-          customBonuscomments: comment
-          # customNominatedBy: 'TODO'
-        }
-        retry_on_error { @client.employee.add_table_row(team_member['id'], 'customBonus', data) }
-      end
-
-      private
-
-      def fields
-        return @fields if @fields
-
-        meta_field_aliases = retry_on_error { @client.meta.fields }.map { |f| f['alias'] }
-        @fields = (Bamboozled::API::FieldCollection.all_names + meta_field_aliases).compact.uniq
-        @fields.delete('flsaCode') # temp fix for problems with BambooHR
-        @fields
-      end
-
-      def meta_fields
-        @meta_fields ||= retry_on_error { @client.meta.lists }
-      end
-
-      def time_off_types
-        @time_off_types ||= retry_on_error { @client.meta.time_off_types }
-      end
-
-      def time_off_estimate(employee_number, end_date = Date.today)
-        id = bamboo_id!(employee_number)
-        retry_on_error { @client.employee.time_off_estimate(id, end_date) }
-      end
-
-      def files(employee_number)
-        id = bamboo_id!(employee_number)
-        @files ||= retry_on_error { @client.employee.files(id) }
-      end
-
-      def retry_on_error(&block)
-        Utils.retry_on_error(errors: [Net::ReadTimeout, Bamboozled::GatewayError, Bamboozled::ServiceUnavailable], delay: 3, &block)
-      end
-
-      def invalidate_cache
-        @employees = nil
-      end
-
-      MALFORMED_FIELDS = [
-        'customExportName/LocationtoTeamPage?',
-        'customI-9Processed',
-        'customJobTitleSpecialty(Multi-Select)'
-      ].freeze
-
-      # Convert BHR team member to Workday.
-      def format_team_member(team_member)
-        return nil if team_member.nil?
-
-        {
-          **team_member.except(*MALFORMED_FIELDS),
-          'customExportNameLocationtoTeamPage' => team_member['customExportName/LocationtoTeamPage?'] || 'No',
-          'customJobTitleSpecialtyMultiSelect' => team_member['customJobTitleSpecialty(Multi-Select)'],
-          'customI9Processed' => team_member['customI-9Processed']
-        }
-      end
-    end
-  end
-end