web-connect 0.1.0

data/lib/netfira/web_connect/models/support/shop/settings.rb

@@ -0,0 +1,42 @@
+require 'forwardable'
+require 'active_support/core_ext/object/deep_dup'
+
+module Netfira::WebConnect
+  class Models::Shop::Settings
+    extend Forwardable
+
+    def initialize(proxy)
+      @proxy = proxy
+      @models = proxy.map{ |model| [model.key.to_sym, model] }.to_h
+      @hash = @models.map{ |key, model| [key, model.typed_value]}.to_h
+    end
+
+    def [](key)
+      @hash[key.to_sym]
+    end
+
+    def []=(key, value)
+      key = key.to_sym
+      model = @models[key] ||= @proxy.new(key: key.to_s)
+      model.typed_value = value
+      model.save!
+      @hash[key] = value
+    end
+
+    def to_h
+      @hash.deep_dup
+    end
+
+    def delete(key)
+      key = key.to_sym
+      return false unless @models[key]
+      @models[key].destroy!
+      @models.delete key
+      @hash.delete key
+      true
+    end
+
+    delegate [:count, :length, :size, :each, :map] => :@hash
+
+  end
+end

data/lib/netfira/web_connect/models/support/shop.rb

@@ -0,0 +1,22 @@
+module Netfira::WebConnect
+  class Models::Shop < Model::Support
+
+    has_many :setting_models, class_name: Models::Setting.name, inverse_of: :shop
+
+    def settings
+      @settings ||= Settings.new(setting_models)
+    end
+
+    def reload
+      @settings = nil
+      super
+    end
+
+    def locale
+      settings[:locale] || Netfira::WebConnect.system_locale
+    end
+
+  end
+end
+
+require_relative 'shop/settings'

data/lib/netfira/web_connect/models/support/table.rb

@@ -0,0 +1,5 @@
+module Netfira::WebConnect
+  class Models::Table < Model::Support
+
+  end
+end

data/lib/netfira/web_connect/models.rb

@@ -0,0 +1,73 @@
+require 'active_support/inflector'
+
+module Netfira::WebConnect
+  module Models
+
+    def self.materialize
+
+      # Scrap any existing definitions
+      Models.constants.each do |name|
+        klass = Models.const_get(name)
+        Models.__send__ :remove_const, name if klass < Model::Record || klass < Model::Relation
+      end
+
+      # Load pre-defined models
+      Dir[File.expand_path('../models/*.rb', __FILE__)].each { |p| load p }
+
+      table_names = []
+      tables_to_localize = []
+      tables_to_relate = []
+
+      Model.connection.tables.reject{|x| x == Netfira::WebConnect.schema_migrations_table_name }.each do |table_name|
+        unprefixed_table_name = unprefix_table_name(table_name)
+        if unprefixed_table_name.nil? or unprefixed_table_name[0] == '_'
+          next
+        elsif l10n_table_name? table_name
+          tables_to_localize << l10n_table_owner_name(unprefixed_table_name)
+        elsif unprefixed_table_name =~ /\A(.+)_to_(.+)\z/
+          tables_to_relate << [$1, $2]
+        else
+          table_names << unprefixed_table_name
+        end
+      end
+
+      table_props = Models::Table.all.map{ |model| [model.name, model] }.to_h
+
+      table_names.each do |name|
+        props = table_props[name]
+        next unless props
+        Model::Record.materialize name.camelize.singularize,
+                                  tables_to_localize.include?(name),
+                                  props
+      end
+
+      tables_to_relate.each do |names|
+        Model::Relation.materialize *names.map{ |x| x.camelize.singularize }
+      end
+
+    end
+
+    private
+
+    def self.unprefix_table_name(name)
+      return unless name.starts_with? Netfira::WebConnect.db_table_prefix.to_s
+      @prefix_range ||= (Netfira::WebConnect.db_table_prefix.length)..-1
+      name[@prefix_range]
+    end
+
+    def self.l10n_table_name?(name)
+      @l10n_suffix ||= Netfira::WebConnect.db_table_l10n_suffix.to_s
+      @l10n_suffix_range ||= (-@l10n_suffix.length)..-1
+      @l10n_suffix == name[@l10n_suffix_range]
+    end
+
+    def self.l10n_table_owner_name(name)
+      name[@l10n_table_name_range ||= 0..(-@l10n_suffix.length - 1)] if l10n_table_name? name
+    end
+
+  end
+end
+
+require_relative 'models/support/setting'
+require_relative 'models/support/shop'
+require_relative 'models/support/table'

