fastlane-plugin-polidea 0.1.0

data/lib/fastlane/plugin/polidea/actions/get_binary_size.rb

@@ -0,0 +1,53 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      BINARY_SIZE = :BINARY_SIZE
+    end
+
+    class GetBinarySizeAction < Action
+      def self.run(config)
+        binary_file = config[:binary]
+
+        UI.user_error!("No IPA or APK file path given, pass using `binary: 'ipa or apk path'`") unless binary_file.to_s.length > 0
+
+        binary_size = File.open(binary_file).size
+        binary_size_in_mb = (binary_size / 1024.0 / 1024.0).round(2)
+
+        Actions.lane_context[SharedValues::BINARY_SIZE] = binary_size
+        ENV[SharedValues::BINARY_SIZE.to_s] = binary_size.to_s
+
+        UI.success("Size of #{binary_file} is #{binary_size_in_mb} MB (#{binary_size} bytes)")
+
+        binary_size
+      end
+
+      def self.description
+        "Measures binary size in bytes"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :binary,
+                                       env_name: "",
+                                       description: ".ipa or .apk file from the build ",
+                                       optional: true,
+                                       default_value: Actions.lane_context[SharedValues::IPA_OUTPUT_PATH] || Actions.lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH])
+        ]
+      end
+
+      def self.output
+        [
+          ['BINARY_SIZE', 'Size of .ipa/.apk in bytes']
+        ]
+      end
+
+      def self.author
+        "Piotrek Dubiel"
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include? platform
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/polidea/actions/mailgun.rb

