effective_posts 1.1.11 → 2.0.3

data/app/mailers/effective/posts_mailer.rb

@@ -10,7 +10,8 @@ module Effective
       mail(
         to: EffectivePosts.mailer[:admin_email],
         from: EffectivePosts.mailer[:default_from],
-        subject: subject_for_post_submitted_to_admin(@post)
+        subject: subject_for_post_submitted_to_admin(@post),
+        tenant: (Tenant.current if defined?(Tenant))
       )
     end
 

data/app/models/effective/post.rb

@@ -1,55 +1,63 @@
 module Effective
   class Post < ActiveRecord::Base
-    acts_as_regionable
+    attr_accessor :current_user
+
     acts_as_slugged
 
-    if EffectivePosts.use_effective_roles && respond_to?(:acts_as_role_restricted)
-      acts_as_role_restricted
-    end
+    log_changes if respond_to?(:log_changes)
+    acts_as_role_restricted if respond_to?(:acts_as_role_restricted)
 
-    if EffectivePosts.use_active_storage && respond_to?(:has_one_attached)
-      has_one_attached :image
-    end
+    has_one_attached :image
+
+    has_rich_text :excerpt
+    has_rich_text :body
 
     self.table_name = EffectivePosts.posts_table_name.to_s
 
-    belongs_to :user, optional: true
+    belongs_to :user, polymorphic: true, optional: true
 
-    # Attributes
-    # title             :string
-    # description       :string
+    effective_resource do
+      title             :string
+      description       :string
 
-    # slug              :string
+      category          :string
+      slug              :string
 
-    # category          :string
+      draft             :boolean
+      published_at      :datetime
+      tags              :text
 
-    # draft             :boolean
-    # published_at      :datetime
-    # tags              :text
+      roles_mask        :integer
 
-    # roles_mask        :integer
+      # Event Fields
+      start_at          :datetime
+      end_at            :datetime
 
-    # Event Fields
-    # start_at          :datetime
-    # end_at            :datetime
-    # location          :string
-    # website_name      :website_name
-    # website_href      :website_href
+      location          :string
+      website_name      :string
+      website_href      :string
 
-    # timestamps
+      timestamps
+    end
+
+    before_validation(if: -> { current_user.present? }) do
+      self.user ||= current_user
+    end
 
     validates :title, presence: true, length: { maximum: 255 }
     validates :description, presence: true, length: { maximum: 150 }
     validates :category, presence: true
-    validates :published_at, presence: true
+    validates :published_at, presence: true, unless: -> { draft? }
 
-    validates :start_at, presence: true, if: -> { category == 'events'}
+    validates :start_at, presence: true, if: -> { category == 'events' }
 
     scope :drafts, -> { where(draft: true) }
     scope :published, -> { where(draft: false).where("#{EffectivePosts.posts_table_name}.published_at < ?", Time.zone.now) }
     scope :unpublished, -> { where(draft: true).or(where("#{EffectivePosts.posts_table_name}.published_at > ?", Time.zone.now)) }
     scope :with_category, -> (category) { where(category: category.to_s.downcase) }
 
+    scope :deep, -> { with_rich_text_excerpt_and_embeds.with_rich_text_body_and_embeds }
+
     scope :paginate, -> (page: nil, per_page: EffectivePosts.per_page) {
       page = (page || 1).to_i
       offset = [(page - 1), 0].max * per_page
@@ -58,7 +66,7 @@ module Effective
     }
 
     scope :posts, -> (user: nil, category: nil, unpublished: false) {
-      scope = all.includes(:regions).order(published_at: :desc)
+      scope = all.deep.order(published_at: :desc)
 
       if defined?(EffectiveRoles) && EffectivePosts.use_effective_roles
         if user.present? && user.respond_to?(:roles)
@@ -77,16 +85,12 @@ module Effective
       scope
     }
 
-    def to_param
-      slug.presence || "#{id}-#{title.parameterize}"
-    end
-
     def to_s
       title.presence || 'New Post'
     end
 
     def published?
