web-connect 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d2700cd5cc5eadda85a187ac4d92b4b8eb1901d1
+  data.tar.gz: 8be1511337716328f72746dd70235f058c767d24
+SHA512:
+  metadata.gz: 08968c7e607aa00cd578d97df1e2aecf320a3f1dfc6be796d3846166b04d1e5824921a0f22249115f0d739bc43398918a5311e5b7a5ab38394696fedba100b54
+  data.tar.gz: 3d621b56728b17482bc46ce4802bd045712541baa0ea37a0dda47d2076ec05a9c8d20297c0a1f80af4d7455109b2527f37efac37ed4763b99bdb81bbe87dc1c4

data/README.md

@@ -0,0 +1 @@
+This gem provides connectivity between your app and Netfira products.

data/Rakefile

@@ -0,0 +1,3 @@
+task :console do
+  require_relative 'spec/console'
+end

data/lib/netfira/web_connect/components/checksum.rb

@@ -0,0 +1,19 @@
+require 'securerandom'
+
+module Netfira::WebConnect
+  class Checksum < OctaWord
+
+    def self.of(data)
+      new Digest::MD5.digest(data)
+    end
+
+    def =~(what)
+      if what.is_a?(self.class)
+        b == what.b
+      else
+        b == self.class.of(what).b
+      end
+    end
+
+  end
+end

data/lib/netfira/web_connect/components/guid.rb

@@ -0,0 +1,11 @@
+require 'securerandom'
+
+module Netfira::WebConnect
+  class Guid < OctaWord
+
+    def self.create
+      new SecureRandom.random_bytes(16)
+    end
+
+  end
+end

data/lib/netfira/web_connect/components/octa_word.rb

@@ -0,0 +1,73 @@
+require 'active_support/inflector'
+
+class Netfira::WebConnect::OctaWord
+
+  class << self
+
+    def from_binary(digest)
+      new digest
+    end
+
+    alias_method :from, :from_binary
+
+    def from_base64(digest)
+      new (digest[0..21] << '==').unpack('m').first
+    end
+
+    def from_hex(digest)
+      new [digest].pack('H*')
+    end
+
+  end
+
+  def initialize(binary_digest)
+    @binary = binary_digest.b
+  end
+
+  def binary
+    @binary
+  end
+
+  alias_method :b, :binary
+
+  def hex
+    @binary.unpack('H*')[0]
+  end
+
+  def base64
+    [@binary].pack('m0')[0..21]
+  end
+
+  def to_s
+    base64
+  end
+
+  def inspect
+    "#{self.class.name.demodulize}: #{base64}"
+  end
+
+  def eql?(other)
+    case other
+      when Netfira::WebConnect::OctaWord then b == other.b
+      when String
+        case other.length
+          when 16 then other == b
+          when 22 then other == base64
+          when 32 then other == hex
+          else false
+        end
+      else false
+    end
+  end
+
+  alias_method :==, :eql?
+
+  def as_json(options = nil)
+    base64
+  end
+
+end
+
+# Subclasses:
+require_relative 'guid'
+require_relative 'checksum'

data/lib/netfira/web_connect/components.rb

@@ -0,0 +1 @@
+require_relative 'components/octa_word'

data/lib/netfira/web_connect/configuration.rb

@@ -0,0 +1,33 @@
+module Netfira::WebConnect
+  class Configuration
+
+    attr_accessor :db_table_prefix, :file_store, :authenticator, :custom_fields,
+                  :time_zone, :materialize_when_db_changed
+
+    attr_reader :logger, :db
+
+    def initialize(defaults = nil)
+      defaults.each{ |k, v| __send__ :"#{k}=", v } if defaults
+    end
+
+    def on_authenticate(proc = nil, &block)
+      authenticator = proc || block
+      raise 'Authenticator must take exactly two arguments (shop ID and password)' unless authenticator.arity == 2
+      self.authenticator = authenticator
+    end
+
+    def db=(details)
+      @db = details
+      if details
+        Model.establish_connection details
+        Models.materialize if materialize_when_db_changed && !Netfira::WebConnect.needs_migration?
+      end
+    end
+
+    def logger=(logger)
+      @logger = logger
+      Model.logger = logger if logger
+    end
+
+  end
+end