data/lib/netfira/web_connect/rack_app/action.rb

@@ -0,0 +1,66 @@
+require 'active_support/inflector'
+require 'active_support/hash_with_indifferent_access'
+
+#todo needs comment
+module Netfira::WebConnect
+  class RackApp::Action
+    include RackApp::Exceptions::HttpExceptions
+
+    def self.action_classes
+      @action_classes ||= find_action_classes
+    end
+
+    def self.latest_version
+      @latest_version ||= action_classes.keys.max
+    end
+
+    def self.create(action, version = nil)
+      version ||= latest_version
+      klass = nil
+      until klass or version < 1
+        klass = (action_classes[version] || {})[action] # todo needs explination or to be rewritten to be easily readable
+        version -= 1
+      end
+      klass and klass.new
+    end
+
+    def initialize
+      @headers = ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    private
+
+    def self.find_action_classes
+      action_classes = {}
+
+      # Loop through all constants in this class's namespace
+      constants.each do |constant|
+
+        # Match Version# constants (modules containing actions)
+        if constant =~ /\AVersion(\d+)\z/
+
+          # The module containing the actions
+          mod = const_get(constant)
+
+          # A hash of actions, e.g. :commit => Action::Version8::Commit
+          action_classes[$1.to_i] = Hash[mod.constants.map do |name|
+            mod.const_get(name)
+          end.select do |klass|
+            klass < self
+          end.map do |klass|
+            [klass.name.demodulize.underscore.to_sym, klass]
+          end]
+        end
+      end
+
+      action_classes
+    end
+
+  end
+end
+
+# Load action helpers
+Dir[File.expand_path('../action_helpers/*.rb', __FILE__)].each{ |f| require f }
+
+# Pre load all action classes in all versions
+Dir[File.expand_path('../actions/version_*/*.rb', __FILE__)].each{ |f| require f }

data/lib/netfira/web_connect/rack_app/action_helpers/data_types.rb

@@ -0,0 +1,22 @@
+module Netfira::WebConnect
+  class RackApp::Action
+
+    def class_for_record_type(type)
+      class_for_type type, Model::Record
+    end
+
+    def class_for_relation_type(type)
+      class_for_type type, Model::Relation
+    end
+
+    private
+
+    def class_for_type(type, superclass)
+      raise BadRequest, 'No data type specified' if type.nil?
+      klass = Models.const_defined?(type) && Models.const_get(type)
+      raise BadRequest, 'Invalid or unknown data type' unless klass && klass < superclass
+      klass
+    end
+
+  end
+end

data/lib/netfira/web_connect/rack_app/action_helpers/env_importer.rb