@@ -0,0 +1,173 @@
+# rubocop:disable Metrics/MethodLength
+require 'fastlane/erb_template_helper'
+
+module Fastlane
+  module Actions
+    class MailgunAction < Action
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.run(options)
+        Actions.verify_gem!('rest-client')
+        Actions.verify_gem!('premailer')
+        require 'rest-client'
+        require 'premailer'
+        inline_images(options)
+        mailgunit(options)
+      end
+
+      def self.description
+        "Send a success/error message to an email group"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :postmaster,
+                                       env_name: "MAILGUN_SANDBOX_POSTMASTER",
+                                       description: "Mailgun sandbox domain postmaster for your mail"),
+          FastlaneCore::ConfigItem.new(key: :apikey,
+                                       env_name: "MAILGUN_APIKEY",
+                                       description: "Mailgun apikey for your mail"),
+          FastlaneCore::ConfigItem.new(key: :to,
+                                       env_name: "MAILGUN_TO",
+                                       description: "Destination of your mail"),
+          FastlaneCore::ConfigItem.new(key: :from,
+                                       env_name: "MAILGUN_FROM",
+                                       optional: true,
+                                       description: "Mailgun sender name",
+                                       default_value: "Mailgun Sandbox"),
+          FastlaneCore::ConfigItem.new(key: :success,
+                                      env_name: "MAILGUN_SUCCESS",
+                                      description: "Was this build successful? (true/false)",
+                                      optional: true,
+                                      default_value: true,
+                                      is_string: false),
+          FastlaneCore::ConfigItem.new(key: :ci_build_link,
+                                      env_name: "MAILGUN_CI_BUILD_LINK",
+                                      description: "CI Build Link",
+                                      optional: true,
+                                      is_string: true),
+          FastlaneCore::ConfigItem.new(key: :template_path,
+                                      env_name: "MAILGUN_TEMPLATE_PATH",
+                                      description: "Mail HTML template",
+                                      optional: true,
+                                      is_string: true),
+          FastlaneCore::ConfigItem.new(key: :app_icon,
+                                      env_name: "MAILGUN_APP_ICON",
+                                      description: "Path to app icon file",
+                                      is_string: true,
+                                      optional: true,
+                                      default_value: Actions.lane_context[SharedValues::ICON_OUTPUT_PATH]),
+          FastlaneCore::ConfigItem.new(key: :app_name,
+                                      env_name: "MAILGUN_APP_NAME",
+                                      description: "Application name",
+                                      is_string: true,
+                                      default_value: Actions.lane_context[SharedValues::APP_NAME]),
+          FastlaneCore::ConfigItem.new(key: :app_version,
+                                      env_name: "MAILGUN_APP_VERSION",
+                                      description: "Application version",
+                                      is_string: true,
+                                      default_value: Actions.lane_context[SharedValues::APP_VERSION]),
+          FastlaneCore::ConfigItem.new(key: :build_number,
+                                      env_name: "MAILGUN_BUILD_NUMBER",
+                                      description: "Build number",
+                                      default_value: Actions.lane_context[SharedValues::BUILD_NUMBER]),
+          FastlaneCore::ConfigItem.new(key: :installation_link,
+                                      env_name: "MAILGUN_INSTALLATION_LINK",
+                                      description: "Link to installation page",
+                                      is_string: true,
+                                      default_value: Actions.lane_context[SharedValues::S3_HTML_OUTPUT_PATH]),
+          FastlaneCore::ConfigItem.new(key: :release_notes,
+                                      env_name: "MAILGUN_RELEASE_NOTES",
+                                      description: "Release notes",
+                                      type: Array,
+                                      optional: true,
+                                      default_value: []),
+          FastlaneCore::ConfigItem.new(key: :binary_size,
+                                      env_name: "MAILGUN_BINARY_SIZE",
+                                      description: "Binary size",
+                                      type: Fixnum,
+                                      default_value: Actions.lane_context[SharedValues::BINARY_SIZE]),
+          FastlaneCore::ConfigItem.new(key: :inline,
+                                      type: Array,
+                                      optional: true,
+                                      default_value: [])
+        ]
+      end
+
+      def self.author
+        "thiagolioy"
+      end
+
+      def self.inline_images(options)
+        base_path = "#{__dir__}/../templates/images"
+        options[:inline] = [
+          qr_code(options[:installation_link]),
+          File.new(options[:app_icon])
+        ]
+        images = [
+          "polidea-facebook-icon.png",
+          "polidea-github-icon.png",
+          "polidea-logo.png",
+          "polidea-twitter-icon.png"
+        ]
+        images << "icon-placeholder.png" unless options[:app_icon]
+        options[:inline].concat(images.map { |image| File.new("#{base_path}/#{image}") })
+      end
+
+      def self.qr_code(installation_link)
+        qr_code_path = "/tmp/qr_code.png"
+        QRGenerator.new(installation_link, false, ::ChunkyPNG::Color.rgb(103, 103, 103)).generate(qr_code_path)
+        File.new(qr_code_path)
+      end
+
+      def self.mailgunit(options)
+        sandbox_domain = options[:postmaster].split("@").last
+        body = mail_template(options)
+        RestClient.post "https://api:#{options[:apikey]}@api.mailgun.net/v3/#{sandbox_domain}/messages",
+                        from: "#{options[:from]}<#{options[:postmaster]}>",
+                        to: (options[:to]).to_s,
+                        subject: "#{options[:app_name]} #{options[:app_version]} (#{options[:build_number]}) for #{Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]} is ready to install",
+                        html: body,
+                        inline: options[:inline]
+        return body
+      end
+
+      def self.mail_template(options)
+        hash = {
+          author: Actions.git_author_email,
+          last_commit: Actions.last_git_commit_message,
+          is_android: Actions.lane_context[Actions::SharedValues::PLATFORM_NAME] == :android,
+          app_icon: File.basename(options[:app_icon]),
+          app_name: options[:app_name],
+          app_version: options[:app_version],
+          build_number: options[:build_number],
+          installation_link: options[:installation_link],
+          release_notes: options[:release_notes],
+          platform: Actions.lane_context[Actions::SharedValues::PLATFORM_NAME],
+          release_date: DateTime.now.strftime('%b %d, %Y'),
+          binary_size: (options[:binary_size] / 1024.0 / 1024.0).round(2).to_s
+        }
+        hash[:success] = options[:success]
+        hash[:ci_build_link] = options[:ci_build_link]
+
+        # grabs module
+        eth = Fastlane::ErbTemplateHelper
+        # create html from template
+        html_template_path = options[:template_path]
+        if html_template_path && File.exist?(html_template_path)
+          html_template = eth.load_from_path(html_template_path)
+        else
+          html_template = eth.load_from_path("#{__dir__}/../templates/mailgun_template.erb")
+        end
+        premailer = Premailer.new(
+          eth.render(html_template, hash),
+          { warn_level: Premailer::Warnings::SAFE, with_html_string: true }
+        )
+        premailer.to_inline_css
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/MethodLength

data/lib/fastlane/plugin/polidea/actions/polidea_store_action.rb

