fastlane-plugin-slack_bot 0.1.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84150b4d8bfe68f61b291cc1fc396fda4433d946eac7ab1e20a59f64bdb09c28
-  data.tar.gz: 35388a239d7fea67abd814b89dd4221a93512f484005856a929f60bf3b5d442f
+  metadata.gz: 4f2aabbc8c122fde9ab66c2f19a43ee068eeb1905fe71676b58f3f97615df758
+  data.tar.gz: 2f14989f7e4afcf43fd873748b385bb9fb30c5e8b419d4c4ad35b5f910dedd8b
 SHA512:
-  metadata.gz: 9fc6ea47846538f9d50ac3993933a178bcdc0d121b4f0cc6e66a1064b957acc768e837f5b7f6468eef569dddb735761c0cdfe04d608aaad61da0c806e0f2f7cf
-  data.tar.gz: eb2ad02684ebeba9c283990ccc35767cb307aeb174512e0a46dc5db6773e58e8c9897ccedc1235923bbec0153f5c575d9e0b3d27ada869f91c4afbf972528b49
+  metadata.gz: 4aa6547bd6c2d4b3f4275be0296027171e1e4f47e90540bd676e1adedc92840bc5945972e1462ada73f1a30eabf8ba7eeebaf9d46e76205d81053bc2595ceb3b
+  data.tar.gz: 15a515660c49d9ca4b7d9de700c4212692402c05d53feba5b039fadc82c00f7bf03fcd6255b8467c659ef8545028f823723ef3e30cde8efbd7144fc1b1e8ebfc

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2020 Manish Rathi <m.rathi@catawiki.nl>
+Copyright (c) 2021 Manish Rathi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,15 +1,34 @@
 ## Fastlane `slack_bot` plugin
 
 [![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-slack_bot)
-
-## About slack_bot
-
-A fastlane plugin to post slack message using bot api token. 🚀
-Note: `Fastlane` comes with `slack` plugin by default, which uses slack webhook url, which can't send direct message & other limitations.
+![![License]](https://img.shields.io/badge/license-MIT-green.svg?style=flat)
+[![Gem Version](https://badge.fury.io/rb/fastlane-plugin-slack_bot.svg)](https://badge.fury.io/rb/fastlane-plugin-slack_bot)
+![![RubyGem Download Badge]](https://ruby-gem-downloads-badge.herokuapp.com/fastlane-plugin-slack_bot?type=total)
+[![Twitter: @manish](https://img.shields.io/badge/contact-@manish-blue.svg?style=flat)](https://twitter.com/manish_rathi_)
+
+A fastlane plugin to customize your automation workflow(s) with a **Slack Bot** 🤖 using the [Slack APIs](https://api.slack.com/)
+
+- [About](#about)
+- [Getting Started](#getting-started)
+- [Features](#features)
+- [Post a message](#examples-post-a-message) examples
+- [Upload a file](#examples-upload-a-message) examples
+- [About Fastlane](#about-fastlane)
+
+## About
+
+A fastlane plugin to post slack message and much more using Slack bot api token. 🚀\
+**Note:** `Fastlane` comes with built-in `slack` action by default, which uses slack webhook url and have webhook limitations.  
+i.e Listing couple of slack **webhook url** limitations:
+- can't post a direct message to a slack user.
+- can’t post a message inside a slack thread.
+- can’t update a posted slack message.
+- can’t list and upload a file inside a slack channel.
+- much more, compare to a **Slack Bot** 🤖 using the [Slack APIs](https://api.slack.com/)
 
 ## Getting Started
 
-1. Generate `Slack token` for `Fastlane` bot
+1. [Generate `Slack token` for `Fastlane` bot](https://slack.com/intl/en-nl/help/articles/115005265703-Create-a-bot-for-your-workspace)
     - From your Slack organization page, go to `Manage` -> `Custom Integrations`
     - Open `Bots`
     - Add Configuration
@@ -23,43 +42,197 @@ fastlane add_plugin slack_bot
 ```
 If you are using fastlane using Gemfile in your project, add it to your project by running:
 ```bash
-bundle exec fastlane add_plugin slack_bot 
+bundle exec fastlane add_plugin slack_bot
 ```
 
-3. Add `slack_bot` to your lane in `Fastfile` whenever you want to post a slack message
+3. Use `slack_bot` features inside your lane in `Fastfile` whenever you want.
+
+## Features
+Using this `slack_bot` plugin, you can:
+
+- Post a message using [chat.postMessage](https://api.slack.com/methods/chat.postMessage) Slack API
+  - [x] Post a message to a _public_ channel
+  - [x] Post a message to a _private_ channel
+  - [x] Post a message to a _slack user_ (DM)
+  - [x] Post a message inside a _slack thread_ 🧵  (DM)
+
+- Update a message using [chat.update](https://api.slack.com/methods/chat.update) Slack API
+  - [x] update a message in a channel
+
+- List of files in a channel using [files.list](https://api.slack.com/methods/files.list) Slack API
+  - [x] A list of files in a channel, It can be filtered and sliced in various ways.
+
+- Upload a file using [files.upload](https://api.slack.com/methods/files.upload) Slack API
+  - [x] Upload a file to a _public_ channel
+  - [x] Upload a file to a _private_ channel
+  - [x] Upload a file to a _slack user_ (DM)
+  - [x] Upload a file inside a _slack thread_ 🧵  (DM)
+  - [x] Upload a file with multiple channels/users
+
 
-In the following example lets send slack message to `#ios-team` channel for test-flight build.
+## Examples (Post a message)
+
+Let’s post a message to the default slack bot channel.
+
+```ruby
+# share on Slack
+post_to_slack(message: "App successfully released!")
+```
+
+Let’s post a direct message to a slack user that unit tests CI has been failed.
+
+```ruby
+# share on Slack
+post_to_slack(
+  message: "CI: Your unit tests on #{ENV['CI_COMMIT_REF_NAME']} failed",
+  channel: "@SlackUsername" # This can be Slack userID, instead of username i.e @UXXXXX
+)
+```
+
+Let’s post a slack message to the `#ios-team` channel about the new test-flight build.
 
 ```ruby
 lane :beta do
   gym # Build the app and create .ipa file
   pilot # Upload build to TestFlight
-  
+
   version_number = get_version_number # Get project version
   build_number = get_build_number # Get build number
   beta_release_name = "#{version_number}-#{build_number}-beta-release"
-  
+
   # share on Slack
   post_to_slack(
-    api_token: "xyz", # Preferably configure as ENV['SLACK_API_TOKEN']
     message: "Hi team, we have a new test-flight beta build: #{beta_release_name}",
     channel: "#ios-team"
   )
 end
 ```
 
-## Issues and Feedback
+Let’s post a slack message with custom payload.
+
+```ruby
+# share on Slack
+post_to_slack(
+  api_token: "xyz", # Preferably configure as ENV['SLACK_API_TOKEN']
+  message: "App successfully released!",
+  channel: "#channel",  # Optional, by default will post to the default channel configured for the Slack Bot.
+  success: true,        # Optional, defaults to true.
+  payload: {  # Optional, lets you specify any number of your own Slack attachments.
+    "Build Date" => Time.new.to_s,
+    "Built by" => "Jenkins",
+  },
+  default_payloads: [:git_branch, :git_author], # Optional, lets you specify an allowlist of default payloads to include. Pass an empty array to suppress all the default payloads.
+        # Don't add this key, or pass nil, if you want all the default payloads. The available default payloads are: `lane`, `test_result`, `git_branch`, `git_author`, `last_git_commit`, `last_git_commit_hash`.
+  attachment_properties: { # Optional, lets you specify any other properties available for attachments in the slack API (see https://api.slack.com/docs/attachments).
+       # This hash is deep merged with the existing properties set using the other properties above. This allows your own fields properties to be appended to the existing fields that were created using the `payload` property for instance.
+    thumb_url: "http://example.com/path/to/thumb.png",
+    fields: [{
+      title: "My Field",
+      value: "My Value",
+      short: true
+    }]
+  }
+)
+```
+
+Let’s post a slack message inside a slack thread 🧵
+
+```ruby
+lane :release do
+  # Start the release with slack release thread
+  release_thread = post_to_slack(
+    message: "Good morning team, CI has started the AppStore release. You can find more information inside this thread 🧵",
+    channel: "#ios-team"
+  )
+
+  # Important: Save this slack thread timestamp for futher slack messages
+  release_thread_ts = release_thread[:json]["ts"]
+
+  gym # Build the app and create .ipa file
+
+  # Post an update in release thread
+  post_to_slack(
+    message: "App has been build successfully! 💪",
+    channel: "#ios-team",
+    thread_ts: release_thread_ts
+  )
+
+  deliver # Upload build to AppStore
+
+  # Post an update in release thread
+  post_to_slack(
+    message: "App has been uploaded to the AppStore and submitted for Apple's review! 🚀",
+    channel: "#ios-team",
+    thread_ts: release_thread_ts
+  )
+end
+```
+
+## Examples (Upload a file)
+
+Let’s Upload a file to a slack channel that main branch unit tests has been failed, see scan logs.
 
-For any other issues and feedback about this plugin, please submit it to this repository.
+```ruby
+# File upload on Slack
+file_upload_to_slack(
+  initial_comment: "CI: main-branch unit tests failed",
+  file_path: "scan.log",
+  channels: "#ios-team" # Comma-separated list of slack #channel names where the file will be shared
+)
+```
 
-## Troubleshooting
+Let’s Upload a file to a slack user that your branch unit tests has been failed, see scan logs.
 
-If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+```ruby
+# File upload on Slack
+file_upload_to_slack(
+  initial_comment: "CI: Your unit tests on #{ENV['CI_COMMIT_REF_NAME']} failed",
+  file_path: "scan.log",
+  channels: "@SlackUsername" # This can be Slack userID, instead of username i.e @UXXXXX
+)
+```
 
-## Using _fastlane_ Plugins
+Let’s Upload a file inside a slack thread 🧵
 
-For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://docs.fastlane.tools/plugins/create-plugin/).
+```ruby
+lane :release do
+  # Start the release with slack release thread
+  release_thread = post_to_slack(
+    message: "Good morning team, CI has started the AppStore release. You can find more information inside this thread 🧵",
+    channel: "#ios-team"
+  )
+
+  # Important: Save this slack thread timestamp for futher slack messages
+  release_thread_ts = release_thread[:json]["ts"]
+
+  gym # Build the app and create .ipa file
+
+  # Post an update in release thread
+  post_to_slack(
+    message: "App has been build successfully! 💪",
+    channel: "#ios-team",
+    thread_ts: release_thread_ts
+  )
+
+  deliver # Upload build to AppStore
+
+  # Post an update in release thread
+  post_to_slack(
+    message: "App has been uploaded to the AppStore and submitted for Apple's review! 🚀",
+    channel: "#ios-team",
+    thread_ts: release_thread_ts
+  )
+
+  # Spaceship logs file upload on Slack
+  file_upload_to_slack(
+    initial_comment: "Deliver:: Spaceship logs",
+    file_path: "spaceship.log",
+    channels: "#ios-team",
+    thread_ts: release_thread_ts
+  )
+end
+```
 
-## About _fastlane_
+## About Fastlane
 
 _fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/lib/fastlane/plugin/slack_bot/actions/fetch_files_slack.rb

@@ -0,0 +1,81 @@
+require 'fastlane/action'
+require_relative '../helper/slack_bot_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      FETCH_FILES_SLACK_RESULT = :FETCH_FILES_SLACK_RESULT
+    end
+    class FetchFilesSlackAction < Action
+      def self.run(options)
+        require 'excon'
+        require 'json'
+
+        api_url = "https://slack.com/api/files.list"
+        headers = { "Content-Type": "application/json", "Authorization": "Bearer #{options[:api_token]}" }
+        query = { channel: options[:channel], count: options[:count], page: options[:page] }
+
+        response =  Excon.get(api_url, headers: headers, query: query)
+        status_code = response[:status]
+        UI.user_error!("Response body is nil, status code: #{status_code} 💥") if response.body.nil?
+
+        result = {
+          status: status_code,
+          body: response.body,
+          json: JSON.parse(response.body)
+        }
+
+        Actions.lane_context[SharedValues::FETCH_FILES_SLACK_RESULT] = result
+        return result
+      end
+
+      def self.description
+        "List files of any #channel using Slack bot `files.list` api."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "FL_FETCH_FILES_SLACK_BOT_TOKEN",
+                                       description: "Slack bot Token",
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       is_string: true,
+                                       default_value: ENV["SLACK_API_TOKEN"],
+                                       default_value_dynamic: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :channel,
+                                       env_name: "FL_FETCH_FILES_SLACK_CHANNEL",
+                                       description: "slack #channel ID",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :count,
+                                       env_name: "FL_FETCH_FILES_SLACK_COUNT",
+                                       description: "Number of items to return per page, default value: 100",
+                                       default_value: "100",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :page,
+                                       env_name: "FL_FETCH_FILES_SLACK_PAGE",
+                                       description: "Page number of results to return, default value: 1",
+                                       default_value: "1",
+                                       optional: true)
+        ]
+      end
+
+      def self.authors
+        ["crazymanish"]
+      end
+
+      def self.example_code
+        [
+          'fetch_files_slack(channel: "CHXYMXXXX")',
+          'fetch_files_slack(channel: "CHXYMXXXX", count: "10")',
+          'fetch_files_slack(channel: "CHXYMXXXX", count: "10", page: "2")'
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/slack_bot/actions/file_upload_to_slack.rb

@@ -0,0 +1,176 @@
+require 'fastlane/action'
+require_relative '../helper/slack_bot_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      FILE_UPLOAD_TO_SLACK_RESULT = :FILE_UPLOAD_TO_SLACK_RESULT
+    end
+
+    class FileUploadToSlackAction < Action
+      def self.run(params)
+        file_path = params[:file_path]
+
+        if params[:file_name].to_s.empty?
+          file_name = File.basename(file_path, ".*") # if file_path = "/path/file_name.jpeg" then will return "file_name"
+        else
+          file_name = params[:file_name]
+        end
+
+        if params[:file_type].to_s.empty?
+          file_type = File.extname(file_path)[1..-1] # if file_path = "/path/file_name.jpeg" then will return "jpeg"
+        else
+          file_type = params[:file_type]
+        end
+
+        begin
+          require 'faraday'
+
+          api_url = "https://slack.com/api/files.upload"
+          conn = Faraday.new(url: api_url) do |faraday|
+            faraday.request :multipart
+            faraday.request :url_encoded
+            faraday.adapter :net_http
+          end
+
+          payload = {
+            channels: params[:channels],
+            file: Faraday::FilePart.new(file_path, file_type),
+            filename: file_name,
+            filetype: file_type
+          }
+
+          payload[:title] = params[:title] unless params[:title].nil?
+          payload[:initial_comment] = params[:initial_comment] unless params[:initial_comment].nil?
+          payload[:thread_ts] = params[:thread_ts] unless params[:thread_ts].nil?
+
+          response = conn.post do |req|
+            req.headers['Authorization'] = "Bearer #{params[:api_token]}"
+            req.body = payload
+           end
+
+          result = self.formatted_result(response)
+        rescue => exception
+          UI.error("Exception: #{exception}")
+          return nil
+        else
+          UI.success("Successfully uploaded file to Slack! 🚀")
+          Actions.lane_context[SharedValues::FILE_UPLOAD_TO_SLACK_RESULT] = result
+          return result
+        end
+      end
+
+      def self.formatted_result(response)
+        result = {
+          status: response[:status],
+          body: response.body || "",
+          json: self.parse_json(response.body) || {}
+        }
+      end
+
+      def self.parse_json(value)
+        require 'json'
+
+        JSON.parse(value)
+      rescue JSON::ParserError
+        nil
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Upload a file to slack channel"
+      end
+
+      def self.details
+        "Upload a file to slack channel or DM to a slack user"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "FL_FILE_UPLOAD_TO_SLACK_BOT_TOKEN",
+                                       description: "Slack bot Token",
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       is_string: true,
+                                       default_value: ENV["SLACK_API_TOKEN"],
+                                       default_value_dynamic: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :channels,
+                                       env_name: "FL_FETCH_FILES_SLACK_CHANNELS",
+                                       description: "Comma-separated list of slack #channel names where the file will be shared",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :file_path,
+                                       env_name: "FL_FILE_UPLOAD_TO_SLACK_FILE_PATH",
+                                       description: "relative file path which will upload to slack",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :file_name,
+                                       env_name: "FL_FILE_UPLOAD_TO_SLACK_FILE_NAME",
+                                       description: "This is optional filename of the file",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :file_type,
+                                       env_name: "FL_FILE_UPLOAD_TO_SLACK_FILE_TYPE",
+                                       description: "This is optional filetype of the file",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :title,
+                                       env_name: "FL_FILE_UPLOAD_TO_SLACK_TITLE",
+                                       description: "This is optional Title of file",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :initial_comment,
+                                       env_name: "FL_FILE_UPLOAD_TO_SLACK_INITIAL_COMMENT",
+                                       description: "This is optional message text introducing the file",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :thread_ts,
+                                       env_name: "FL_FILE_UPLOAD_TO_SLACK_THREAD_TS",
+                                       description: "Provide another message's ts value to make this message a reply",
+                                       is_string: true,
+                                       optional: true)
+        ]
+      end
+
+      def self.authors
+        ["crazymanish"]
+      end
+
+      def self.example_code
+        [
+          'file_upload_to_slack(
+            channels: "slack_channel_name",
+            file_path: "fastlane/test.png"
+          )',
+          'file_upload_to_slack(
+            title: "This is test title",
+            channels: "slack_channel_name1, slack_channel_name2",
+            file_path: "fastlane/report.xml"
+          )',
+          'file_upload_to_slack(
+            title: "This is test title",
+            initial_comment: "This is test initial comment",
+            channels: "slack_channel_name",
+            file_path: "fastlane/screenshots.zip"
+          )',
+          'file_upload_to_slack(
+            title: "This is test title", # Optional, uploading file title
+            initial_comment: "This is test initial comment",  # Optional, uploading file initial comment
+            channels: "slack_channel_name",
+            file_path: "fastlane/screenshots.zip",
+            thread_ts: thread_ts # Optional, Provide parent slack message `ts` value to upload this file as a reply.
+          )'
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/slack_bot/actions/post_to_slack.rb

@@ -3,37 +3,72 @@ require_relative '../helper/slack_bot_helper'
 
 module Fastlane
   module Actions
+    module SharedValues
+      POST_TO_SLACK_RESULT = :POST_TO_SLACK_RESULT
+    end
+
     class PostToSlackAction < Action
       def self.run(options)
         require 'slack-notifier'
 
         options[:message] = (options[:message].to_s || '').gsub('\n', "\n")
         options[:message] = Slack::Notifier::Util::LinkFormatter.format(options[:message])
-
         options[:pretext] = options[:pretext].gsub('\n', "\n") unless options[:pretext].nil?
 
         if options[:channel].to_s.length > 0
           slack_channel = options[:channel]
-          slack_channel = ('#' + options[:channel]) unless ['#', '@'].include?(slack_channel[0]) # send message to channel by default
+          slack_channel = ('#' + options[:channel]) unless ['#', 'C', '@'].include?(slack_channel[0]) # Add prefix(#) by default, if needed
         end
 
         slack_attachment = SlackAction.generate_slack_attachments(options)
+        bot_username = options[:username]
+        bot_icon_url = options[:icon_url]
 
         begin
           require 'excon'
 
           api_url = "https://slack.com/api/chat.postMessage"
-          headers = { "Content-Type": "application/json", "Authorization": "Bearer #{options[:api_token]}" }
-          payload = { channel: slack_channel, attachments: [slack_attachment] }.to_json
+          headers = {
+            "Content-Type": "application/json; charset=utf-8",
+            "Authorization": "Bearer #{options[:api_token]}"
+          }
+          payload = {
+            channel: slack_channel,
+            username: bot_username,
+            icon_url: bot_icon_url,
+            attachments: [slack_attachment]
+          }
+          payload[:thread_ts] = options[:thread_ts] unless options[:thread_ts].nil?
+          payload = payload.to_json
 
-          Excon.post(api_url, headers: headers, body: payload)
+          response = Excon.post(api_url, headers: headers, body: payload)
+          result = self.formatted_result(response)
         rescue => exception
           UI.error("Exception: #{exception}")
+          return nil
         else
           UI.success("Successfully sent Slack notification")
+          Actions.lane_context[SharedValues::POST_TO_SLACK_RESULT] = result
+          return result
         end
       end
 
+      def self.formatted_result(response)
+        result = {
+          status: response[:status],
+          body: response.body || "",
+          json: self.parse_json(response.body) || {}
+        }
+      end
+
+      def self.parse_json(value)
+        require 'json'
+
+        JSON.parse(value)
+      rescue JSON::ParserError
+        nil
+      end
+
       def self.description
         "Post a slack message"
       end
@@ -57,6 +92,18 @@ module Fastlane
                                        env_name: "FL_POST_TO_SLACK_CHANNEL",
                                        description: "#channel or @username",
                                        optional: true),
+          FastlaneCore::ConfigItem.new(key: :username,
+                                       env_name: "FL_SLACK_USERNAME",
+                                       description: "Overrides the bot's username (chat:write.customize scope required)",
+                                       default_value: "fastlane",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :icon_url,
+                                       env_name: "FL_SLACK_ICON_URL",
+                                       description: "Overrides the bot's image (chat:write.customize scope required)",
+                                       default_value: "https://fastlane.tools/assets/img/fastlane_icon.png",
+                                       is_string: true,
+                                       optional: true),
           FastlaneCore::ConfigItem.new(key: :pretext,
                                        env_name: "FL_POST_TO_SLACK_PRETEXT",
                                        description: "This is optional text that appears above the message attachment block. This supports the standard Slack markup language",
@@ -74,6 +121,7 @@ module Fastlane
                                        env_name: "FL_POST_TO_SLACK_DEFAULT_PAYLOADS",
                                        description: "Remove some of the default payloads. More information about the available payloads on GitHub",
                                        optional: true,
+                                       default_value: ['lane', 'test_result', 'git_branch', 'git_author', 'last_git_commit', 'last_git_commit_hash'],
                                        type: Array),
           FastlaneCore::ConfigItem.new(key: :attachment_properties,
                                        env_name: "FL_POST_TO_SLACK_ATTACHMENT_PROPERTIES",
@@ -85,7 +133,11 @@ module Fastlane
                                        description: "Was this successful? (true/false)",
                                        optional: true,
                                        default_value: true,
-                                       is_string: false)
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :thread_ts,
+                                       env_name: "FL_POST_TO_SLACK_THREAD_TS",
+                                       description: "Provide another message's ts value to make this message a reply",
+                                       optional: true)
         ]
       end
 

data/lib/fastlane/plugin/slack_bot/actions/update_slack_message.rb

@@ -0,0 +1,149 @@
+require 'fastlane/action'
+require_relative '../helper/slack_bot_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      UPDATE_SLACK_MESSAGE_RESULT = :UPDATE_SLACK_MESSAGE_RESULT
+    end
+    class UpdateSlackMessageAction < Action
+      def self.run(options)
+        require 'slack-notifier'
+
+        options[:message] = (options[:message].to_s || '').gsub('\n', "\n")
+        options[:message] = Slack::Notifier::Util::LinkFormatter.format(options[:message])
+        options[:pretext] = options[:pretext].gsub('\n', "\n") unless options[:pretext].nil?
+        slack_attachment = SlackAction.generate_slack_attachments(options)
+
+        begin
+          require 'excon'
+
+          api_url = "https://slack.com/api/chat.update"
+          headers = { "Content-Type": "application/json", "Authorization": "Bearer #{options[:api_token]}" }
+          payload = { channel: options[:channel], attachments: [slack_attachment], ts: options[:ts] }.to_json
+
+          response = Excon.post(api_url, headers: headers, body: payload)
+          result = self.formatted_result(response)
+        rescue => exception
+          UI.error("Exception: #{exception}")
+          return nil
+        else
+          UI.success("Successfully updated the Slack message")
+          Actions.lane_context[SharedValues::UPDATE_SLACK_MESSAGE_RESULT] = result
+          return result
+        end
+      end
+
+      def self.formatted_result(response)
+        result = {
+          status: response[:status],
+          body: response.body || "",
+          json: self.parse_json(response.body) || {}
+        }
+      end
+
+      def self.parse_json(value)
+        require 'json'
+
+        JSON.parse(value)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def self.description
+        "Update a slack message using time-stamp(ts) value"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "FL_UPDATE_SLACK_MESSAGE_BOT_TOKEN",
+                                       description: "Slack bot Token",
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       is_string: true,
+                                       default_value: ENV["SLACK_API_TOKEN"],
+                                       default_value_dynamic: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :ts,
+                                       env_name: "FL_UPDATE_SLACK_MESSAGE_TS",
+                                       description: "Timestamp of the message to be updated",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :channel,
+                                       env_name: "FL_UPDATE_SLACK_MESSAGE_CHANNEL",
+                                       description: "Slack channel i.e C1234567890",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :pretext,
+                                       env_name: "FL_UPDATE_SLACK_MESSAGE_PRETEXT",
+                                       description: "This is optional text that appears above the message attachment block. This supports the standard Slack markup language",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :message,
+                                       env_name: "FL_UPDATE_SLACK_MESSAGE_MESSAGE",
+                                       description: "The message that should be displayed on Slack",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :payload,
+                                       env_name: "FL_UPDATE_SLACK_MESSAGE_PAYLOAD",
+                                       description: "Add additional information to this post. payload must be a hash containing any key with any value",
+                                       default_value: {},
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :default_payloads,
+                                       env_name: "FL_UPDATE_SLACK_MESSAGE_DEFAULT_PAYLOADS",
+                                       description: "Remove some of the default payloads. More information about the available payloads on GitHub",
+                                       optional: true,
+                                       default_value: ['lane', 'test_result', 'git_branch', 'git_author', 'last_git_commit', 'last_git_commit_hash'],
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :attachment_properties,
+                                       env_name: "FL_UPDATE_SLACK_MESSAGE_ATTACHMENT_PROPERTIES",
+                                       description: "Merge additional properties in the slack attachment, see https://api.slack.com/docs/attachments",
+                                       default_value: {},
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :success,
+                                       env_name: "FL_UPDATE_SLACK_MESSAGE_SUCCESS",
+                                       description: "Was this successful? (true/false)",
+                                       optional: true,
+                                       default_value: true,
+                                       is_string: false)
+        ]
+      end
+
+      def self.authors
+        ["crazymanish"]
+      end
+
+      def self.example_code
+        [
+          'update_slack_message(
+            ts: "1609711037.000100",
+            channel: "C1234567890",
+            message: "Update: App successfully released!"
+          )',
+          'update_slack_message(
+            ts: "1609711037.000100",
+            channel: "C1234567890",
+            message: "Update: App successfully released!",
+            success: true,        # Optional, defaults to true.
+            payload: {            # Optional, lets you specify any number of your own Slack attachments.
+              "Build Date" => Time.new.to_s,
+              "Built by" => "Jenkins",
+            },
+            default_payloads: [:git_branch, :git_author], # Optional, lets you specify a whitelist of default payloads to include. Pass an empty array to suppress all the default payloads.
+                                                          # Don\'t add this key, or pass nil, if you want all the default payloads. The available default payloads are: `lane`, `test_result`, `git_branch`, `git_author`, `last_git_commit`, `last_git_commit_hash`.
+            attachment_properties: { # Optional, lets you specify any other properties available for attachments in the slack API (see https://api.slack.com/docs/attachments).
+                                     # This hash is deep merged with the existing properties set using the other properties above. This allows your own fields properties to be appended to the existing fields that were created using the `payload` property for instance.
+              thumb_url: "http://example.com/path/to/thumb.png",
+              fields: [{
+                title: "My Field",
+                value: "My Value",
+                short: true
+              }]
+            }
+          )'
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/slack_bot/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module SlackBot
-    VERSION = "0.1.1"
+    VERSION = "0.4.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-slack_bot
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Manish Rathi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-27 00:00:00.000000000 Z
+date: 2021-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -145,7 +145,10 @@ files:
 - LICENSE
 - README.md
 - lib/fastlane/plugin/slack_bot.rb
+- lib/fastlane/plugin/slack_bot/actions/fetch_files_slack.rb
+- lib/fastlane/plugin/slack_bot/actions/file_upload_to_slack.rb
 - lib/fastlane/plugin/slack_bot/actions/post_to_slack.rb
+- lib/fastlane/plugin/slack_bot/actions/update_slack_message.rb
 - lib/fastlane/plugin/slack_bot/helper/slack_bot_helper.rb
 - lib/fastlane/plugin/slack_bot/version.rb
 homepage: https://github.com/crazymanish/fastlane-plugin-slack_bot
@@ -167,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: "A fastlane plugin to post slack message using bot api token. \U0001F680"