data/lib/netfira/web_connect/db_schema/20140514_support.rb

@@ -0,0 +1,38 @@
+class Support < Netfira::WebConnect::Migration
+  using Refinements
+
+  def change
+
+    create_table :_tables do |t|
+      t.string :name, limit: 50, indexed: true
+      t.string :origin_key, limit: 20
+      t.boolean :file
+      t.boolean :writable
+      t.boolean :sendable
+    end
+
+    create_table :_shops do |t|
+      t.string :name
+      t.index :name, unique: true
+    end
+
+    Netfira::WebConnect::Models::Shop.create id: 0
+
+    create_table :_settings do |t|
+      t.references :shop
+      t.string :key
+      t.binary :value, limit: 0x10000
+      t.string :content_type
+    end
+
+    create_table :_custom_fields do |t|
+      t.references :shop
+      t.references :table
+      t.references :record
+      t.string :key
+      t.binary :value, limit: 0x10000
+    end
+
+  end
+
+end

data/lib/netfira/web_connect/db_schema/20140515_alpha.rb

@@ -0,0 +1,106 @@
+class Alpha < Netfira::WebConnect::Migration
+  using Refinements
+
+  def change
+
+    def product(t)
+      t.decimal :unit_price, precision: 12, scale: 4
+      t.decimal :unit_tax, precision: 12, scale: 4
+      t.localized_string :part
+      t.localized_string :description
+    end
+
+    def buyer(t)
+      t.string :name
+      t.string :contact
+      t.string :email, limit: 100
+      t.string :phone, limit: 30
+      t.string :fax, limit: 30
+      %w[billing_ shipping_].each do |type|
+        t.string :"#{type}address_1", limit: 150
+        t.string :"#{type}address_2", limit: 150
+        t.string :"#{type}city", limit: 150
+        t.string :"#{type}state", limit: 150
+        t.string :"#{type}country", limit: 2
+        t.string :"#{type}post_code", limit: 20
+      end
+
+    end
+
+    create_record_table :products, with_l10n: true do |t|
+      product t
+
+      t.localized_string :category
+      t.localized_string :long_description, limit: 0x10000
+
+      t.decimal :stock, precision: 12, scale: 4
+      t.string :stock_text
+
+      t.integer :length
+      t.integer :height
+      t.integer :width
+      t.decimal :weight, precision: 14, scale: 3
+
+      t.boolean :show_on_website
+    end
+
+    create_record_table :categories, with_l10n: true do |t|
+      t.integer :parent_id
+      t.localized_string :name
+    end
+
+    create_record_table :buyers, origin_key: :nf_code do |t|
+      buyer t
+
+      t.binary :pin, limit: 255
+      t.boolean :website_access
+      t.boolean :allow_products
+      t.boolean :restrict_products
+    end
+
+    create_record_table :orders, sendable: true do |t|
+      t.string :nf_code
+      buyer t
+
+      t.string :buyer_reference
+      t.string :currency_code, limit: 3
+
+      t.string :shipping_method
+      t.decimal :shipping_price, precision: 12, scale: 4
+      t.decimal :shipping_tax, precision: 12, scale: 4
+      t.string :shipping_account
+      t.string :shipping_password
+
+      t.string :payment_method
+      t.boolean :payment_received
+      t.string :payment_reference
+      t.string :payment_error_code, limit: 16
+
+      t.string :comment, limit: 0x10000
+    end
+
+    create_record_table :order_lines, writable: true do |t|
+      t.string :product_id
+      product t
+
+      t.references :order
+      t.decimal :quantity, precision: 12, scale: 4
+      t.string :comment, limit: 0x10000
+    end
+
+    create_file_table :images do |t|
+      t.float :focus_point_top
+      t.float :focus_point_left
+      t.integer :size
+      t.integer :width
+      t.integer :height
+    end
+    create_file_table :attachments
+
+    create_relation_table :products, :images
+    create_relation_table :products, :categories
+    create_relation_table :products, :attachments
+    create_relation_table :products, :buyers
+
+  end
+end

