standard_automation_library 0.2.1.pre.temp

data/lib/standard_automation_library/api_clients/slack.rb

@@ -0,0 +1,499 @@
+require 'slack-ruby-client'
+require 'yaml'
+require 'set'
+
+require_relative '../util/path_container'
+require_relative '../errors/slack_api_error'
+
+# Slack client to do what fastlane can't. Client used to send
+# messages so they can subsequently be updated.
+class SlackClient
+  NOT_FOUND = 'NOT_FOUND'.freeze
+
+  def initialize(api_token, userid_mapping_file_path_container = nil, valid_email_suffixes = [], is_dry_run: false)
+    @client = Slack::Web::Client.new(token: api_token)
+    @userid_mapping_file_path_container = userid_mapping_file_path_container
+    @valid_email_suffixes = valid_email_suffixes
+    @is_dry_run = is_dry_run
+    @team_domain = nil
+    @channel_name_id_cache = {}
+    @user_id_cache = {}
+  end
+
+  attr_accessor :client
+
+  def team_domain
+    @team_domain ||= @client.team_info['team']['domain']
+    @team_domain
+  end
+
+  # Attempt to find user_ids from a list of names or display names.
+  # This method will return a list of the same size with the
+  # resolved user_ids in the same index position(s) in the supplied list.
+  # Slack IDs that could not be found or are ambiguous will have a nil output in the returned lists.
+  # Entries from the userid_mapping_file will take precedence.
+  #
+  # This method uses a cache and tries very hard to only iterate through every user in the workspace
+  # a only single time and only if necessary. Iterating through all users in a workspace is very slow.
+  # Use user_ids_from_emails for faster performance if possible.
+  def user_ids_from_names(names)
+    load_cache_from_userid_map
+
+    output_user_ids = Array.new(names.size)
+
+    normalized_names = names.map { |name| safe_unicode_normalize(name).downcase }
+
+    # Get the list of names that aren't in the cache.
+    # Put the user_ids that are in the cache into their final places in the output array.
+    cache_miss_names = normalized_names.each_with_index.map do |name, index|
+      cached_user_id = @user_id_cache[name]
+      if cached_user_id
+        output_user_ids[index] = cached_user_id
+        nil
+      else
+        name
+      end
+    end.compact
+
+    unless cache_miss_names.empty?
+      cache_miss_names_hash = cache_miss_names.each_with_object({}) { |element, hash| hash[element] = nil }
+
+      @client.users_list(limit: 1000) do |response_page|
+        raise "Error getting slack user list: #{response_page['error']}" unless response_page['ok']
+
+        response_page['members'].each do |member_json|
+          next if member_json['deleted']
+
+          profile_json = member_json['profile']
+
+          # If the name of the person we're interating on is one of interest then attempt to put the id in the hash
+          # If the id has already been added then we know we've found an ambiguous name so we mark that with a value
+          # of -1
+          real_name = profile_json['real_name'].downcase
+          display_name = profile_json['display_name'].downcase
+          if cache_miss_names_hash.key?(real_name)
+            cache_miss_names_hash[real_name] = if cache_miss_names_hash[real_name].nil?
+                                                 member_json['id']
+                                               else
+                                                 -1
+                                               end
+          elsif cache_miss_names_hash.key?(display_name)
+            current_cache_value = cache_miss_names_hash[display_name]
+            cache_miss_names_hash[display_name] = if current_cache_value.nil?
+                                                    member_json['id']
+                                                  else
+                                                    -1
+                                                  end
+          end
+        end
+      end
+
+      cache_miss_names_hash.each do |key, value|
+        next if value.nil? || value == -1
+
+        # indexes of matching elements in the input list
+        indexes = normalized_names.map.with_index { |_val, i| i }.select do |i|
+          normalized_names[i] == key
+        end
+        indexes.each { |i| output_user_ids[i] = value }
+        @user_id_cache[key] = value
+      end
+    end
+
+    output_user_ids
+  end
+
+  # This method expects the userid_mapping_file_path be a yaml file with a certain structure.
+  # A toplevel map where each key is the domain name of the workspace. The value of that is
+  # another map where the keys are identifiers (names, email addresses, etc) and the values
+  # are slack userids.
+  def load_cache_from_userid_map
+    userid_mapping_file_path = @userid_mapping_file_path_container&.path
+    return if userid_mapping_file_path.nil?
+
+    all_slack_workspaces = File.open(userid_mapping_file_path) { |f| YAML.safe_load(f) }
+    mapping_for_team = all_slack_workspaces.fetch(team_domain, [])
+    mapping_for_team.each do |key, value|
+      @user_id_cache[key.downcase] = value
+    end
+  end
+
+  # Finds user id's via email lookups. Much faster than searching for someone
+  # by name. Returns an array of the same length. This array contains resolved
+  # user_ids or nil in the same index of the array for the input email address.
+  def user_ids_from_emails(email_addresses)
+    load_cache_from_userid_map
+    email_addresses.map do |email_address|
+      cache_key = email_address.downcase
+      if @user_id_cache[cache_key]
+        @user_id_cache[cache_key]
+      else
+        begin
+          user_id = @client.users_lookupByEmail(email: email_address)['user']['id']
+          @user_id_cache[cache_key] = user_id
+          user_id
+        rescue StandardError => e
+          raise e unless e.message.include?('users_not_found')
+
+          nil
+        end
+      end
+    end
+  end
+
+  # This is the preferred entry point for finding user ids. The input is a list of names or email addresses.
+  # This method will return a list the same size as the input list with all possible user_ids resolved.
+  # Unresolved user identifiers in the input list will have a nil value in the returned list. Optionally raise an
+  # error if the input list does not have the same amount of non-nil outputs as it does inputs.
+  #
+  # Process input email addresses by searching for both the input email address and emails constructed by
+  # appending the valid_suffixes on them. If we get back a single user_id then we found a match.
+  #
+  # Process non-email addresses by first forming them into email addresses and searching as emails. This is
+  # much faster than searching over all users so do this first.
+  #
+  # If there are still unidentified users then search over all slack users for a match. Only unambiguous matches
+  # are returned.
+  def user_ids(user_identifiers, error_if_not_found: false)
+    load_cache_from_userid_map
+
+    output_list = Array.new(user_identifiers.size)
+
+    user_identifiers_downcase = user_identifiers.compact.map(&:downcase)
+
+    names_email_miss = []
+    user_identifiers_downcase.each_with_index do |user_identifier, index|
+      if @user_id_cache[user_identifier]
+        output_list[index] = @user_id_cache[user_identifier]
+      elsif user_identifier.include?('@')
+        # process email addresses separately.
+        fuzzed_email_addresses = @valid_email_suffixes.map do |email_suffix|
+          "#{user_identifier.split('@')[0]}@#{email_suffix}"
+        end
+        fuzzed_email_addresses << user_identifier
+        email_user_ids = user_ids_from_emails(fuzzed_email_addresses.uniq).compact
+        output_list[index] = email_user_ids[0] if email_user_ids.size == 1
+      else
+        email_prefix = name_to_email_prefix(user_identifier)
+        name_email_addresses = @valid_email_suffixes.map { |email_suffix| "#{email_prefix}@#{email_suffix}" }
+        name_email_user_ids = user_ids_from_emails(name_email_addresses.uniq).compact
+        if name_email_user_ids.size == 1
+          output_list[index] = name_email_user_ids[0]
+        else
+          names_email_miss << user_identifier
+        end
+      end
+    end
+
+    names_email_miss_uniq = names_email_miss.uniq
+    name_user_ids = user_ids_from_names(names_email_miss_uniq)
+    name_user_ids.each_with_index do |user_id, index|
+      next if user_id.nil?
+
+      name = names_email_miss_uniq[index]
+      indexes = user_identifiers_downcase.map.with_index { |_val, i| i }.select do |i|
+        user_identifiers_downcase[i] == name
+      end
+      indexes.each { |i| output_list[i] = user_id }
+    end
+
+    if error_if_not_found
+      users_not_found = output_list.each_with_index.map do |user, index|
+        user_identifiers_downcase[index] if user.nil?
+      end.compact.uniq
+      raise "Not all slack user_ids found for input list: #{users_not_found}" unless users_not_found.empty?
+    end
+    output_list
+  end
+
+  # Format name into an email address prefix and convert special characters to their ascii
+  # equivalents since characters like á (which becomes a) don't show up up in email addresses.
+  # Also be sure to remove anything that is not lowercase letters and periods from the email
+  # prefix.
+  def name_to_email_prefix(name)
+    normalized_name = safe_unicode_normalize(name, :nfkd).encode('ASCII', replace: '')
+    email_prefix = normalized_name.strip.split.map(&:downcase).join('.')
+    email_prefix.gsub(/[^a-z.]/, '')
+  end
+
+  # update slack channel topic
+  def set_channel_topic(channel_name, new_topic)
+    channel_ids = unique_channel_ids([channel_name])
+    raise "Cannot find channel with name #{channel_name}" if channel_ids.empty?
+
+    channel_id = channel_ids[0]
+    if @is_dry_run
+      puts "Would have set topic of channel #{channel_id} to '#{new_topic}'"
+    else
+      @client.conversations_setTopic(channel: channel_id, topic: new_topic)
+    end
+  end
+
+  # Get a channel's current topic
+  def channel_topic(channel_name)
+    channel_ids = unique_channel_ids([channel_name])
+    raise "Cannot find channel with name #{channel_name}" if channel_ids.empty?
+
+    channel_id = channel_ids[0]
+    response = @client.conversations_info(channel: channel_id)
+    response['channel']['topic']['value']
+  end
+
+  def channel_members(channel)
+    channel_id = unique_channel_ids([channel])[0]
+    raise "Cannot find channel with name #{channel}" if channel_id.nil?
+
+    all_members = []
+    @client.conversations_members(channel: channel_id) do |response_page|
+      raise "Error getting slack conversation members: #{response_page['error']}" unless response_page['ok']
+
+      all_members += response_page['members']
+    end
+    all_members
+  end
+
+  def invite_to_channel_if_needed(channel, users_to_invite)
+    return if users_to_invite.empty?
+
+    channel_id = unique_channel_ids([channel])[0]
+    raise "Cannot find channel with name #{channel}" if channel_id.nil?
+
+    current_member_ids = channel_members(channel_id)
+    member_id_set = Set.new(current_member_ids)
+
+    users_to_invite.reject! { |user_id| member_id_set.include?(user_id) }
+    return if users_to_invite.empty?
+
+    if @is_dry_run
+      puts "Would have invited users #{users_to_invite} to channel #{channel}"
+    else
+      @client.conversations_invite(channel: channel_id, users: users_to_invite.join(','))
+    end
+  end
+
+  # Send a message to a slack channel or user_id.
+  # Get user_id from matching_user_ids, user_id_from_email or slack_user_ids in slack_service.
+  def send_message(channel_name: nil, user_id: nil, message: nil, attachments: nil, icon_url: nil)
+    raise 'Must supply one of new_message or attachments to send a slack message' if message.nil? && attachments.nil?
+
+    raise 'Must supply one of channel_name or user_id' if channel_name.nil? && user_id.nil?
+
+    options = {}
+    if user_id
+      options[:channel] = user_id
+    elsif channel_name
+      channel_ids = unique_channel_ids([channel_name])
+      raise "Cannot find channel with name #{channel_name}" if channel_ids.empty?
+
+      options[:channel] = channel_ids[0]
+    end
+    options[:text] = message unless message.nil?
+    options[:attachments] = attachments unless attachments.nil?
+    options[:icon_url] = icon_url unless icon_url.nil?
+
+    if @is_dry_run
+      puts "Would have sent message with options: #{options}"
+    else
+      response_json = @client.chat_postMessage(options)
+      raise SlackAPIError, "Error sending message: #{response_json['error']}" unless response_json['ok']
+    end
+  end
+
+  # Sends an initial message and makes it a thread for the additional messages formatted as Slack API blocks
+  # For an example of formatted_reply_blocks see bugsnag_service.make_slack_block_from_bugsnag_error()
+  def send_messages_in_thread(channel_name, initial_message, formatted_reply_blocks)
+    channel_ids = unique_channel_ids([channel_name])
+    raise "Cannot find channel with name #{channel_name}" if channel_ids.empty?
+
+    initial_options = { channel: channel_ids[0], text: initial_message }
+    if @is_dry_run
+      puts "Would have sent message with options: #{initial_options}"
+      response_json = { ts: 'dry_run' }
+    else
+      response_json = @client.chat_postMessage(initial_options)
+      raise SlackAPIError, "Error sending initial thread message: #{response_json['error']}" unless response_json['ok']
+    end
+
+    formatted_reply_blocks.each do |reply|
+      reply_options = {
+        channel: channel_name,
+        thread_ts: response_json['ts'],
+        blocks: reply
+      }
+
+      if @is_dry_run
+        puts "Would have sent reply with options: #{reply_options}"
+      else
+        reply_json = @client.chat_postMessage(reply_options)
+        raise "Error sending thread reply: #{reply_json['error']}" unless reply_json['ok']
+      end
+    end
+  end
+
+  # update previously sent message in a channel.
+  # Send new message if previous one isn't found or fail if fail_if_message_not_found.
+  def update_or_send_message(
+    channel_name,
+    message_identifying_content,
+    new_message: nil,
+    attachments: nil,
+    icon_url: nil,
+    fail_if_message_not_found: false,
+    historical_lookup_count: 100
+  )
+    error_message = 'Must supply one of new_message or attachments to update a slack messages'
+    raise error_message if new_message.nil? && attachments.nil?
+
+    channel_ids = unique_channel_ids([channel_name])
+    channel_id = channel_ids[0]
+
+    raise "Cannot find channel #{channel_name}" if channel_id.nil?
+
+    timestamp = old_message_timestamp(
+      channel_id,
+      message_identifying_content,
+      options: { limit: historical_lookup_count }
+    )
+
+    options = {
+      channel: channel_id
+    }
+    options[:text] = new_message unless new_message.nil?
+    options[:attachments] = attachments unless attachments.nil?
+    error_message = "Slack message with identifying content not found: '#{message_identifying_content}'"
+    raise error_message if timestamp.nil? && fail_if_message_not_found
+
+    if timestamp.nil?
+      options[:icon_url] = icon_url unless icon_url.nil?
+      if @is_dry_run
+        puts "Would have sent message with options: #{options}"
+        response_json = { 'ok' => true }
+      else
+        response_json = @client.chat_postMessage(options)
+      end
+    else
+      options[:ts] = timestamp
+      if @is_dry_run
+        puts "Would have updated message with options: #{options}"
+        response_json = { 'ok' => true }
+      else
+        response_json = @client.chat_update(options)
+      end
+    end
+    raise SlackAPIError, "Error updating message: #{response_json['error']}" unless response_json['ok']
+  end
+
+  # Given a list of channel strings, a mix of channel names and channel ID's,
+  # we want to find all the unique channel ID's that all of those strings represent.
+  # First, look in the cache for any precomputed ID's and add those to the final list.
+  # Divide non cached entries into channel ID's and channel names. Hitting the conversations_info
+  # API tells us quickly if that channel ID exists or not. Finally, we iterate through all
+  # channels once to find all of the channel ID's that match any channel names supplied.
+  # Iterating through all channels is by far the slowest part so only do this if necessary.
+  # This method will only return valid channel ID's so the returned list may be shorter
+  # than the input list of channel strings.
+  def unique_channel_ids(channel_strings)
+    unique_channel_ids = []
+    channel_ids = []
+    channel_names = []
+
+    channel_strings.each do |channel_string|
+      cache_result = @channel_name_id_cache[channel_string]
+      unless cache_result.nil?
+        unique_channel_ids << cache_result unless cache_result == NOT_FOUND
+        next
+      end
+
+      if channel_string =~ /^[A-Z0-9]+$/
+        channel_ids << channel_string
+      else
+        channel_names << channel_string
+      end
+    end
+
+    channel_ids.each do |channel_id|
+      # if the channel id doesn't exist then conversations_info will
+      # throw an exception
+      @client.conversations_info(channel: channel_id)
+      unique_channel_ids << channel_id
+      @channel_name_id_cache[channel_id] = channel_id
+    rescue StandardError => e
+      raise e unless e.message.include?('channel_not_found')
+
+      @channel_name_id_cache[channel_id] = NOT_FOUND
+    end
+
+    unless channel_names.empty?
+      channels_found = []
+      @client.conversations_list(
+        types: 'public_channel,private_channel',
+        limit: 1000,
+        exclude_archived: true
+      ) do |response_page|
+        raise "Error getting slack channel list: #{response_page['error']}" unless response_page['ok']
+
+        response_page['channels'].each do |channel_json|
+          channel_names.each do |channel_name|
+            next if channel_json['name'] != channel_name
+
+            @channel_name_id_cache[channel_name] = channel_json['id']
+            unique_channel_ids << channel_json['id']
+            channels_found << channel_name
+          end
+        end
+        # don't continue iterating if we've found all the channel names
+        break if channels_found.size == channel_names.size
+      end
+
+      channels_names_not_found = channel_names - channels_found
+      channels_names_not_found.each do |not_found_channel|
+        @channel_name_id_cache[not_found_channel] = NOT_FOUND
+      end
+    end
+    unique_channel_ids.uniq
+  end
+
+  # Find the timestamp of a message in a given channel containing the message_identifying text
+  # Return the timestamp of the first message encountered satisfying the criteria starting from
+  # the most recent message in the channel. Only look at the most recent 100 messages by default. If no
+  # message is found return nil.
+  def old_message_timestamp(channel_identifier, message_identifying_content, options: {})
+    channel_ids = unique_channel_ids([channel_identifier])
+    channel_id = channel_ids[0]
+    raise "Cannot find channel #{channel_identifier}" if channel_id.nil?
+
+    response_json = @client.conversations_history({ channel: channel_id }.merge(options))
+    error_message = "Error getting slack channel history for channel id #{channel_id}: #{response_json['error']}"
+    raise error_message unless response_json['ok']
+
+    response_json['messages'].each do |message_json|
+      next unless message_json['type'] == 'message'
+
+      return message_json['ts'] if message_includes_content(message_json, message_identifying_content)
+    end
+    nil
+  end
+
+  # determine if a message contains a certain snippet of content.
+  # A message has a text field but it can also have multiple attachments.
+  # An attachment can have text in the fallback, pretext, title, and text fields
+  # so check all of those fields for each attachment in addition to the main message
+  # text field. Return true if the message identifying content appears in
+  # any of those fields in a message.
+  def message_includes_content(message_json, message_identifying_content)
+    message_json.fetch('text', '').include?(message_identifying_content) ||
+      message_json.fetch('attachments', []).flat_map do |attachment|
+        %w[pretext fallback text title].map do |key|
+          attachment.fetch(key, '').include?(message_identifying_content)
+        end
+      end.any?
+  end
+
+  def safe_unicode_normalize(string, normalize_options = :nfc)
+    string.unicode_normalize(normalize_options)
+  rescue StandardError => e
+    raise e unless e.message.include?('Unicode Normalization not appropriate')
+
+    string
+  end
+end

