candy_check 0.1.0.pre → 0.3.0

data/lib/candy_check/app_store/receipt_collection.rb

@@ -8,15 +8,17 @@ module CandyCheck
 
       # Initializes a new instance which bases on a JSON result
       # from Apple's verification server
-      # @param attributes [Array<Hash>]
+      # @param attributes [Array<Hash>] raw data from Apple's server
       def initialize(attributes)
-        @receipts = attributes.map { |r| Receipt.new(r) }
+        @receipts = attributes.map {|r| Receipt.new(r) }.sort{ |a, b|
+          a.purchase_date - b.purchase_date
+        }
       end
 
       # Check if the latest expiration date is passed
       # @return [bool]
       def expired?
-        overdue_days > 0
+        expires_at.to_time <= Time.now.utc
       end
 
       # Check if in trial

data/lib/candy_check/app_store/subscription_verification.rb

@@ -3,13 +3,28 @@ module CandyCheck
     # Verifies a latest_receipt_info block against a verification server.
     # The call return either an {ReceiptCollection} or a {VerificationFailure}
     class SubscriptionVerification < CandyCheck::AppStore::Verification
+      # Builds a fresh verification run
+      # @param endpoint_url [String] the verification URL to use
+      # @param receipt_data [String] the raw data to be verified
+      # @param secret [String] optional: shared secret
+      # @param product_ids [Array<String>] optional: select specific products
+      def initialize(
+        endpoint_url,
+        receipt_data,
+        secret = nil,
+        product_ids = nil
+      )
+        super(endpoint_url, receipt_data, secret)
+        @product_ids = product_ids
+      end
+
       # Performs the verification against the remote server
       # @return [ReceiptCollection] if successful
       # @return [VerificationFailure] otherwise
       def call!
         verify!
         if valid?
-          ReceiptCollection.new(@response['latest_receipt_info'])
+          build_collection(@response['latest_receipt_info'])
         else
           VerificationFailure.fetch(@response['status'])
         end
@@ -17,6 +32,15 @@ module CandyCheck
 
       private
 
+      def build_collection(latest_receipt_info)
+        unless @product_ids.nil?
+          latest_receipt_info = latest_receipt_info.select do |info|
+            @product_ids.include?(info['product_id'])
+          end
+        end
+        ReceiptCollection.new(latest_receipt_info)
+      end
+
       def valid?
         status_is_ok = @response['status'] == STATUS_OK
         @response && status_is_ok && @response['latest_receipt_info']

data/lib/candy_check/app_store/verification.rb

@@ -16,7 +16,7 @@ module CandyCheck
       # Builds a fresh verification run
       # @param endpoint_url [String] the verification URL to use
       # @param receipt_data [String] the raw data to be verified
-      # @param secret [String] the optional shared secret
+      # @param secret [String] optional: shared secret
       def initialize(endpoint_url, receipt_data, secret = nil)
         @endpoint_url = endpoint_url
         @receipt_data = receipt_data

data/lib/candy_check/app_store/verifier.rb

@@ -30,33 +30,33 @@ module CandyCheck
       # @return [Receipt] if successful
       # @return [VerificationFailure] otherwise
       def verify(receipt_data, secret = nil)
-        @verifier = Verification
-        fetch_receipt_information(receipt_data, secret)
+        fetch_receipt_information(Verification, [receipt_data, secret])
       end
 
       # Calls a subscription verification for the given input
       # @param receipt_data [String] the raw data to be verified
-      # @param secret [string] the optional shared secret
+      # @param secret [String] optional: shared secret
+      # @param product_ids [Array<String>] optional: products to filter
       # @return [ReceiptCollection] if successful
       # @return [Verification] otherwise
-      def verify_subscription(receipt_data, secret = nil)
-        @verifier = SubscriptionVerification
-        fetch_receipt_information(receipt_data, secret)
+      def verify_subscription(receipt_data, secret = nil, product_ids = nil)
+        args = [receipt_data, secret, product_ids]
+        fetch_receipt_information(SubscriptionVerification, args)
       end
 
       private
 
