app_status_notification 0.9.0.beta1

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module AppStatusNotification
+  class ConnectAPI
+    module Client
+      module AppStoreVersion
+        def versions(query = {})
+          get('appStoreVersions', query)
+        end
+
+        def version(id, query = {})
+          get("appStoreVersions/#{id}", query)
+        end
+
+        def select_version_build(id, build_id:)
+          body = {
+            data: {
+              type: 'builds',
+              id: build_id
+            }
+          }
+
+          patch("appStoreVersions/#{id}/relationships/build", body: body)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module AppStatusNotification
+  class ConnectAPI
+    module Client
+      module Build
+        def app_latest_build(id)
+          app_builds(id, limit: 1).to_model
+        end
+
+        def app_builds(id, **kargs)
+          kargs = kargs.merge(filter: { app: id })
+          builds(**kargs)
+        end
+
+        def builds(limit: 200, sort: '-uploadedDate',
+          includes: ConnectAPI::Model::Build::ESSENTIAL_INCLUDES,
+                   **kargs)
+
+          kargs = kargs.merge(limit: limit)
+            .merge(sort: sort)
+            .merge(include: includes)
+
+          get('builds', **kargs)
+        end
+      end
+    end
+  end
+end

data/lib/app_status_notification/connect_api/model.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+module AppStatusNotification
+  class ConnectAPI
+    module Platform
+      IOS = 'IOS'
+      MAC_OS = 'MAC_OS'
+      TV_OS = 'TV_OS'
+      WATCH_OS = 'WATCH_OS'
+
+      ALL = [IOS, MAC_OS, TV_OS, WATCH_OS]
+    end
+
+    module ProcessStatus
+      PROCESSING = 'PROCESSING'
+      FAILED = 'FAILED'
+      INVALID = 'INVALID'
+      VALID = 'VALID'
+    end
+
+    module Model
+      def self.included(base)
+        Parser.types ||= []
+        Parser.types << base
+        base.extend(Parser)
+      end
+
+      attr_accessor :id
+      attr_reader :attributes
+      attr_reader :rate
+
+      def initialize(id, attributes, rate)
+        @id = id
+        @attributes = attributes
+        @rate = rate
+
+        update_attributes(attributes)
+      end
+
+      def update_attributes(attributes)
+        (attributes || []).each do |key, value|
+
+          method = "#{key.to_s.underscore}=".to_sym
+          self.send(method, value) if self.respond_to?(method)
+        end
+      end
+    end
+
+    module Parser
+      class << self
+        attr_accessor :types
+        attr_accessor :types_cache
+      end
+
+      def self.parse(response, rate)
+        body = response.body
+        data = body['data']
+        raise ConnectAPIError, 'No data' unless data
+
+        included = body['included'] || []
+        if data.kind_of?(Hash)
+          inflate_model(data, included, rate: rate)
+        elsif data.kind_of?(Array)
+          return data.map do |model_data|
+            inflate_model(model_data, included, rate: rate)
+          end
+        else
+          raise ConnectAPIError, "'data' is neither a hash nor an array"
+        end
+      end
+
+      def self.inflate_model(model_data, included, rate: {})
+        # Find class
+        type_class = find_class(model_data)
+        raise "No type class found for #{model_data['type']}" unless type_class
+
+        # Get id and attributes needed for inflating
+        id = model_data['id']
+        attributes = model_data['attributes']
+
+        # Instantiate object and inflate relationships
+        relationships = model_data['relationships'] || []
+        type_instance = type_class.new(id, attributes, rate)
+
+        inflate_model_relationships(type_instance, relationships, included)
+      end
+
+      def self.find_class(model_data)
+        # Initialize cache
+        @types_cache ||= {}
+
+        # Find class in cache
+        type_string = model_data['type']
+        type_class = @types_cache[type_string]
+        return type_class if type_class
+
+        # Find class in array
+        type_class = @types.find do |type|
+          type.type == type_string
+        end
+
+        # Cache and return class
+        type_class
+      end
+
+      def self.inflate_model_relationships(type_instance, relationships, included)
+        # Relationship attributes to set
+        attributes = {}
+
+        # 1. Iterate over relationships
+        # 2. Find id and type
+        # 3. Find matching id and type in included
+        # 4. Inflate matching data and set in attributes
+        relationships.each do |key, value|
+          # Validate data exists
+          value_data_or_datas = value['data']
+          next unless value_data_or_datas
+
+          # Map an included data object
+          map_data = lambda do |value_data|
+            id = value_data['id']
+            type = value_data['type']
+
+            relationship_data = included.find do |included_data|
+              id == included_data['id'] && type == included_data['type']
+            end
+
+            inflate_model(relationship_data, included) if relationship_data
+          end
+
+          # Map a hash or an array of data
+          if value_data_or_datas.kind_of?(Hash)
+            attributes[key] = map_data.call(value_data_or_datas)
+          elsif value_data_or_datas.kind_of?(Array)
+            attributes[key] = value_data_or_datas.map(&map_data)
+          end
+        end
+
+        type_instance.update_attributes(attributes)
+        type_instance
+      end
+    end
+  end
+end
+
+require 'app_status_notification/connect_api/models/app'
+require 'app_status_notification/connect_api/models/app_store_version'
+require 'app_status_notification/connect_api/models/build'
+require 'app_status_notification/connect_api/models/pre_release_version'
+require 'app_status_notification/connect_api/models/app_store_version_submission'

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'app_status_notification/connect_api/model'
+
+module AppStatusNotification::ConnectAPI::Model
+  class App
+    include AppStatusNotification::ConnectAPI::Model
+
+    attr_accessor :name
+    attr_accessor :bundle_id
+    attr_accessor :sku
+    attr_accessor :primary_locale
+    attr_accessor :is_opted_in_to_distribute_ios_app_on_mac_app_store
+    attr_accessor :removed
+    attr_accessor :is_aag
+    attr_accessor :available_in_new_territories
+    attr_accessor :content_rights_declaration
+
+    # include
+    attr_accessor :app_store_versions
+    attr_accessor :builds
+
+    def self.type
+      'apps'
+    end
+  end
+end