-      !draft? && published_at < Time.zone.now
+      !draft? && published_at.present? && published_at < Time.zone.now
     end
 
     def approved?
@@ -97,53 +101,34 @@ module Effective
       category == 'events'
     end
 
-    def body
-      region(:body).content
-    end
-
-    def body=(input)
-      region(:body).content = input
-    end
-
     # 3.333 words/second is the default reading speed.
     def time_to_read_in_seconds(reading_speed = 3.333)
       (regions.to_a.sum { |region| (region.content || '').scan(/\w+/).size } / reading_speed).seconds
     end
 
     def send_post_submitted_to_admin!
-      send_email(:post_submitted_to_admin, to_param)
+      deliver_method = EffectivePosts.mailer[:deliver_method] || EffectiveResources.deliver_method
+      Effective::PostsMailer.post_submitted_to_admin(to_param).send(deliver_method)
     end
 
     # Returns a duplicated post object, or throws an exception
-    def duplicate!
+    def duplicate
       Post.new(attributes.except('id', 'updated_at', 'created_at')).tap do |post|
         post.title = post.title + ' (Copy)'
         post.slug = post.slug + '-copy'
         post.draft = true
 
-        regions.each do |region|
-          post.regions.build(region.attributes.except('id', 'updated_at', 'created_at'))
-        end
-
-        post.save!
+        post.body = body
+        post.excerpt = excerpt
       end
     end
 
-    private
+    def duplicate!
+      duplicate.tap { |post| post.save! }
+    end
 
-    def send_email(email, *mailer_args)
-      begin
-        if EffectivePosts.mailer[:delayed_job_deliver] && EffectivePosts.mailer[:deliver_method] == :deliver_later
-          Effective::PostsMailer.delay.public_send(email, *mailer_args)
-        elsif EffectivePosts.mailer[:deliver_method].present?
-          Effective::PostsMailer.public_send(email, *mailer_args).public_send(EffectivePosts.mailer[:deliver_method])
-        else
-          Effective::PostsMailer.public_send(email, *mailer_args).deliver_now
-        end
-      rescue => e
-        raise e unless Rails.env.production?
-        return false
-      end
+    def approve!
+      update!(draft: false)
     end
 
   end

data/app/views/admin/posts/_form.html.haml

@@ -3,7 +3,13 @@
 
   - if f.object.persisted? || f.object.errors.include?(:slug)
     - current_url = effective_posts.post_path(f.object)
-  = f.text_field :slug, hint: "The slug controls this post's internet address. Be careful, changing the slug will break links that other websites may have to the old address.<br>#{('This post is currently reachable via ' + link_to(current_url.gsub(f.object.slug, '<strong>' + f.object.slug + '</strong>').html_safe, current_url)) if current_url && f.object.slug.present? }".html_safe
+
+    = f.text_field :slug, required: f.object.persisted?,
+      hint: "The slug controls this post's internet address. Be careful, changing the slug will break links that other websites may have to the old address.<br>#{('This post is currently reachable via ' + link_to(current_url.gsub(f.object.slug, '<strong>' + f.object.slug + '</strong>').html_safe, current_url)) if current_url && f.object.slug.present? }".html_safe
+
+  = f.rich_text_area :excerpt, hint: 'Will be used for the post excerpt on index pages.'
+
+  = f.text_field :description, hint: 'The content of the post meta tags.', maxlength: 150
 
   - if Array(EffectivePosts.categories).length > 1
     = f.select :category, EffectivePosts.categories
@@ -13,8 +19,7 @@
   - if EffectivePosts.use_active_storage
     = f.file_field :image, hint: 'An image for your post'
 
-  = f.ck_editor :excerpt, hint: 'Will be used for the post excerpt on index pages.'
-  = f.text_field :description, hint: 'The content of the post meta tags.', maxlength: 150
+  = f.rich_text_area :body, hint: 'The main body of your post'
 
   = render partial: '/effective/posts/additional_fields', locals: { post: post, form: f, f: f }
 
