app_status_notification 0.9.0.beta1

data/lib/app_status_notification/command.rb

@@ -0,0 +1,64 @@
+require 'app_status_notification'
+require 'app_status_notification/version'
+
+require 'gli'
+
+class AppStatusNotification::Command
+  extend GLI::App
+
+  program_desc 'Manage iOS app status notification'
+
+  version AppStatusNotification::VERSION
+
+  subcommand_option_handling :normal
+  arguments :strict
+
+  desc 'Enable development mode (use .local.yml config)'
+  switch [:d, :development]
+
+  desc 'Set log level'
+  default_value 'info'
+  arg_name 'value'
+  flag [:'log-level']
+
+  desc 'Set config path'
+  arg_name 'config'
+  flag [:c, :config]
+
+  desc 'Set locale path'
+  arg_name 'locale'
+  flag [:locale]
+
+  desc 'Start watch service'
+  arg_name 'Describe arguments to ddd here'
+  command :watch do |c|
+    c.action do |global_options, options, args|
+      AppStatusNotification.watch(global_options[:config])
+    end
+  end
+
+  pre do |global,command,options,args|
+    AppStatusNotification.development(global[:development])
+    # Pre logic here
+    # Return true to proceed; false to abort and not call the
+    # chosen command
+    # Use skips_pre before a command to skip this block
+    # on that command only
+    true
+  end
+
+  post do |global,command,options,args|
+    # Post logic here
+    # Use skips_post before a command to skip this
+    # block on that command only
+  end
+
+  on_error do |exception|
+    puts exception.backtrace unless exception.is_a?(Interrupt)
+    # Error logic here
+    # return false to skip default error handling
+    true
+  end
+
+  default_command :watch
+end

