web-connect 0.1.0

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

@@ -0,0 +1,51 @@
+module Netfira::WebConnect
+  class Model::Record
+
+    # These methods help relate and unrelate records
+    module Relations
+
+      def relate(record)
+        error_messages = {
+            no_relation: 'You cannot add a %s to a %s',
+            wrong_shop: 'Tried to add a record from shop %s to shop %s'
+        }
+        prepare_relation(record, error_messages) do |relation_class, attrs|
+          relation_class.find_or_create_by attrs
+        end
+      end
+
+      alias_method :<<, :relate
+
+      def unrelate(record)
+        error_messages = {
+            no_relation: 'You cannot remove a %s from a %s',
+            wrong_shop: 'Tried to remove a record of shop %s from shop %s'
+        }
+        prepare_relation(record, error_messages) do |relation_class, attrs|
+          relation_class.where(attrs).destroy_all
+        end
+      end
+
+      private
+
+      # This method assists #relate and #unrelate
+      def prepare_relation(record, error_messages)
+
+        # The class of the relation between self and record
+        relation_class = Model::Record::Relation.for(self, record)
+
+        # Error for unrelatable classes
+        raise error_messages[:no_relation] % [record.class.name.demodulize, self.class.name.demodulize] unless relation_class
+
+        # Error for shop mismatches
+        raise error_messages[:wrong_shop] % [record.shop_id, shop_id] unless shop_id == record.shop_id
+
+        # The attributes to use for create or delete, e.g. {product_id: 1, category_id: 2}
+        attrs = [self, record].map{ |r| ["#{r.class.name.demodulize.underscore}_id", r.id]}.to_h
+
+        yield relation_class, attrs
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Netfira::WebConnect
+  class Model::Record
+
+    module Sendable
+      extend ActiveSupport::Concern
+
+      included do
+        after_initialize :create_guid
+        enum delivery_status: [:unsent, :sent, :delivered]
+      end
+
+      def guid
+        @guid ||= Guid.from(self[:guid])
+      end
+
+      def guid=(value)
+        raise 'GUIDs are read-only'
+      end
+
+      private
+
+      def create_guid
+        self[:guid] ||= (@guid = Guid.create).b
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'bigdecimal'
+
+module Netfira::WebConnect
+  class Model::Record
+
+    module Serializer
+      extend ActiveSupport::Concern
+
+      EXCLUDE_FROM_SERIALIZE = %w[id shop_id digest delivery_status created_at updated_at]
+
+      included do
+
+        private
+
+        # Returns an array of three arrays of keys, e.g.
+        # [ ['product_id', 'unit_price'], ['description'], [] ]
+        def self.attributes_to_serialize
+          @attributes_to_serialize ||= [
+              attribute_names - EXCLUDE_FROM_SERIALIZE,
+              has_languages? ? self::Translation.translated_attribute_names : [],
+              [] # Custom attributes (not implemented)
+          ]
+        end
+      end
+
+      def to_s
+
+        # Map each array of keys from the above method into a sorted hash of key/value pairs
+        data = self.class.attributes_to_serialize.map do |keys|
+          pairs = keys.sort.map do |key|
+            [key.camelize(:lower), cast_for_serialization(__send__ key)]
+          end
+          pairs.reject!{ |v| v[1].nil? }.to_h
+        end
+
+        # Return the class name and the sets above, e.g. Product{...},{...},{...}
+        self.class.name.demodulize << JSON.generate(data)[1..-2]
+      end
+
+      private
+
+      def cast_for_serialization(value)
+        if TranslatedString === value
+          value = value.sort
+          value = value.empty? ? nil : value.to_h
+        elsif Numeric === value
+          value = (value == value.floor) ? value.to_i : value.to_f
+        elsif OctaWord === value
+          value = value.to_s
+        end
+        value
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'forwardable'
+
+module Netfira::WebConnect
+
+  # This class represents a translated string on a model, e.g. product.description.
+  # Callbacks are supplied by the Model::Record::Translations mixin
+  class Model::Record::TranslatedString
+    extend Forwardable
+
+    def initialize
+      @callbacks = {}
+    end
+
+    def [](lang)
+      @callbacks[:get].call lang
+    end
+
+    def []=(lang, value)
+      @callbacks[:set].call lang, value
+    end
+
+    def on(action, &block)
+      @callbacks[action] = block
+    end
+
+    def to_s
+      self[nil]
+    end
+
+    def to_h
+      @callbacks[:all].call
+    end
+
+    def merge!(values)
+      values.each{ |key, value| self[key] = value }
+      self
+    end
+
+    delegate %i[count length size each map sort select reject] => :to_h
+
+  end
+end

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