data/lib/standard_automation_library/danger/danger_jira.rb

@@ -0,0 +1,169 @@
+require 'danger'
+
+require_relative '../util/shared_constants'
+
+NEXT_GEN = 'next-gen'.freeze
+
+module DangerChecks
+  # JIRA related Danger checks
+  class JIRA
+    def initialize(
+      dangerfile,
+      jira_service,
+      platform_service,
+      slack_channels = [],
+      slack_service = nil,
+      max_number_of_issues = 10
+    )
+      @dangerfile = dangerfile
+      @jira_service = jira_service
+      @platform_service = platform_service
+      @slack_channels = slack_channels
+      @slack_service = slack_service
+      @max_number_of_issues = max_number_of_issues
+    end
+
+    # Attempts to modify all JIRA issues referenced in the commit messages of a pull request.
+    # Only pull requests targeting whitelisted_branches will be operated on. Merge commit messages
+    # are ignored. Add a fix version to the ticket which is the version of the app in the target branch.
+    # Also, modify the `OS Platform` field to the platform of the app as returned by platform_service.platform.
+    #
+    # @param whitelisted_target_branches [List]. List of whitelisted target branches that determine if this automation
+    # is run.
+    def execute(whitelisted_target_branches)
+      source_branch = @dangerfile.github.pr_json['head']['ref']
+      target_branch = @dangerfile.github.pr_json['base']['ref']
+      starts_with_automerge_prefix = source_branch.start_with?(SharedConstants::AUTOMERGE_BRANCH_PREFIX)
+      is_not_valid_target_branch = !whitelisted_target_branches.include?(target_branch)
+      if starts_with_automerge_prefix || is_not_valid_target_branch
+        puts 'The source and target branches of this PR do not meet the criteria for JIRA automation.'
+        return
+      end
+
+      filtered_project_keys = @jira_service.filtered_project_keys
+      if filtered_project_keys.empty?
+        @dangerfile.warn('Cannot connect to JIRA server. Skipping issue automation.')
+        return
+      end
+      all_git_commits = @dangerfile.git.commits
+      pr_number = @dangerfile.github.pr_json['number']
+      puts "ALL NON-MERGE COMMITS in PR #{pr_number}"
+      non_merge_commits = all_git_commits.map do |commit|
+        next if commit.parents.size > 1 # Don't process merge commits.
+
+        puts "#{commit}: #{commit.message}"
+        commit
+      end.compact
+
+      return if @dangerfile.github.pr_json['title'].match?(/\b(wip)\b/i)
+
+      jira_issue_references = non_merge_commits.flat_map do |commit|
+        @jira_service.find_issue_references_in_text(commit.message, filtered_project_keys)
+      end.uniq.compact.reject { |issue| commit.message.include?("!#{issue}") || commit.message.match?(/\b(wip)\b/i) }
+      puts "All JIRA issue references: #{jira_issue_references}"
+
+      if jira_issue_references.size > @max_number_of_issues
+        message = "More than #{@max_number_of_issues} JIRA issue references detected by danger in PR #{pr_number}. " \
+                  'Not modifying JIRA issues.'
+        @dangerfile.warn(message)
+        if !@slack_service.nil? && !@slack_channels.empty?
+          @slack_service.send_message(
+            channel_strings: @slack_channels,
+            message: message + " #{@dangerfile.github.pr_json['html_url']}"
+          )
+        end
+        return
+      end
+
+      fix_version = @platform_service.app_version(@platform_service.remote_branch(@dangerfile.github.branch_for_base))
+
+      jira_issue_references.each do |jira_issue_reference|
+        jira_issue = @jira_service.issue(jira_issue_reference)
+        if jira_issue.nil?
+          @dangerfile.warn("JIRA issue #{jira_issue_reference} does not exist.")
+          next
+        end
+
+        project_key = jira_issue.project_key
+        unless filtered_project_keys.include?(project_key)
+          puts "Project key #{project_key} is not valid. Skipping issue #{jira_issue_reference}"
+          next
+        end
+
+        manage_platform(jira_issue, @platform_service.platform_name)
+
+        jira_project = @jira_service.project(jira_issue.project_key)
+        if jira_project.nil?
+          @dangerfile.warn("Cannot find JIRA project with key #{jira_issue.project_key}")
+          next
+        end
+        manage_fix_version(jira_issue, jira_project, fix_version)
+      end
+    end
+
+    def manage_fix_version(jira_issue, jira_project, fix_version)
+      # Skip if issue already has fix version
+      if jira_issue.fix_version?(fix_version)
+        puts "Issue #{jira_issue.key} already has fix version #{fix_version}"
+        return
+      end
+
+      if jira_project.style == NEXT_GEN
+        @dangerfile.warn("Fix version #{fix_version} cannot be added to JIRA issue #{jira_issue.key} " \
+                         "because project #{jira_project.key} is a next-gen project and does not have fix versions.")
+        return
+      end
+
+      # if the project doesn't have the fix version add it to the project
+      if !jira_project.fix_version?(fix_version) && !jira_project.add_fix_version(fix_version)
+        @dangerfile.warn(
+          "Failed to add fix version #{fix_version} to JIRA project #{jira_project.key}. " \
+          "Ensure that `#{@jira_service.username}` is an administrator of that project."
+        )
+        return
+      end
+
+      preexisting_fix_versions = jira_issue.fix_versions
+
+      # then add the fix version to the issue.
+      unless jira_issue.add_fix_version(fix_version)
+        @dangerfile.warn("Failed to add fix version #{fix_version} to JIRA issue #{jira_issue.key}.")
+        return
+      end
+
+      return if preexisting_fix_versions.empty?
+
+      preexisting_fix_versions << fix_version
+      sorted_versions = preexisting_fix_versions.sort
+      @dangerfile.warn("JIRA issue #{jira_issue.key} has multiple fix versions: #{sorted_versions.join(', ')}")
+    end
+
+    def manage_platform(jira_issue, platform_name)
+      # we want to manage both the OS Platform field, which we're moving away from, and
+      # the Platform field. Do not warn if the OS Platform field does not exist on an issue.
+      { 'Platform' => 'array', 'OS Platform' => 'option' }.each do |field_name, field_type|
+        platform_data = jira_issue.custom_field_data(field_name)
+        platform_already_added = false
+        if platform_data
+          platform_already_added = if field_type == 'array'
+                                     platform_data.any? { |item| item['value'] == platform_name }
+                                   else
+                                     platform_data['value'] == platform_name
+                                   end
+        end
+
+        if platform_already_added
+          puts "Issue #{jira_issue.key} already has '#{field_name}' #{platform_name}"
+        else
+          failed_to_modify_platform = "Failed to modify '#{field_name}' field for JIRA " \
+                                      "issue #{jira_issue.key} to #{platform_name}."
+          @dangerfile.warn(failed_to_modify_platform) unless jira_issue.update_custom_field(field_name, platform_name)
+        end
+      rescue StandardError => e
+        puts e.message
+        do_not_warn = e.message.include?('No such field exists') && field_name == 'OS Platform'
+        @dangerfile.warn(e.message) unless do_not_warn
+      end
+    end
+  end
+end

data/lib/standard_automation_library/errors/slack_api_error.rb

@@ -0,0 +1,6 @@
+# Error created to identify Slack API problems
+class SlackAPIError < StandardError
+  def initialize(message = 'There was an error with the Slack API')
+    super
+  end
+end