data/lib/app_status_notification/config.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require 'app_status_notification/version'
+require 'anyway_config'
+require 'raven/base'
+require 'logger'
+require 'i18n'
+
+module AppStatusNotification
+  class Config < Anyway::Config
+    config_name :notification
+
+    attr_config accounts: [],
+                notifications: {},
+                refresh_interval: 60,
+                locale: 'zh',
+                dry: false,
+                enable_crash_report: true,
+                crash_report: 'https://aa7c78acbb324fcf93169fce2b7e5758@o333914.ingest.sentry.io/5575774'
+
+    def load_locale(path, file = '*.yml')
+      path = File.join(path) unless path.ends_with?(file)
+      I18n.load_path << Dir[path]
+    end
+
+    def debug?
+      (ENV['ASN_ENV'] || ENV['RACK_ENV'] || ENV['RAILS_ENV']) != 'production'
+    end
+
+    def dry?
+      !!dry
+    end
+
+    def env
+      debug? ? 'development' : 'production'
+    end
+
+    def logger
+      return @logger if @logger
+
+      @logger = Logger.new(STDOUT)
+      @logger.level = debug? ? Logger::DEBUG : Logger::INFO
+      @logger
+    end
+
+    def accounts
+      @account ||= Account.parse(super)
+    end
+
+    def store_path
+      File.join(File.expand_path('../../', __dir__), 'stores')
+    end
+
+    def config_path
+      File.join(File.expand_path('../../', __dir__), 'config')
+    end
+
+    on_load :configure_locale
+    on_load :ensure_accounts
+    on_load :ensure_notifications
+    on_load :configure_crash_report
+
+    private
+
+    def configure_locale
+      # built-in
+      I18n.load_path << Dir[File.join(config_path, 'locales', '*.yml')]
+
+      # default locale
+      I18n.locale = locale.to_sym
+    end
+
+    def configure_crash_report
+      return unless enable_crash_report
+
+      Raven.configure do |raven|
+        raven.dsn = crash_report
+        raven.current_environment = env
+        raven.logger = logger
+        raven.release = AppStatusNotification::VERSION
+        raven.excluded_exceptions += [
+          'Faraday::SSLError',
+          'Spaceship::UnauthorizedAccessError',
+          'Interrupt',
+          'SystemExit',
+          'SignalException',
+          'Faraday::ConnectionFailed'
+        ]
+
+        raven.before_send = lambda { |event, hint|
+          event.extra = {
+            config: self.to_filtered_h
+          }
+
+          event
+        }
+      end
+    end
+
+    def ensure_accounts
+      %w[key_id issuer_id apps].each do |key|
+        accounts.each do |account|
+          unless account.send(key.to_sym)
+            raise ConfigError, "Missing account properties: #{key}"
+          end
+
+          unless account.key_path && account.key_exists?
+            raise ConfigError, "Can not find key file, place one into config directory, Eg: config/AuthKey_xxx.p8"
+          end
+        end
+      end
+    end
+
+    def ensure_notifications
+      if notifications.nil? || notifications.empty?
+        raise ConfigError, "Missing notifications"
+      elsif notifications.is_a?(Hash)
+        notifications.each do |key, url|
+          raise ConfigError, "Missing url properties: #{key}" unless url
+        end
+      end
+    end
+
+    def to_filtered_h
+      @to_filtered_h ||= to_h.each_with_object({}) do |(k, v), obj|
+        case k
+        when :accounts
+          obj[k] = filter_accounts
+        when :notifications
+          obj[k] = filter_notifications(v)
+        when :crash_report
+          obj[k] = filtered_token(v)
+        else
+          obj[k] = v
+        end
+      end
+    end
+
+    def filter_accounts
+      accounts.each_with_object([]) do |account,  obj|
+        item = {
+          issuer_id: filtered_token(account.issuer_id),
+          key_id: filtered_token(account.key_id),
+          key_path: filtered_token(account.key_path),
+          apps: []
+        }
+
+        account.apps.each do |app|
+          item[:apps] << {
+            id: filtered_token(app.id),
+            notifications: app.notifications
+          }
+        end
+
+        obj << item
+      end
+    end
+
+    def filter_notifications(notifications)
+      notifications.each_with_object({}) do |(k, v), obj|
+        new_v = v.dup
+        new_v['webhook_url'] = filtered_token(new_v['webhook_url'])
+        obj[k] = new_v
+      end
+    end
+
+    def filtered_token(chars)
+      chars = chars.to_s
+      return '*' * chars.size if chars.size < 4
+
+      average = chars.size / 4
+      prefix = chars[0..average - 1]
+      hidden = '*' * (average * 2)
+      suffix = chars[(prefix.size + average * 2)..-1]
+      "#{prefix}#{hidden}#{suffix}"
+    end
+
+    class Account
+      def self.parse(accounts)
+        [].tap do |obj|
+          accounts.each do |account|
+            obj << Account.new(account)
+          end
+        end
+      end
+
+      attr_reader :issuer_id, :key_id, :key_path
+      attr_reader :apps
+
+      def initialize(raw)
+        @issuer_id = raw['issuer_id']
+        @key_id = raw['key_id']
+        @key_path = raw['key_path']
+        @apps = App.parse(raw['apps'])
+      end
+
+      def key_exists?
+        File.file?(key_path) || File.readable?(key_path)
+      end
+
+      def private_key
+        File.read(key_path)
+      end
+
+      class App
+        def self.parse(apps)
+          raise MissingAppsConfigError, 'Unable handle all apps of account, add app id(s) under accounts with name `apps`.' unless apps
+
+          [].tap do |obj|
+            apps.each do |app|
+              obj << App.new(app)
+            end
+          end
+        end
+
+        attr_reader :id
+
+        def initialize(raw)
+          case raw
+          when String, Integer
+            @id = raw.to_s
+          when Hash
+            @id = raw['id'].to_s
+            @notifications = raw['notifications']
+          end
+        end
+
+        def notifications
+          @notifications ||= []
+        end
+      end
+    end
+  end
+end

