effective_email_templates 1.0.11 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd45246572ae7b8d6eab683d911aba2fb4d74e2b9ac9f805fb6faea71ebef8b6
-  data.tar.gz: b37ed1adc75b8773d6c5caa57510e434b4537c2512bc63d1adf7b36d1ebe2939
+  metadata.gz: 633c93cac11add92db1adcfdd7d2441dbf928f12abc4182798e4c66d93995fe3
+  data.tar.gz: 85d947fcfd9da53aa93cf0b7e43e677633f250167a43afc67b1c6a71dc376a54
 SHA512:
-  metadata.gz: 93297ce10d8e17183bd52a0c89cf393c42182a7ac4875669ac375f775a9a166770d7d6ffec1f7c9c385e4f40cb8f74e2f240ad2d428bc8b09dd2b4d8ddaaf5c4
-  data.tar.gz: 16a24643ba98a5ad269071eb992e3c73ae7f4d02cbab1c331b083cce8d45ad231e8c8a22a554e547aa94fb748aa98d62f5199a8391f6723778e889b50e5d8b03
+  metadata.gz: 4e8ed05ed566941bb48fe9ec8be95bfc4d2019b7dbbee3fd0d282fd7c01061e5e51cfc13468bd466fc09c60b1f95ad8088db37af5095eb2fdb4929c6539bd993
+  data.tar.gz: '089e9291f52db8749cb282b2b087e162acb30c9b0c61da47d5e489a4ab18affd5f77e36aa5018f036efcde410f3ecb1594923c93fa3e57c5ccdb7211f70647f4'

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2020 Code and Effect Inc.
+Copyright 2021 Code and Effect Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -114,67 +114,21 @@ EmailTemplatesMailer.welcome(user).deliver
 
 ## Authorization
 
-All authorization checks are handled via the config.authorization_method found in the `app/config/initializers/effective_email_templates.rb` file.
+All authorization checks are handled via the effective_resources gem found in the `config/initializers/effective_resources.rb` file.
 
-It is intended for flow through to CanCan or Pundit, but neither of those gems are required.
-
-This method is called by all controller actions with the appropriate action and resource
-
-Action will be one of [:index, :show, :new, :create, :edit, :update, :destroy]
-
-Resource will the appropriate Effective::EmailTemplate object or class
-
-The authorization method is defined in the initializer file:
-
-```ruby
-# As a Proc (with CanCan)
-config.authorization_method = Proc.new { |controller, action, resource| authorize!(action, resource) }
-```
-
-```ruby
-# As a Custom Method
-config.authorization_method = :my_authorization_method
-```
-
-and then in your application_controller.rb:
-
-```ruby
-def my_authorization_method(action, resource)
-  current_user.is?(:admin) || EffectivePunditPolicy.new(current_user, resource).send('#{action}?')
-end
-```
-
-or disabled entirely:
-
-```ruby
-config.authorization_method = false
-```
-
-If the method or proc returns false (user is not authorized) an Effective::AccessDenied exception will be raised
-
-You can rescue from this exception by adding the following to your application_controller.rb:
-
-```ruby
-rescue_from Effective::AccessDenied do |exception|
-  respond_to do |format|
-    format.html { render 'static_pages/access_denied', :status => 403 }
-    format.any { render :text => 'Access Denied', :status => 403 }
-  end
-end
-```
 
 ### Permissions
 
 To allow a user to see the admin area, using CanCan:
 
 ```ruby
-can :manage, Effective::EmailTemplate
+can [:index, :edit, :update, :destroy], Effective::EmailTemplate
 can :admin, :effective_email_templates
 ```
 
 ## License
 