@@ -0,0 +1,248 @@
+# rubocop:disable Metrics/MethodLength
+
+require 'net/http'
+require 'uri'
+require 'json'
+
+module Fastlane
+  module Actions
+    class PolideaStoreAction < Action
+      def self.run(params)
+        platform = Actions.lane_context[Actions::SharedValues::PLATFORM_NAME].to_sym
+        validate(platform, params)
+        config = get_config(platform, params)
+        app_name, app_identifier, version = notify(platform, config)
+
+        UI.success("Successfully uploaded #{app_name} (#{app_identifier})")
+        UI.success("version: #{version}")
+        UI.success("using icon from #{params[:icon_url]}")
+        UI.success("using plist from #{params[:plist_url]}") if platform == :ios
+        UI.success("with release notes: #{params[:release_notes]}") if params[:release_notes]
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Polidea Store upload action"
+      end
+
+      def self.details
+        "Notify Polidea Store about new app version"
+      end
+
+      def self.author
+        ["Piotrek Dubiel"]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+            env_name: "POLIDEA_STORE_API_TOKEN",
+            description: "API Token for Polidea Store",
+            verify_block: proc do |value|
+              UI.user_error!("No API token for Polidea Store given, pass using `api_token: 'token'`") unless value and !value.empty?
+            end),
+          FastlaneCore::ConfigItem.new(key: :ipa,
+            env_name: "",
+            description: ".ipa file for the build ",
+            optional: true,
+            default_value: Actions.lane_context[SharedValues::IPA_OUTPUT_PATH]),
+          FastlaneCore::ConfigItem.new(key: :apk,
+            env_name: "",
+            description: ".apk file for the build ",
+            optional: true,
+            default_value: Actions.lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH]),
+          FastlaneCore::ConfigItem.new(key: :plist_url,
+            env_name: "POLIDEA_STORE_PLIST_URL",
+            description: "Url to uploaded plist",
+            default_value: Actions.lane_context[SharedValues::S3_PLIST_OUTPUT_PATH],
+            verify_block: proc do |value|
+              UI.user_error!("No plist url given, pass using `plist_url: 'url'` or make sure s3 action succeded and exposed S3_PLIST_OUTPUT_PATH shared value") unless value and !value.empty?
+            end),
+          FastlaneCore::ConfigItem.new(key: :apk_url,
+            env_name: "POLIDEA_STORE_APK_URL",
+            description: "Url to uploaded apk",
+            default_value: Actions.lane_context[SharedValues::S3_APK_OUTPUT_PATH],
+            verify_block: proc do |value|
+              UI.user_error!("No apk url given, pass using `apk_url: 'url'` or make sure s3 action succeded and exposed S3_APK_OUTPUT_PATH shared value") unless value and !value.empty?
+            end),
+          FastlaneCore::ConfigItem.new(key: :icon_url,
+            env_name: "POLIDEA_STORE_ICON_URL",
+            description: "Url to uploaded app icon",
+            default_value: Actions.lane_context[SharedValues::S3_ICON_OUTPUT_PATH],
+            verify_block: proc do |value|
+              UI.user_error!("No icon url given, pass using `icon_url: 'url'` or make sure s3 action succeded and exposed S3_ICON_OUTPUT_PATH shared value") unless value and !value.empty?
+            end),
+          FastlaneCore::ConfigItem.new(key: :release_notes,
+            env_name: "POLIDEA_STORE_RELEASE_NOTES",
+            description: "Release notes to be attached to uploaded version",
+            is_string: true,
+            optional: true),
+          FastlaneCore::ConfigItem.new(key: :app_name,
+            env_name: "",
+            description: "Application name (defaults to bundle name on iOS)", # TODO: edit for Android
+            is_string: true,
+            optional: true),
+          FastlaneCore::ConfigItem.new(key: :bundle_id,
+            env_name: "",
+            description: "Bundle id",
+            is_string: true,
+            optional: true),
+          FastlaneCore::ConfigItem.new(key: :bundle_version,
+            env_name: "",
+            description: "Bundle version", # TODO: edit for Android
+            is_string: true,
+            optional: true),
+          FastlaneCore::ConfigItem.new(key: :package_name,
+            env_name: "",
+            description: "Package name",
+            is_string: true,
+            optional: true),
+          FastlaneCore::ConfigItem.new(key: :version_name,
+            env_name: "",
+            description: "Version name",
+            is_string: true,
+            optional: true),
+          FastlaneCore::ConfigItem.new(key: :version_code,
+            env_name: "",
+            description: "Version code",
+            type: Fixnum,
+            optional: true),
+          FastlaneCore::ConfigItem.new(key: :binary_size,
+            env_name: "POLIDEA_STORE_RELESASE_NOTES",
+            description: ".ipa/.apk binary size in bytes",
+            type: Fixnum,
+            optional: true)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include? platform
+      end
+
+      def self.validate(platform, params)
+        binary_size = params[:binary_size] || Actions.lane_context[Actions::SharedValues::BINARY_SIZE]
+        UI.user_error!("No binary size given, pass using `binary_size: bytes` or make sure get_binary_size action succeded and exposed BINARY_SIZE shared value") unless binary_size and !binary_size.nil?
+
+        case platform
+        when :android
+          UI.user_error!("No .apk file given, pass using `apk: 'apk path'` or make sure gradle action succeded and exposed GRADLE_APK_OUTPUT_PATH shared value") unless params[:apk] and !params[:apk].empty?
+        when :ios
+          UI.user_error!("No .ipa file given, pass using `ipa: 'ipa path'` or make sure gym action succeded and exposed IPA_OUTPUT_PATH shared value") unless params[:ipa] and !params[:ipa].empty?
+        end
+      end
+
+      def self.get_config(platform, params)
+        binary_size = params[:binary_size] || Actions.lane_context[Actions::SharedValues::BINARY_SIZE]
+
+        case platform
+        when :ios
+          info = FastlaneCore::IpaFileAnalyser.fetch_info_plist_file(params[:ipa])
+          app_name = params[:app_name] || info['CFBundleName']
+          app_identifier = params[:bundle_id] || info['CFBundleIdentifier']
+          version = params[:bundle_version] || info['CFBundleShortVersionString']
+          href = params[:plist_url]
+          url_scheme = get_url_scheme(info)
+        when :android
+          manifest = Android::Apk.new(params[:apk]).manifest
+          app_name = params[:app_name] || manifest.label
+          app_identifier = params[:package_name] || manifest.package_name
+          version = params[:version_name] || manifest.version_name
+          version_code = params[:version_code] || manifest.version_code
+          href = params[:apk_url]
+        end
+
+        config = {
+          api_token: params[:api_token],
+          app_name: app_name,
+          app_identifier: app_identifier,
+          version: version,
+          version_code: version_code,
+          icon_url: params[:icon_url],
+          href: href,
+          release_notes: params[:release_notes],
+          binary_size: binary_size,
+          url_scheme: url_scheme
+        }
+
+        return config
+      end
+
+      def self.notify(platform, params)
+        uri = URI.parse(url(platform, params[:app_identifier]))
+
+        version = {
+          version: params[:version],
+          releaseNotes: params[:release_notes],
+          href: params[:href],
+          bytes: params[:binary_size]
+        }
+
+        version[:prefixSchema] = params[:url_scheme] if platform == :ios
+        version[:versionCode] = params[:version_code] if platform == :android
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+
+        req = create_request(uri, params[:api_token], {
+          name: params[:app_name],
+          icon: {
+            href: params[:icon_url]
+          },
+          versions: [version]
+        })
+
+        response = http.request(req)
+        unless response.code == "204"
+          UI.user_error! "Polidea Store backend responded with [#{response.code}] #{response.body}"
+        end
+
+        return params[:app_name], params[:app_identifier], params[:version]
+      end
+      private_class_method :notify
+
+      def self.url(platform, app_identifier)
+        "#{base_url}/#{platform}/apps/#{app_identifier}/versions"
+      end
+      private_class_method :url
+
+      def self.base_url
+        "https://polideastore.herokuapp.com"
+        # "https://polideastore-staging.herokuapp.com"
+      end
+      private_class_method :base_url
+
+      def self.create_request(uri, upload_token, params)
+        req = Net::HTTP::Post.new(uri.request_uri)
+        req['Content-Type'] = 'application/json'
+        req['Upload-Token'] = upload_token
+        req.body = JSON.generate(params)
+        req
+      end
+      private_class_method :create_request
+
+      def self.itms_href(plist_url)
+        "itms-services://?action=download-manifest&url=#{plist_url}"
+      end
+      private_class_method :itms_href
+
+      def self.get_url_scheme(plist)
+        url_scheme = nil
+        url_types = plist['CFBundleURLTypes']
+        unless url_types.nil?
+          url_type = url_types[0]
+          url_schemes = url_type['CFBundleURLSchemes']
+          unless url_schemes.nil?
+            url_scheme = url_schemes[0]
+          end
+        end
+        url_scheme
+      end
+      private_class_method :get_url_scheme
+    end
+  end
+end
+
+# rubocop:enable Metrics/MethodLength