cortex 0.1.1

data/app/models/concerns/cortex/has_firstname_lastname.rb

@@ -0,0 +1,11 @@
+module Cortex
+  module HasFirstnameLastname
+    extend ActiveSupport::Concern
+
+    included do
+      def fullname
+        lastname.to_s == '' ? firstname : "#{firstname} #{lastname}"
+      end
+    end
+  end
+end

data/app/models/concerns/cortex/has_gravatar.rb

@@ -0,0 +1,18 @@
+module Cortex
+  module HasGravatar
+    extend ActiveSupport::Concern
+
+    included do
+      def avatars
+        hash = email ? Digest::MD5.hexdigest(email) : '00000000000000000000000000000000'
+        url = "//www.gravatar.com/avatar/#{hash}"
+        {
+          default: "#{url}",
+          small: "#{url}?s=200",
+          medium: "#{url}?s=400",
+          large: "#{url}?s=1000"
+        }
+      end
+    end
+  end
+end

data/app/models/concerns/cortex/searchable.rb

@@ -0,0 +1,11 @@
+module Cortex
+  module Searchable
+    extend ActiveSupport::Concern
+
+    included do
+      include Elasticsearch::Model
+
+      index_name "#{Rails.env}_#{model_name.to_s.parameterize(separator: '_')}"
+    end
+  end
+end

data/app/models/concerns/cortex/searchable_content_item.rb

@@ -0,0 +1,31 @@
+module Cortex
+  module SearchableContentItem
+    extend ActiveSupport::Concern
+
+    included do
+      include Cortex::Searchable
+
+      after_commit on: [:create] do
+        __elasticsearch__.index_document(index: content_type.content_items_index_name)
+      end
+
+      after_commit on: [:update] do
+        # Perform a full document re-index, as update_document ignores methods: https://github.com/elastic/elasticsearch-rails/issues/306#issuecomment-121817954
+        __elasticsearch__.index_document(index: content_type.content_items_index_name)
+      end
+
+      after_commit on: [:destroy] do
+        __elasticsearch__.delete_document(index: content_type.content_items_index_name)
+      end
+
+      def as_indexed_json(options = {})
+        json = as_json
+        field_items.each do |field_item|
+          field_type = field_item.field.field_type_instance(field_name: field_item.field.name)
+          json.merge!(field_type.field_item_as_indexed_json_for_field_type(field_item))
+        end
+        json
+      end
+    end
+  end
+end

data/app/models/concerns/cortex/searchable_content_item_for_content_type.rb

@@ -0,0 +1,52 @@
+module Cortex
+  module SearchableContentItemForContentType
+    extend ActiveSupport::Concern
+
+    included do
+      after_commit on: [:create] do
+        self.class.__elasticsearch__.create_index!(index: content_items_index_name, mappings: content_item_mappings)
+      end
+
+      after_commit on: [:destroy] do
+        self.class.__elasticsearch__.delete_index!(index: content_items_index_name)
+      end
+
+      after_commit on: [:update] do
+        self.class.__elasticsearch__.delete_index!(index: content_items_index_name)
+        self.class.__elasticsearch__.create_index!(index: content_items_index_name, mappings: content_item_mappings)
+        # TODO: implement & move import to ContentItem to mass-refresh all ContentItems for a ContentType
+        #self.class.__elasticsearch__.import()
+      end
+
+      def content_items_index_name
+        @content_items_index_name ||= "#{Rails.env}_content_type_#{name_id}_content_items"
+      end
+    end
+
+    private
+
+    def content_item_mappings
+      mappings = Elasticsearch::Model::Indexing::Mappings.new(content_items_index_name, { dynamic: false })
+      mappings.indexes :tenant_id, type: :keyword, index: :not_analyzed
+      mappings.indexes :content_type_id, type: :keyword, index: :not_analyzed
+      mappings.indexes :creator_id, type: :keyword, index: :not_analyzed
+      mappings.indexes :updated_by_id, type: :keyword, index: :not_analyzed
+      mappings.indexes :state, analyzer: :keyword, index: :not_analyzed
+      mappings.indexes :created_at, type: :date, include_in_all: false
+      mappings.indexes :updated_at, type: :date, include_in_all: false
+      mappings.indexes :deleted_at, type: :date, include_in_all: false
+
+      fields.each do |field|
+        mappings.indexes field.elasticsearch_mapping[:name], content_item_field_mappings(field)
+      end
+
+      mappings
+    end
+
+    def content_item_field_mappings(field)
+      mappings = { type: field.elasticsearch_mapping[:type] }
+      mappings[:analyzer] = field.elasticsearch_mapping[:analyzer] if field.elasticsearch_mapping[:analyzer]
+      mappings
+    end
+  end
+end

