cardmarket_cli 0.0.0

data/lib/cardmarket_cli.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'cardmarket_cli/version'
+require 'cardmarket_cli/account'
+require 'cardmarket_cli/logger'
+require 'cardmarket_cli/entities/deletable'
+require 'cardmarket_cli/entities/entity'
+require 'cardmarket_cli/entities/changeable'
+require 'cardmarket_cli/entities/meta_product'
+require 'cardmarket_cli/entities/product'
+require 'cardmarket_cli/entities/wantslist'
+require 'cardmarket_cli/entities/wantslist_item'
+
+module CardmarketCLI
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/cardmarket_cli/account.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'oauth'
+require 'typhoeus'
+require 'oauth/request_proxy/typhoeus_request'
+require 'xmlsimple'
+require 'cgi'
+require 'cardmarket_cli/logger'
+require 'json'
+
+module CardmarketCLI
+  ##
+  #
+  class Account
+    attr_reader :request_limit, :request_count
+
+    def initialize(app_token, app_secret, access_token, access_token_secret, options = {})
+      options[:site] ||= options[:test] ? 'https://sandbox.cardmarket.com' : 'https://api.cardmarket.com'
+      @oauth_consumer = OAuth::Consumer.new(app_token, app_secret, site: options[:site])
+      @access_token = OAuth::AccessToken.new(@oauth_consumer, access_token, access_token_secret)
+    end
+
+    def get(path, body: nil, format: :json, params: {})
+      request(path, :get, body: body, format: format, params: params)
+    end
+
+    def put(path, body: nil, format: :json, params: {})
+      request(path, :put, body: body, format: format, params: params)
+    end
+
+    def post(path, body: nil, format: :json, params: {})
+      request(path, :post, body: body, format: format, params: params)
+    end
+
+    def delete(path, body: nil, format: :json, params: {})
+      request(path, :delete, body: body, format: format, params: params)
+    end
+
+    def request(path, method, body: nil, format: :json, params: {})
+      uri = make_uri(path, format: format, params: params)
+      req = Typhoeus::Request.new(uri, method: method, body: make_body(body))
+      oauth_helper = OAuth::Client::Helper.new(req, consumer: @oauth_consumer, token: @access_token, request_uri: uri)
+      req.options[:headers].merge!(
+        { 'Authorization' => oauth_helper.header + ", realm=#{make_uri(path, format: format).inspect}" }
+      )
+      LOGGER.info log_request(method, uri, body)
+      run_req(req)
+    end
+
+    def make_uri(path, format: :json, params: {})
+      raise "Unknown format #{format}" unless %i[json xml].include?(format)
+
+      params = "#{'?' unless params.empty?}#{params.to_a.map { |k, v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }
+                                              .join('&')}"
+      "#{@oauth_consumer.site}/ws/v2.0/output.#{format}/#{path}#{params}"
+    end
+
+    def make_body(body)
+      if body.respond_to? :each
+        body = XmlSimple.xml_out(body, RootName: 'request', XmlDeclaration: '<?xml version="1.0" encoding="UTF-8" ?>',
+                                       SuppressEmpty: nil, NoAttr: true)
+      end
+      body
+    end
+
+    private
+
+    def run_req(req)
+      response = req.run
+      @request_count = get_from_header(response, /X-Request-Limit-Count: \d+/).to_i
+      @request_limit = get_from_header(response, /X-Request-Limit-Max: \d+/).to_i
+      LOGGER.info("#{response.response_code} (#{response.return_code}) (Limit: "\
+                  "#{request_count || '?'}/#{request_limit || '?'})")
+      LOGGER.debug { JSON.parse(response.response_body).to_yaml }
+      response
+    end
+
+    def get_from_header(response, regex)
+      match = response.response_headers.match(regex)
+      match&.size&.positive? ? match[0].split(':')&.fetch(1) : nil
+    end
+
+    def log_request(method, uri, body)
+      LOGGER.info("#{method.to_s.capitalize}: #{uri.inspect}")
+      LOGGER.debug { body.to_yaml }
+    end
+  end
+end