@@ -22,19 +27,11 @@
 
   = f.check_box :draft, hint: 'Save this post as a draft. It will not be accessible on the website.'
 
-  - unless EffectivePosts.use_fullscreen_editor
-    = f.ck_editor :body, hint: 'The content of your post.'
-
   - if defined?(EffectiveRoles) && f.object.respond_to?(:roles) && EffectivePosts.use_effective_roles
     = render partial: '/admin/posts/roles', locals: { post: post, form: f, f: f }
 
   = f.submit do
     = f.save 'Save'
-
-    - if EffectivePosts.use_fullscreen_editor
-      = f.save 'Save and Edit Content', class: 'btn btn-secondary'
-
     = f.save 'Save and View', class: 'btn btn-secondary'
-
     - if f.object.persisted?
       = f.save 'Duplicate', class: 'btn btn-info'

data/app/views/admin/posts/excerpts.html.haml

@@ -6,10 +6,10 @@
       %h2.post-title= link_to post, effective_post_path(post)
   .row
     .col-sm-6
-      %pre= effective_region(post, :body, editable: false)
+      %pre= post.body
 
     .col-sm-6
-      %pre= post_excerpt(post)
+      %pre= post.excerpt
 
   .row
     .col-sm-12

data/app/views/effective/posts/_form.html.haml

@@ -13,7 +13,7 @@
   - if EffectivePosts.use_active_storage
     = f.file_field :image, hint: 'An image for your post'
 
-  = f.ck_editor :excerpt, hint: 'Will be used for the post excerpt on index pages.'
+  = f.rich_text_area :excerpt, hint: 'Will be used for the post excerpt on index pages.'
   = f.text_field :description, hint: 'The content of the post meta tags.', maxlength: 150
 
   = render partial: '/effective/posts/additional_fields', locals: { post: post, form: f, f: f }
@@ -22,7 +22,6 @@
 
   = f.check_box :draft, hint: 'Save this post as a draft. It will not be accessible on the website.'
 
-  - unless EffectivePosts.use_fullscreen_editor
-    = f.ck_editor :body, hint: 'The content of your post.'
+  = f.rich_text_area :body, hint: 'The main body of your post'
 
   = f.submit 'Save'

data/app/views/effective/posts/_post.html.haml

@@ -6,4 +6,4 @@
     = admin_post_status_badge(post)
 
   .post-content.post-excerpt
-    = post_excerpt(post)
+    = post.excerpt

data/app/views/effective/posts/_sidebar.html.haml

@@ -18,11 +18,10 @@
   - if posts.length == 0
     %li= link_to 'None', effective_posts.posts_path, class: 'disabled'
 
-- if EffectivePosts.authorized?(self, :admin, :effective_posts)
+- if EffectiveResources.authorized?(self, :admin, :effective_posts)
   %h4.dashboard-title Admin
   %ul.list-unstyled
     %li= link_to 'All Posts', effective_posts.admin_posts_path
 
     - if @post.present?
-      %li= link_to 'Edit Post Content', effective_regions.edit_path(effective_posts.post_path(@post, exit: effective_posts.post_path(@post)))
       %li= link_to 'Edit Post Settings', effective_posts.edit_admin_post_path(@post)

data/app/views/effective/posts/show.html.haml

@@ -9,5 +9,4 @@
     = render 'effective/posts/event', post: @post
 
     .post-body.post-content
-      = effective_region @post, :body do
-        %p Default content
+      = @post.body

data/app/views/effective/posts/submitted.html.haml

@@ -2,7 +2,7 @@
 
 %p= EffectivePosts.submissions_note
 
-- if EffectivePosts.authorized?(controller, :edit, @post)
+- if EffectiveResources.authorized?(controller, :edit, @post)
   %p= link_to 'Edit Post', effective_posts.edit_post_path(@post), class: 'btn btn-primary btn-edit-post'
 
 %hr

