georgia 0.7.0

data/app/mailers/georgia/notifier.rb

@@ -0,0 +1,33 @@
+module Georgia
+  class Notifier < ActionMailer::Base
+
+    include SendGrid
+
+    def notify_admins(message, url)
+      @message = message
+      @url = url
+      emails_to = Georgia::User.admins.map(&:email)
+      unless emails_to.empty?
+        mail(
+          from: "georgia@motioneleven.com",
+          to: emails_to,
+          subject: @message
+          )
+      end
+    end
+
+    def notify_editors(message, url)
+      @message = message
+      @url = url
+      emails_to = Georgia::User.editors.map(&:email)
+      unless emails_to.empty?
+        mail(
+          from: "georgia@motioneleven.com",
+          to: emails_to,
+          subject: @message
+          )
+      end
+    end
+
+  end
+end

data/app/models/ability.rb

@@ -0,0 +1,19 @@
+require 'cancan'
+
+class Ability
+  include CanCan::Ability
+
+  def initialize(user)
+    user ||= Georgia::User.new
+
+    if user.has_role? 'Admin'
+      can :manage, :all
+    elsif user.has_role? 'Editor'
+      can :manage, :all
+      cannot :manage, Georgia::User
+    else # or if user is Guest
+      can [:read, :edit, :update, :search, :draft, :review], :all
+      cannot :manage, Georgia::User
+    end
+  end
+end

data/app/models/ckeditor/asset.rb

@@ -0,0 +1,61 @@
+class Ckeditor::Asset < ActiveRecord::Base
+
+  # to allow media_path in to_jq_upload
+  include Georgia::Engine.routes.url_helpers
+
+  include Ckeditor::Orm::ActiveRecord::AssetBase
+  include Georgia::Concerns::Taggable
+
+  delegate :url, :current_path, :content_type, to: :data
+
+  mount_uploader :data, CkeditorAttachmentFileUploader, mount_on: :data_file_name
+
+  validates :data, presence: true
+  attr_accessible :data
+
+  paginates_per 15
+
+  scope :latest, order('created_at DESC')
+
+  def to_jq_upload
+    {
+      "name" => read_attribute(:data),
+      "size" => data.size,
+      "url" => data.url,
+      "delete_url" => media_path(id: id),
+      "delete_type" => "DELETE"
+    }
+  end
+
+  def extension
+    @extension ||= data_content_type.gsub(/.*\/(.*)/, '\1')
+  end
+
+  searchable do
+    text :filename, stored: true
+    text :tags do
+      tag_list.join(', ')
+    end
+    string :tags, stored: true, multiple: true do
+      tag_list
+    end
+    string :extension, stored: true do
+      extension.try(:downcase)
+    end
+    time :updated_at
+    integer :size, stored: true do
+      size / 1024 # gives size in KB
+    end
+  end
+
+  SIZE_RANGE = {
+    '< 25 KB' => 0..25,
+    '25 KB to 100 KB' => 25..100,
+    '100 KB to 500 KB' => 100..500,
+    '500 KB to 1 MB' => 500..1000,
+    '> 1 MB' => 1000..999999
+  }
+
+
+
+end

data/app/models/ckeditor/attachment_file.rb

@@ -0,0 +1,7 @@
+class Ckeditor::AttachmentFile < Ckeditor::Asset
+  mount_uploader :data, CkeditorAttachmentFileUploader, :mount_on => :data_file_name
+
+  def url_thumb
+    @url_thumb ||= Ckeditor::Utils.filethumb(filename)
+  end
+end

data/app/models/ckeditor/picture.rb

@@ -0,0 +1,15 @@
+class Ckeditor::Picture < Ckeditor::Asset
+
+  mount_uploader :data, CkeditorPictureUploader, mount_on: :data_file_name
+
+  has_many :contents, foreign_key: :image_id, class_name: Georgia::Content
+
+  def featured?
+    @featured ||= !contents_count.zero?
+  end
+
+  def pages
+    @pages ||= contents.map(&:contentable).map(&:page).compact.uniq
+  end
+
+end