data/lib/cardmarket_cli/entities/changeable.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'cardmarket_cli/entities/entity'
+
+module CardmarketCLI
+  module Entities
+    ##
+    # Base for all entities with changeable attributes in the API
+    class Changeable < Entity
+      def initialize(id, account, params)
+        super(id, account, params)
+        @changed = false
+      end
+
+      def changed?
+        @changed
+      end
+
+      protected
+
+      attr_writer :changed
+
+      class << self
+        protected
+
+        def attr_(*symbols)
+          attr_r(*symbols)
+          symbols.each do |symbol|
+            define_method "#{symbol}=" do |val|
+              return if @params[symbol] == val
+
+              @params[symbol] = val
+              @changed = true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cardmarket_cli/entities/deletable.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module CardmarketCLI
+  module Entities
+    ##
+    # marks that an entity can be deleted
+    module Deletable
+      def list_attr(symbol, options = {})
+        options = { plural: "#{symbol}s", default: true, suffix: true, add: 'add', delete: 'delete', hash: false }
+                  .merge!(options)
+        def_modifiers(symbol, options[:plural], options)
+        def_reader(options[:plural], options[:hash])
+        def_brackets(options[:plural], options[:hash]) if options[:default]
+        def_clear(options[:plural], options[:hash])
+        symbol
+      end
+
+      private
+
+      def def_modifiers(symbol, plural, options)
+        options = { suffix: true, add: 'add', delete: 'delete', hash: false }.merge! options
+        if options[:hash]
+          def_add_hash(symbol, plural, options[:add], options[:suffix])
+          def_delete_hash(symbol, plural, options[:delete], options[:suffix])
+        else
+          def_add_array(symbol, plural, options[:add], options[:suffix])
+          def_delete_array(symbol, plural, options[:delete], options[:suffix])
+        end
+      end
+
+      def def_add_hash(symbol, plural, name, suffix)
+        define_method "#{name}#{"_#{symbol}" if suffix}" do |params|
+          key, value, = params
+          instance_variable_set("@#{plural}", {}) unless instance_variable_defined? "@#{plural}"
+          instance_variable_set("@deleted_#{plural}", {}) unless instance_variable_defined? "@deleted_#{plural}"
+          instance_variable_get("@#{plural}")[key] = value if key
+          instance_variable_get("@deleted_#{plural}").delete(key)
+          { key => value }
+        end
+      end
+
+      def def_add_array(symbol, plural, name, suffix)
+        define_method "#{name}#{"_#{symbol}" if suffix}" do |value|
+          instance_variable_set("@#{plural}", []) unless instance_variable_defined? "@#{plural}"
+          instance_variable_set("@deleted_#{plural}", []) unless instance_variable_defined? "@deleted_#{plural}"
+          instance_variable_get("@#{plural}") << value if value
+          instance_variable_get("@deleted_#{plural}").delete(value)
+          value
+        end
+      end
+
+      def def_delete_hash(symbol, plural, name, suffix)
+        define_method "#{name}#{"_#{symbol}" if suffix}" do |key|
+          instance_variable_set("@#{plural}", {}) unless instance_variable_defined? "@#{plural}"
+          instance_variable_set("@deleted_#{plural}", {}) unless instance_variable_defined? "@deleted_#{plural}"
+          deleted = instance_variable_get("@#{plural}").delete(key)
+          instance_variable_get("@deleted_#{plural}")[key] = deleted if deleted
+          deleted
+        end
+      end
+
+      def def_delete_array(symbol, plural, name, suffix)
+        define_method "#{name}#{"_#{symbol}" if suffix}" do |value|
+          instance_variable_set("@#{plural}", []) unless instance_variable_defined? "@#{plural}"
+          instance_variable_set("@deleted_#{plural}", []) unless instance_variable_defined? "@deleted_#{plural}"
+          deleted = instance_variable_get("@#{plural}").delete(value)
+          instance_variable_get("@deleted_#{plural}") << deleted if deleted
+          deleted
+        end
+      end
+
+      def def_reader(plural, hash)
+        return if respond_to? plural.to_s.to_sym
+
+        def_reader_normal(plural, hash)
+        def_reader_deleted(plural, hash)
+      end
+
+      def def_reader_normal(plural, hash)
+        define_method plural.to_s do
+          instance_variable_set("@#{plural}", hash ? {} : []) unless instance_variable_defined? "@#{plural}"
+          instance_variable_get("@#{plural}").dup
+        end
+      end
+
+      def def_reader_deleted(plural, hash)
+        define_method "deleted_#{plural}" do
+          unless instance_variable_defined? "@deleted_#{plural}"
+            instance_variable_set("@deleted_#{plural}", hash ? {} : [])
+          end
+          instance_variable_get("@deleted_#{plural}").dup
+        end
+      end
+
+      def def_brackets(plural, hash)
+        return if respond_to? :[]
+
+        define_method :[] do |key|
+          instance_variable_set("@#{plural}", hash ? {} : []) unless instance_variable_defined? "@#{plural}"
+          instance_variable_get("@#{plural}")[key]
+        end
+      end
+
+      def def_clear(plural, hash)
+        define_method :clear do
+          instance_variable_set("@#{plural}", hash ? {} : [])
+          instance_variable_set("@deleted_#{plural}", hash ? {} : [])
+        end
+        private :clear
+      end
+    end
+  end
+end

