cortex-plugins-core 0.3.0

data/app/models/asset_field_type.rb

@@ -0,0 +1,114 @@
+class AssetFieldType < FieldType
+  VALIDATION_TYPES = {
+      presence: :valid_presence_validation?,
+      size: :valid_size_validation?,
+      content_type: :valid_content_type_validation?
+  }.freeze
+
+  attr_accessor :asset_file_name,
+                :asset_content_type,
+                :asset_file_size,
+                :asset_updated_at,
+                :field_name
+
+  attr_reader :data, :validations, :dimensions
+
+  has_attached_file :asset
+  do_not_validate_attachment_file_type :asset
+  before_save :extract_dimensions
+
+  validates :asset, attachment_presence: true, if: :validate_presence?
+
+  def validations=(validations_hash)
+    @validations = validations_hash.deep_symbolize_keys
+  end
+
+  def data=(data_hash)
+    self.asset = data_hash.deep_symbolize_keys[:asset]
+  end
+
+  def data
+    {
+        'asset': {
+            'file_name': asset_file_name,
+            'url': asset.url,
+            'dimensions': dimensions,
+            'content_type': asset_content_type,
+            'file_size': asset_file_size,
+            'updated_at': asset_updated_at
+        }
+    }
+  end
+
+  def acceptable_validations?
+    valid_types? && valid_options?
+  end
+
+  def field_item_as_indexed_json_for_field_type(field_item, options = {})
+    json = {}
+    json[mapping_field_name] = asset_file_name
+    json
+  end
+
+  def mapping
+    {name: mapping_field_name, type: :string, analyzer: :keyword}
+  end
+
+  private
+
+  def image?
+    asset_content_type =~ %r{^(image|(x-)?application)/(bmp|gif|jpeg|jpg|pjpeg|png|x-png)$}
+  end
+
+  def extract_dimensions
+    return unless image?
+    tempfile = asset.queued_for_write[:original]
+    unless tempfile.nil?
+      geometry = Paperclip::Geometry.from_file(tempfile)
+      @dimensions = {
+          width: geometry.width.to_i,
+          height: geometry.height.to_i
+      }
+    end
+  end
+
+  def mapping_field_name
+    "#{field_name.parameterize('_')}_asset_file_name"
+  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
+
+  def validate_presence?
+    @validations.key? :presence
+  end
+
+  alias_method :valid_presence_validation?, :validate_presence?
+
+  def valid_size_validation?
+    begin
+      AttachmentSizeValidator.new(validations[:size].merge(attributes: :asset))
+      true
+    rescue ArgumentError, NoMethodError
+      false
+    end
+  end
+
+  def valid_content_type_validation?
+    begin
+      AttachmentContentTypeValidator.new(validations[:content_type].merge(attributes: :asset))
+      true
+    rescue ArgumentError, NoMethodError
+      false
+    end
+  end
+end

data/app/models/boolean_field_type.rb

@@ -0,0 +1,36 @@
+class BooleanFieldType < FieldType
+  attr_accessor :data, :value, :field_name
+  attr_reader :validations, :metadata
+
+  def validations=(validations_hash)
+    @validations = {}
+  end
+
+  def data=(data_hash)
+    @value = data_hash.deep_symbolize_keys[:value]
+  end
+
+  def metadata=(metadata_hash)
+    @metadata = metadata_hash.deep_symbolize_keys
+  end
+
+  def field_item_as_indexed_json_for_field_type(field_item, options = {})
+    json = {}
+    json[mapping_field_name] = field_item.data['boolean']
+    json
+  end
+
+  def mapping
+    { name: mapping_field_name, type: :string, analyzer: :snowball }
+  end
+
+  def acceptable_validations?
+    true
+  end
+
+  private
+
+  def mapping_field_name
+    "#{field_name.parameterize('_')}_boolean"
+  end
+end

data/app/models/date_time_field_type.rb