@@ -0,0 +1,59 @@
+module Netfira::WebConnect
+  class RackApp::Action
+
+    def import_env(env)
+      @env = env
+
+      # Parse the environment
+      request = Rack::Request.new env
+
+      # Authentication
+      authenticator = Netfira::WebConnect.authenticator
+      if authenticator.respond_to? :call
+        shop_name = env['HTTP_X_SHOP_NAME']
+        password = request['pw'] || env['HTTP_X_PASSWORD']
+
+        # Basic auth
+        auth = Rack::Auth::Basic::Request.new(env)
+        if auth.provided? && auth.basic?
+          shop_name ||= auth.username
+          password ||= auth.credentials[1]
+        end
+
+        result = authenticator.call shop_name, password
+        raise Unauthorized unless result
+        header :x_vary_password, result if String === result
+        @shop = Netfira::WebConnect::Models::Shop.find_or_create_by(name: shop_name)
+
+      elsif authenticator.nil?
+        @shop = Netfira::WebConnect.anonymous_shop
+      else
+        raise 'Authenticator is not callable'
+      end
+
+      # The request verb (PUT, GET, POST etc)
+      @verb = request.request_method.downcase.to_sym
+
+      # Query string
+      @query_string = request.GET
+
+      # The X-Timeout header
+      timeout = env['HTTP_X_TIMEOUT']
+      @timeout = timeout.to_i if timeout
+
+      # Path components
+      if env['PATH_INFO'] =~ /\A\/\d+\/[^\/]+\/(.+)\z/
+        @path = $1.split('/').map{ |x| Rack::Utils.unescape x }
+      end
+
+      # Input
+      if put? or post?
+        @input = request.body
+        @input = StringIO.new(@input.read.unpack('m').first) if env['CONTENT_ENCODING'] == 'base64'
+        @input = JSON.parse @input.read if request.media_type == 'application/json'
+      end
+
+    end
+
+  end
+end

data/lib/netfira/web_connect/rack_app/action_helpers/env_methods.rb

@@ -0,0 +1,23 @@
+module Netfira::WebConnect
+  class RackApp::Action
+
+    attr_reader :timeout, :input, :path, :verb, :shop, :headers, :query_string, :env
+
+    # This method sets a response header, e.g.header 'Content-Type', 'text/plain'
+    def header(name, value)
+      name = name.to_s.split(/[- _]/).map(&:capitalize).join('-').to_sym
+      if value
+        headers[name] = value
+      else
+        headers.delete name
+      end
+    end
+
+    # These methods tell you if a given verb was used, e.g. post?
+    %w[get post put delete].each do |verb|
+      define_method(:"#{verb}?") { self.verb.to_s == verb }
+    end
+
+
+  end
+end

data/lib/netfira/web_connect/rack_app/actions/version_1/not_supported.rb

@@ -0,0 +1,11 @@
+class Netfira::WebConnect::RackApp
+  module Action::Version1
+    %w[Commit Info Settings Checksums Files].each do |name|
+      const_set name, (Class.new(Action) do
+        def call
+          raise Exceptions::HttpExceptions::NotFound
+        end
+      end)
+    end
+  end
+end

data/lib/netfira/web_connect/rack_app/actions/version_8/checksums.rb

@@ -0,0 +1,14 @@
+class Netfira::WebConnect::RackApp
+  module Action::Version8
+    class Checksums < Action
+      def call
+        raise MethodNotAllowed unless get?
+
+        klass = class_for_record_type(query_string['type'])
+        checksums = klass.where(shop_id: shop.id).map{ |record| [record.origin_id, record.digest]}.to_h
+
+        {checksums: checksums}
+      end
+    end
+  end
+end

data/lib/netfira/web_connect/rack_app/actions/version_8/commit/records.rb

@@ -0,0 +1,45 @@
+module Netfira::WebConnect
+  module RackApp::Action::Version8
+    class Commit
+
+      private
+
+      def commit_records(records)
+        records.each do |class_name, attribute_sets|
+          klass = class_for_record_type(class_name)
+          attribute_sets.each do |attributes|
+            update_record klass, attributes
+          end
+        end
+      end
+
+      def update_record(klass, attributes)
+        origin_key = attributes[klass.origin_key.to_s.camelize(:lower)]
+        raise BadRequest, "#{klass.name.demodulize} sent with no #{klass.origin_key}" unless origin_key
+        record = klass.find_or_initialize_by_origin_id(shop, origin_key)
+        attributes.each do |key, value|
+          key = key.underscore
+          next if key == origin_key
+          if key == 'checksum' && klass < Model::Record::FileRecord
+            request_file klass, attributes['fileName'] if record.checksum != value
+            next
+          end
+          record.write_with_type_casting(key.to_sym, value) or raise BadRequest, "#{klass.name.demodulize.pluralize} don't have #{key} fields"
+        end
+        record.save or raise InternalServerError, record.errors
+        complete_record record
+      end
+
+      def complete_record(record)
+        list = complete[:records][record.class.name.demodulize] ||= {}
+        list[record.origin_id.to_s] = record.digest
+      end
+
+      def request_file(klass, file_name)
+        list = files_to_send[klass.name.demodulize] ||= []
+        list << file_name unless list.include? file_name
+      end
+
+    end
+  end
+end