data/lib/cardmarket_cli/entities/entity.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module CardmarketCLI
+  module Entities
+    ##
+    # Base for all entities in the API
+    class Entity
+      attr_reader :id
+
+      def initialize(id, account, params = {})
+        @id = id
+        @params = params
+        @account = account
+      end
+
+      protected
+
+      attr_writer :id
+      attr_accessor :account, :params
+
+      class << self
+        protected
+
+        def attr_r(*symbols)
+          symbols.each do |symbol|
+            define_method symbol do
+              @params[symbol]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cardmarket_cli/entities/meta_product.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'cardmarket_cli/entities/unique'
+require 'cardmarket_cli/entities/entity'
+require 'cardmarket_cli/entities/product'
+require 'cardmarket_cli/logger'
+
+module CardmarketCLI
+  module Entities
+    ##
+    # See https://api.cardmarket.com/ws/documentation/API_2.0:Entities:Metaproduct
+    class MetaProduct < Entity
+      PARAMS = %i[en_name loc_name products].freeze
+      PATH_BASE = 'metaproducts'
+      attr_r(*(PARAMS - [:products]))
+      attr_reader :updated_at
+
+      def initialize(id, account, params = {})
+        super(id, account, { products: [] })
+        merge_params(params)
+        MetaProduct.send(:add, self)
+      end
+
+      def meta?
+        true
+      end
+
+      def products
+        read unless params[:products]
+        params[:products].dup
+      end
+
+      def read
+        LOGGER.debug("Reading Metaproduct #{en_name}(#{id})")
+        response = account.get("#{PATH_BASE}/#{id}")
+        hash = JSON.parse(response.response_body)
+        hash['metaproduct']&.store('product', hash['product'])
+        MetaProduct.from_hash(account, hash['metaproduct'])
+      end
+
+      private
+
+      def merge_params(params)
+        self.params[:products] = self.params[:products].union(params[:products] || [])
+        self.params.merge!(params.slice(*PARAMS))
+        @updated_at = Time.now
+        self
+      end
+
+      class << self
+        extend Unique
+        uniq_attr :instance
+
+        private :new
+
+        def from_hash(account, hash)
+          hash.transform_keys! { |key| key.underscore.to_sym }
+          hash[:products] = []
+          hash.delete(:product)&.each do |product|
+            hash[:products] << Product.from_hash(account, product)
+          end
+          MetaProduct.create(hash[:id_metaproduct], account, hash)
+        end
+
+        def create(id, account, params = {})
+          self[id]&.send(:merge_params, params) || new(id, account, params)
+        end
+
+        def search_all(account, search_string, exact: false)
+          start = 0
+          products = []
+          loop do
+            search(account, search_string, products, start, exact: exact)
+            break unless products.count == start += 100
+          end
+          products
+        end
+
+        def search(account, search_string, array, start, exact: false)
+          response = account.get("#{PATH_BASE}/find", params: { search_all: search_string, exact: exact, start: start,
+                                                                maxResults: 100, idGame: 1, idLanguage: 1 })
+          JSON.parse(response.response_body)['metaproduct']&.each do |product|
+            array << from_hash(account, product)
+          end
+          array
+        end
+      end
+    end
+  end
+end

data/lib/cardmarket_cli/entities/product.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'cardmarket_cli/entities/unique'
+require 'cardmarket_cli/entities/entity'
+require 'cardmarket_cli/logger'
+
+module CardmarketCLI
+  module Entities
+    ##
+    # See https://api.cardmarket.com/ws/documentation/API_2.0:Entities:Product
+    class Product < Entity
+      PARAMS = %i[en_name loc_name meta_product expansion_name rarity count_articles count_foils price_guide].freeze
+      PATH_BASE = 'products'
+      attr_r(*(PARAMS - [:price_guide]))
+
+      def initialize(id, account, params = {})
+        super(id, account, {})
+        merge_params(params)
+        Product.send(:add, self)
+      end
+
+      def meta?
+        false
+      end
+
+      def read
+        LOGGER.debug("Reading Product #{en_name}(#{id})")
+        response = account.get("#{PATH_BASE}/#{id}")
+        hash = JSON.parse(response.response_body)['product']
+        hash['expansion_name'] ||= hash['expansion']&.fetch('enName')
+        Product.from_hash(account, hash)
+      end
+
+      def price_guide
+        params[:price_guide].dup
+      end
+
+      private
+
+      def merge_params(params)
+        params[:price_guide]&.transform_keys! { |key| key.to_s.underscore.to_sym }&.delete(nil)
+        self.params.merge!(params.slice(*PARAMS))
+        self.params[:rarity] = self.params[:rarity]&.to_s&.downcase!&.to_sym
+        @updated_at = Time.now
+        self
+      end
+
+      class << self
+        extend Unique
+        uniq_attr :instance
+
+        private :new
+
+        def from_hash(account, hash)
+          hash.transform_keys! { |key| key.underscore.to_sym }
+          hash[:meta_product] = MetaProduct.create(hash.delete(:id_metaproduct), account)
+          product = Product.create(hash[:id_product], account, hash)
+          hash[:meta_product]&.send(:merge_params, { products: [product] })
+          product
+        end
+
+        def create(id, account, params = {})
+          self[id]&.send(:merge_params, params) || new(id, account, params)
+        end
+
+        def search_all(account, search_string, exact: false)
+          start = 0
+          products = []
+          loop do
+            search(account, search_string, products, start, exact: exact)
+            break unless products.count == start += 100
+          end
+          products
+        end
+
+        def search(account, search_string, array, start, exact: false)
+          response = account.get("#{PATH_BASE}/find", params: { search_all: search_string, exact: exact, start: start,
+                                                                maxResults: 100, idGame: 1, idLanguage: 1 })
+          JSON.parse(response.response_body)['product']&.each do |product|
+            array << from_hash(account, product)
+          end
+          array
+        end
+      end
+    end
+  end
+end