-      def fetch_receipt_information(receipt_data, secret = nil)
+      def fetch_receipt_information(verifier_class, args)
         default_endpoint, opposite_endpoint = endpoints
-        result = call_for(default_endpoint, receipt_data, secret)
+        result = call_for(verifier_class, args.dup.unshift(default_endpoint))
         if should_retry?(result)
-          return call_for(opposite_endpoint, receipt_data, secret)
+          return call_for(verifier_class, args.dup.unshift(opposite_endpoint))
         end
         result
       end
 
-      def call_for(endpoint_url, receipt_data, secret)
-        @verifier.new(endpoint_url, receipt_data, secret).call!
+      def call_for(verifier_class, args)
+        verifier_class.new(*args).call!
       end
 
       def should_retry?(result)

data/lib/candy_check/cli/app.rb

@@ -1,4 +1,4 @@
-require 'thor'
+require "thor"
 
 module CandyCheck
   module CLI
@@ -6,54 +6,37 @@ module CandyCheck
     # @example
     #   $> candy_check help
     class App < Thor
-      package_name 'CandyCheck'
+      package_name "CandyCheck"
 
-      desc 'app_store RECEIPT_DATA', 'Verify a base64 encoded AppStore receipt'
+      desc "app_store RECEIPT_DATA", "Verify a base64 encoded AppStore receipt"
       method_option :environment,
-                    default: 'production',
+                    default: "production",
                     type: :string,
                     enum: %w(production sandbox),
-                    aliases: '-e',
-                    desc: 'The environment to use for verfication'
+                    aliases: "-e",
+                    desc: "The environment to use for verfication"
       method_option :secret,
-                    aliases: '-s',
+                    aliases: "-s",
                     type: :string,
-                    desc: 'The shared secret for auto-renewable subscriptions'
+                    desc: "The shared secret for auto-renewable subscriptions"
+
       def app_store(receipt)
         Commands::AppStore.run(receipt, options)
       end
 
-      desc 'play_store PACKAGE PRODUCT_ID TOKEN', 'Verify PlayStore purchase'
-      method_option :issuer,
-                    required: true,
-                    type: :string,
-                    aliases: '-i',
-                    desc: 'The issuer\'s email address for the API call'
-      method_option :key_file,
+      desc "play_store PACKAGE PRODUCT_ID TOKEN", "Verify PlayStore purchase"
+      method_option :json_key_file,
                     required: true,
                     type: :string,
-                    aliases: '-k',
-                    desc: 'The key file to use for API authentication'
-      method_option :key_secret,
-                    default: 'notasecret',
-                    type: :string,
-                    aliases: '-s',
-                    desc: 'The secret to decrypt the key_file'
-      method_option :application_name,
-                    default: 'CandyCheck',
-                    type: :string,
-                    aliases: '-a',
-                    desc: 'Your application\'s name'
-      method_option :application_version,
-                    default: CandyCheck::VERSION,
-                    type: :string,
-                    aliases: '-v',
-                    desc: 'Your application\'s version'
+                    aliases: "-k",
+                    desc: "The json key file to use for API authentication"
+
       def play_store(package, product_id, token)
         Commands::PlayStore.run(package, product_id, token, options)
       end
 
-      desc 'version', 'Print the gem\'s version'
+      desc "version", 'Print the gem\'s version'
+
       def version
         Commands::Version.run
       end

data/lib/candy_check/cli/commands/play_store.rb

@@ -4,17 +4,13 @@ module CandyCheck
       # Command to verify an PlayStore purchase
       class PlayStore < Base
         # Prepare a verification run from the terminal
-        # @param package [String]
+        # @param package_name [String]
         # @param product_id [String]
         # @param token [String]
         # @param options [Hash]
-        # @option options [String] :issuer to use for API access
-        # @option options [String] :key_file to use for API access
-        # @option options [String] :key_secret to decrypt the key file
-        # @option options [String] :application_name for the API call
-        # @option options [String] :application_version for the API call
-        def initialize(package, product_id, token, options)
-          @package = package
+        # @option options [String] :json_key_file to use for API access
+        def initialize(package_name, product_id, token, options)
+          @package = package_name
           @product_id = product_id
           @token = token
           super(options)