data/lib/netfira/web_connect/rack_app/actions/version_8/commit/relations.rb

@@ -0,0 +1,48 @@
+class Netfira::WebConnect::RackApp
+  module Action::Version8
+    class Commit
+
+      private
+
+      def commit_relations(relations)
+        relations.each do |class_name, relation_sets|
+          klass = class_for_relation_type class_name.sub('&', 'To')
+          relation_sets.each do |relation|
+            update_relation klass, relation
+            complete_relation class_name, relation
+          end
+        end
+      end
+
+      def update_relation(klass, relation)
+
+        # Make a hash of models => IDs, e.g. {Product => '123', Image => 'file.jpg'}
+        origin_ids = [relation['a'], relation['b']].each_with_index.map do |origin_id, index|
+          [klass.related_classes[index], origin_id]
+        end.to_h
+
+        if relation['x']
+          relate_records origin_ids
+        else
+          unrelate_records origin_ids
+        end
+      end
+
+      def relate_records(origin_ids)
+        records = origin_ids.map{ |k, id| k.find_or_create_by_origin_id shop, id }
+        records[0] << records[1]
+      end
+
+      def unrelate_records(origin_ids)
+        records = origin_ids.map{ |k, id| k.find_by_origin_id shop, id }.reject(&:nil?)
+        records[0].delete records[1] if records.size == 2
+      end
+
+      def complete_relation(class_name, relation)
+        list = complete[:relations][class_name] ||= []
+        list << relation
+      end
+
+    end
+  end
+end

data/lib/netfira/web_connect/rack_app/actions/version_8/commit.rb

@@ -0,0 +1,33 @@
+class Netfira::WebConnect::RackApp
+  module Action::Version8
+    class Commit < Action
+
+      def call
+        raise MethodNotAllowed unless verb == :post
+        commit_records input['records'] if input['records']
+        commit_relations input['relations'] if input['relations']
+        {
+            complete: complete,
+            filesToSend: files_to_send
+        }
+      end
+
+      private
+
+      def files_to_send
+        @files_to_send ||= {}
+      end
+
+      def complete
+        @complete ||= {
+            records: {},
+            relations: {}
+        }
+      end
+
+    end
+  end
+end
+
+require_relative 'commit/records'
+require_relative 'commit/relations'

data/lib/netfira/web_connect/rack_app/actions/version_8/files.rb

@@ -0,0 +1,21 @@
+class Netfira::WebConnect::RackApp
+  module Action::Version8
+    class Files < Action
+      def call
+        raise MethodNotAllowed unless post?
+        klass = class_for_record_type(path[0])
+        raise BadRequest, "You can't upload files for that data type" unless klass < Netfira::WebConnect::Model::Record::FileRecord
+
+        file_name = path[1]
+        raise BadRequest, 'You must specify a file name' unless file_name.length > 0
+
+        file = klass.find_or_initialize_by_origin_id(shop, file_name)
+        file << input
+        file.file_name = file_name
+
+        file.save or raise InternalServerError, file.errors
+        {}
+      end
+    end
+  end
+end

data/lib/netfira/web_connect/rack_app/actions/version_8/info.rb