-MIT License.  Copyright [Code and Effect Inc.](http://www.codeandeffect.com/)
+MIT License. Copyright [Code and Effect Inc.](http://www.codeandeffect.com/)
 
 
 ## Contributing

data/app/controllers/admin/email_templates_controller.rb

@@ -1,87 +1,19 @@
 module Admin
   class EmailTemplatesController < ApplicationController
-    before_action :authenticate_user! if respond_to?(:authenticate_user!)
+    before_action(:authenticate_user!) if defined?(Devise)
+    before_action { EffectiveResources.authorize!(self, :admin, :effective_email_templates) }
 
-    layout (EffectiveEmailTemplates.layout.kind_of?(Hash) ? EffectiveEmailTemplates.layout[:admin_email_templates] : EffectiveEmailTemplates.layout)
+    include Effective::CrudController
 
-    def index
-      @datatable = EffectiveEmailTemplatesDatatable.new
-      @page_title = 'Email Templates'
-
-      authorize_effective_email_templates!
-    end
-
-    def new
-      @email_template = Effective::EmailTemplate.new
-      @page_title = 'New Email Template'
-
-      authorize_effective_email_templates!
-    end
-
-    def create
-      @email_template = Effective::EmailTemplate.new(email_template_params)
-      @page_title = 'New Email Template'
-
-      authorize_effective_email_templates!
-
-      if @email_template.save
-        flash[:success] = 'Successfully created email template'
-        redirect_to effective_email_templates.admin_email_templates_path
-      else
-        flash.now[:danger] = 'Unable to create email template'
-        render :new
-      end
-    end
-
-    def edit
-      @email_template =
-        Effective::EmailTemplate.where(id: params[:id]).or(
-          Effective::EmailTemplate.where(template_name: params[:id])
-        ).first!
-
-      @page_title = 'Edit Email Template'
-
-      authorize_effective_email_templates!
+    if (config = EffectiveEmailTemplates.layout)
+      layout(config.kind_of?(Hash) ? config[:admin] : config)
     end
 
-    def update
-      @email_template = Effective::EmailTemplate.find(params[:id])
-      @page_title = 'Edit Email Template'
-
-      authorize_effective_email_templates!
-
-      if @email_template.update(email_template_params)
-        flash[:success] = 'Successfully updated email template'
-        redirect_to effective_email_templates.admin_email_templates_path
-      else
-        flash.now[:danger] = 'Unable to update email template'
-        render :edit
-      end
-    end
-
-    def destroy
-      @email_template = Effective::EmailTemplate.find(params[:id])
-
-      authorize_effective_email_templates!
-
-      if @email_template.destroy
-        flash[:success] = 'Successfully deleted email template'
-      else
-        flash[:danger] = 'Unable to delete email template'
-      end
-
-      redirect_to effective_email_templates.admin_email_templates_path
-    end
-
-    private
-
-    def authorize_effective_email_templates!
-      EffectiveEmailTemplates.authorize!(self, :admin, :effective_email_templates)
-      EffectiveEmailTemplates.authorize!(self, action_name.to_sym, @email_template || Effective::EmailTemplate)
-    end
+    submit :save, 'Save'
+    submit :save, 'Save and Add New', redirect: :new
 
     def email_template_params
-      params.require(:effective_email_template).permit(EffectiveEmailTemplates.permitted_params)
+      params.require(:effective_email_template).permit!
     end
 
   end

data/app/datatables/effective_email_templates_datatable.rb

@@ -8,15 +8,24 @@ class EffectiveEmailTemplatesDatatable < Effective::Datatable
     col :id, visible: false
 
     col :template_name, label: 'Name'
-    col :from
-    col :cc
-    col :bcc
+
+    col :from do |email_template|
+      html_escape(email_template.from)
+    end
+
+    col :cc do |email_template|
+      html_escape(email_template.cc)
+    end
+
+    col :bcc do |email_template|
+      html_escape(email_template.bcc)
+    end
+
     col :subject
     col :body
-
     col :content_type, visible: false
 
-    actions_col partial: '/admin/email_templates/actions', partial_as: 'email_template'
+    actions_col
   end
 
   collection do

data/app/helpers/effective_email_templates_helper.rb

@@ -13,6 +13,7 @@ module EffectiveEmailTemplatesHelper
 
       if mail.present?
         email_review.body = mail.message.body
+        email_review.subject = mail.message.subject
       end
     end
 

data/app/mailers/concerns/effective_email_templates_mailer.rb

@@ -0,0 +1,35 @@
+# HasOneEmailReview
+# Allows any model to easily review an email template and make changes to the body
+
+module EffectiveEmailTemplatesMailer
+  extend ActiveSupport::Concern
+
+  def mail(headers = {}, &block)
+    email_template = Effective::EmailTemplate.where(template_name: action_name).first!
+    assigns = (@assigns || {})
+
+    # Parse assigns. Special keys for body and subject.
+    body = assigns.delete(:body) || headers[:body] || headers['body']
+    email_template.body = body if body.present?
+
+    subject = assigns.delete(:subject) || headers[:subject] || headers['subject']
+    email_template.subject = subject if subject.present?
+
+    # Add any _url helpers
+    assigns = route_url_assigns(email_template).merge(assigns)
+
+    # Render from the template, possibly with updated body
+    rendered = email_template.render(assigns)
+
+    super(rendered.merge(headers.except(:body, :subject, 'body', 'subject')))
+  end
+
+  private
+
+  def route_url_assigns(email_template)
+    email_template.template_variables.select { |name| name.ends_with?('_url') }.inject({}) do |h, name|
+      h[name] = public_send(name) if respond_to?(name); h
+    end
+  end
+
+end

data/app/mailers/effective/email_templates_mailer.rb

@@ -1,31 +1,5 @@
 module Effective
   class EmailTemplatesMailer < ::ActionMailer::Base
-
-    def mail(headers = {}, &block)
-      email_template = Effective::EmailTemplate.where(template_name: action_name).first!
-
-      # Parse Assigns. :body is a special key
-      assigns = (@assigns || {})
-
-      if (body = assigns.delete(:body))
-        email_template.body = body
-      end
-
-      assigns = route_url_assigns(email_template).merge(assigns)
-
-      # Render from the template, possibly with updated body
-      rendered = email_template.render(assigns)
-
-      super(rendered.merge(headers))
-    end
-
-    private
-
-    def route_url_assigns(email_template)
-      email_template.template_variables.select { |name| name.ends_with?('_url') }.inject({}) do |h, name|
-        h[name] = public_send(name) if respond_to?(name); h
-      end
-    end
-
+    include EffectiveEmailTemplatesMailer
   end
 end

data/app/models/effective/email_review.rb

@@ -4,25 +4,32 @@ module Effective
 
     attr_accessor :email_template
     attr_accessor :template_name
+
     attr_accessor :body
+    attr_accessor :subject
+    attr_accessor :from
+    attr_accessor :cc
+    attr_accessor :bcc
 
     def self.build(attributes = {})
-      new(attributes).tap do |email_review|
-        email_review.body ||= email_review.email_template&.body
-        email_review.template_name ||= email_review.email_template&.template_name
-      end
-    end
+      email_review = new(attributes)
+      template = email_review.email_template
 
-    validates :body, presence: true
-
-    validate(if: -> { body.present? }) do
-      begin
-        Liquid::Template.parse(body)
-      rescue Liquid::SyntaxError => e
-        errors.add(:body, e.message)
+      if template.present?
+        email_review.body ||= template.body
+        email_review.subject ||= template.subject
+        email_review.from ||= template.from
+        email_review.cc ||= template.cc
+        email_review.bcc ||= template.bcc
+        email_review.template_name ||= template.template_name
       end
+
+      email_review
     end
 
+    validates :body, presence: true, liquid: true
+    validates :subject, liquid: true
+
     def email_template
       @email_template ||= Effective::EmailTemplate.where(template_name: template_name).first
     end

data/app/models/effective/email_template.rb

@@ -2,42 +2,32 @@ module Effective
   class EmailTemplate < ActiveRecord::Base
     self.table_name = EffectiveEmailTemplates.email_templates_table_name.to_s
 
+    attr_accessor :current_user
+
     log_changes if respond_to?(:log_changes)
 
     CONTENT_TYPES = ['text/plain', 'text/html']
 
-    # Attributes
-    # subject           :string
-    # from              :string
-    # cc                :string
-    # bcc               :string
-    # body              :text
-    # content_type      :string
-    #
-    # template_name     :string
-    #
-    # timestamps
+    effective_resource do
+      template_name     :string
+      content_type      :string
 
-    before_validation do
-      self.content_type ||= CONTENT_TYPES.first
-    end
+      subject           :string
+      from              :string
+      cc                :string
+      bcc               :string
+      body              :text
 
-    before_validation(if: -> { body.present? }) do
-      begin
-        Liquid::Template.parse(body)
-      rescue Liquid::SyntaxError => e
-        errors.add(:body, e.message)
-      end
+      timestamps
     end
 
-    before_validation(if: -> { subject.present? }) do
-      begin
-        Liquid::Template.parse(subject)
-      rescue Liquid::SyntaxError => e
-        errors.add(:subject, e.message)
-      end
+    before_validation do
+      self.content_type ||= CONTENT_TYPES.first
     end
 
+    validates :body, liquid: true
+    validates :subject, liquid: true
+
     validates :subject, presence: true
     validates :from, presence: true
     validates :body, presence: true

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

@@ -4,7 +4,7 @@
   - if EffectiveEmailTemplates.select_content_type
     = f.select :content_type, Effective::EmailTemplate::CONTENT_TYPES
 
-  = f.email_field :from, hint: 'Whom the email will be sent from'
+  = f.text_field :from, hint: 'Whom the email will be sent from'
   = f.text_field :cc
   = f.text_field :bcc
 

data/config/effective_email_templates.rb

@@ -2,37 +2,9 @@ EffectiveEmailTemplates.setup do |config|
   # Configure Database Tables
   config.email_templates_table_name = :email_templates
 
-  # 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 { |controller, action, resource| authorize!(action, resource) } # CanCanCan
-
   # Layout Settings
-  # Configure the Layout per controller, or all at once
-
-  # config.layout = 'application'   # All EffectiveEmailTemplates controllers will use this layout
-  config.layout = {
-    email_templates: 'application',
-    admin_email_templates: 'admin'
-  }
+  # config.layout = { application: 'application', admin: 'admin' }
 
   # Not allowed to select text/html by default
   config.select_content_type = false
-
 end

data/lib/effective_email_templates/engine.rb

@@ -2,6 +2,9 @@ module EffectiveEmailTemplates
   class Engine < ::Rails::Engine
     engine_name 'effective_email_templates'
 
+    config.autoload_paths += Dir["#{config.root}/lib/validators/"]
+    config.eager_load_paths += Dir["#{config.root}/lib/validators/"]
+
     # Set up our default configuration options.
     initializer 'effective_email_templates.defaults', before: :load_config_initializers do |app|
       eval File.read("#{config.root}/config/effective_email_templates.rb")
@@ -16,4 +19,3 @@ module EffectiveEmailTemplates
 
   end
 end
-

data/lib/effective_email_templates/importer.rb

@@ -1,24 +1,30 @@
 module EffectiveEmailTemplates
   class Importer
-    def self.import(quiet: false)
-      new().execute(overwrite: false, quiet: quiet)
+    def self.import(quiet: false, paths: nil)
+      new().execute(overwrite: false, paths: paths, quiet: quiet)
     end
 
-    def self.overwrite(quiet: false)
-      new().execute(overwrite: true, quiet: quiet)
+    def self.overwrite(quiet: false, paths: nil)
+      new().execute(overwrite: true, paths: paths, quiet: quiet)
     end
 
-    def execute(overwrite:, quiet: false)
-      Dir[Rails.root.join('app', 'views', '**', '*.liquid')].each do |filepath|
-        name = File.basename(filepath, '.liquid')
-        email_template = Effective::EmailTemplate.find_or_initialize_by(template_name: name)
+    def execute(overwrite:, paths: nil, quiet: false)
+      return false unless ActiveRecord::Base.connection.table_exists?(EffectiveEmailTemplates.email_templates_table_name)
 
-        if email_template.persisted? && !overwrite
-          puts("SKIPPED #{filename(filepath)}") unless quiet
-          next
-        end
+      paths ||= ActionController::Base.view_paths.map(&:path)
+
+      paths.each do |path|
+        Dir[Rails.root.join(path, '**', '*_mailer/', '*.liquid')].each do |filepath|
+          name = File.basename(filepath, '.liquid')
+          email_template = Effective::EmailTemplate.find_or_initialize_by(template_name: name)
 
-        save(email_template, filepath, quiet: quiet)
+          if email_template.persisted? && !overwrite
+            puts("SKIPPED #{filename(filepath)}") unless quiet
+            next
+          end
+
+          save(email_template, filepath, quiet: quiet)
+        end
       end
     end
 

data/lib/effective_email_templates/version.rb

@@ -1,3 +1,3 @@
 module EffectiveEmailTemplates
-  VERSION = '1.0.11'.freeze
+  VERSION = '1.1.1'.freeze
 end

data/lib/effective_email_templates.rb

@@ -1,37 +1,18 @@
-require "liquid"
-require "effective_email_templates/engine"
-require "effective_email_templates/version"
+require 'liquid'
+require 'effective_resources'
+require 'effective_email_templates/engine'
+require 'effective_email_templates/version'
 
 module EffectiveEmailTemplates
 
-  mattr_accessor :email_templates_table_name
-  mattr_accessor :authorization_method
-  mattr_accessor :select_content_type
-  mattr_accessor :layout
-
-  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
+    [:email_templates_table_name, :select_content_type, :layout]
   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
-    [:from, :bcc, :cc, :subject, :body, :content_type]
+    @permitted_params ||= [:from, :bcc, :cc, :subject, :body, :content_type]
   end
 
 end

data/lib/validators/liquid_validator.rb

@@ -0,0 +1,15 @@
+# An ActiveRecord validator for any liquid field that you would use with effective_email_templates or otherwise
+#
+# validates :body, liquid: true
+
+class LiquidValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    if value.present?
+      begin
+        Liquid::Template.parse(value)
+      rescue Liquid::SyntaxError => e
+        record.errors.add(attribute, e.message)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_email_templates
 version: !ruby/object:Gem::Version
-  version: 1.0.11
+  version: 1.1.1
 platform: ruby
 authors:
 - Code and Effect
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-09-04 00:00:00.000000000 Z
+date: 2021-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -92,15 +92,12 @@ files:
 - app/controllers/admin/email_templates_controller.rb
 - app/datatables/effective_email_templates_datatable.rb
 - app/helpers/effective_email_templates_helper.rb
+- app/mailers/concerns/effective_email_templates_mailer.rb
 - app/mailers/effective/email_templates_mailer.rb
 - app/models/concerns/has_one_email_review.rb
-- app/models/effective/access_denied.rb
 - app/models/effective/email_review.rb
 - app/models/effective/email_template.rb
-- app/views/admin/email_templates/_actions.html.haml
 - app/views/admin/email_templates/_form.html.haml
-- app/views/admin/email_templates/edit.html.haml
-- app/views/admin/email_templates/index.html.haml
 - app/views/effective/email_reviews/_fields.html.haml
 - app/views/layouts/effective_email_templates_mailer_layout.html.haml
 - config/effective_email_templates.rb
@@ -115,6 +112,7 @@ files:
 - lib/effective_email_templates/version.rb
 - lib/generators/effective_email_templates/install_generator.rb
 - lib/tasks/effective_email_templates_tasks.rake
+- lib/validators/liquid_validator.rb
 homepage: https://github.com/code-and-effect/effective_email_templates
 licenses:
 - MIT

data/app/models/effective/access_denied.rb

@@ -1,17 +0,0 @@
-unless defined?(Effective::AccessDenied)
-  module Effective
-    class AccessDenied < StandardError
-      attr_reader :action, :subject
-
-      def initialize(message = nil, action = nil, subject = nil)
-        @message = message
-        @action = action
-        @subject = subject
-      end
-
-      def to_s
-        @message || I18n.t(:'unauthorized.default', :default => 'Access Denied')
-      end
-    end
-  end
-end

data/app/views/admin/email_templates/_actions.html.haml

@@ -1,5 +0,0 @@
-= dropdown(variation: :dropleft) do
-  = dropdown_link_to 'Edit', effective_email_templates.edit_admin_email_template_path(email_template)
-
-  = dropdown_link_to "Delete #{email_template}", effective_email_templates.admin_email_template_path(email_template),
-    data: { method: :delete, confirm: "Really delete #{email_template}?" }

data/app/views/admin/email_templates/edit.html.haml

@@ -1,3 +0,0 @@
-%h1.effective-admin-heading= @page_title
-
-= render partial: 'form', locals: { email_template: @email_template }

data/app/views/admin/email_templates/index.html.haml

@@ -1,3 +0,0 @@
-%h1.effective-admin-heading= @page_title
-
-= render_datatable @datatable