@@ -22,17 +18,20 @@ module CandyCheck
 
         # Print the result of the verification to the terminal
         def run
-          verifier = CandyCheck::PlayStore::Verifier.new(config)
-          verifier.boot!
-          result = verifier.verify(@package, @product_id, @token)
+          verifier = CandyCheck::PlayStore::Verifier.new(authorization: authorization)
+          result = verifier.verify_product_purchase(
+            package_name: @package,
+            product_id: @product_id,
+            token: @token,
+          )
           out.print "#{result.class}:"
           out.pretty result
         end
 
         private
 
-        def config
-          CandyCheck::PlayStore::Config.new(options)
+        def authorization
+          CandyCheck::PlayStore.authorization(options["json_key_file"])
         end
       end
     end

data/lib/candy_check/play_store.rb

@@ -1,17 +1,27 @@
-require 'google/api_client'
+require "google/apis/androidpublisher_v3"
 
-require 'candy_check/play_store/discovery_repository'
-require 'candy_check/play_store/client'
-require 'candy_check/play_store/config'
-require 'candy_check/play_store/receipt'
-require 'candy_check/play_store/subscription'
-require 'candy_check/play_store/verification'
-require 'candy_check/play_store/subscription_verification'
-require 'candy_check/play_store/verification_failure'
-require 'candy_check/play_store/verifier'
+require "candy_check/play_store/android_publisher_service"
+require "candy_check/play_store/product_purchases/product_purchase"
+require "candy_check/play_store/subscription_purchases/subscription_purchase"
+require "candy_check/play_store/product_purchases/product_verification"
+require "candy_check/play_store/product_acknowledgements/acknowledgement"
+require "candy_check/play_store/product_acknowledgements/response"
+require "candy_check/play_store/subscription_purchases/subscription_verification"
+require "candy_check/play_store/verification_failure"
+require "candy_check/play_store/verifier"
+require "candy_check/play_store/acknowledger"
 
 module CandyCheck
   # Module to request and verify a AppStore receipt
   module PlayStore
+    # Build an authorization object
+    # @param json_key_file [String]
+    # @return [Google::Auth::ServiceAccountCredentials]
+    def self.authorization(json_key_file)
+      Google::Auth::ServiceAccountCredentials.make_creds(
+        json_key_io: File.open(json_key_file),
+        scope: "https://www.googleapis.com/auth/androidpublisher",
+      )
+    end
   end
 end

data/lib/candy_check/play_store/acknowledger.rb

@@ -0,0 +1,19 @@
+module CandyCheck
+  module PlayStore
+    class Acknowledger
+      def initialize(authorization:)
+        @authorization = authorization
+      end
+
+      def acknowledge_product_purchase(package_name:, product_id:, token:)
+        acknowledger = CandyCheck::PlayStore::ProductAcknowledgements::Acknowledgement.new(
+          package_name: package_name,
+          product_id: product_id,
+          token: token,
+          authorization: @authorization,
+        )
+        acknowledger.call!
+      end
+    end
+  end
+end

data/lib/candy_check/play_store/android_publisher_service.rb

@@ -0,0 +1,6 @@
+module CandyCheck
+  module PlayStore
+    class AndroidPublisherService < Google::Apis::AndroidpublisherV3::AndroidPublisherService
+    end
+  end
+end

data/lib/candy_check/play_store/product_acknowledgements/acknowledgement.rb