data/lib/app_status_notification/connect_api.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday_middleware'
+
+require 'app_status_notification/connect_api/auth'
+require 'app_status_notification/connect_api/response'
+require 'app_status_notification/connect_api/model'
+
+module AppStatusNotification
+  class ConnectAPI
+    Dir[File.expand_path('connect_api/clients/*.rb', __dir__)].each { |f| require f }
+
+    ENDPOINT = 'https://api.appstoreconnect.apple.com/v1'
+
+    include Client::App
+    include Client::AppStoreVersion
+    include Client::Build
+
+    def self.from_context(context, **kargs)
+      new(**kargs.merge(
+        issuer_id: context.issuer_id,
+        key_id: context.key_id,
+        private_key: context.private_key,
+      ))
+    end
+
+    attr_reader :connection
+
+    def initialize(**kargs)
+      configure_connection(**kargs)
+    end
+
+    %w[get post patch delete].each do |method|
+      define_method method do |path, options = {}|
+        params = options.dup
+        connection.authorization :Bearer, @auth.token
+
+        if %w[post patch].include?(method)
+          body = params[:body].to_json
+          headers = params[:headers] || {}
+          headers[:content_type] ||= 'application/json'
+          validates connection.send(method, path, body, headers)
+        else
+          validates connection.send(method, path, params)
+        end
+      end
+    end
+
+    private
+
+    def validates(response)
+      case response.status
+      when 200, 201, 204
+        # 200: get requests
+        # 201: post requests
+        # 204: patch, delete requests
+        handle_response response
+      when 429
+        # 429 Rate Limit Exceeded
+        raise RateLimitExceededError.parse(response)
+      else
+        raise ConnectAPIError.parse(response)
+      end
+    end
+
+    def handle_response(response)
+      response = Response.new(response, connection)
+
+      if (remaining = response.rate[:remaining]) && remaining.to_i.zero?
+        raise RateLimitExceededError, "Request limit reached #{response.rate[:limit]} in the previous 60 minutes with url: #{response.request_url}"
+      end
+
+      response
+    end
+
+    def configure_connection(**kargs)
+      @auth = Auth.new(**kargs)
+      endpoint = kargs[:endpoint] || ENDPOINT
+
+      connection_opts= {}
+      connection_opts[:proxy] = ENV['ASN_PROXY'] if ENV['ASN_PROXY']
+      @connection = Faraday.new(endpoint, connection_opts) do |builder|
+        builder.request :url_encoded
+        builder.headers[:content_type] = 'application/json'
+
+        builder.response :json, content_type: /\bjson$/
+        builder.response :logger if kargs[:debug] || ENV['ASN_DEBUG']
+      end
+    end
+  end
+end

data/lib/app_status_notification/connect_api/auth.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'jwt'
+
+module AppStatusNotification
+  class ConnectAPI
+    class Auth
+      AUDIENCE = 'appstoreconnect-v1'
+      ALGORITHM = 'ES256'
+      EXPIRE_DURATION = 20 * 60
+
+      attr_reader :issuer_id, :key_id, :private_key
+
+      def initialize(**kargs)
+        @issuer_id = kargs[:issuer_id]
+        @key_id = kargs[:key_id]
+        @private_key = handle_private_key(kargs[:private_key])
+      end
+
+      def token
+        JWT.encode(payload, private_key, ALGORITHM, header_fields)
+      end
+
+      private
+
+      def payload
+        {
+          aud: AUDIENCE,
+          iss: issuer_id,
+          exp: Time.now.to_i + EXPIRE_DURATION
+        }
+      end
+
+      def header_fields
+        { kid: key_id }
+      end
+
+      def handle_private_key(key)
+        key = File.open(key) if File.file?(key)
+        OpenSSL::PKey.read(key)
+      end
+    end
+  end
+end

data/lib/app_status_notification/connect_api/clients/app.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module AppStatusNotification
+  class ConnectAPI
+    module Client
+      module App
+        def apps(query = {})
+          get("apps", query = {})
+        end
+
+        def app(id, query = {})
+          get("apps/#{id}", query).to_model
+        end
+
+        def app_versions(id, query = {})
+          get("apps/#{id}/appStoreVersions", query)
+        end
+
+        def app_edit_version(id, includes: ConnectAPI::Model::AppStoreVersion::ESSENTIAL_INCLUDES)
+          filters = {
+            appStoreState: [
+              ConnectAPI::Model::AppStoreVersion::AppStoreState::PREPARE_FOR_SUBMISSION,
+              ConnectAPI::Model::AppStoreVersion::AppStoreState::DEVELOPER_REJECTED,
+              ConnectAPI::Model::AppStoreVersion::AppStoreState::REJECTED,
+              ConnectAPI::Model::AppStoreVersion::AppStoreState::METADATA_REJECTED,
+              ConnectAPI::Model::AppStoreVersion::AppStoreState::WAITING_FOR_REVIEW,
+              ConnectAPI::Model::AppStoreVersion::AppStoreState::INVALID_BINARY,
+              ConnectAPI::Model::AppStoreVersion::AppStoreState::IN_REVIEW,
+              ConnectAPI::Model::AppStoreVersion::AppStoreState::PENDING_DEVELOPER_RELEASE
+            ].join(',')
+          }
+
+          app_versions(id, include: includes, filter: filters).to_model
+        end
+
+        def app_live_version(id, includes: ConnectAPI::Model::AppStoreVersion::ESSENTIAL_INCLUDES)
+          filters = {
+            appStoreState: ConnectAPI::Model::AppStoreVersion::AppStoreState::READY_FOR_SALE
+          }
+
+          app_versions(id, include: includes, filter: filters).to_model
+        end
+      end
+    end
+  end
+end