data/lib/app_status_notification/connect_api/models/app_store_version.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'app_status_notification/connect_api/model'
+
+module AppStatusNotification::ConnectAPI::Model
+  class AppStoreVersion
+    include AppStatusNotification::ConnectAPI::Model
+
+    attr_accessor :platform
+    attr_accessor :version_string
+    attr_accessor :app_store_state
+    attr_accessor :release_type
+    attr_accessor :earliest_release_date # 2020-06-17T12:00:00-07:00
+    attr_accessor :uses_idfa
+    attr_accessor :downloadable
+    attr_accessor :created_date
+    attr_accessor :version
+    attr_accessor :uploaded_date
+    attr_accessor :expiration_date
+    attr_accessor :expired
+    attr_accessor :store_icon
+    attr_accessor :watch_store_icon
+    attr_accessor :copyright
+    attr_accessor :min_os_version
+
+    # include
+    attr_accessor :app
+    attr_accessor :app_store_version_submission
+    attr_accessor :build
+
+    ESSENTIAL_INCLUDES = [
+      'app',
+      'appStoreVersionSubmission',
+      'build'
+    ].join(',')
+
+    module AppStoreState
+      READY_FOR_SALE = 'READY_FOR_SALE'
+      PROCESSING_FOR_APP_STORE = 'PROCESSING_FOR_APP_STORE'
+      PENDING_DEVELOPER_RELEASE = 'PENDING_DEVELOPER_RELEASE'
+      IN_REVIEW = 'IN_REVIEW'
+      WAITING_FOR_REVIEW = 'WAITING_FOR_REVIEW'
+      DEVELOPER_REJECTED = 'DEVELOPER_REJECTED'
+      REJECTED = 'REJECTED'
+      PREPARE_FOR_SUBMISSION = 'PREPARE_FOR_SUBMISSION'
+      METADATA_REJECTED = 'METADATA_REJECTED'
+      INVALID_BINARY = 'INVALID_BINARY'
+    end
+
+    module ReleaseType
+      AFTER_APPROVAL = 'AFTER_APPROVAL'
+      MANUAL = 'MANUAL'
+      SCHEDULED = 'SCHEDULED'
+    end
+
+    def self.type
+      'appStoreVersions'
+    end
+
+    def on_sale?
+      app_store_state == AppStoreState::READY_FOR_SALE ||
+      app_store_state == AppStoreState::PROCESSING_FOR_APP_STORE
+    end
+
+    def in_review?
+      app_store_state == AppStoreState::IN_REVIEW
+    end
+
+    def preparing?
+      app_store_state == AppStoreState::PREPARE_FOR_SUBMISSION ||
+      app_store_state == AppStoreState::DEVELOPER_REJECTED
+    end
+
+    def rejected?
+      app_store_state == AppStoreState::REJECTED ||
+      app_store_state == AppStoreState::METADATA_REJECTED ||
+      app_store_state == AppStoreState::INVALID_BINARY
+    end
+
+    def editable?
+      preparing? || rejected?
+    end
+  end
+end