data/lib/netfira/web_connect/events.rb

@@ -0,0 +1,14 @@
+module Netfira::WebConnect
+
+  def self.event_delegates
+    @event_delegates ||= []
+  end
+
+  def self.dispatch_event(event, *args)
+    target = :"on_#{event}"
+    event_delegates.map do |delegate|
+      delegate.__send__(target, *args) if delegate.respond_to? target
+    end
+  end
+
+end

data/lib/netfira/web_connect/migration/base_methods.rb

@@ -0,0 +1,59 @@
+module Netfira::WebConnect
+
+  def self.migrate
+    force_db_connection { ActiveRecord::Migrator.migrate migrations_dir }
+  end
+
+  def self.rollback
+    force_db_connection { ActiveRecord::Migrator.rollback migrations_dir }
+  end
+
+  def self.needs_migration?
+    original = ActiveRecord::Migrator.migrations_paths
+    ActiveRecord::Migrator.migrations_paths = [migrations_dir]
+    result = force_db_connection { ActiveRecord::Migrator.needs_migration? }
+    ActiveRecord::Migrator.migrations_paths = original
+    result
+  end
+
+  private
+
+  def self.migrations_dir
+    @migrations_dir ||= ROOT.join('web_connect/db_schema').to_s
+  end
+
+  # This method tricks ActiveRecord into using the connection for Netfira::WebConnect::Model
+  # instead of the ActiveRecord::Base connection, which it's hard-wired to do for migrations
+  # and other tasks. Two methods are backed up and replaced, then restored after yield. Those
+  # methods are identical to the originals, except they specify `Model` in place of `self`.
+  def self.force_db_connection
+
+    # Save the original methods
+    originals = [:connection_pool, :retrieve_connection, :schema_migrations_table_name].map do |name|
+      [name, ActiveRecord::Base.method(name)]
+    end.to_h
+
+    # Add some new methods
+    class << ActiveRecord::Base
+      def connection_pool
+        connection_handler.retrieve_connection_pool(Model) or raise ActiveRecord::ConnectionNotEstablished
+      end
+      def retrieve_connection
+        connection_handler.retrieve_connection(Model)
+      end
+      def schema_migrations_table_name
+        Netfira::WebConnect.schema_migrations_table_name
+      end
+    end
+
+    # Run the given block
+    result = yield
+
+    # Restore the original methods
+    originals.each { |name, method| ActiveRecord::Base.define_singleton_method name, method }
+
+    # Return the result of the given block
+    result
+  end
+
+end

data/lib/netfira/web_connect/migration/refinements.rb

@@ -0,0 +1,16 @@
+class Netfira::WebConnect::Migration
+  module Refinements
+
+    class << self
+      attr_accessor :running_migration
+    end
+
+    refine ActiveRecord::ConnectionAdapters::TableDefinition do
+
+      def localized_string(*args)
+        Refinements.running_migration.add_localized_string(args) or string *args
+      end
+
+    end
+  end
+end

data/lib/netfira/web_connect/migration.rb