data/config/effective_posts.rb

@@ -29,46 +29,12 @@ EffectivePosts.setup do |config|
   # The author is the user that created the Effective::Post object
   config.post_meta_author = true
 
-  # Authorization Method
-  #
-  # This method is called by all controller actions with the appropriate action and resource
-  # If the method returns false, an Effective::AccessDenied Error will be raised (see README.md for complete info)
-  #
-  # Use via Proc (and with CanCan):
-  # config.authorization_method = Proc.new { |controller, action, resource| can?(action, resource) }
-  #
-  # Use via custom method:
-  # config.authorization_method = :my_authorization_method
-  #
-  # And then in your application_controller.rb:
-  #
-  # def my_authorization_method(action, resource)
-  #   current_user.is?(:admin)
-  # end
-  #
-  # Or disable the check completely:
-  # config.authorization_method = false
-  config.authorization_method = Proc.new do |controller, action, resource|
-    authorize!(action, resource)
-    resource.respond_to?(:roles_permit?) ? resource.roles_permit?(current_user) : true
-  end
-
   # Layout Settings
-  # Configure the Layout per controller, or all at once
-  config.layout = {
-    posts: 'application',
-    admin: 'admin'
-  }
-
-  # Add additional permitted params
-  # config.permitted_params += [:additional_field]
+  # config.layout = { application: 'application', admin: 'admin' }
 
   # Display the effective roles 'choose roles' input when an admin creates a new post
   config.use_effective_roles = false
 
-  # Hides the Save and Edit Content links from admin. They can just use the textarea input.
-  config.use_fullscreen_editor = true
-
   # Display a file upload field when the admin creates a new post to collect a post.image
   config.use_active_storage = true
 
@@ -107,8 +73,7 @@ EffectivePosts.setup do |config|
     default_from: 'info@example.com',
     admin_email: 'admin@example.com',
 
-    deliver_method: nil,   # :deliver (rails < 4.2), :deliver_now (rails >= 4.2) or :deliver_later
-    delayed_job_deliver: false
+    deliver_method: :deliver_now
   }
 
 end

data/config/routes.rb

@@ -1,41 +1,35 @@
 EffectivePosts::Engine.routes.draw do
   namespace :admin do
-    resources :posts, except: [:show]
-
-    if EffectivePosts.submissions_enabled && EffectivePosts.submissions_require_approval
-      match 'posts/:id/approve', to: 'posts#approve', via: :get, as: :approve_post
+    resources :posts, except: [:show] do
+      post :approve, on: :member
     end
-
-    match 'posts/excerpts', to: 'posts#excerpts', via: :get
   end
 
-  scope :module => 'effective' do
-    categories = Array(EffectivePosts.categories).map { |cat| cat.to_s unless cat == 'posts'}.compact
-    onlies = ([:index, :show] unless EffectivePosts.submissions_enabled)
+  scope module: 'effective' do
+    # Post Routes
+    resources :posts
 
-    if EffectivePosts.use_blog_routes
-      categories.each do |category|
-        match "blog/category/#{category}", to: 'posts#index', via: :get, defaults: { category: category }
-      end
+    # Blog Routes
+    match 'blog/category/:category', to: 'posts#index', via: :get, constraints: lambda { |req|
+      EffectivePosts.use_blog_routes && EffectivePosts.categories.include?(req.params['category'].to_sym)
+    }
 
-      resources :posts, only: onlies, path: 'blog'
-    elsif EffectivePosts.use_category_routes
-      categories.each do |category|
-        match category, to: 'posts#index', via: :get, defaults: { category: category }
-        match "#{category}/:id", to: 'posts#show', via: :get, defaults: { category: category }
-      end
+    resources :posts, only: [:index, :show], path: 'blog', constraints: lambda { |req|
+      EffectivePosts.use_blog_routes
+    }
 