@@ -0,0 +1,18 @@
+class Netfira::WebConnect::RackApp
+  module Action::Version8
+    class Info < Action
+      def call
+        {
+            info: {
+                apiVersion: Action.latest_version,
+                libVersion: Netfira::WebConnect::VERSION,
+                schema: Netfira::WebConnect.schema,
+                customFields: false,
+                acceptableRequestTypes: env['WC_ACCEPTABLE_REQUEST_TYPES'] || ['unpacked'],
+                locale: shop.locale
+            }
+        }
+      end
+    end
+  end
+end

data/lib/netfira/web_connect/rack_app/actions/version_8/settings.rb

@@ -0,0 +1,79 @@
+class Netfira::WebConnect::RackApp
+  module Action::Version8
+    class Settings < Action
+      def call
+        key = path && path.first
+        if key
+          handle_single key
+        else
+          handle_multiple
+        end
+      end
+
+      private
+
+      def handle_single(key)
+        case verb
+          when :put, :post then update_single key
+          when :get then get_single key
+          when :delete then delete_single key
+          else raise MethodNotAllowed
+        end
+      end
+
+      def update_single(key)
+        if input.respond_to? :read
+          setting = shop.setting_models.find_or_initialize_by(key: key)
+          setting.value = input.read
+          setting.content_type = env['CONTENT_TYPE'] || 'application/x-octet-stream'
+          setting.save
+        else
+          shop.settings[key] = input
+        end
+        {}
+      end
+
+      def get_single(key)
+        setting = shop.setting_models.find_by(key: key)
+        raise NotFound unless setting
+        # if setting.content_type == 'application/json'
+        #   JSON.parse(setting.value, quirks_mode: true)
+        # else
+          header 'Content-Type', setting.content_type
+          setting.value
+        # end
+      end
+
+      def delete_single(key)
+        shop.setting_models.where(key: key).destroy_all
+        {}
+      end
+
+      def handle_multiple
+        case verb
+          when :put, :post then update_multiple
+          when :get then get_all
+          when :delete then delete_all
+          else raise MethodNotAllowed
+        end
+      end
+
+      def update_multiple
+        input.each do |key, value|
+          shop.settings[key] = value.unpack('m').first
+        end
+        {}
+      end
+
+      def get_all
+        {settings: shop.setting_models.map{ |model| [model.key, [model.value.b].pack('m0')] }.to_h}
+      end
+
+      def delete_all
+        shop.setting_models.destroy_all
+        {}
+      end
+
+    end
+  end
+end

data/lib/netfira/web_connect/rack_app/exceptions/http_exception.rb

@@ -0,0 +1,44 @@
+require 'rack/utils'
+require 'forwardable'
+
+module Netfira::WebConnect::RackApp::Exceptions
+
+  class HttpException < Base
+    extend Forwardable
+
+    class << self
+      attr_accessor :status, :code, :category
+      attr_reader :headers
+    end
+
+    def_delegators :'self.class', :status, :code, :category
+
+    def initialize(*args, &block)
+      super *args, &block
+      @headers = self.class.headers.dup
+    end
+
+    attr_reader :headers
+
+  end
+
+  module HttpExceptions
+
+    Rack::Utils::HTTP_STATUS_CODES.each do |code, status|
+      next if status == 'Unassigned'
+      const_set status.gsub(/[ -](\w)/){$1.upcase}.sub(/ .*/, ''), (Class.new(HttpException) do
+
+        @status = status
+        @code = code
+        @category = code / 100
+
+        @headers = {}
+
+      end)
+    end
+
+    Unauthorized.headers['WWW-Authenticate'] = 'Basic realm="Authentication required"'
+
+  end
+
+end

data/lib/netfira/web_connect/rack_app/exceptions.rb

@@ -0,0 +1,6 @@
+module Netfira::WebConnect::RackApp::Exceptions
+  class Base < Exception
+  end
+end
+
+require_relative 'exceptions/http_exception'