@@ -0,0 +1,101 @@
+require 'active_record'
+
+module Netfira::WebConnect
+  class Migration < ActiveRecord::Migration
+
+    class << self
+      attr_accessor :log_to_stdout
+    end
+
+    def add_localized_string(args)
+      @l10n_buffer << args if @l10n_buffer
+    end
+
+    def create_table(table_name, options = {}, &block)
+      super table_prefix(table_name), options, &block
+    end
+
+    def create_record_table(table_name, options = {})
+      Refinements.running_migration = self
+      @l10n_buffer = options[:with_l10n] && []
+      options[:writable] ||= options[:sendable]
+      create_table table_name, options do |t|
+        t.string options[:origin_key] || :"#{table_name.to_s.singularize}_id", index: true unless options[:writable]
+        yield t
+        t.references :shop
+        if options[:sendable]
+          t.binary :guid, index: true
+          t.integer :delivery_status, default: 0, limit: 3, index: true
+        end
+        t.binary :digest, limit: 16
+        t.timestamps
+      end
+      if @l10n_buffer
+        create_l10n_table table_name do |t|
+          @l10n_buffer.each do |args|
+            t.string *args
+          end
+        end
+      end
+      add_table_def table_name, options
+    end
+
+    def create_l10n_table(table_name)
+      create_table l10n_suffix(table_name) do |t|
+        t.references table_name.to_s.singularize.to_sym, index: true
+        t.string :language, limit: 20, index: true
+        yield t
+      end
+    end
+
+    def create_file_table(table_name)
+      create_table table_name do |t|
+        t.references :shop
+        t.string :file_name, index: true
+        t.string :locale
+        yield t if block_given?
+        t.binary :checksum, limit: 16
+        t.binary :digest, limit: 16
+        t.timestamps
+      end
+      add_table_def table_name, {}, true
+    end
+
+    def create_relation_table(first, second)
+      first, second = [first, second].sort
+      create_table :"#{first}_to_#{second}" do |t|
+        t.references first.to_s.singularize, second.to_s.singularize, index: true
+      end
+    end
+
+    def add_table_def(table_name, options, is_file = false)
+      Models::Table.create options.select{|k| %i[origin_key writable sendable].include? k}.merge name: table_name,
+                                                                                                 file: is_file
+    end
+
+    def write(text = '')
+      if verbose
+        puts text if Migration.log_to_stdout
+        Netfira::WebConnect.logger.info text
+      end
+    end
+
+    def schema_migrations_table_name
+      Netfira::WebConnect.schema_migrations_table_name
+    end
+
+    private
+
+    def l10n_suffix(name = '')
+      Netfira::WebConnect.db_table_l10n_suffix name
+    end
+
+    def table_prefix(name = '')
+      Netfira::WebConnect.db_table_prefix name
+    end
+
+  end
+end
+
+require_relative 'migration/refinements'
+require_relative 'migration/base_methods'

data/lib/netfira/web_connect/model/record/digests.rb

@@ -0,0 +1,24 @@
+module Netfira::WebConnect
+  class Model::Record
+
+    module Digests
+      extend ActiveSupport::Concern
+
+      included do
+        before_save :write_digest
+      end
+
+      def digest
+        changed? ? Checksum.of(to_s) : Checksum.new(self[:digest])
+      end
+
+      private
+
+      def write_digest
+        self.digest = digest.b
+      end
+
+    end
+
+  end
+end

data/lib/netfira/web_connect/model/record/events.rb

@@ -0,0 +1,35 @@
+module Netfira::WebConnect
+  class Model::Record
+    module Events
+      extend ActiveSupport::Concern
+
+      included do
+        around_save :dispatch_create_or_update
+        before_destroy :dispatch_destroy
+      end
+
+      private
+
+      def dispatch_create_or_update
+        previous = persisted? && changed_attributes.map do |key, value|
+          # TODO: solve this type casting issue without guessing by attribute names!
+          value = Checksum.new(value) if value and (key == 'checksum' or key == 'digest')
+          [key, value]
+        end.to_h
+        yield
+        as_readonly do
+          if previous
+            Netfira::WebConnect.dispatch_event "update_#{self.class.single_name}", self, previous
+          else
+            Netfira::WebConnect.dispatch_event "create_#{self.class.single_name}", self
+          end
+        end
+      end
+
+      def dispatch_destroy
+        as_readonly { Netfira::WebConnect.dispatch_event "delete_#{self.class.single_name}", self }
+      end
+
+    end
+  end
+end