-      resources :posts, only: onlies
-    else
-      resources :posts, only: onlies
-    end
+    # Category routes
+    match ':category', to: 'posts#index', via: :get, constraints: lambda { |req|
+      EffectivePosts.use_category_routes && EffectivePosts.categories.include?(req.params['category'].to_sym)
+    }
+
+    match ":category/:id", to: 'posts#show', via: :get, constraints: lambda { |req|
+      EffectivePosts.use_category_routes && EffectivePosts.categories.include?(req.params['category'].to_sym)
+    }
   end
 
 end
 
-# Automatically mount the engine as an append
-Rails.application.routes.append do
-  unless Rails.application.routes.routes.find { |r| r.name == 'effective_posts' }
-    mount EffectivePosts::Engine => '/', :as => 'effective_posts'
-  end
+Rails.application.routes.draw do
+  mount EffectivePosts::Engine => '/', as: 'effective_posts'
 end

data/db/migrate/01_create_effective_posts.rb.erb

@@ -2,10 +2,9 @@ class CreateEffectivePosts < ActiveRecord::Migration[4.2]
   def self.up
     create_table <%= @posts_table_name %> do |t|
       t.integer :user_id
+      t.string :user_type
 
       t.string :title
-      t.text :excerpt
-
       t.string :description
 
       t.string :category

data/lib/effective_posts.rb

@@ -1,64 +1,28 @@
-require 'nokogiri'
-require 'effective_datatables'
-require 'effective_regions'
+require 'effective_resources'
 require 'effective_posts/engine'
 require 'effective_posts/version'
 
 module EffectivePosts
-  mattr_accessor :posts_table_name
 
-  mattr_accessor :authorization_method
-  mattr_accessor :permitted_params
-
-  mattr_accessor :layout
-  mattr_accessor :simple_form_options
-  mattr_accessor :admin_simple_form_options
-
-  mattr_accessor :categories
-  mattr_accessor :use_category_routes
-  mattr_accessor :use_blog_routes
-
-  mattr_accessor :use_effective_roles
-  mattr_accessor :use_fullscreen_editor
-  mattr_accessor :use_active_storage
-
-  mattr_accessor :per_page
-  mattr_accessor :post_meta_author
-
-  mattr_accessor :submissions_enabled
-  mattr_accessor :submissions_require_current_user
-  mattr_accessor :submissions_require_approval
-  mattr_accessor :submissions_note
-
-  # These are hashes of configs
-  mattr_accessor :mailer
-
-  def self.setup
-    yield self
-  end
-
-  def self.authorized?(controller, action, resource)
-    @_exceptions ||= [Effective::AccessDenied, (CanCan::AccessDenied if defined?(CanCan)), (Pundit::NotAuthorizedError if defined?(Pundit))].compact
-
-    return !!authorization_method unless authorization_method.respond_to?(:call)
-    controller = controller.controller if controller.respond_to?(:controller)
-
-    begin
-      !!(controller || self).instance_exec((controller || self), action, resource, &authorization_method)
-    rescue *@_exceptions
-      false
-    end
+  def self.config_keys
+    [
+      :posts_table_name, :layout, :categories,
+      :use_category_routes, :use_blog_routes,
+      :use_effective_roles, :use_active_storage,
+      :per_page, :post_meta_author,
+      :submissions_enabled, :submissions_require_current_user,
+      :submissions_require_approval, :submissions_note,
+      :mailer
+    ]
   end
 
-  def self.authorize!(controller, action, resource)
-    raise Effective::AccessDenied.new('Access Denied', action, resource) unless authorized?(controller, action, resource)
-  end
+  include EffectiveGem
 
   def self.permitted_params
-   [
+    @permitted_params ||= [
       :title, :excerpt, :description, :draft, :category, :slug, :published_at, :body, :tags, :extra,
       :image, :start_at, :end_at, :location, :website_name, :website_href, roles: []
-    ].compact
+    ]
   end
 
 end