data/app/models/concerns/cortex/searchable_content_type.rb

@@ -0,0 +1,11 @@
+module Cortex
+  module SearchableContentType
+    extend ActiveSupport::Concern
+
+    included do
+      include Cortex::Searchable
+
+      # TODO: ContentType mappings
+    end
+  end
+end

data/app/models/cortex/application_record.rb

@@ -0,0 +1,17 @@
+module Cortex
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+
+    acts_as_paranoid
+
+    # A bug in ES-Rails 5.x is breaking document updates:
+    # https://github.com/elastic/elasticsearch-rails/issues/669
+    after_commit :refresh_elasticsearch_index, on: :update
+
+    private
+
+    def refresh_elasticsearch_index
+      __elasticsearch__.index_document(refresh: true) if defined? __elasticsearch__
+    end
+  end
+end

data/app/models/cortex/content_item.rb

@@ -0,0 +1,71 @@
+module Cortex
+  class ContentItem < Cortex::ApplicationRecord
+    include ActiveModel::Transitions
+
+    include Cortex::SearchableContentItem
+    include Cortex::BelongsToTenant
+
+    scope :last_updated_at, -> { order(updated_at: :desc).select('updated_at').first.updated_at }
+
+    belongs_to :creator, class_name: 'User'
+    belongs_to :updated_by, class_name: 'User', optional: true
+    belongs_to :content_type
+    has_many :field_items, dependent: :destroy, autosave: true
+
+    accepts_nested_attributes_for :field_items
+
+    default_scope { order(created_at: :desc) }
+
+    validates :creator, :content_type, presence: true
+
+    state_machine do
+      state :draft
+      state :scheduled
+
+      event :schedule do
+        transitions :to => :scheduled, :from => [:draft]
+      end
+
+      event :draft do
+        transitions :to => :draft, :from => [:scheduled]
+      end
+    end
+
+    def publish_state
+      GetPublishStateTransaction.new.call(self).value!
+    end
+
+    # FieldItem and State Convenience Methods. TODO: move to concern? transactions?
+    def method_missing(method_name, *arguments, &block)
+      super unless dynamic_method?(method_name)
+
+      if dynamic_state_check?(method_name)
+        # Used to check state - allows for methods such as #published? and #expired?
+        # Will return true if the active_state corresponds to the name of the method
+        "#{publish_state.downcase}?" == method_name.to_s
+      else
+        # Used to query for any field on the relevant ContentType and return data from the content_item
+        field_items.find { |field_item| field_item.field.name.parameterize(separator: '_') == method_name.to_s }.data.values.first
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      dynamic_method?(method_name) || super
+    end
+
+    private
+
+    def dynamic_method?(method_name)
+      dynamic_state_check?(method_name) || has_field_item?(method_name)
+    end
+
+    def dynamic_state_check?(method_name)
+      method_name.to_s.include? '?'
+    end
+
+    # TODO: this logic effectively gets called multiple times (slow?) - how do we optimize or cache the result?
+    def has_field_item?(method_name)
+      field_items.any? { |field_item| field_item.field.name.parameterize(separator: '_') == method_name.to_s }
+    end
+  end
+end

data/app/models/cortex/content_type.rb

@@ -0,0 +1,27 @@
+module Cortex
+  class ContentType < Cortex::ApplicationRecord
+    include Cortex::SearchableContentType
+    include Cortex::SearchableContentItemForContentType
+    include Cortex::BelongsToTenant
+
+    validates :name, :creator, :contract, presence: true
+    validates_uniqueness_of :name,
+                            :name_id,
+                            scope: :tenant_id,
+                            message: 'should be unique within a Tenant'
+
+    belongs_to :creator, class_name: 'User'
+    belongs_to :contract
+    has_many :fields
+    has_many :content_items
+    has_many :contentable_decorators, as: :contentable
+    has_many :decorators, through: :contentable_decorators
+
+    accepts_nested_attributes_for :fields
+
+    # TODO: Extract to a concern
+    def self.permissions
+      Permission.select { |perm| perm.resource_type = self }
+    end
+  end
+end

data/app/models/cortex/contentable_decorator.rb

@@ -0,0 +1,8 @@
+module Cortex
+  class ContentableDecorator < Cortex::ApplicationRecord
+    include Cortex::BelongsToTenant
+
+    belongs_to :decorator
+    belongs_to :contentable, polymorphic: true
+  end
+end

data/app/models/cortex/contract.rb

@@ -0,0 +1,12 @@
+# TODO: Refactor
+module Cortex
+  class Contract < Cortex::ApplicationRecord
+    include Cortex::BelongsToTenant
+
+    validates :name, presence: true
+
+    has_many :content_types
+    has_many :contentable_decorators, as: :contentable
+    has_many :decorators, through: :contentable_decorators
+  end
+end