data/lib/netfira/web_connect/model/record/file_record.rb

@@ -0,0 +1,79 @@
+require 'paperclip'
+
+Paperclip.interpolates :shop_id do |record, x|
+  record.instance.shop_id
+end
+
+Paperclip.interpolates :model_type do |record, x|
+  record.instance.class.name.demodulize.underscore.pluralize
+end
+
+module Netfira::WebConnect
+  class Model::Record::FileRecord
+    include Paperclip::Glue
+
+    class << self
+
+      def table_name
+        self == Model::Record::FileRecord ? Models::Table.table_name : super
+      end
+
+      def origin_key
+        :file_name
+      end
+
+    end
+
+    after_initialize :set_file_defaults
+
+    def <<(input)
+      if input.is_a? Model::Record
+        super input
+      else
+        self.data = input
+      end
+    end
+
+    def checksum
+      bin = self[:checksum]
+      @checksum ||= bin && Checksum.new(bin)
+    end
+
+    def checksum=(value)
+      @checksum = nil
+      self[:checksum] = Checksum === value ? value.b : value
+    end
+
+    def data
+      attachment.present? ? Paperclip.io_adapters.for(attachment) : nil
+    end
+
+    def data=(value)
+      self.attachment = value
+      value.rewind
+      self.checksum = Checksum.of(value.read)
+    end
+
+    def attachment_file_name
+      file_name
+    end
+
+    def attachment_file_name=(value)
+      self.file_name = value
+    end
+
+    def attachment_file_size
+      size
+    end
+
+    def attachment_file_size=(value)
+      self.size = value
+    end
+
+    private
+
+    def set_file_defaults
+      self.locale ||= shop.locale
+    end
+  end
+end

data/lib/netfira/web_connect/model/record/materialization.rb

@@ -0,0 +1,59 @@
+module Netfira::WebConnect
+  class Model::Record
+    module Materialization
+
+      def materialize(name, has_languages, props)
+
+        # Get a reference to the record class, creating it if it doesn't exist
+        klass = begin
+          Models.const_get name
+        rescue NameError
+          Models.const_set name, Class.new(props.file ? FileRecord : self)
+        end
+
+        # Give the model access to properties from the `tables` table
+        klass.instance_variable_set :@table_props, props
+
+        # Add a reference to the record's shop
+        shop_relation = name.underscore.pluralize.to_sym
+        klass.belongs_to :shop,
+                         class_name: 'Netfira::WebConnect::Models::Shop',
+                         inverse_of: shop_relation
+
+        # Add a has-many to Shop so we can do Shop.first.products etc
+        Models::Shop.has_many shop_relation, inverse_of: :shop
+
+        # Set up access to localised fields
+        if has_languages
+          Model::Record::Translation.materialize klass
+          klass.include Model::Record::Translations
+          translated_attributes = klass::Translation.attribute_names.reject do |attribute|
+            (%w[id language] << "#{klass.single_name}_id").include? attribute
+          end
+          translated_attributes.each do |attribute|
+            klass.__send__ :define_method, :"#{attribute}" do
+              self.get_translated_string attribute.to_sym
+            end
+            klass.__send__ :define_method, :"#{attribute}=" do |value|
+              self.set_translated_string attribute.to_sym, value
+            end
+          end
+        end
+
+        # Set up tree behaviour (parent/child relations)
+        klass.include Model::Record::Tree if klass.tree?
+
+        # Set up sendable behaviour
+        klass.include Model::Record::Sendable if klass.sendable?
+
+        # Set up file record behaviour
+        if klass.has_file?
+          klass.has_attached_file :attachment, Netfira::WebConnect.file_store
+          klass.do_not_validate_attachment_file_type :attachment
+        end
+
+      end
+
+    end
+  end
+end