data/app/models/georgia/clone.rb

@@ -0,0 +1,101 @@
+module Georgia
+  class Clone
+
+    attr_accessor :instance, :duplicate
+
+    def initialize instance
+      raise 'Instance must be persisted to be copied' if instance.new_record?
+      @instance = instance
+      @duplicate = instance.class.new
+    end
+
+    # Returns an exact persisted version of itself with all Georgia::Page associations
+    # The resulting instance has a '(Copy)' title and '-copy' slug
+    def copy
+      copy_page
+      duplicate.current_revision = clone_current_revision
+      alter_slug
+      alter_title
+      duplicate.save!
+      duplicate
+    end
+
+    # Returns a copy of the current revision in 'draft' state
+    def draft
+      clone_current_revision(state: 'draft')
+    end
+
+    # Returns a copy of the current revision in 'revision' state
+    def store
+      @instance.revisions << clone_current_revision(state: 'revision')
+      @instance.save
+    end
+
+    private
+
+    def copy_page
+      duplicate.ancestry = instance.ancestry
+      duplicate.tag_list = instance.tag_list
+    end
+
+    def clone_current_revision options={}
+      state = options.fetch(:state, 'draft')
+      @duplicate_revision = Georgia::Revision.new(template: instance.current_revision.template, state: state) do |r|
+        r.contents = clone_contents
+        r.ui_associations = clone_ui_associations
+        r.slides = clone_slides
+      end
+      @duplicate_revision
+    end
+
+    def clone_contents
+      instance.current_revision.contents.map{|c| clone_content(c)}
+    end
+
+    def clone_ui_associations
+      instance.current_revision.ui_associations.map{|ui_assoc| clone_ui_association(ui_assoc)}
+    end
+
+    def clone_slides
+      instance.current_revision.slides.map do |slide|
+        new_slide = Georgia::Slide.new(page_id: slide.page_id)
+        slide.contents.each do |content|
+          new_slide.contents << clone_content(content)
+        end
+        new_slide
+      end
+    end
+
+    def clone_content(content)
+      Georgia::Content.new(
+        locale: content.locale,
+        text: content.text,
+        title: content.title,
+        excerpt: content.excerpt,
+        image_id: content.image_id,
+        keyword_list: content.keyword_list
+      )
+    end
+
+    def clone_ui_association(ui_assoc)
+      Georgia::UiAssociation.new(
+        page_id: ui_assoc.page_id,
+        widget_id: ui_assoc.widget_id,
+        ui_section_id: ui_assoc.ui_section_id
+      )
+    end
+
+    # alter the slug to add '-copy' at the end and keep url unique
+    def alter_slug
+      duplicate.slug = "#{instance.slug}-copy"
+    end
+
+    # alter the title to keep original title unique
+    def alter_title
+      duplicate.current_revision.contents.each do |content|
+        content.update_attribute(:title, "#{content.title} (Copy)")
+      end
+    end
+
+  end
+end

data/app/models/georgia/concerns/cacheable.rb

@@ -0,0 +1,18 @@
+require 'active_support/concern'
+
+module Georgia
+  module Concerns
+    module Cacheable
+      extend ActiveSupport::Concern
+
+      included do
+
+        def cache_key
+          [self.url, self.updated_at.to_i].join('/')
+        end
+
+      end
+
+    end
+  end
+end

data/app/models/georgia/concerns/contentable.rb

@@ -0,0 +1,22 @@
+require 'active_support/concern'
+
+module Georgia
+  module Concerns
+    module Contentable
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :contents, as: :contentable, dependent: :destroy, class_name: Georgia::Content
+        accepts_nested_attributes_for :contents
+        attr_accessible :contents_attributes
+
+        def content
+          @content ||= contents.select{|c| c.locale == I18n.locale.to_s}.first || Georgia::Content.new
+        end
+
+				delegate :title, :text, :excerpt, :keywords, :keyword_list, :image, :locale, to: :content
+      end
+
+    end
+  end
+end