data/lib/app_status_notification/connect_api/models/app_store_version_submission.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'app_status_notification/connect_api/model'
+
+module AppStatusNotification::ConnectAPI::Model
+  class AppStoreVersionSubmission
+    include AppStatusNotification::ConnectAPI::Model
+
+    attr_accessor :can_reject
+
+    def self.type
+      'appStoreVersionSubmissions'
+    end
+  end
+end

data/lib/app_status_notification/connect_api/models/build.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'app_status_notification/connect_api/model'
+
+module AppStatusNotification::ConnectAPI::Model
+  class Build
+    include AppStatusNotification::ConnectAPI::Model
+
+    attr_accessor :version
+    attr_accessor :uploaded_date
+    attr_accessor :expiration_date
+    attr_accessor :expired
+    attr_accessor :min_os_version
+    attr_accessor :icon_asset_token
+    attr_accessor :processing_state
+    attr_accessor :uses_non_exempt_encryption
+
+    attr_accessor :app
+    attr_accessor :beta_app_review_submission
+    attr_accessor :beta_build_metrics
+    attr_accessor :build_beta_detail
+    attr_accessor :pre_release_version
+
+    ESSENTIAL_INCLUDES = 'app,preReleaseVersion'
+
+    def self.type
+      'builds'
+    end
+  end
+end

data/lib/app_status_notification/connect_api/models/pre_release_version.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'app_status_notification/connect_api/model'
+
+module AppStatusNotification::ConnectAPI::Model
+  class PreReleaseVersion
+    include AppStatusNotification::ConnectAPI::Model
+
+    attr_accessor :version
+    attr_accessor :platform
+
+    def self.type
+      return 'preReleaseVersions'
+    end
+  end
+end

data/lib/app_status_notification/connect_api/response.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module AppStatusNotification
+  class ConnectAPI
+    class Response
+      include Enumerable
+      extend Forwardable
+
+      attr_reader :response, :connection
+
+      def initialize(response, connection)
+        @response = response
+        @connection = connection
+      end
+
+      def_delegators :@response, :status, :headers
+
+      def request_url
+        @response.env.url
+      end
+
+      def rate
+        return {} unless value = response.headers[:x_rate_limit]
+
+        value.split(';').inject({}) do |r, q|
+          k, v = q.split(':')
+          case k
+          when 'user-hour-lim'
+            r.merge!(limit: v)
+          when 'user-hour-rem'
+            r.merge!(remaining: v)
+          end
+        end
+      end
+
+      def next_link
+        return if response.nil?
+
+        links = response[:links] || {}
+        links[:next]
+      end
+
+      # def all_pages
+      #   next_pages(count: 0)
+      # end
+
+      # def next_pages(count: 1)
+      #   count = count.to_i
+      #   count = 0 if count <= 0
+
+      #   responses = [self]
+      #   counter = 0
+
+      #   resp = self
+      #   loop do
+      #     resp = resp.next_page
+      #     break if resp.nil?
+
+      #     responses << resp
+      #     counter += 1
+
+      #     break if counter >= count
+      #   end
+
+      #   responses
+      # end
+
+      # def next_url
+      #   return if response.nil?
+
+      #   links = response[:links] || {}
+      #   links[:next]
+      # end
+
+      # def next_page
+      #   return unless url = next_url
+
+      #   Response.new(connection.get(url), connection)
+      # end
+
+      def to_model
+        to_models.first
+      end
+
+      def to_models
+        return [] if response.nil?
+
+        model_or_models = ConnectAPI::Parser.parse(response, rate)
+        [model_or_models].flatten
+      end
+
+      def each(&block)
+        to_models.each do |model|
+          yield(model)
+        end
+      end
+    end
+  end
+end
+