@@ -0,0 +1,45 @@
+module CandyCheck
+  module PlayStore
+    module ProductAcknowledgements
+      # Verifies a purchase token against the PlayStore API
+
+      class Acknowledgement
+        # @return [String] the package_name which will be queried
+        attr_reader :package_name
+        # @return [String] the item id which will be queried
+        attr_reader :product_id
+        # @return [String] the token for authentication
+        attr_reader :token
+
+        # Initializes a new call to the API
+        # @param package_name [String]
+        # @param product_id [String]
+        # @param token [String]
+        def initialize(package_name:, product_id:, token:, authorization:)
+          @package_name = package_name
+          @product_id = product_id
+          @token = token
+          @authorization = authorization
+        end
+
+        def call!
+          acknowledge!
+
+          CandyCheck::PlayStore::ProductAcknowledgements::Response.new(
+            result: @response[:result], error_data: @response[:error_data])
+        end
+
+        private
+
+        def acknowledge!
+          service = CandyCheck::PlayStore::AndroidPublisherService.new
+
+          service.authorization = @authorization
+          service.acknowledge_purchase_product(package_name, product_id, token) do |result, error_data|
+            @response = { result: result, error_data: error_data }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/candy_check/play_store/product_acknowledgements/response.rb

@@ -0,0 +1,24 @@
+module CandyCheck
+  module PlayStore
+    module ProductAcknowledgements
+      class Response
+        def initialize(result:, error_data:)
+          @result = result
+          @error_data = error_data
+        end
+
+        def acknowledged?
+          !!result
+        end
+
+        def error
+          return unless error_data
+
+          { status_code: error_data.status_code, body: error_data.body }
+        end
+
+        attr_reader :result, :error_data
+      end
+    end
+  end
+end

data/lib/candy_check/play_store/product_purchases/product_purchase.rb

@@ -0,0 +1,90 @@
+module CandyCheck
+  module PlayStore
+    module ProductPurchases
+      # Describes a successful response from the PlayStore verification server
+      class ProductPurchase
+        include Utils::AttributeReader
+
+        # Returns the raw ProductPurchase from google-api-client gem
+        # @return [Google::Apis::AndroidpublisherV3::ProductPurchase]
+        attr_reader :product_purchase
+
+        # Purchased product (0 is purchased, don't ask me why)
+        # @see https://developers.google.com/android-publisher/api-ref/purchases/products
+        PURCHASE_STATE_PURCHASED = 0
+
+        # A consumed product
+        CONSUMPTION_STATE_CONSUMED = 1
+
+        # Initializes a new instance which bases on a JSON result
+        # from PlayStore API servers
+        # @param product_purchase [Google::Apis::AndroidpublisherV3::ProductPurchase]
+        def initialize(product_purchase)
+          @product_purchase = product_purchase
+        end
+
+        # The purchase state of the order. Possible values are:
+        #   * 0: Purchased
+        #   * 1: Cancelled
+        # @return [Fixnum]
+        def purchase_state
+          @product_purchase.purchase_state
+        end
+
+        # The consumption state of the inapp product. Possible values are:
+        #   * 0: Yet to be consumed
+        #   * 1: Consumed
+        # @return [Fixnum]
+        def consumption_state
+          @product_purchase.consumption_state
+        end
+
+        # The developer payload which was used when buying the product
+        # @return [String]
+        def developer_payload
+          @product_purchase.developer_payload
+        end
+
+        # This kind represents an inappPurchase object in the androidpublisher
+        # service.
+        # @return [String]
+        def kind
+          @product_purchase.kind
+        end
+
+        # The order id
+        # @return [String]
+        def order_id
+          @product_purchase.order_id
+        end
+
+        # The time the product was purchased, in milliseconds since the
+        # epoch (Jan 1, 1970)
+        # @return [Fixnum]
+        def purchase_time_millis
+          @product_purchase.purchase_time_millis
+        end
+
+        # A product may be purchased or canceled. Ensure a receipt
+        # is valid before granting some candy
+        # @return [Boolean]
+        def valid?
+          purchase_state == PURCHASE_STATE_PURCHASED
+        end
+
+        # A purchased product may already be consumed. In this case you
+        # should grant candy even if it's valid.
+        # @return [Boolean]
+        def consumed?
+          consumption_state == CONSUMPTION_STATE_CONSUMED
+        end
+
+        # The date and time the product was purchased
+        # @return [DateTime]
+        def purchased_at
+          Time.at(purchase_time_millis / 1000).utc.to_datetime
+        end
+      end
+    end
+  end
+end