@@ -0,0 +1,58 @@
+module Netfira::WebConnect
+
+  # Subclasses of this model represents rows from translation tables, e.g. nf_products_l10n.
+  # Subclasses are materialized when their parent record models are materialized.
+  class Model::Record::Translation
+
+    class << self
+
+      def materialize(owner_class)
+
+        # Make a translation model, e.g. Product::Translation
+        klass = Class.new(self)
+        owner_class.const_set :Translation, klass
+
+        # Keep a reference to the owner class
+        klass.instance_variable_set :@owner_class, owner_class
+
+        # Give translations references back to their parent records
+        klass.belongs_to :owner,
+                         class_name: owner_class.name,
+                         foreign_key: "#{owner_class.name.demodulize.underscore}_id",
+                         inverse_of: :translation_models
+
+        # Add a translations relation, e.g. product.translations
+        owner_class.has_many :translation_models,
+                             class_name: klass.name,
+                             inverse_of: :owner,
+                             autosave: true
+
+        # Add translations to the default scope, as they will almost
+        # always be needed for lookups
+        owner_class.default_scope { includes :translation_models }
+
+      end
+
+      def translated_attribute_names
+        @translated_attribute_names ||= attribute_names - ['id', 'language', "#{@owner_class.single_name}_id"]
+      end
+
+      def table_name
+        @table_name ||= if self == Model::Record::Translation
+          Models::Table.table_name
+        else
+          Netfira::WebConnect.db_table_prefix(plural_name).to_s
+        end
+      end
+
+      def single_name
+        @single_name ||= Netfira::WebConnect.db_table_l10n_suffix @owner_class.single_name
+      end
+
+      def plural_name
+        @plural_name ||= Netfira::WebConnect.db_table_l10n_suffix @owner_class.plural_name
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Netfira::WebConnect
+  class Model::Record
+
+    # This module is mixed into records that have translations.
+    module Translations
+
+      # Called when getting a translated string, e.g. product.description
+      def get_translated_string(key)
+        translated_string_for key
+      end
+
+      # Called when assigning a translated string, e.g. product.description = 'Stuff'
+      def set_translated_string(key, value)
+        if Hash === value
+          replace_translations_for key, value
+        else
+          translated_string_for(key)[nil] = value
+        end
+      end
+
+      def locale
+        shop.locale
+      end
+
+      private
+
+      def translations
+        @translations ||= translation_models.map{ |model| [model.language, model]}.to_h
+      end
+
+      def translated_strings
+        @translated_strings ||= {}
+      end
+
+      def translation_for_language(lang)
+        lang = lang.to_s
+        translations[lang] ||= translation_models.build(language: lang)
+      end
+
+      def replace_translations_for(key, value)
+        translations.each { |lang, model| model[key] = value[lang] }
+        translated_string_for(key).merge! value
+      end
+
+      def translated_string_for(key)
+        translated_strings[key] ||= begin
+          t = Model::Record::TranslatedString.new
+          t.on(:get) { |lang|        translation_for_language(lang || locale).__send__ key }
+          t.on(:set) { |lang, value| translation_for_language(lang || locale).__send__ :"#{key}=", value }
+          t.on(:all) { translations.map{ |lang, model| [lang, model[key]] }.reject{ |x| x[1].nil? }.to_h }
+          t
+        end
+      end
+
+      def clear_translations
+        @translations = nil
+        @translated_strings = nil
+        self
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Netfira::WebConnect
+  module Model::Record::Tree
+
+    def children
+      self.class.where(parent_id: id)
+    end
+
+    def parent
+      @parent ||= parent_id && self.class.find_by(id: parent_id)
+    end
+
+  end
+end

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

