dm_newsletter 4.2.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9a3b03f31653026403d126ca9b3abf692aac4819
+  data.tar.gz: 90255c7249b1d731919e056aaab344ae76f62442
+SHA512:
+  metadata.gz: c260c52c8739df5137ebb2f7cb7484326d699a101a307a207270162658db99b4ec1042a6146858b715e17fb69b99146f1ac3ff7f69c74e3a408e64c48905aa00
+  data.tar.gz: bf3be1368f65dbc081072d03345b36975f6c0e659dbbbc4a9061af33e57c9549025e1e038b4acde530def16438d9ea2b70d92c7d1e1de8037625064a883ca62f

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 digitalMoksha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,33 @@
+# dm_newsletter
+
+**dm_newsletter** provides the newsletter management system for the MokshaCMS collection of gems.
+
+_The MokshaCMS collection of gems provides an integrated system of services for content, event, forum, learning, and newsletter management.  It supports sites with multiple languages and mutliple distinct sites per installation.  Administration is built in.  Additional services/engines can be written to provide additional functionality._
+
+- core foundation ([dm_core](https://github.com/digitalmoksha/dm_core))
+- content management ([dm_cms](https://github.com/digitalmoksha/dm_cms))
+- event management ([dm_event](https://github.com/digitalmoksha/dm_event))
+- forum management ([dm_forum](https://github.com/digitalmoksha/dm_forum))
+- learning management ([dm_lms](https://github.com/digitalmoksha/dm_lms))
+- newsletter management ([dm_newsletter](https://github.com/digitalmoksha/dm_newsletter))
+
+## Installation
+
+Add the following to your Gem file:
+
+```
+gem 'dm_preferences',       '~> 1.0'
+gem 'dm_core',              git: 'https://github.com/digitalmoksha/dm_core.git', branch: '4-2-stable'
+gem 'dm_cms',               git: 'https://github.com/digitalmoksha/dm_cms.git', branch: '4-2-stable'
+gem 'dm_newsletter',        git: 'https://github.com/digitalmoksha/dm_newsletter.git', branch: '4-2-stable'
+gem 'themes_for_rails',     git: 'git://github.com/digitalmoksha/themes_for_rails.git'
+gem 'aced_rails',           git: 'git://github.com/digitalmoksha/aced_rails.git'
+```
+
+After running `bundle install`, run 
+
+```
+rake dm_core:install:migrations
+rake dm_cms:install:migrations
+rake dm_newsletter:install:migrations
+```

data/Rakefile

@@ -0,0 +1,30 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'DmNewsletter'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare')
+
+task :default => :spec

data/app/assets/stylesheets/dm_newsletter/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */

data/app/controllers/dm_newsletter/admin/admin_controller.rb

@@ -0,0 +1,16 @@
+class DmNewsletter::Admin::AdminController < DmCore::Admin::AdminController
+  include DmNewsletter::NewslettersHelper
+  helper  'dm_newsletter/newsletters'
+
+  before_filter   :authorize_access
+  
+protected
+
+  #------------------------------------------------------------------------------
+  def authorize_access
+    unless can?(:manage_newsletters, :all)
+      flash[:alert] = "Unauthorized Access!"
+      redirect_to current_account.index_path 
+    end
+  end
+end

data/app/controllers/dm_newsletter/admin/newsletters_controller.rb

@@ -0,0 +1,81 @@
+class DmNewsletter::Admin::NewslettersController < DmNewsletter::Admin::AdminController
+  include DmNewsletter::PermittedParams
+
+  #before_filter   :mailchimp_guard,   only:   [:new, :edit, :create, :update]
+  before_filter   :newsletter_lookup, except: [:index, :new, :create, :synchronize_lists]
+
+  #------------------------------------------------------------------------------
+  def index
+    @newsletters = using_mailchimp? ? MailchimpNewsletter.all : StandardNewsletter.all
+    @newsletters.each { |newsletter| newsletter.update_list_stats }
+  end
+
+  #------------------------------------------------------------------------------
+  def new
+    @newsletter = using_mailchimp? ? MailchimpNewsletter.new : StandardNewsletter.new
+  end
+
+  #------------------------------------------------------------------------------
+  def edit
+  end
+
+  #------------------------------------------------------------------------------
+  def create
+    @newsletter = using_mailchimp? ? MailchimpNewsletter.new(mailchimp_newsletter_params) : StandardNewsletter.new(standard_newsletter_params)
+    if @newsletter.save
+      redirect_to admin_newsletters_url, notice: 'Newsletter was successfully created.'
+    else
+      render action: :new
+    end
+  end
+
+  #------------------------------------------------------------------------------
+  def update
+    if @newsletter.update_attributes(newsletter_params)
+      redirect_to admin_newsletters_url, notice: 'Newsletter was successfully updated.'
+    else
+      render action: :edit
+    end
+  end
+
+  #------------------------------------------------------------------------------
+  def destroy
+    @newsletter.destroy
+
+    redirect_to admin_newsletters_url
+  end
+
+  #------------------------------------------------------------------------------
+  def show
+    # @subscriptions  = @newsletter.subscriptions
+    @folder_list = @newsletter.folder_list
+  end
+  
+  #------------------------------------------------------------------------------
+  def synchronize_lists
+    if using_mailchimp?
+      MailchimpNewsletter.synchronize
+      redirect_to(admin_newsletters_url, notice: 'Synchronized with Mailchimp') and return
+    else
+      redirect_to(admin_newsletters_url) and return
+    end
+  end
+  
+private
+
+  #------------------------------------------------------------------------------
+  def newsletter_lookup
+    @newsletter = Newsletter.find(params[:id])
+  end
+  
+  # Protects certain actions from being run if we're using mailchimp integration
+  #------------------------------------------------------------------------------
+  def mailchimp_guard
+    if using_mailchimp?
+      redirect_to(admin_newsletters_url, error: 'Action not supported when using Mailchimp') and return false
+    else
+      true
+    end
+  end
+
+end

data/app/controllers/dm_newsletter/application_controller.rb

@@ -0,0 +1,3 @@
+class DmNewsletter::ApplicationController < ::ApplicationController
+  include ApplicationHelper
+end

data/app/controllers/dm_newsletter/newsletters_controller.rb

@@ -0,0 +1,50 @@
+class DmNewsletter::NewslettersController < DmNewsletter::ApplicationController
+
+  # Handle a newsletter signup.  By submitting using a Rails form
+  # and then adding via the MailChimp API, it should cut out automated signups
+  # from spam bots, because the authenticity token will be validated first.
+  #------------------------------------------------------------------------------
+  def subscribe_to_newsletter
+    subscription_params = params['subscription'] || {}
+    user_or_email       = current_user ? current_user : subscription_params['email']
+    @newsletter         = Newsletter.find_newsletter(params['token'])
+
+    if @newsletter
+      result = @newsletter.subscribe(user_or_email, subscription_params)
+      respond_to do |format|
+        if result[:success]
+          msg = I18n.t('nms.subscription_successful')
+          format.html { redirect_to (request.env['HTTP_REFERER'].blank? ? main_app.index_url : :back), notice: msg }
+          format.json { render json: { success: true, msg: msg } }
+        else
+          msg = I18n.t(@newsletter.map_error_to_msg(result[:code]))
+          format.html { redirect_to :back, alert: msg }
+          format.json { render json: { success: false, msg: msg } }
+        end
+      end
+    end
+  end
+
+  # Unsubscribe current user from newsletter.  We only support direct unsubscribing
+  # for a logged in user
+  #------------------------------------------------------------------------------
+  def unsubscribe_from_newsletter
+    email       = current_user ? current_user.email : ''
+    @newsletter = Newsletter.find_newsletter(params['token'])
+    
+    if (@newsletter)
+      result = @newsletter.unsubscribe(email)
+      respond_to do |format|
+        if result
+          msg = I18n.t('nms.unsubscribe_successuful')
+          format.html { redirect_to (request.env['HTTP_REFERER'].blank? ? main_app.index_url : :back), notice: msg }
+          format.js { render json: { success: true, msg: msg } }
+        else
+          msg = I18n.t('nms.Email_NotExists')
+          format.html { redirect_to :back, alert: msg }
+          format.js { render json: { success: false, msg: msg } }
+        end
+      end
+    end
+  end
+end

data/app/helpers/dm_newsletter/newsletters_helper.rb

@@ -0,0 +1,8 @@
+module DmNewsletter::NewslettersHelper
+  
+  #------------------------------------------------------------------------------
+  def using_mailchimp?
+    Account.current.preferred_nms_use_mailchimp?
+  end
+  
+end

data/app/models/dm_newsletter/concerns/ability.rb

@@ -0,0 +1,37 @@
+# Wrap lms specific CanCan rules.  Should be included in the main app's
+# Ability class.
+# NOTE:  When checking abilities, don't check for Class level abilities,
+# unless you don't care about the instance level.  For example, don't
+# use both styles
+#   can? :moderate, Forum
+#   can? :moderate, @forum
+# In this case, if you need to check the class level, then use specific
+#    current_user.has_role? :moderator, Forum
+#------------------------------------------------------------------------------
+
+module DmNewsletter
+  module Concerns
+    module Ability
+      def dm_newsletter_abilities(user)
+        #--- Admin
+        if user && user.has_role?(:newsletter_manager)
+          can :manage_newsletters, :all
+          can :access_admin, :all
+        end
+      end
+    end
+  end
+end
+
+#------------------------------------------------------------------------------
+# The abilities get basically compiled.  So if you use
+#
+#    can :moderate, Forum, :id => Forum.with_role(:moderator, user).map(&:id)
+#
+# this will execute the Forum.with_role query once during Ability.new.  However
+#
+#    can :moderate, Forum do |forum|
+#      user.has_role? :moderator, forum
+#    end
+#
+# this will execute the has_role? block on each call to can?

data/app/models/dm_newsletter/permitted_params.rb

@@ -0,0 +1,20 @@
+module DmNewsletter
+  module PermittedParams
+
+    #------------------------------------------------------------------------------
+    def newsletter_params
+      params.require(:newsletter).permit! if can? :manage_newsletters, :all
+    end
+
+    #------------------------------------------------------------------------------
+    def standard_newsletter_params
+      params.require(:standard_newsletter).permit! if can? :manage_newsletters, :all
+    end
+
+    #------------------------------------------------------------------------------
+    def mailchimp_newsletter_params
+      params.require(:mailchimp_newsletter).permit! if can? :manage_newsletters, :all
+    end
+
+  end
+end

data/app/models/mailchimp_newsletter.rb

@@ -0,0 +1,217 @@
+# Integrates MailChimp into our system.  Using the 'gibbon' gem to interface
+# with MailChimp API V2
+#------------------------------------------------------------------------------
+class MailchimpNewsletter < Newsletter
+
+  MAILCHIMP_ERRORS = {  200 => 'List_DoesNotExist',
+                        214 => 'List_AlreadySubscribed',
+                        232 => 'Email_NotExists'
+                     }.freeze
+
+  validate        :validate_list_id
+  after_create    :update_list_stats
+  
+  #------------------------------------------------------------------------------
+  def self.signup_information(token, options = {})
+    information = { newsletter: self.find_newsletter(token, options) }
+    if information[:newsletter]
+      information[:grouping] = information[:newsletter].groupings[0]
+      if options[:current_user]
+        subscriber = MailchimpNewsletterSubscriber.subscriber_info(information[:newsletter], options[:current_user].email)
+        information[:subscriber] = (subscriber && subscriber.subscribed? ? subscriber : nil)
+      end
+    end
+    return information
+  end
+
+  # Make sure list id is specified, and it's valid with MailChimp
+  #------------------------------------------------------------------------------
+  def validate_list_id
+    unless self.mc_id.blank?
+      api         = MailchimpNewsletter.api
+      list_info   = api.lists.list(filters: {list_id: self.mc_id, exact: true})
+      if !list_info['errors'].empty?
+        errors[:mc_id] << (list_info['errors'][0]['error'])
+      end
+    else  
+      errors[:mc_id] << ("list id must be provided")
+    end
+  end 
+
+  # Retrieve list of groupings from Mailchimp
+  #------------------------------------------------------------------------------
+  def groupings
+    begin
+      api       = MailchimpNewsletter.api
+      groupings = api.lists.interest_groupings(id: self.mc_id)
+    rescue Gibbon::MailChimpError => exception
+      #--- groupings are not enabled for this list
+      return []
+    end
+  end
+  
+  # subscribe user or email to the newsletter
+  # Setting the Accept-Language will cause MC to send the confirmation in the users
+  # language if the list auto-translate is turned on
+  #------------------------------------------------------------------------------
+  def subscribe(user_or_email, options = {FNAME: '', LNAME: ''})
+    return { success: false, code: 232 } if user_or_email.blank?
+    api         = MailchimpNewsletter.api
+    headers     = {'Accept-Language' => I18n.locale.to_s}
+
+    #--- update data if user logged in. Don't for an unprotected subscribe. but honor value if passed in
+    options.reverse_merge!  update_existing: user_or_email.is_a?(User)
+
+    #--- remove any invalid merge vars or other options
+    merge_vars = options.except('new-email', :email, :optin_ip, :optin_time, :mc_location, :mc_notes,
+                                :update_existing, :mc_language, :headers)
+
+    #--- groupings needs to be an Array, but the form usually sends it as a Hash
+    merge_vars['GROUPINGS'] = [merge_vars['GROUPINGS']] if merge_vars['GROUPINGS'] && !merge_vars['GROUPINGS'].is_a?(Array)
+
+    if user_or_email.is_a?(User)
+      email                 = {email: user_or_email.email}
+      merge_vars[:FNAME]    = user_or_email.first_name
+      merge_vars[:LNAME]    = user_or_email.last_name
+      merge_vars[:COUNTRY]  = user_or_email.country.english_name if user_or_email.country
+    else
+      email               = {email: user_or_email}
+    end
+    merge_vars[:SPAMAPI]      = 1
+    merge_vars[:MC_LANGUAGE]  = I18n.locale  # set the language to the current locale they are using
+    api.lists.subscribe(id: self.mc_id, email: email, merge_vars: merge_vars, 
+                        double_optin: true, update_existing: options[:update_existing], replace_interests: true,
+                        headers: headers)
+    return { success: true, code: 0 }
+  rescue Gibbon::MailChimpError => exception
+    Rails.logger.info "=== Error Subscribing #{email} : #{exception.to_s}"
+    return { success: false, code: exception.code }
+  end
+
+  # unsubscribe email from the newsletter
+  #------------------------------------------------------------------------------
+  def unsubscribe(email)
+    return false if email.blank?
+
+    api = MailchimpNewsletter.api
+    api.lists.unsubscribe(id: self.mc_id, email: {email: email}, delete_member: false, send_goodbye: true, send_notify: true)
+    return true
+  rescue Gibbon::MailChimpError => exception
+    Rails.logger.info "=== Error Unsubscribing #{email} : #{exception.to_s}"
+    return false
+  end
+
+  #------------------------------------------------------------------------------
+  def update_list_stats
+    api         = MailchimpNewsletter.api
+    list_info   = api.lists.list(filters: {list_id: self.mc_id, exact: true})
+
+    #--- update the newsletter
+    if list_info['errors'].empty?
+      self.update_attributes(
+        name:               list_info['data'][0]['name'],
+        subscribed_count:   list_info['data'][0]['stats']['member_count'],
+        unsubscribed_count: list_info['data'][0]['stats']['unsubscribe_count'],
+        cleaned_count:      list_info['data'][0]['stats']['cleaned_count'],
+        created_at:         list_info['data'][0]['date_created'])
+    else
+      #--- looks like the list was deleted at MailChimp, mark as deleted
+      self.update_attribute(:deleted, true)
+    end
+  end
+
+  # get a list of sent campaigns. Can specify :folder_id to get only those
+  # in a specfic folder
+  #------------------------------------------------------------------------------
+  def sent_campaign_list(options = {start: 0, limit: 100})
+    api                 = MailchimpNewsletter.api
+    list_params         = {sort_field: 'send_time', sort_dir: 'DESC', 
+                          filters: {list_id: self.mc_id}}
+    list_params[:start] = options[:start] ? options[:start] : 0
+    list_params[:limit] = options[:limit] ? options[:limit] : 100
+    list_params[:filters][:folder_id] = options[:folder_id] if options[:folder_id]
+      
+    campaigns   = api.campaigns.list(list_params)
+  end
+
+  # Get simplified list of sent campaigns. Useful for showing archived
+  # campaigns on the front end
+  #------------------------------------------------------------------------------
+  def sent_campaign_list_simple(options = {start: 0, limit: 100})
+    list      = sent_campaign_list(options)
+    campaigns = list['data'].map {|item| {subject:      item['subject'], 
+                                          sent_on:      item['send_time'].to_datetime,
+                                          archive_url:  item['archive_url']} }
+  end
+
+  #------------------------------------------------------------------------------
+  def folder_list(type = 'campaign')
+    api         = MailchimpNewsletter.api
+    folder_list = api.folders.list(type: type)
+    folder_list.sort! {|x, y| x['name'] <=> y['name']}
+  end
+  
+  #------------------------------------------------------------------------------
+  def map_error_to_msg(code)
+    return MAILCHIMP_ERRORS[code] ? "nms.#{MAILCHIMP_ERRORS[code]}" : 'nms.mc_unknown_error'
+  end
+  
+  # Grab an API object to work with
+  #------------------------------------------------------------------------------
+  def self.api
+    if !Account.current.preferred_nms_api_key.blank?
+      Gibbon::API.new(Account.current.preferred_nms_api_key)
+    else
+      nil
+    end
+  end
+  
+  # is the email already subscribed to this list
+  #------------------------------------------------------------------------------
+  def email_subscribed?(email)
+    subscriber = MailchimpNewsletterSubscriber.subscriber_info(self, email)
+    return subscriber.present? && subscriber.subscribed?
+  end
+  
+  # Query the lists in MailChimp, and create / update what we have in the database.
+  # If a list no longer exists, we will delete it and any attached information
+  # Note: [todo] This function is currently not used.  Still determining if it's needed.
+  #       Keep here until final decision.
+  #------------------------------------------------------------------------------
+  # def self.synchronize
+  #   newsletters = MailchimpNewsletter.all
+  #   api         = MailchimpNewsletter.api
+  #   lists       = api.lists.list
+  #   
+  #   unless lists['data'].nil?
+  #     lists['data'].each do |list|
+  #       index = newsletters.find_index { |item| item.mc_id == list['id'] }
+  #       if index
+  #         #--- update the newsletter
+  #         newsletters[index].update_attributes(
+  #           name:               list['name'],
+  #           subscribed_count:   list['stats']['member_count'],
+  #           unsubscribed_count: list['stats']['unsubscribe_count'],
+  #           cleaned_count:      list['stats']['cleaned_count'])
+  #         newsletters.delete_at(index)
+  #       else
+  #         #--- create a new newsletter
+  #         MailchimpNewsletter.create!(
+  #           name:               list['name'], 
+  #           mc_id:              list['id'],
+  #           created_at:         list['date_created'])
+  #       end
+  #     end
+  # 
+  #     #--- if any left, then mark them as deleted
+  #     newsletters.each { |old_list| old_list.update_attribute(:deleted, true) }
+  #     
+  #     #--- update the lists_synced_on time
+  #     account = Account.current
+  #     account.preferred_nms_lists_synced_on = Time.now
+  #     account.save
+  #   end
+  # rescue Gibbon::MailChimpError
+  # end
+  
+end