@@ -0,0 +1,77 @@
+class DateTimeFieldType < FieldType
+  VALIDATION_TYPES = {
+    presence: :valid_presence_validation?
+  }.freeze
+
+  attr_accessor :data, :timestamp, :field_name
+  attr_reader :validations, :metadata
+
+  validates :timestamp, presence: true, if: :validate_presence?
+  validate :timestamp_is_valid?
+
+  def validations=(validations_hash)
+    @validations = validations_hash.deep_symbolize_keys
+  end
+
+  def data=(data_hash)
+    @timestamp = data_hash.deep_symbolize_keys[:timestamp]
+  end
+
+  def metadata=(metadata_hash)
+    @metadata = metadata_hash.deep_symbolize_keys
+  end
+
+  def acceptable_validations?
+    valid_types? && valid_options?
+  end
+
+  def field_item_as_indexed_json_for_field_type(field_item, options = {})
+    json = {}
+    json[mapping_field_name] = field_item.data['date_time']
+    json
+  end
+
+  def mapping
+    {name: mapping_field_name, type: :string, analyzer: :snowball}
+  end
+
+  private
+
+  def mapping_field_name
+    "#{field_name.parameterize('_')}_date_time"
+  end
+
+  def timestamp_is_valid?
+    if @timestamp.nil?
+      true
+    else
+      begin
+        DateTime.parse(@timestamp)
+        true
+      rescue ArgumentError
+        errors.add(:timestamp, 'must be a valid date')
+        false
+      end
+    end
+  end
+
+  def valid_types?
+    validations.all? do |type, options|
+      VALIDATION_TYPES.include?(type)
+    end
+  end
+
+  def valid_options?
+    validations.all? do |type, options|
+      self.send(VALIDATION_TYPES[type])
+    end
+  end
+
+  def valid_presence_validation?
+    @validations.key? :presence
+  end
+
+  def validate_presence?
+    @validations.key? :presence
+  end
+end

data/app/models/tag_field_type.rb

@@ -0,0 +1,63 @@
+class TagFieldType < FieldType
+  VALIDATION_TYPES = {
+    presence: :valid_presence_validation?
+  }.freeze
+
+  attr_accessor :data, :tag_list, :field_name
+  attr_reader :validations, :metadata
+
+  validates :tag_list, presence: true, if: :validate_presence?
+
+  def validations=(validations_hash)
+    @validations = validations_hash.deep_symbolize_keys
+  end
+
+  def data=(data_hash)
+    @tag_list = data_hash.deep_symbolize_keys[:tag_list]
+    @tag_list.nil? ? nil : (@tag_list = @tag_list.split(","))
+  end
+
+  def metadata=(metadata_hash)
+    @metadata = metadata_hash.deep_symbolize_keys
+  end
+
+  def acceptable_validations?
+    valid_types? && valid_options?
+  end
+
+  def field_item_as_indexed_json_for_field_type(field_item, options = {})
+    json = {}
+    json[mapping_field_name] = field_item.data['tag']
+    json
+  end
+
+  def mapping
+    {name: mapping_field_name, type: :string, analyzer: :snowball}
+  end
+
+  private
+
+  def mapping_field_name
+    "#{field_name.parameterize('_')}_tag"
+  end
+
+  def valid_types?
+    validations.all? do |type, options|
+      VALIDATION_TYPES.include?(type)
+    end
+  end
+
+  def valid_options?
+    validations.all? do |type, options|
+      self.send(VALIDATION_TYPES[type])
+    end
+  end
+
+  def valid_presence_validation?
+    @validations.key? :presence
+  end
+
+  def validate_presence?
+    @validations.key? :presence
+  end
+end

data/app/models/text_field_type.rb