@@ -0,0 +1,132 @@
+require_relative 'record/relations'
+require_relative 'record/materialization'
+require_relative 'record/serializer'
+require_relative 'record/digests'
+require_relative 'record/sendable'
+require_relative 'record/events'
+
+module Netfira::WebConnect
+  class Model::Record
+    extend Materialization
+    include Relations
+    include Serializer
+    include Digests
+    include Events
+
+    class << self
+
+      def table_name
+        @table_name ||= if self == Model::Record
+          Models::Table.table_name
+        else
+          Netfira::WebConnect.db_table_prefix(plural_name).to_s
+        end
+      end
+
+      def has_languages?
+        const_defined? :Translation, false
+      end
+
+      def tree?
+        @is_tree ||= attribute_names.include? 'parent_id'
+      end
+
+      def origin_key
+        @origin_key ||= if sendable?
+                          :guid
+                        elsif writable?
+                          nil
+                        else
+                          (table_props.origin_key || "#{single_name}_id").to_sym
+                        end
+      end
+
+      def writable?
+        @writable ||= table_props.writable
+      end
+
+      def sendable?
+        @sendable ||= table_props.sendable
+      end
+
+      def find_by_origin_id(shop, id)
+        id = id.b if OctaWord === id
+        find_by origin_key => id, shop_id: shop.id
+      end
+
+      def find_or_initialize_by_origin_id(shop, id)
+        find_by_origin_id(shop, id) || new(origin_key => id, shop_id: shop.id)
+      end
+
+      def find_or_create_by_origin_id(shop, id)
+        record = find_or_initialize_by_origin_id(shop, id)
+        record.save unless record.persisted?
+        record
+      end
+
+      def has_file?
+        @has_file ||= self < FileRecord
+      end
+
+      def schema
+        @schema ||= Netfira::WebConnect.schema[self]
+      end
+
+    end
+
+    after_initialize :init
+
+    %i[has_languages? tree? origin_key writable? sendable? has_file?].each do |method|
+      define_method(method) { self.class.__send__ method }
+    end
+
+    def origin_id
+      __send__ origin_key
+    end
+
+    def as_readonly
+      readonly!
+      yield
+      instance_variable_set :@readonly, false
+    end
+
+    def reload
+      clear_translations if has_languages?
+      super
+    end
+
+    def write_with_type_casting(key, value)
+      schema = self.class.schema
+      if schema.localize.include? key
+        set_translated_string key, value
+      else
+        type = schema.columns[key]
+        return false unless type
+        value = value.to_s if type == 'string'
+        write_attribute key, value
+      end
+      true
+    end
+
+    private
+
+    def self.table_props
+      @table_props
+    end
+
+    def init
+      self.shop_id ||= 0
+    end
+
+    def after_add_relation(model)
+      model.shop_id = shop_id
+    end
+
+  end
+end
+
+require_relative 'record/file_record'
+require_relative 'record/translated_string'
+require_relative 'record/translation'
+require_relative 'record/translations'
+require_relative 'record/tree'

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

@@ -0,0 +1,34 @@
+module Netfira::WebConnect
+  class Model::Relation
+    module Events
+      extend ActiveSupport::Concern
+
+      included do
+        after_save    :dispatch_create
+        after_destroy :dispatch_destroy
+      end
+
+      private
+
+      def dispatch_create
+        dispatch_relation_event 'add_%s_to_%s'
+      end
+
+      def dispatch_destroy
+        dispatch_relation_event 'remove_%s_from_%s'
+      end
+
+      def dispatch_relation_event(event_name_template)
+        [records, records.reverse].each do |records|
+          event_name = (event_name_template % records.map{ |record| record.class.single_name }).to_sym
+          records[0].as_readonly do
+            records[1].as_readonly do
+              Netfira::WebConnect.dispatch_event event_name, *records
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/netfira/web_connect/model/relation.rb

@@ -0,0 +1,67 @@
+require_relative 'relation/events'
+
+module Netfira::WebConnect
+  class Model::Relation
+    include Events
+
+    class << self
+
+      attr_reader :related_classes
+
+      def materialize(name_a, name_b)
+        klass = Class.new(self)
+        Models.const_set "#{name_a}To#{name_b}", klass
+        klass.related_classes = [name_a, name_b].map{ |n| Models.const_get n.camelize.singularize }
+      end
+
+      def related_classes=(classes)
+        raise 'Related classes have already been set' if related_classes
+        @related_classes = classes
+        classes.each_with_index do |related_class, index|
+
+          # The class on the opposite side of the relation. For example:
+          # related_class => Product
+          # opposite_class => Category
+          opposite_class = related_classes[1 - index]
+
+          # Name of the reference to add to the related class, e.g. Product#category_relations
+          relation_name = :"#{opposite_class.single_name}_relations"
+
+          # The relation class's reference, e.g. CategoryToProduct#product
+          belongs_to related_class.single_name.to_sym
+
+          # The related class's reference to the relation, e.g. Product#category_relations
+          related_class.has_many relation_name,
+                                 class_name: name,
+                                 inverse_of: related_class.single_name.to_sym
+
+          # The related class's reference to the other related class,
+          # e.g. Product#categories (at last!)
+          related_class.has_many opposite_class.plural_name.to_sym,
+                                 through: relation_name,
+                                 after_add: :after_add_relation
+
+        end
+      end
+
+      def table_name
+        @table_name ||= if self == Model::Relation
+          Models::Table.table_name
+        else
+          Netfira::WebConnect.db_table_prefix(related_classes.map(&:plural_name).join '_to_').to_s
+        end
+      end
+
+      def for(class_a, class_b)
+        name = [class_a, class_b].map{ |c| (c.is_a?(Class) ? c : c.class).name.demodulize }.sort.join 'To'
+        Models.const_get name if Models.const_defined? name
+      end
+
+    end
+
+    def records
+      self.class.related_classes.map{ |klass| __send__ klass.single_name.to_sym }
+    end
+
+  end
+end

