newsletter 0.0.1

data/app/controllers/newsletter/pieces_controller.rb

@@ -0,0 +1,72 @@
+module Newsletter
+  class PiecesController < ::Newsletter::ApplicationController
+    layout 'admin'
+    before_filter :find_piece, :except => [:new,:create,:index]
+    before_filter :find_newsletter
+    before_filter :find_element
+    before_filter :find_area
+
+    def index
+      @pieces = @newsletter.pieces.active
+    end
+
+    def show
+    end
+
+    def new
+      @piece = Piece.new({
+        :area_id => @area.id,
+        :element_id => @element.id,
+        :newsletter_id => @newsletter.id
+      })
+    end
+
+    def edit
+    end
+
+    def create
+      @piece = Piece.new(params[:piece])
+      if @piece.save
+        flash[:notice] = 'Piece was successfully created.'
+        redirect_to(edit_newsletter_path(@newsletter))
+      else
+        render :action => "new"
+      end
+    end
+
+    def update
+      if @piece.update_attributes(params[:piece])
+        flash[:notice] = 'Piece was successfully updated.'
+        redirect_to(edit_newsletter_path(@newsletter))
+      else
+        render :action => "edit"
+      end
+    end
+
+    def destroy
+      @piece.destroy
+      redirect_to(newsletter_path(@newsletter,:editor=>1))
+    end
+  
+    protected 
+  
+    def find_piece 
+      @piece = Piece.find_by_id(params[:id])
+    end
+  
+    def find_newsletter
+      return @newsletter = @piece.newsletter unless @piece.nil?
+      @newsletter = ::Newsletter::Newsletter.find(params[:newsletter_id] || params[:piece][:newsletter_id])
+    end
+  
+    def find_element
+      return @element = @piece.element unless @piece.nil?
+      @element = Element.find(params[:element_id] || params[:piece][:element_id])
+    end
+  
+    def find_area
+      return @area = @piece.area unless @piece.nil?
+      @area = Area.find(params[:area_id] || params[:piece][:area_id])
+    end
+  end
+end

data/app/helpers/newsletter/application_helper.rb

@@ -0,0 +1,4 @@
+module Newsletter
+  module ApplicationHelper
+  end
+end

data/app/helpers/newsletter/areas_helper.rb

@@ -0,0 +1,4 @@
+module Newsletter
+  module AreasHelper
+  end
+end

data/app/helpers/newsletter/assets_helper.rb

@@ -0,0 +1,4 @@
+module Newsletter
+  module AssetsHelper
+  end
+end

data/app/helpers/newsletter/designs_helper.rb

@@ -0,0 +1,11 @@
+module Newsletter
+  module DesignsHelper
+    #left 'newsletter' in function name for helper scoping
+    def add_newsletter_area_link(name)
+      link_to_function name, {:class => "button"} do |page|
+        page.insert_html :bottom, :areas, :partial => 'newsletter_area', 
+          :object => Area.new
+      end  
+    end
+  end
+end

data/app/helpers/newsletter/elements_helper.rb

@@ -0,0 +1,4 @@
+module Newsletter
+  module ElementsHelper
+  end
+end

data/app/helpers/newsletter/field_values_helper.rb

@@ -0,0 +1,4 @@
+module Newsletter
+  module FieldValuesHelper
+  end
+end

data/app/helpers/newsletter/fields_helper.rb

@@ -0,0 +1,4 @@
+module Newsletter
+  module FieldsHelper
+  end
+end

data/app/helpers/newsletter/newsletters_helper.rb