data/app/models/cortex/decorator.rb

@@ -0,0 +1,13 @@
+module Cortex
+  class Decorator < Cortex::ApplicationRecord
+    include Cortex::BelongsToTenant
+
+    has_many :contentable_decorators
+
+    validates :name, :data, presence: true
+
+    def data
+      self[:data].deep_symbolize_keys
+    end
+  end
+end

data/app/models/cortex/field.rb

@@ -0,0 +1,36 @@
+module Cortex
+  class Field < Cortex::ApplicationRecord
+    belongs_to :content_type, touch: true
+    has_many :field_items
+    has_many :content_items, through: :field_items
+
+    validates :name, :content_type, :field_type, presence: true
+    validate :acceptable_field_type
+    validates_uniqueness_of :name,
+                            :name_id,
+                            scope: :content_type_id,
+                            message: 'should be unique within a ContentType'
+
+    def field_type_instance(options = {})
+      field_type.camelize.constantize.new(options)
+    end
+
+    def elasticsearch_mapping
+      field_type_instance(field_name: name).elasticsearch_mapping
+    end
+
+    def tenant
+      content_type.tenant
+    end
+
+    private
+
+    def acceptable_field_type
+      begin
+        Cortex::FieldType.get_subtype_constant(field_type)
+      rescue NameError
+        errors.add(:field_type, 'must be an available field type')
+      end
+    end
+  end
+end

data/app/models/cortex/field_item.rb

@@ -0,0 +1,54 @@
+module Cortex
+  class FieldItem < Cortex::ApplicationRecord
+    belongs_to :field
+    belongs_to :content_item, touch: true
+
+    validates :field, :content_item, presence: true
+    validate :field_item_content_is_valid, if: :field_is_present
+
+    def data=(data_hash)
+      # Reset @field_type_instance so that massaged data can be re-generated every time @data is set, not just on init
+      @field_type_instance = nil
+      super(field_type_instance(data_hash).data || data_hash)
+    end
+
+    def tenant
+      content_item.tenant
+    end
+
+    private
+
+    def field_type_instance_params(data_hash)
+      # Carefully construct a params object so we don't trigger our fragile setters when a value is nil
+      params = { metadata: field.metadata.merge({ existing_data: data }), field: field, validations: field.validations }
+      params[:data] = data_hash if data_hash
+      params
+    end
+
+    def field_type_instance(data_hash = nil)
+      field_type_class = FieldType.get_subtype_constant(field.field_type)
+      # data_before_typecast will give us a non-mutilated hash with Objects intact, just in case validations get called first
+      @field_type_instance ||= field_type_class.new(field_type_instance_params(data_hash))
+      @field_type_instance.save
+      @field_type_instance
+    end
+
+    def field_is_present
+      field.present?
+    end
+
+    def field_item_content_is_valid
+      add_specific_errors unless field_item_validates
+    end
+
+    def field_item_validates
+      field_type_instance.valid?
+    end
+
+    def add_specific_errors
+      field_type_instance.errors.each do |k, v|
+        errors.add(field.name.to_sym, v)
+      end
+    end
+  end
+end

data/app/models/cortex/field_type.rb

@@ -0,0 +1,44 @@
+module Cortex
+  class FieldType < Cortex::ApplicationRecord
+    extend ActiveSupport::DescendantsTracker
+
+    attr_accessor :field_name, :field
+    attr_reader :data, :validations, :metadata
+
+    def self.direct_descendant_names
+      direct_descendants.map { |descendant| descendant.name.underscore }
+    end
+
+    def self.get_subtype_constant(descendant_name)
+      descendant_name.camelize.constantize
+    end
+
+    def elasticsearch_mapping
+      raise 'Not implemented'
+    end
+
+    def validations=(validations_hash)
+      @validations = validations_hash.deep_symbolize_keys if validations_hash
+    end
+
+    def metadata=(metadata_hash)
+      @metadata = metadata_hash.deep_symbolize_keys if metadata_hash
+    end
+
+    def acceptable_validations?
+      valid_types? && valid_options?
+    end
+
+    def valid_types?
+      validations.all? do |type, options|
+        VALIDATION_TYPES.include?(type.to_sym)
+      end
+    end
+
+    def valid_options?
+      validations.all? do |type, options|
+        self.send(VALIDATION_TYPES[type])
+      end
+    end
+  end
+end

data/app/models/cortex/permission.rb

@@ -0,0 +1,11 @@
+module Cortex
+  class Permission < Cortex::ApplicationRecord
+    has_and_belongs_to_many :roles
+
+    validates :name, :resource_type, presence: true
+
+    def resource
+      resource_type.constantize
+    end
+  end
+end