data/lib/netfira/web_connect/model/support.rb

@@ -0,0 +1,13 @@
+module Netfira::WebConnect
+  class Model::Support
+
+    def self.table_name
+      @table_name ||= if self == Model::Support
+        Models::Table.table_name
+      else
+        Netfira::WebConnect.db_table_prefix('_' << name.demodulize.underscore.pluralize).to_s
+      end
+    end
+
+  end
+end

data/lib/netfira/web_connect/model.rb

@@ -0,0 +1,33 @@
+module Netfira::WebConnect
+  class Model < ActiveRecord::Base
+    class Record < self
+      class FileRecord < self
+      end
+      class Translation < Model
+      end
+    end
+    class Relation < self
+    end
+    class Support < self
+    end
+
+    class << self
+      def table_name
+        Models::Table.table_name
+      end
+
+      def single_name
+        @single_name ||= name.demodulize.underscore
+      end
+
+      def plural_name
+        @plural_name ||= single_name.pluralize
+      end
+    end
+
+  end
+end
+
+require_relative 'model/record'
+require_relative 'model/relation'
+require_relative 'model/support'

data/lib/netfira/web_connect/models/image.rb

@@ -0,0 +1,48 @@
+require 'ostruct'
+require 'fastimage'
+
+module Netfira::WebConnect
+  class Models::Image < Model::Record::FileRecord
+
+    def focus_point=(point)
+      self.focus_point_top = point[:top]
+      self.focus_point_left = point[:left]
+      self.focus_point
+    end
+
+    def focus_point
+      @focus_point ||= FocusPoint.new(self)
+    end
+
+    def data=(value)
+      super value
+      self.width, self.height = FastImage.size(attachment.staged_path)
+    end
+
+    def dimensions
+      [width, height]
+    end
+
+    def dimensions=(value)
+      self.width, self.height = value
+    end
+
+    class FocusPoint
+
+      def initialize(image)
+        @image = image
+      end
+
+      %w[top left].each do |attr|
+        define_method :"#{attr}" do
+          @image[:"focus_point_#{attr}"]
+        end
+        define_method :"#{attr}=" do |value|
+          @image[:"focus_point_#{attr}"] = value
+        end
+      end
+
+    end
+
+  end
+end

data/lib/netfira/web_connect/models/order.rb

@@ -0,0 +1,5 @@
+module Netfira::WebConnect
+  class Models::Order < Model::Record
+    has_many :lines, class_name: "#{name}Line"
+  end
+end

data/lib/netfira/web_connect/models/order_line.rb

@@ -0,0 +1,13 @@
+module Netfira::WebConnect
+  class Models::OrderLine < Model::Record
+    belongs_to :order
+
+    after_initialize :set_defaults
+
+    private
+
+    def set_defaults
+      self.quantity ||= 1
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Netfira::WebConnect
+  class Models::Setting < Model::Support
+
+    belongs_to :shop, inverse_of: :setting_models
+
+    def typed_value
+      case content_type
+        when 'application/json' then JSON.parse(value, quirks_mode: true)
+        when 'application/octet-stream' then value.b
+        when /^text\/plain;charset=(.+)$/ then value.force_encoding($1)
+        else value
+      end
+    end
+
+    def typed_value=(value)
+      if String === value
+        if value.encoding.name == 'ASCII-8BIT'
+          self.value = value.b
+          self.content_type = 'application/octet-stream'
+        else
+          self.value = value.force_encoding('UTF-8')
+          self.content_type = 'text/plain;charset=UTF-8'
+        end
+      else
+        self.value = JSON.generate(value, quirks_mode: true)
+        self.content_type = 'application/json'
+      end
+    end
+
+  end
+end