@@ -0,0 +1,43 @@
+module Newsletter
+  module NewslettersHelper
+    def render_area
+      render @newsletter.design.areas.by_newsletter(@newsletter)
+    end
+
+    def is_email?
+      params[:mode].eql?('email')
+    end
+
+    def filter(text)
+      new_text = filter_eols_to_brs(text,text)
+      new_text = filter_email_addresses_to_mailtos(new_text,text)
+      new_text = filter_urls_to_links(new_text,text)
+      new_text.html_safe
+    end
+
+    protected 
+    def filter_eols_to_brs(text,orig_text)
+      return '' if text.blank?
+      return '' if orig_text =~ /<br\s*\/>/i
+      text.gsub(/(\r\n|\r|\n)/,'<br/>')
+    end
+
+    def filter_email_addresses_to_mailtos(text,orig_text)
+      return '' if text.blank?
+      return text if orig_text =~ /<a\s+href/i
+   text.gsub(/([a-z0-9!#\$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#\$%&'*+\/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?:[A-Z]{2}|com|org|net|gov|mil|biz|info|mobi|name|aero|jobs|museum)\b)/mi,%Q|<a href="mailto:\\1" target="_blank">\\1</a>|)
+    end
+
+    def filter_urls_to_links(text,orig_text)
+      return '' if text.blank?
+      return text if orig_text =~ /<a\s+href/i
+text.gsub(/(\b(?:(?:https?|ftp|file):\/\/|www\.|ftp\.)(?:\([-A-Z0-9+&@#\/%=~_|$?!:,.]*\)|[-A-Z0-9+&@#\/%=~_|$?!:,.])*(?:\([-A-Z0-9+&@#\/%=~_|$?!:,.]*\)|[A-Z0-9+&@#\/%=~_|$]))/mi) do |match|
+        if match.to_s.include?('://') 
+           %Q|<a href="#{match}" target="_blank">#{match}</a>|
+        else
+           %Q|<a href="http://#{match}" target="_blank">#{match}</a>|
+        end
+      end
+    end
+  end
+end

data/app/helpers/newsletter/pieces_helper.rb

@@ -0,0 +1,4 @@
+module Newsletter
+  module PiecesHelper
+  end
+end

data/app/models/newsletter/area.rb

@@ -0,0 +1,50 @@
+=begin rdoc
+Author::    Chris Hauboldt (mailto:biz@lnstar.com)
+Copyright:: 2009 Lone Star Internet Inc.
+
+Areas define what elements can exist in a part of a newleter design. Also used to group and order actual Pieces in a filled in Newsletter.
+
+=end
+
+module Newsletter
+  class Area < ActiveRecord::Base
+    self.table_name =  "#{::Newsletter.table_prefix}areas"
+    belongs_to :design, :class_name => 'Newsletter::Design'
+    has_and_belongs_to_many :elements, :order => 'name', :join_table => 
+      "#{::Newsletter.table_prefix}areas_#{::Newsletter.table_prefix}elements",
+      :class_name => 'Newsletter::Element'
+    has_many  :pieces, :order => 'sequence', :class_name => "Newsletter::Piece"
+    belongs_to :updated_by, :class_name => 'User'
+  
+    attr_accessor :should_destroy
+
+    attr_protected :id
+  
+    validates_presence_of :name
+    #FIXME: make this work with deletable or convert to auditable, and extend it to access destroyed records
+    #validates_uniqueness_of :name, :scope => :design_id
+  
+    scope :active, :conditions => {:deleted_at => nil}
+    scope :by_name, lambda {|name| {:conditions => {:name => name}}}
+  
+    include Deleteable
+  
+    # returns field data so that Newsletter::Design.export(instance) can export itself to a YAML file
+    def export_fields
+      { :name => name,
+        :description => description 
+      }
+    end
+
+    # builds areas from data pulled out of an exported YAML file by Newsletter::Design.import(class)
+    def self.import(design,data)
+      area = Area.create(:name => data[:name], :description => data[:description])
+      area.design = design
+      area.save
+    end
+  
+    def should_destroy?
+      should_destroy.to_i == 1
+    end
+  end
+end

data/app/models/newsletter/asset.rb

@@ -0,0 +1,31 @@
+=begin rdoc
+Author::    Chris Hauboldt (mailto:biz@lnstar.com)
+Copyright:: 2009 Lone Star Internet Inc.
+
+Wrapper for attachment_fu files plugin, and is used by NewsletterPieces to save assets.
+
+=end
+
+module Newsletter
+  class Asset < ActiveRecord::Base
+    self.table_name =  "#{::Newsletter.table_prefix}assets"
+    belongs_to :field, :conditions => {:type => 'Newsletter::Field::InlineAsset'}, 
+      :class_name => 'Newsletter::Field::InlineAsset'
+    belongs_to :piece, :class_name => 'Newsletter::Piece'
+    
+    mount_uploader :image, AssetUploader
+      
+    attr_protected :id
+
+    scope :by_piece, lambda{|piece| where("piece_id IS NOT NULL AND piece_id=?", piece.try(:id)) }
+
+    def public_filename
+      return File.join(::Newsletter::Asset.build_public_dirname(id),File.basename(self[:image])) if self[:image].present?
+      nil
+    end
+
+    def self.build_public_dirname(id)
+      "#{::Newsletter.asset_path}/#{("%08d" %id)[-8,4]}/#{("%08d" %id)[-4,4]}"
+    end
+  end
+end

data/app/models/newsletter/design.rb

@@ -0,0 +1,160 @@
+=begin rdoc
+Author::    Chris Hauboldt (mailto:biz@lnstar.com)
+Copyright:: 2009 Lone Star Internet Inc.
+
+Newsletter::Designs define a main layout, with areas to group Elements/Pieces.
+
+
+=end
+
+module Newsletter
+  class Design < ActiveRecord::Base
+    self.table_name =  "#{::Newsletter.table_prefix}designs"
+    has_many :areas, :order => :name, :class_name => 'Newsletter::Area'
+    has_many :elements, :order => :name, :class_name => 'Newsletter::Element'
+    belongs_to :updated_by, :class_name => 'User'
+    after_create :write_design
+  
+    accepts_nested_attributes_for :areas
+
+    attr_accessible :name, :description, :html_text, :areas_attributes
+
+    scope :active, :conditions => {:deleted_at => nil}
+  
+    validates_presence_of :name
+
+    # attr_protected :id
+    #FIXME: make this work with deletable or convert to auditable, and extend it to access destroyed records
+    #validates_uniqueness_of :name
+
+    # Export a design's data to a YAML file. 
+    def export(filename=nil)
+      filename = "#{::Newsletter.designs_path}/exports/#{name_as_path}-export.yaml" unless filename
+      FileUtils.mkdir_p(File.dirname(filename))
+      File.open(filename,'w') do |file|
+        YAML.dump( {
+          :name => name,
+          :html_text => html_text,
+          :description => description,
+          :areas => areas.collect{|area| area.export_fields}, 
+          :elements => elements.collect{|element| element.export_fields}
+        },file)
+      end
+    end
+  
+    # Import a design from a YAML file, 
+    # Parameters:
+    #   filename - path/name of file on filesystem
+    #   design_name => rename design if already taken
+    def self.import(filename,design_name=nil)
+      raise "You must give a filename to import!" unless filename
+      data = YAML.load_file(filename)
+      transaction do 
+        data[:name] = design_name if design_name
+        design = Design.create!(:name => data[:name], 
+          :html_text => data[:html_text],
+          :description => data[:description])
+        data[:areas].each do |area_data|
+          Area.import(design,area_data)
+        end
+        data[:elements].each do |element_data|
+          Element.import(design,element_data)
+        end
+      end
+    end
+
+    # returns path to newsletter design for use in views and is the same for actual file
+    def view_path(this_name=nil)
+      "#{base_design_path(this_name)}/layout.html.erb"
+    end
+  
+    # 
+    def base_design_path(this_name=nil)
+      "#{::Newsletter.designs_path}/designs/#{name_as_path(this_name)}"
+    end
+  
+
+
+    def html_text
+      return @html_text if @html_text
+      @html_text = read_design
+    end
+  
+    def html_text=(text)
+       @html_text = text
+    end
+  
+    # def area_attributes=(area_attributes)
+    #   area_attributes.each do |attributes|
+    #     if attributes[:id].blank?
+    #       Rails.logger.debug "Building Area : #{attributes.inspect}"
+    #       areas.build(attributes)
+    #     else
+    #       Rails.logger.debug "Setting Area data: #{attributes.inspect}"
+    #       area = areas.detect{|area| area.id == attributes[:id].to_i}
+    #       area.attributes = attributes
+    #     end
+    #   end
+    # end
+
+  
+    def name=(new_name)
+      return if self[:name].eql?(new_name)
+      @old_name = self[:name] unless @old_name
+      self[:name] = new_name
+    end
+  
+    def save(*args)
+      transaction do 
+        move_design_on_name_change
+        write_design
+        super
+      end
+    end  
+  
+    # returns a version of name that is nice for filesytem use
+    def name_as_path(this_name=nil)
+      this_name = name unless this_name
+      this_name.gsub(/[^a-zA-Z0-9-]/,'_')
+    end
+  
+    include Deleteable
+    protected
+    def read_design
+      File.readlines(view_path).join
+    rescue => e
+      #flash[:warning] << "Couldn't open design for element '#{name}' which should exist at: #{file_path} #{e.message}"
+      ""
+    end
+
+    def write_all_designs
+      areas.collect{|area| area.elements}.flatten.uniq.each{|element| element.send(:write_design)}
+      write_design
+    end
+  
+    def move_design_on_name_change
+      return unless @old_name and File.exists?(view_path(@old_name))
+      FileUtils.mv(base_design_path(@old_name),base_design_path)
+    end
+
+    def write_design
+      FileUtils.mkdir_p(File.dirname(view_path)) unless File.exists?(File.dirname(view_path))
+      File.open(view_path,File::WRONLY|File::TRUNC|File::CREAT) do |file|
+        file.write html_text
+      end
+    end
+  
+  
+    # def save_areas
+    #   areas.each do |area|
+    #     if area.should_destroy?
+    #       Rails.logger.debug "Destroying newsletter area: #{area.inspect}"
+    #       area.destroy
+    #     else
+    #       Rails.logger.debug "Saving newsletter area: #{area.inspect}"
+    #       area.save
+    #     end
+    #   end
+    # end
+  end
+end

data/app/models/newsletter/element.rb

@@ -0,0 +1,169 @@
+=begin rdoc
+Author::    Chris Hauboldt (mailto:biz@lnstar.com)
+Copyright:: 2009 Lone Star Internet Inc.
+
+Newsletter::Elements define the way a Newsletter::Piece looks with an erb design and the data it can hold with Newsletter::Fields. They can exist in multiple Newsletter::Areas, but currently belong to only 1 design.
+
+=end
+
+module Newsletter
+  class Element < ActiveRecord::Base
+    self.table_name =  "#{::Newsletter.table_prefix}elements"
+    has_and_belongs_to_many :areas, :class_name => 'Newsletter::Area',
+      :join_table => "#{::Newsletter.table_prefix}areas_#{::Newsletter.table_prefix}elements"
+    has_many :fields, :order => 'sequence', :class_name => 'Newsletter::Field'
+    has_many :pieces, :class_name => 'Newsletter::Piece'
+    belongs_to :design, :class_name => 'Newsletter::Design'
+    belongs_to :updated_by, :class_name => 'User'
+  
+    scope :by_design, lambda{|design| {:conditions =>{:design_id => design.id}}}
+  
+    validates_presence_of :name
+
+    accepts_nested_attributes_for :fields
+
+    attr_protected :id
+    #FIXME: make this work with deletable or convert to auditable, and extend it to access destroyed records
+    #validates_uniqueness_of :name, :scope => :design_id
+  
+    # defines the design path for the element as used in a render :partial => (without '_')
+    def view_path(this_name=nil)
+        this_name = self[:name] unless this_name
+          "#{::Newsletter.designs_path}/designs/#{design.name.gsub(/[^a-zA-Z0-9-]/,'_')}/elements/#{name_as_path(this_name)}.html.erb"
+    end
+  
+    # returns a version of name that is nice for filesytem use
+    def name_as_path(this_name=nil)
+      this_name = name unless this_name
+      this_name.gsub(/[^a-zA-Z0-9-]/,'_').downcase
+    end
+  
+    # defines where the file is in the filesystem
+    def file_path(this_name=nil)
+      File.dirname(view_path(this_name)) + '/_' + File.basename(view_path(this_name))
+    end
+  
+    # used to record old name of an element such that the design can be moved to the new name
+    def name=(new_name)
+      return if self[:name].eql?(new_name)
+      @old_name = self[:name] unless @old_name
+      self[:name] = new_name
+    end
+  
+    # retrieves the html erb design from the file system
+    def html_text
+      return @html_text if @html_text
+      @html_text = read_design
+    end
+
+    # sets and saves the html erb design to update the file after a successful save
+    def html_text=(text)
+      @html_text = text
+    end
+  
+    def update_attributes(params={})
+      transaction do 
+        super
+      end
+    end
+  # {"0"=>{"name"=>"asdfas", "label"=>"asdfasd", "description"=>"fasdfasdf", 
+  #   "type"=>"Newsletter::Field::TextArea", "_destroy"=>"false", "id"=>"22"},
+  #    "1"=>{"name"=>"asdfasdf", "label"=>"asdfasdf", "description"=>"asdfasdf",
+  #     "type"=>"Newsletter::Field::InlineAsset", "_destroy"=>"false", "id"=>"23"}}
+  #   # # used to modify Newsletter::Fields in-form
+    def fields_attributes=(fields_attributes)
+      @fields_attributes = fields_attributes
+    end
+
+    def save_fields
+      @fields_attributes.each_pair do |index,attributes|
+        should_destroy = ['true','1'].include?attributes.delete(:_destroy)
+        if attributes[:id].blank?
+          next if should_destroy
+          attributes.delete(:id)
+          klass = attributes.delete(:type)
+          fields << klass.constantize.new(attributes)
+        else
+          id = attributes.delete(:id).to_i
+          if should_destroy
+            fields.where(id: id).limit(1).each(&:destroy)
+          else
+            type = attributes.delete(:type)
+            field = fields.detect{|field| field.id == id}
+            field.update_attributes(attributes)
+            field = Field.morph(field,type) unless field.class.name.eql?(type)
+          end
+        end
+      end
+    end
+  
+    # returns field data so that Newsletter::Design.export(instance) can export itself to a YAML file  
+    def export_fields
+      { :name => name,
+        :description => description,
+        :html_text => html_text,
+        :areas => areas.collect{|area| area.export_fields},
+        :fields => fields.collect{|field| field.export_fields}
+      }
+    end
+  
+    # builds areas from data pulled out of an exported YAML file by Newsletter::Design.import(class)  
+    def self.import(design,data)
+      element = Element.new(:name => data[:name], 
+        :html_text => data[:html_text],
+        :description => data[:description])
+      element.design = design
+      element.save
+      data[:areas].each do |area_data|
+        element.areas <<
+          Area.find_all_by_design_id_and_name(design.id,area_data[:name])
+      end
+      data[:fields].each do |field_data|
+          Field.import(element,field_data)
+      end
+    end
+  
+    def save(*args)
+      transaction do 
+        move_design_on_name_change
+        write_design
+        super
+        save_fields
+      end
+    end
+  
+    include Deleteable
+    protected
+    def read_design
+      File.readlines(file_path).join
+    rescue => e
+      #send back an empty string if no file exists yet for the design... don't raise an error
+      ""
+    end
+  
+    def write_design
+      FileUtils.mkdir_p(File.dirname(file_path)) unless File.exists?(File.dirname(file_path))
+      File.open(file_path,File::WRONLY|File::TRUNC|File::CREAT) do |file|
+        file.write html_text
+      end
+    end
+  
+    def move_design_on_name_change
+      return unless @old_name and File.exists?(file_path(@old_name))
+      FileUtils.mv(file_path(@old_name),file_path)
+    end
+  
+    # def save_fields
+    #   Rails.logger.warn "Fields: #{fields.inspect}"
+    #   fields.each do |field|
+    #     if field.should_destroy?
+    #       Rails.logger.warn "Destroy Field: #{field.inspect}"
+    #       field.delete
+    #     else
+    #       Rails.logger.warn "Save Field: #{field.inspect}"
+    #       field.save!      
+    #     end
+    #   end
+    # end
+  end
+end

data/app/models/newsletter/field/inline_asset.rb

@@ -0,0 +1,67 @@
+=begin rdoc
+Author::    Chris Hauboldt (mailto:biz@lnstar.com)
+Copyright:: 2009 Lone Star Internet Inc.
+
+InlineAsset is a Newsletter::Field that allows either a url or an uploaded asset(image/document) to be used in a Newsletter.
+
+=end
+
+module Newsletter
+  class Field::InlineAsset < Field
+    has_many :assets, :foreign_key => :field_id, 
+      :class_name => 'Newsletter::Asset'
+
+    attr_protected :id
+
+    # overridden from main class to choose between a Newsletter::Asset or a given URL
+    def value_for_piece(piece)
+      Value.new(:url => url_for_piece(piece), :text => get_value(piece,:text), :asset => asset(piece))
+    end
+
+    # overridden from main class to choose between a Newsletter::Asset or a given URL
+    def set_value_for_piece(piece,params)
+      if params[:url]
+        unless url_for_piece(piece).eql?(params[:url])
+          asset(piece).destroy if asset(piece)
+          set_value(piece,:url,params[:url])
+        end
+      end
+      set_value(piece,:text,params[:text]) if params[:text]
+      if params[:uploaded_data]
+        asset = asset(piece)
+        if asset && params[:asset_id] == asset.id.to_s
+          asset.image = params[:uploaded_data]
+        else
+          asset = assets.build
+          piece.assets << asset
+          asset.image = params[:uploaded_data]
+        end
+        asset.save
+      end
+    end
+
+    # uniformly get URL so we can know whether it has been modified and delete 
+    # any asset uploaded
+    def url_for_piece(piece)
+      return "#{::Newsletter.site_url}/#{asset(piece).public_filename}" unless asset(piece).try(:public_filename).nil?
+      get_value(piece,:url)
+    end
+
+    def asset(piece)
+      assets.by_piece(piece).first
+    end
+
+    # create nicer accessors for use in design since this is more than one value, unlike other
+    # fields
+    class Value
+      attr_accessor :url, :text, :asset, :asset_id
+      def initialize(params)
+        @url = params[:url]
+        @text = params[:text]
+        @asset = params[:asset]
+        @asset_id = @asset.nil? ? nil : @asset.id
+      end
+    end
+
+  end
+end

data/app/models/newsletter/field/text.rb

@@ -0,0 +1,15 @@
+=begin rdoc
+Author::    Chris Hauboldt (mailto:biz@lnstar.com)
+Copyright:: 2009 Lone Star Internet Inc.
+
+Dumb text field, created so that we can choose for them to have text areas and text fields.
+
+=end
+
+module Newsletter
+    class Field::Text < Field
+      def keys
+        ['text']
+      end
+    end
+end

data/app/models/newsletter/field/text_area.rb

@@ -0,0 +1,15 @@
+=begin rdoc
+Author::    Chris Hauboldt (mailto:biz@lnstar.com)
+Copyright:: 2009 Lone Star Internet Inc.
+
+Dumb text area, created so that we can choose for them to have text areas and text fields.
+
+=end
+
+module Newsletter
+    class Field::TextArea < Field
+      def keys
+        ['text_area']
+      end
+    end
+end