data/app/models/georgia/concerns/indexable.rb

@@ -0,0 +1,67 @@
+require 'active_support/concern'
+
+module Georgia
+  module Concerns
+    module Indexable
+      extend ActiveSupport::Concern
+
+      included do
+
+        class << self
+
+          # Default fields to be include in searchable block
+          # Children of Georgia::Page can use this to extend their own searchable block
+          def indexable_fields
+            Proc.new {
+              text :title, stored: true do
+                revisions.map{|r| r.contents.map(&:title)}.flatten.uniq.join(', ')
+              end
+              text :excerpt, stored: true do
+                revisions.map{|r| r.contents.map(&:excerpt)}.flatten.uniq.join(', ')
+              end
+              text :text do
+                revisions.map{|r| r.contents.map(&:text)}.flatten.uniq.join(', ')
+              end
+              text :keywords do
+                revisions.map{|r| r.contents.map(&:keyword_list)}.flatten.uniq.join(', ')
+              end
+              text :template do
+                revisions.map(&:template).uniq.join(', ')
+              end
+              text :tags do
+                tag_list.join(', ')
+              end
+              text :url
+              string :class_name do
+                self.class.name
+              end
+              string :title
+              string :excerpt
+              string :text
+              string :url
+              string :template
+              string :state do
+                publish_state
+              end
+              string :keywords, stored: true, multiple: true do
+                revisions.map{|r| r.contents.map(&:keyword_list)}.flatten.uniq
+              end
+              string :tag_list, stored: true, multiple: true #Facets (multiple)
+              string :tags do #Ordering (single list)
+                tag_list.join(', ')
+              end
+              time :updated_at # default for ordering
+            }
+          end
+
+        end
+
+        searchable do
+          instance_eval &self.indexable_fields
+        end
+
+      end
+
+    end
+  end
+end

data/app/models/georgia/concerns/orderable.rb

@@ -0,0 +1,21 @@
+require 'active_support/concern'
+
+module Georgia
+  module Concerns
+    module Orderable
+      extend ActiveSupport::Concern
+
+      included do
+
+        acts_as_list
+        attr_accessible :position
+
+        scope :ordered, order(:position)
+
+      end
+
+      module ClassMethods
+      end
+    end
+  end
+end

data/app/models/georgia/concerns/publishable.rb

@@ -0,0 +1,35 @@
+require 'active_support/concern'
+
+module Georgia
+  module Concerns
+    module Publishable
+      extend ActiveSupport::Concern
+
+      included do
+
+        scope :published, where(public: true)
+
+        def publish
+          self.update_attribute(:public, true)
+        end
+
+        def unpublish
+          self.update_attribute(:public, false)
+        end
+
+        def public?
+          self.public
+        end
+        alias_method :published?, :public?
+
+        def publish_state
+          public? ? 'public' : 'private'
+        end
+
+      end
+
+      module ClassMethods
+      end
+    end
+  end
+end

data/app/models/georgia/concerns/revisionable.rb

@@ -0,0 +1,38 @@
+require 'active_support/concern'
+
+module Georgia
+  module Concerns
+    module Revisionable
+      extend ActiveSupport::Concern
+
+      included do
+
+        has_many :revisions, as: :revisionable, dependent: :destroy
+        belongs_to :current_revision, class_name: Georgia::Revision, foreign_key: :revision_id
+
+        delegate :title, :text, :excerpt, :keywords, :keyword_list, :image, to: :current_revision, allow_nil: true
+        delegate :template, :content, :slides, :widgets, to: :current_revision, allow_nil: true
+        delegate :draft?, :review?, :revision?, to: :current_revision, allow_nil: true
+
+        def draft
+          Georgia::Clone.new(self).draft
+        end
+
+        def store
+          Georgia::Clone.new(self).store
+        end
+
+        def copy
+          Georgia::Clone.new(self).copy
+        end
+
+        def approve_revision revision
+          current_revision.store if current_revision
+          self.update_attribute(:revision_id, revision.id)
+        end
+
+      end
+
+    end
+  end
+end