@@ -0,0 +1,86 @@
+class TextFieldType < FieldType
+  VALIDATION_TYPES = {
+    length: :valid_length_validation?,
+    presence: :valid_presence_validation?
+  }.freeze
+
+  attr_accessor :data, :text, :field_name
+  attr_reader :validations, :metadata
+
+  validates :text, presence: true, if: :validate_presence?
+  validate :text_length, if: :validate_length?
+
+  def validations=(validations_hash)
+    @validations = validations_hash.deep_symbolize_keys
+  end
+
+  def data=(data_hash)
+    @text = data_hash.deep_symbolize_keys[:text]
+  end
+
+  def metadata=(metadata_hash)
+    @metadata = metadata_hash.deep_symbolize_keys
+  end
+
+  def acceptable_validations?
+    valid_types? && valid_options?
+  end
+
+  def field_item_as_indexed_json_for_field_type(field_item, options = {})
+    json = {}
+    json[mapping_field_name] = field_item.data['text']
+    json
+  end
+
+  def mapping
+    {name: mapping_field_name, type: :string, analyzer: :snowball}
+  end
+
+  private
+
+  def mapping_field_name
+    "#{field_name.parameterize('_')}_text"
+  end
+
+  def valid_types?
+    validations.all? do |type, options|
+      VALIDATION_TYPES.include?(type)
+    end
+  end
+
+  def valid_options?
+    validations.all? do |type, options|
+      self.send(VALIDATION_TYPES[type])
+    end
+  end
+
+  def valid_length_validation?
+    begin
+      LengthValidator.new(validations[:length].merge(attributes: [:text]))
+      true
+    rescue ArgumentError, NoMethodError
+      false
+    end
+  end
+
+  def valid_presence_validation?
+    @validations.key? :presence
+  end
+
+  def text_present
+    errors.add(:text, "must be present") if @text.empty?
+  end
+
+  def text_length
+    validator = LengthValidator.new(validations[:length].merge(attributes: [:text]))
+    validator.validate_each(self, :text, text)
+  end
+
+  def validate_presence?
+    @validations.key? :presence
+  end
+
+  def validate_length?
+    @validations.key? :length
+  end
+end

data/app/models/tree_field_type.rb

@@ -0,0 +1,111 @@
+class TreeFieldType < FieldType
+  VALIDATION_TYPES = {
+    presence: :valid_presence_validation?,
+    maximum: :valid_maximum_validation?,
+    minimum: :valid_minimum_validation?
+  }.freeze
+
+  attr_accessor :data, :values, :field_name
+  attr_reader :validations, :metadata
+
+  validates :values, presence: true, if: :validate_presence?
+  validate  :minimum, if: :validate_minimum?
+  validate  :maximum, if: :validate_maximum?
+
+  def validations=(validations_hash)
+    @validations = validations_hash.deep_symbolize_keys
+  end
+
+  def data=(data_hash)
+    values = data_hash.deep_symbolize_keys[:values]
+
+    if values.is_a?(Hash)
+      @values = values.keys
+    else
+      @values = [values]
+    end
+  end
+
+  def metadata=(metadata_hash)
+    @metadata = metadata_hash.deep_symbolize_keys.extend(Hashie::Extensions::DeepLocate)
+  end
+
+  def acceptable_validations?
+    valid_types? && valid_options?
+  end
+
+  def field_item_as_indexed_json_for_field_type(field_item, options = {})
+    json = {}
+    json[mapping_field_name] = field_item.data['tree']
+    json
+  end
+
+  def mapping
+    { name: mapping_field_name, type: :string, analyzer: :snowball }
+  end
+
+  private
+
+  def mapping_field_name
+    "#{field_name.parameterize('_')}_tree"
+  end
+
+  def minimum
+    unless @values.nil?
+      if @values.length >= @validations[:minimum]
+        true
+      else
+        errors.add(:minimum, "You have selected too few values.")
+        false
+      end
+    end
+  end
+
+  def maximum
+    unless @values.nil?
+      if @values.length <= @validations[:maximum]
+        true
+      else
+        errors.add(:maximum, "You have selected too many values.")
+        false
+      end
+    end
+  end
+
+  def valid_types?
+    validations.all? do |type, options|
+      VALIDATION_TYPES.include?(type)
+    end
+  end
+
+  def valid_options?
+    validations.all? do |type, options|
+      self.send(VALIDATION_TYPES[type])
+    end
+  end
+
+  def valid_presence_validation?
+    @validations.key? :presence
+  end
+
+  def valid_maximum_validation?
+    @validations.key? :maximum
+  end
+
+  def valid_minimum_validation?
+    @validations.key? :minimum
+  end
+
+  def validate_presence?
+    @validations.key? :presence
+  end
+
+  def validate_minimum?
+    @validations.key? :minimum
+  end
+
+  def validate_maximum?
+    @validations.key? :maximum
+  end
+
+end

data/app/models/user_field_type.rb

@@ -0,0 +1,72 @@
+class UserFieldType < FieldType
+  VALIDATION_TYPES = {
+    presence: :valid_presence_validation?
+  }.freeze
+
+  attr_accessor :data, :user_id, :field_name
+  attr_reader :validations, :metadata
+
+  validates :user_id, presence: true, if: :validate_presence?
+  validate :valid_user_id?
+
+  def validations=(validations_hash)
+    @validations = validations_hash.deep_symbolize_keys
+  end
+
+  def data=(data_hash)
+    @user_id = data_hash.deep_symbolize_keys[:user_id]
+  end
+
+  def metadata=(metadata_hash)
+    @metadata = metadata_hash.deep_symbolize_keys
+  end
+
+  def acceptable_validations?
+    valid_types? && valid_options?
+  end
+
+  def field_item_as_indexed_json_for_field_type(field_item, options = {})
+    json = {}
+    json[mapping_field_name] = field_item.data['user']
+    json
+  end
+
+  def mapping
+    {name: mapping_field_name, type: :string, analyzer: :snowball}
+  end
+
+  private
+
+  def mapping_field_name
+    "#{field_name.parameterize('_')}_user"
+  end
+
+  def valid_user_id?
+    return true if id.nil?
+
+    unless User.exists?(id)
+      errors.add(:user_id, "Must be for a Valid User")
+      false
+    end
+  end
+
+  def valid_types?
+    validations.all? do |type, options|
+      VALIDATION_TYPES.include?(type)
+    end
+  end
+
+  def valid_options?
+    validations.all? do |type, options|
+      self.send(VALIDATION_TYPES[type])
+    end
+  end
+
+  def valid_presence_validation?
+    @validations.key? :presence
+  end
+
+  def validate_presence?
+    @validations.key? :presence
+  end
+end

data/lib/cortex/plugins/core/engine.rb

@@ -0,0 +1,10 @@
+require 'ckeditor'
+
+module Cortex
+  module Plugins
+    module Core
+      class Engine < ::Rails::Engine
+      end
+    end
+  end
+end

data/lib/cortex/plugins/core/version.rb

@@ -0,0 +1,7 @@
+module Cortex
+  module Plugins
+    module Core
+      VERSION = '0.3.0'
+    end
+  end
+end

data/lib/cortex/plugins/core.rb

@@ -0,0 +1,8 @@
+require "cortex/plugins/core/engine"
+
+module Cortex
+  module Plugins
+    module Core
+    end
+  end
+end

data/lib/tasks/cortex/core/db.rake

@@ -0,0 +1,30 @@
+Bundler.require(:default, Rails.env)
+
+namespace :cortex do
+  namespace :core do
+    namespace :db do
+      desc 'Re-Seeds (will wipe existing ContentTypes!) Cortex with Core Custom Content Seed Data'
+      task reseed: :environment do
+        Rake::Task['cortex:core:db:clear'].execute
+        Rake::Task['cortex:core:media:seed'].execute
+        Rake::Task['employer:blog:seed'].execute # TODO: Extract
+      end
+
+      desc 'Clear Existing Custom Content Data From DB'
+      task clear: :environment do
+        puts "Clearing ContentTypes..."
+        ContentType.destroy_all
+        puts "Clearing Fields..."
+        Field.destroy_all
+        puts "Clearing ContentItems..."
+        ContentItem.destroy_all
+        puts "Clearing FieldItems..."
+        FieldItem.destroy_all
+        puts "Clearing ContentableDecorators..."
+        ContentableDecorator.destroy_all
+        puts "Clearing Decorators..."
+        Decorator.destroy_all
+      end
+    end
+  end
+end