imagine_cms 3.0.0.beta6 → 3.0.0.beta7

data/app/controllers/management/cms_controller.rb

@@ -0,0 +1,1669 @@
+class Management::CmsController < Management::ApplicationController # :nodoc:
+  before_filter :check_permissions
+  before_filter :block_basic_users, :except => [
+    :index, :edit_page_content,
+    :include_codepress, :disable_caching, :garbage_collect,
+    :select_page, :list_pages_select, :request_review,
+    :toolbar_preview, :toolbar_edit,
+    
+    :create_file_link, :upload_file, :receive_file,
+    
+    :upload_image, :receive_image, :crop_image, :save_crop, :upload_status,
+    :upload_thumb, :crop_thumb, :save_crop_thumb,
+    :upload_feature_image, :crop_feature_image, :save_crop_feature_image,
+    
+    :receive_gallery, :complete_gallery, :gallery_setup, :add_to_gallery,
+    :gallery_management, :select_gallery, :set_gallery_order, :save_gallery_settings,
+    :sort_images, :sort_images_save,
+    :image_details, :update_caption,
+    :delete_photo, :delete_gallery,
+    
+    :pages, :list_pages, :edit_page, :page_attribute, :set_page_version
+  ]
+  
+  before_filter :convert_invalid_chars_in_params
+  
+  upload_status_for :receive_image
+  upload_status_for :add_to_gallery
+  
+  cache_sweeper :cms_content_sweeper
+  
+  def check_permissions
+    if !user_has_permission?(:manage_cms)
+      render '/errors/permission_denied'
+      return false
+    end
+  end
+  
+  def block_basic_users
+    return true unless UseCmsAccessLevels
+    unless user_has_permission?(:manage_cms_full_access) && @user.cms_allowed_sections.to_s.strip.blank?
+      render '/errors/permission_denied'
+      return false
+    end
+  end
+  
+  def validate_user_access
+    unless @user.cms_allowed_sections.to_s.strip.blank?
+      allowed_sections = @user.cms_allowed_sections.split(',').map { |s| s.strip }.reject { |s| s.blank? }
+      if @pg
+        path = '/' + @pg.path
+      else
+        parent = CmsPage.find_by_id(params[:parent_id] || params[:pg][:parent_id]) rescue nil
+        return false if !parent
+        path = '/' + parent.path
+      end
+      
+      allowed = false
+      allowed_sections.each { |s| allowed ||= (path =~ /^#{s}/) }
+      
+      if !allowed
+        respond_to do |wants|
+          wants.js    { render :text => "Sorry, you don't have permission to edit this page."         }
+          wants.html  { redirect_to "/#{@pg.path}#{@pg.path == '' ? '' : '/'}version/#{@pg.version}"  }
+        end
+        return false
+      end
+    end
+    
+    return true
+  end
+  
+  
+  def index
+  end
+  
+  def templates
+    @temps = CmsTemplate.find(:all, :order => 'name')
+  end
+  
+  def edit_template
+    @temp = CmsTemplate.find_by_id(params[:id]) || CmsTemplate.new
+    
+    if request.post?
+      @temp.assign_attributes(params[:temp])
+      
+      begin
+        @pg = CmsPage.new
+        @page_objects = HashObject.new
+        render_to_string :inline => @temp.content
+      rescue Exception => e
+        message = e.message
+        flash.now[:error] = "<pre>#{ERB::Util.html_escape(message)}</pre>".html_safe
+        logger.debug e
+        return
+      end
+      
+      # this must come after the render_to_string so that we capture template
+      # options embedded in snippets
+      @temp.options = @template_options
+      
+      if !@temp.save
+        flash.now[:error] = @temp.errors.full_messages.join('<br/>')
+      else
+        flash[:notice] = 'Template saved.'
+        redirect_to :action => 'edit_template', :id => @temp.id and return
+      end
+    end
+  end
+  
+  def snippets
+    @snippets = CmsSnippet.find(:all, :order => 'name')
+  end
+  
+  def edit_snippet
+    @snip = CmsSnippet.find_by_id(params[:id]) || CmsSnippet.new
+    
+    if request.post?
+      @snip.assign_attributes(params[:snip])
+      
+      begin
+        @pg = CmsPage.new
+        @page_objects = HashObject.new
+        render_to_string :inline => @snip.content
+      rescue Exception => e
+        message = e.message
+        flash.now[:error] = "<pre>#{ERB::Util.html_escape(message)}</pre>".html_safe
+        logger.debug e
+        return
+      end
+      
+      if !@snip.save
+        @error = @snip.errors.full_messages.join('<br/>')
+      else
+        flash[:notice] = 'Snippet saved.'
+        redirect_to :action => 'edit_snippet', :id => @snip.id and return
+      end
+    end
+  end
+  
+  def edit_master
+    @file_type = case params[:id]
+      when 'template' then 'html'
+      when 'web_stylesheet', 'print_stylesheet' then 'css'
+      else nil
+    end
+    
+    filename = case params[:id]
+      when 'template'         then File.join('app', 'views', 'layouts', 'application.rhtml')
+      when 'web_stylesheet'   then File.join('public', 'stylesheets', 'default.css')
+      when 'print_stylesheet' then File.join('public', 'stylesheets', 'print.css')
+      when 'ie_stylesheet'    then File.join('public', 'stylesheets', 'ie.css')
+      when 'ie6_stylesheet'   then File.join('public', 'stylesheets', 'ie6.css')
+    end
+    filename = File.join(Rails.root, filename)
+    
+    case request.method
+    when :get
+      @file_content = File.open(filename, 'r').read
+    when :post
+      begin
+        @pg = CmsPage.new
+        @page_objects = HashObject.new
+        render_to_string :inline => params[:file_content]
+      rescue Exception => e
+        message = e.message
+        flash.now[:error] = "<pre>#{ERB::Util.html_escape(message)}</pre>"
+        logger.debug e
+        return
+      end
+      
+      begin
+        if params[:file_content].empty?
+          flash[:error] = 'An error occurred, please contact support.'
+        else
+          File.open(filename, 'w') { |f| f.write(params[:file_content]) }
+          flash[:notice] = 'File saved.'
+        end
+        
+        CmsPage.find(:all).each do |page|
+          expire_page :controller => 'cms/content', :action => 'show', :content_path => page.path.split('/')
+        end
+        
+        redirect_to :action => 'edit_master', :id => params[:id]
+      rescue Exception => e
+        message = e.message
+        flash.now[:error] = "<pre>#{ERB::Util.html_escape(message)}</pre>"
+        log_error(e)
+      end
+    end
+  end
+  
+  def pages
+    @page_levels = [ '' ].concat((params[:path] || session[:cms_pages_path] || '').split('/').reject { |l| l.empty? })
+    @page_levels << ''
+    @path = ''
+    @page = nil
+  end
+  
+  def list_pages
+    @page_level = params[:level].to_i
+    @parent = CmsPage.find_by_id(params[:parent_id])
+    
+    if @page_level == 0
+      render :partial => 'list_page', :locals => { :list_page => CmsPage.find(1) } and return
+    else
+      if @parent
+        @pages = @parent.children
+        session[:cms_pages_path] = @parent.path
+      else
+        @pages = nil
+      end
+    end
+    
+    render :partial => 'list_pages'
+  end
+  
+  def edit_page
+    @pg = CmsPage.find_by_id(params[:id])
+    validate_user_access or return
+    @pg ||= CmsPage.new
+    
+    @parent = @pg.parent || CmsPage.find_by_id(params[:parent_id])
+    if @parent
+      @pg.parent ||= @parent
+      @pg.template ||= @parent.template
+    end
+    
+    @attrs = CmsPageObject.find(:all, :conditions => [ "obj_type = 'attribute'" ], :order => 'name').map { |attr| attr.name }.uniq
+    
+    if params[:mode] == 'ajax_new' || params[:mode] == 'ajax_edit'
+      @pg.published_version = -1 if params[:mode] == 'ajax_new'
+      load_page_objects
+      load_template_options
+      render :partial => 'edit_page' and return
+    end
+    
+    if request.post?
+      params[:pg] ||= {}
+      
+      if params[:pg][:article_date_year]
+        params[:pg][:article_date] = Time.utc(params[:pg].delete(:article_date_year),
+                                                 params[:pg].delete(:article_date_month),
+                                                 params[:pg].delete(:article_date_day))
+      end
+      if params[:pg][:article_end_date_year]
+        params[:pg][:article_end_date] = Time.utc(params[:pg].delete(:article_end_date_year),
+                                                     params[:pg].delete(:article_end_date_month),
+                                                     params[:pg].delete(:article_end_date_day))
+      end
+      if params[:pg][:published_date_year]
+        params[:pg][:published_date] = Time.utc(params[:pg].delete(:published_date_year),
+                                                   params[:pg].delete(:published_date_month),
+                                                   params[:pg].delete(:published_date_day))
+      end
+      if params[:pg][:expires]
+        date = Time.utc(params[:pg].delete(:expiration_date_year),
+                           params[:pg].delete(:expiration_date_month),
+                           params[:pg].delete(:expiration_date_day))
+        params[:pg][:expiration_date] = date if params[:pg][:expires] == 'true'
+      end
+      
+      @pg.assign_attributes(params[:pg])
+      unless params[:use_article_date_range].to_i > 0
+        @pg.article_end_date = nil
+      end
+      @pg.updated_by ||= session[:user_id]
+      @pg.updated_by_username ||= session[:user_username]
+      
+      save_function = @pg.new_record? ? 'save' : 'save_without_revision'
+      
+      if @pg.send(save_function)
+        # now try to save tags
+        begin
+          tags_to_delete = @pg.tags
+          params[:tags].split(',').map { |t| t.strip }.reject { |t| t.empty? }.compact.each do |t|
+            @pg.tags.create(:name => t) unless @pg.tags.find_by_name(t)
+            tags_to_delete.reject! { |tag| tag.name == t }
+          end
+          tags_to_delete.each { |t| t.destroy }
+        rescue Exception => e
+          logger.debug e
+        end
+        
+        # now try to save page objects (just attributes in this case)
+        begin
+          objects_to_delete = @pg.objects.find(:all, :conditions => [ "obj_type = 'attribute' or obj_type = 'option'" ])
+          
+          (params[:page_objects] || {}).each do |key,val|
+            next if key.empty? || val.empty?
+            
+            key =~ /^obj-(\w+?)-(.+?)$/
+            obj = @pg.objects.find(:first, :conditions => [ "name = ? and obj_type = ?", $2, $1 ])
+            obj ||= @pg.objects.build(:name => $2, :obj_type => $1)
+            obj.content = val
+            obj.save
+            objects_to_delete.reject! { |obj| obj.name == $2 }
+          end
+          
+          objects_to_delete.each { |t| t.destroy }
+        rescue Exception => e
+          logger.debug e
+        end
+        
+        render :update do |page|
+          case params[:return_to]
+          when 'preview'
+            page.redirect_to "/#{@pg.path}"
+          else
+            flash[:notice] = 'Page saved.'
+            session[:cms_pages_path] = @pg.path
+            page.redirect_to :action => 'pages'
+          end
+        end
+        
+      else
+        # save failed, display errors
+        render :update do |page|
+          page.replace_html 'save_errors', @pg.errors.full_messages.join('<br/>')
+          page << "try { $('btn_next').disabled = false; } catch (e) {}"
+          page << "try { $('btn_finish').disabled = false; } catch (e) {}"
+          page << "try { $('btn_save').disabled = false; $('btn_save').value = 'Save'; } catch (e) {}"
+        end and return
+      end
+    end
+  end
+  
+  def delete_page
+    @pg = CmsPage.find_by_id(params[:id])
+    
+    if !@pg
+      flash[:error] = "Sorry, couldn't find the requested page."
+    elsif @pg.children.size > 0
+      flash[:error] = "This page contains other pages. Please delete those first if you are sure you want to delete this page."
+    elsif @pg.id == 1
+      flash[:error] = "You cannot delete the home page."
+    else
+      flash[:notice] = "Page deleted."
+      session[:cms_pages_path] = @pg.parent.path rescue nil
+      @pg.destroy
+    end
+    
+    redirect_to :action => 'pages'
+  end
+  
+  def select_page
+    @page_levels = [ '' ].concat((params[:path] || session[:cms_pages_path] || '').split('/').reject { |l| l.empty? })
+    @page_levels << ''
+    @path = ''
+    @page = nil
+    
+    render :layout => false
+  end
+  
+  def list_pages_select
+    @page_level = params[:level].to_i
+    @parent = CmsPage.find_by_id(params[:parent_id])
+    
+    if @page_level == 0
+      render :partial => 'list_page_select', :locals => { :list_page_select => CmsPage.find(1) } and return
+    else
+      if @parent
+        @pages = @parent.children
+        session[:cms_pages_path] = @parent.path
+      else
+        @pages = nil
+      end
+    end
+    
+    render :partial => 'list_pages_select'
+  end
+  
+  def show_template_options
+    @pg = CmsPage.find_by_id(params[:id]) || CmsPage.new
+    @pg.cms_template_id = params[:template_id]
+    
+    load_page_objects
+    load_template_options
+    
+    render :partial => 'template_options'
+  end
+  
+  def page_attribute
+    render :nothing => true and return unless params[:name]
+    
+    @page_objects = HashObject.new({ params[:name] => params[:value] })
+    render :partial => 'page_attribute', :locals => { :name => params[:name] }
+  end
+  
+  def edit_page_content
+    @pg = CmsPage.find(params[:id])
+    validate_user_access or return
+    
+    @page_objects = HashObject.new(params[:page_objects] || {})
+    
+    if request.get?
+      @pg.revert_to(params[:version]) if params[:version]
+      @pg.objects.find(:all, :conditions => [ 'cms_page_version = ?', @pg.version ]).each do |obj|
+        key = "obj-#{obj.obj_type.to_s}-#{obj.name}"
+        @page_objects[key] = obj.content.html_safe
+      end
+      
+      @dynamic_javascripts ||= []
+      @dynamic_javascripts << url_for(:action => 'page_tags_for_lookup')
+      
+      @stylesheets ||= []
+      @stylesheets << 'imagine_ccs'
+      
+      @template_content = substitute_placeholders(@pg.template.content, @pg)
+      render :layout => 'application'
+    
+    elsif request.post?
+      CmsPage.transaction do
+        # need to revise this later if we implement deletion of page objects
+        old_objs = @pg.objects.find(:all, :conditions => [ 'cms_page_version = ?', @pg.version ])
+        
+        @pg.updated_by = session[:user_id]
+        @pg.updated_by_username = session[:user_username]
+        
+        # if basic user, make sure published version is not set to 'latest'
+        if (UseCmsAccessLevels && !user_has_permission?(:manage_cms_full_access)) && @pg.published_version == 0
+          @pg.published_version = @pg.version
+        end
+        
+        @pg.save
+        
+        # do a little bit of classification... for now, just identify page lists
+        page_lists = []
+        @page_objects.each do |key,val|
+          key =~ /^obj-(\w+?)-(\w+?)-sources-tag-count$/
+          if $1 == 'page_list'
+            page_lists << "obj-#{$1}-#{$2}"
+          end
+        end
+        
+        # run through page lists and do a little housekeeping
+        page_lists.each do |key|
+          # optimize source lists: tags
+          if @page_objects["#{key}-sources-tag-count"].to_i > 0
+            tags = []
+            for i in 0...@page_objects["#{key}-sources-tag-count"].to_i
+              tags << @page_objects["#{key}-sources-tag#{i}"]
+            end
+            tags.reject! { |tag| tag.empty? }
+            @page_objects["#{key}-sources-tag-count"] = tags.size
+            tags.each_with_index do |tag, i|
+              @page_objects["#{key}-sources-tag#{i}"] = tag
+            end
+          end
+          # optimize source lists: folders
+          if @page_objects["#{key}-sources-folder-count"].to_i > 0
+            folders = []
+            for i in 0...@page_objects["#{key}-sources-folder-count"].to_i
+              folders << @page_objects["#{key}-sources-folder#{i}"]
+            end
+            folders.reject! { |folder| folder.empty? }
+            @page_objects["#{key}-sources-folder-count"] = folders.size
+            folders.each_with_index do |folder, i|
+              @page_objects["#{key}-sources-folder#{i}"] = folder
+            end
+          end
+          
+          # consolidate date picker fields
+          if @page_objects["#{key}-date-range-custom-start_year"]
+            @page_objects["#{key}-date-range-custom-start"] = 
+              Time.utc(@page_objects.delete("#{key}-date-range-custom-start_year"),
+                          @page_objects.delete("#{key}-date-range-custom-start_month"),
+                          @page_objects.delete("#{key}-date-range-custom-start_day"))
+          end
+          if @page_objects["#{key}-date-range-custom-end_year"]
+            @page_objects["#{key}-date-range-custom-end"] = 
+              Time.utc(@page_objects.delete("#{key}-date-range-custom-end_year"),
+                          @page_objects.delete("#{key}-date-range-custom-end_month"),
+                          @page_objects.delete("#{key}-date-range-custom-end_day"))
+          end
+        end
+        
+        @page_objects.each do |key,val|
+          key =~ /^obj-(\w+?)-(.+?)$/
+          obj = @pg.objects.build(:name => $2, :obj_type => $1)
+          
+          # do a little bit of "censorship" to fix up Word pastes
+          if val.is_a?(String)
+            # all meta and link tags
+            val.gsub!(/(<\/?)(meta|link)(.*?)>/m, '')
+            
+            # the dreaded MsoNormal
+            val.gsub!(' class="MsoNormal"', '')
+            
+            # remove all font-family/font-size css styles, as well as font tags
+            val.gsub!(/font-(?:family|size):.*?(;|")/, '\3')
+            val.gsub!(/<font.*?>(.*?)<\/font>/, '\1')
+            
+            # strange conditional IE stuff
+            val.gsub!(/<!--\[if(.*?)<!(--)?\[endif\]-->/m, '')
+            
+            # not even sure what these are supposed to be
+            val.gsub!(/<xml>(.*?)<\/xml>/m, '')
+            
+            # pirate styles not welcome
+            val.gsub!(/<style>(.*?)<\/style>/m, '')
+            
+            # images pointing to the local drive??
+            val.gsub!(/<img src="file:(.*?)>/, '')
+            
+            # miscellany
+            val.gsub!('<!--StartFragment-->', '')
+            val.gsub!('<!--EndFragment-->', '')
+            val.gsub!(/<span style="(?:;*)">(.*?)<\/span>/m, '\1')
+            val.gsub!(' style="(?:;*)"', '')
+            val.gsub!('<b></b>', '')
+            
+            # we could try to catch all strange ms tags...
+            #val.gsub!(/(<\/?)(?:o|u1):p>/, '\1p>')
+            #val.gsub!(/(<\/?)(?:st1):(.*?)>/, '')
+            
+            # but it's easier just remove all tags with colons in them
+            val.gsub!(/(<\/?)[\w\d]+:[\w\d]+(.*?)>/, '')
+          end
+          
+          obj.content = val
+          obj.save
+        end
+        
+        old_objs.each do |obj|
+          unless @pg.objects.find(:all, :conditions => [ 'name = ? and cms_page_version = ?', obj.name, @pg.version])
+            obj = @pg.objects.build(:name => obj.name, :obj_type => obj.type, :content => obj.content)
+          end
+        end
+        
+        # update index for searching
+        @pg.update_index
+        @pg.save_without_revision
+      end
+      
+      redirect_to "/#{@pg.path}#{@pg.path == '' ? '' : '/'}version/#{@pg.version}"
+    end
+  end
+  
+  def insert_page_object_config
+    @pg = CmsPage.find(params[:id])
+    
+    load_page_objects
+    @pg.revert_to(params[:version]) if params[:version]
+    @pg.objects.find(:all, :conditions => [ 'cms_page_version = ?', @pg.version]).each do |obj|
+      key = "obj-#{obj.obj_type.to_s}-#{obj.name}"
+      @page_objects[key] = obj.content
+    end
+    
+    name = params[:name]
+    render :nothing => true and return unless name
+    
+    parent_key = params[:parent_key]
+    type = params[:type]
+    render :nothing => true and return unless type == 'page_list'
+    
+    key = "obj-#{type}-#{name.gsub(/[^\w]/, '_')}"
+    
+    render :update do |page|
+      page.insert_html :bottom, "page_object_config_#{parent_key}", :partial => 'page_list',
+                                                                    :locals => { :name => name, :key => key }
+    end
+  end
+  
+  def page_tags_for_lookup
+    @tags = CmsPageTag.find(:all, :order => 'name').map { |tag| tag.name }.uniq
+    headers['content-type'] = 'text/javascript'
+    render :layout => false
+  end
+  
+  def page_attributes_for_lookup
+    @attrs = CmsPageObject.find(:all, :conditions => [ "obj_type = 'attribute'" ], :order => 'name').map { |attr| attr.name }.uniq
+    headers['content-type'] = 'text/javascript'
+    render :layout => false
+  end
+  
+  def page_list_add_tag
+    render :partial => 'page_list_source_tag', :locals => { :i => params[:i], :key => params[:key] }
+  end
+  
+  def page_list_add_folder
+    render :partial => 'page_list_source_folder', :locals => { :i => params[:i], :key => params[:key] }
+  end
+  
+  def set_page_version
+    if (UseCmsAccessLevels && user_has_permission?(:manage_cms_publishing) || user_has_permission?(:manage_cms_full_access)) || user_has_permission?(:manage_cms)
+      if params[:id] && params[:pg]
+        @pg = CmsPage.find(params[:id])
+        validate_user_access or return
+        @pg.published_version = params[:pg][:published_version]
+        @pg.update_index
+        @pg.save_without_revision
+      end
+    end
+    
+    render :nothing => true
+  end
+  
+  def request_review
+    @pg = CmsPage.find(params[:id])
+    @version = params[:version].to_i
+    
+    # send email to request administrative review
+    # find all users with email address set
+    User.find(:all).reject { |u| !u.active? || !u.can_manage_cms_publishing? || !u.cms_allowed_sections.blank? }.each do |u|
+      next unless valid_email_address?(u.email_address)
+      begin
+        Mailer.deliver_cms_request_review(url_for(:controller => '/cms/content', :action => 'show', :content_path => []) + @pg.path, @pg.title, @version, u, @user, params[:change_description].to_s)
+      rescue Exception => e
+        log_error(e)
+      end
+    end
+    
+    render :nothing => true
+  end
+  
+  #
+  # helpers
+  #
+  
+  def insert_object(name, type = :text, options = {}, html_options = {})
+    extend ActionView::Helpers::FormHelper
+    extend ActionView::Helpers::JavaScriptHelper
+    extend ActionView::Helpers::PrototypeHelper
+    extend ActionView::Helpers::TagHelper
+    extend ActionView::Helpers::TextHelper
+    
+    key = "obj-#{type.to_s}-#{name.gsub(/[^\w]/, '_')}"
+    @page_objects[key] ||= ''
+    
+    case type.to_sym
+    when :string
+      @page_objects[key] = options[:content] if @page_objects[key].empty?
+      text_field(:page_objects, key, options)
+    when :text
+      @page_objects[key] = options[:content] if @page_objects[key].empty?
+      focusOnLoad = !defined?(@cms_text_editor_placed)
+      @cms_text_editor_placed = true
+      content = ''.html_safe
+      content << text_area(:page_objects, key, { :dojoType => 'Editor2', :toolbarGroup => 'main', :isToolbarGroupLeader => 'false',
+                           :focusOnLoad => focusOnLoad.to_s, :style => 'border: 2px dashed gray; padding: 5px',
+                           :minHeight => '100px' }.update(html_options))
+      content << content_tag(:div, ''.html_safe, :id => "page_object_config_#{key}")
+      content << javascript_tag("addLoadEvent(function () { scanForPageObjects(#{@pg.id}, '#{key}', #{@pg.version}); });")
+      content << observe_field("page_objects_#{key}", :function => "scanForPageObjects(#{@pg.id}, '#{key}', #{@pg.version});", :frequency => 2)
+      content
+    when :page_list
+      @page_objects["#{key}-min-item-count"] ||= 3 unless options[:item_min_count]
+      @page_objects["#{key}-max-item-count"] ||= 5 unless options[:item_count]
+      @page_objects["#{key}-item-offset"] ||= 0 unless options[:item_offset]
+      @page_objects["#{key}-sort-first-field"] ||= options[:primary_sort_key]
+      @page_objects["#{key}-sort-first-direction"] ||= options[:primary_sort_direction]
+      @page_objects["#{key}-sort-second-field"] ||= options[:secondary_sort_key]
+      @page_objects["#{key}-sort-second-direction"] ||= options[:secondary_sort_direction]
+      
+      render_to_string(:partial => 'page_list', :locals => { :name => name, :key => key }).html_safe
+    when :snippet
+      @snippet = CmsSnippet.find_by_name(name)
+      if @snippet
+        erb_render(substitute_placeholders(@snippet.content, @pg))
+      else
+        'Could not find snippet "' + name + '" in the database.'
+      end
+    else
+      "Unknown object type: #{type.to_s}"
+    end
+  end
+  helper_method :insert_object
+  
+  def disable_caching ; end
+  helper_method :disable_caching
+  
+  #
+  # cms toolbars
+  #
+  
+  def toolbar_edit
+    @pg = CmsPage.find_by_id(params[:id])
+    render :layout => false
+  end
+  
+  def toolbar_preview
+    @pg = CmsPage.find_by_id(params[:id])
+    render :layout => false
+  end
+  
+  #
+  # image upload
+  #
+  
+  def upload_image
+    @pg = CmsPage.find_by_id(params[:id])
+    target_dir = File.join(Rails.root, 'public', 'images', 'content', @pg.path)
+    
+    if File.exists?(target_dir)
+      redirect_to :action => 'select_gallery', :id => @pg, :gallery_id => params[:gallery_id]
+    else
+      render :partial => 'upload_image'
+    end
+  end
+  
+  def receive_image
+    @pg = CmsPage.find_by_id(params[:id])
+    begin
+      data = params[:file][:data]
+      original_filename = data.original_filename
+      target_dir = File.join(Rails.root, 'public', 'assets', 'content', @pg.path)
+      localfile = File.join(target_dir, original_filename)
+      
+      begin
+        FileUtils.mkdir_p target_dir
+      rescue Exception => e
+        logger.debug "Exception: #{e}"
+        log_error(e)
+        finish_upload_status "''" and return
+      end
+      
+      unless params[:overwrite].to_i == 1
+        count = 0
+        while File.exists?(localfile)
+          count += 1
+          localfile = File.join(target_dir, File.basename(original_filename, File.extname(original_filename))) + "-#{count}" + File.extname(original_filename)
+        end
+      end
+      
+      begin
+        File.open(localfile, 'wb') { |f| f.write('test') }
+      rescue Exception => e
+        logger.debug "Exception: #{e}"
+        log_error(e)
+        finish_upload_status "''" and return
+      end
+      
+      begin
+        File.open(localfile, 'wb') { |f| f.write(data.read) }
+      rescue Exception => e
+        logger.debug "Exception: #{e}"
+        log_error(e)
+        finish_upload_status "''" and return
+      end
+    rescue Exception => e
+      logger.debug params.inspect
+      # logger.debug "Exception: #{e}"
+      log_error(e)
+      finish_upload_status "''" and return
+    end
+    
+    upload_progress.message = "File received successfully."
+    finish_upload_status "'#{File.basename(localfile)}'" and return
+  end
+  
+  def crop_image
+    @pg = CmsPage.find_by_id(params[:id])
+    localfile = File.basename(params[:filename])
+    
+    # get out now if user clicked finish
+    if params[:next_clicked].to_i != 1
+      @image_file = localfile
+      render :partial => 'crop_results' and return
+    end
+    
+    
+    # if we're still here... let's crop!
+    target_dir = File.join(Rails.root, 'public', 'images', 'content', @pg.path)
+    localfile = File.join(target_dir, localfile)
+    testfile = File.join(target_dir, File.basename(localfile, File.extname(localfile))) + '-croptest' + File.extname(localfile)
+    
+    # make a smaller version to help with cropping
+    im = MiniMagick::Image.from_file(localfile)
+    im.resize "500x400>"
+    im.write(testfile)
+    File.chmod(0644, testfile)
+    
+    @width = im[:width]
+    @height = im[:height]
+    @height = 1 if @height == 0
+    @image_file = File.basename(testfile)
+    @aspect_ratio = @width.to_f/@height
+    
+    render :partial => 'crop_image'
+  end
+  
+  def save_crop
+    @pg = CmsPage.find_by_id(params[:id])
+    target_dir = File.join(Rails.root, 'public', 'images', 'content', @pg.path)
+    testfile = File.join(target_dir, File.basename(params[:filename]))
+    localfile = testfile.split(/-croptest/).join('')
+    
+    # need to scale up requested position/dimensions based on how big test image
+    # is relative to original image
+    orig_im = MiniMagick::Image.from_file(localfile)
+    test_im = MiniMagick::Image.from_file(testfile)
+    scale = orig_im[:width].to_f / test_im[:width]
+    
+    x1 = params[:image][:x1].to_i * scale
+    y1 = params[:image][:y1].to_i * scale
+    width = params[:image][:width].to_i * scale
+    height = params[:image][:height].to_i * scale
+    
+    max_width = params[:image][:max_width].to_i
+    max_height = params[:image][:max_height].to_i
+    dirty = false
+    
+    # crop if user selected something
+    if params[:image][:width].to_i > 0
+      logger.debug "cropping @ (#{x1}, #{y1}) to size #{width} x #{height}"
+      orig_im.crop "#{width}x#{height}+#{x1}+#{y1}"
+      dirty = true
+    end
+    
+    # resize if the resultant image is bigger than max dims
+    if max_width > 0 && max_height > 0
+      if orig_im[:width] > max_width || orig_im[:height] > max_height
+        logger.debug "resizing to max dims #{max_width} x #{max_height}"
+        orig_im.resize "#{max_width}x#{max_height}"
+        dirty = true
+      end
+    end
+    
+    orig_im.write(localfile) if dirty
+    @image_file = localfile
+    File.unlink testfile
+    
+    render :partial => 'crop_results'
+  end
+  
+  def receive_gallery
+    require 'zip/zip'
+    
+    @pg = CmsPage.find_by_id(params[:id])
+    begin
+      data = params[:gallery_file][:data]
+      target_dir = File.join(Rails.root, 'public', 'images', 'content', @pg.path)
+      localdir = File.join(target_dir, 'gallery_1')
+      
+      begin
+        FileUtils.mkdir_p target_dir
+      rescue Exception => e
+        logger.debug "Exception: #{e}"
+        log_error(e)
+        finish_upload_status "''" and return
+      end
+      
+      unless params[:overwrite].to_i == 1
+        count = 1
+        while File.exists?(localdir)
+          count += 1
+          localdir = File.join(target_dir, "gallery_#{count}")
+        end
+      end
+      
+      begin
+        FileUtils.mkdir_p File.join(localdir, 'temp')
+      rescue Exception => e
+        logger.debug "Exception: #{e}"
+        log_error(e)
+        finish_upload_status "''" and return
+      end
+      
+      # read zip file
+      entries = []
+      Zip::ZipFile.foreach(data.path) do |zipentry|
+        next if ![ '.jpg', '.jpeg', '.png', '.gif' ].include?(File.extname(zipentry.name).downcase) || zipentry.size < 1000
+        next if File.basename(zipentry.name) =~ /^\._/
+        
+        entries << zipentry
+      end
+      entries.sort! { |a,b| File.basename(a.name).downcase <=> File.basename(b.name).downcase }
+      
+      Zip::ZipFile.open(data.path) do |zipfile|
+        entries.each_with_index do |zipentry, index|
+          upload_progress.message = "Extracting #{File.basename(zipentry.name)}"
+          ext = File.extname(zipentry.name)
+          #name = File.basename(zipentry.name, ext)
+          #localfile = File.join(localdir, 'temp', name.downcase.gsub(/[^\w\d]/, '') + ext.downcase)
+          localfile = File.join(localdir, 'temp', (index+1).to_s + ext.downcase)
+          jpgfile = File.join(localdir, 'temp', (index+1).to_s + '.jpg')
+          
+          begin
+            zipentry.extract(localfile)
+            
+            im = MiniMagick::Image.from_file(localfile)
+            im.write(jpgfile)
+            
+            File.unlink(localfile) if localfile != jpgfile
+            
+          rescue Exception => e
+            log_error(e)
+          end
+        end
+      end
+    rescue Exception => e
+      logger.debug params.inspect
+      log_error(e)
+      finish_upload_status "''" and return
+    end
+    
+    upload_progress.message = "File received successfully."
+    finish_upload_status "'#{File.basename(localdir)}'" and return
+  end
+  
+  def gallery_setup
+    @pg = CmsPage.find_by_id(params[:id])
+    target_dir = File.join('images', 'content', @pg.path)
+    @dirname = File.join(target_dir, File.basename(params[:dirname]), 'temp')
+    Dir.chdir(File.join(Rails.root, 'public'))
+    @images = Dir.glob("#{@dirname}/*.{jpg,jpeg,png,gif}").sort
+    Dir.chdir(Rails.root)
+    @thumbs = []
+    
+    @images.each do |img|
+      next if img.include?('-thumb')
+      
+      thumbfile = File.join(Rails.root, 'public', @dirname, File.basename(img, File.extname(img))) + '-thumb.jpg'
+      #@thumbs << File.basename(img, File.extname(img))
+      @thumbs << File.join(@dirname, File.basename(img, File.extname(img))) + 
+'-thumb.jpg'
+      
+      next if File.exists?(thumbfile)
+      
+      im = MiniMagick::Image.from_file(File.join(Rails.root, 'public', img))
+      im.resize "80x80" # hardcoded!
+      im.write(thumbfile)
+      File.chmod(0644, thumbfile)
+    end
+    
+    @thumbs.sort! { |a,b| File.basename(a, File.extname(a)).to_i <=> File.basename(b, File.extname(b)).to_i }
+    session[:gallery_thumbs_ordered] = @thumbs.map { |thumb| File.basename(thumb, File.extname(thumb)) }
+    
+    render :partial => 'gallery_setup'
+  end
+  
+  def complete_gallery
+    @pg = CmsPage.find(params[:id])
+    target_dir = File.join('images', 'content', @pg.path)
+    @dirname = File.join(target_dir, File.basename(params[:dirname]))
+    @thumbs = session[:gallery_thumbs_ordered]
+    max_width = params[:max_width].to_i
+    max_width = GalleryMaxWidth unless max_width > 0
+    max_height = params[:max_height].to_i
+    max_height = GalleryMaxHeight unless max_height > 0
+    
+    create_captions_file(@pg.id, { :gallery_id => File.basename(params[:dirname]) })
+    
+    @thumbs.each_with_index do |thumb, index|
+      thumb.gsub!(/-thumb/, '')
+      tempfile = File.join(Rails.root, 'public', @dirname, 'temp', thumb + '.jpg')
+      tempthumbfile = File.join(Rails.root, 'public', @dirname, 'temp', thumb + '-thumb.jpg')
+      
+      localfile = File.join(Rails.root, 'public', @dirname, (index+1).to_s + '.jpg')
+      thumbfile = File.join(Rails.root, 'public', @dirname, (index+1).to_s + '-thumb.jpg')
+      
+      im = MiniMagick::Image.from_file(tempfile)
+      if im[:width] > max_width || im[:height] > max_height
+        im.resize("#{max_width}x#{max_height}")
+      end
+      im.write(localfile)
+      
+      small = MiniMagick::Image.from_file(tempfile)
+      small.crop_resized(GalleryThumbWidth, GalleryThumbHeight)
+      small.write(thumbfile)
+      
+      File.chmod(0644, localfile, thumbfile)
+      
+      begin
+        File.unlink(tempfile)
+        File.unlink(tempthumbfile)
+      rescue Exception => e
+        # not that big a deal if we can't delete
+      end
+    end
+    
+    begin
+      Dir.rmdir(File.join(Rails.root, 'public', @dirname, 'temp'))
+    rescue Exception => e
+      # not that big a deal if we can't delete
+    end
+    
+    create_preview_images
+    
+    render :partial => 'complete_gallery'
+  end
+
+  def gallery_management
+    @pg = CmsPage.find_by_id(params[:id])
+    galleries_dir = File.join(Rails.root, 'public', 'images', 'content', @pg.path)
+    @galleries = Dir.glob("#{galleries_dir}/gallery_*")
+    gallery_dir = File.join(galleries_dir, params[:gallery_id].to_s)
+    
+    @images = Dir.glob("#{gallery_dir}/*.{jpg,jpeg,png,gif}").reject { |img| img.include?('thumb') }.map { |img| File.basename(img).split('.').first.to_i }.sort
+    
+    create_preview_images
+    
+    if params[:gallery_id]
+      @gallery = load_gallery_settings_from_file(params[:gallery_id])
+    end
+    
+    render :layout => false
+  end
+  
+  def set_gallery_order
+    session[:gallery_thumbs_ordered] = params[:image_sorter]
+    render :nothing => true
+  end
+  
+  def select_gallery
+    @pg = CmsPage.find_by_id(params[:id])
+    @target_dir = File.join(Rails.root, 'public', 'images', 'content', @pg.path)
+    @galleries = Dir.glob("#{@target_dir}/gallery_*")
+    
+    create_preview_images
+    
+    if request.post?
+      unless params[:gallery_id].downcase == "new"
+        redirect_to :action => 'gallery_management', :id => @pg, :gallery_id => params[:gallery_id] and return
+      else
+        render :partial => 'upload_image' and return
+      end
+    else
+      render :partial => 'select_gallery' and return
+    end
+  end
+  
+  def save_gallery_settings
+    if request.post?
+      @pg = CmsPage.find_by_id(params[:id])
+      save_gallery_settings_to_file(params[:gallery_id], params[:gallery])
+      
+      render :nothing => true
+    end
+  end
+  
+  def sort_images
+    @pg = CmsPage.find_by_id(params[:id])
+    gallery_dir = File.join(Rails.root, 'public', 'images', 'content', @pg.path, params[:gallery_id])
+    
+    @images = Dir.glob("#{gallery_dir}/*.{jpg,jpeg,png,gif}").reject { |img| img.include?('thumb') }.map { |img| File.basename(img).split('.').first.to_i }.sort
+    
+    if params[:images]
+      session[:gallery_images_sorted] = params[:images]
+      render :nothing => true
+    else    
+      render :partial => 'sort_images'
+    end
+  end
+  
+  def sort_images_save
+    @pg = CmsPage.find_by_id(params[:id])
+    gallery_dir = File.join(Rails.root, 'public', 'images', 'content', @pg.path, params[:gallery_id])
+    temp_dir = File.join(gallery_dir, 'temp')
+    sorted_images = session[:gallery_images_sorted] || []
+    
+    if sorted_images == []
+      redirect_to :action => 'gallery_management', :id => @pg, :gallery_id => params[:gallery_id]
+      return
+    end
+    
+    FileUtils.rm_rf(temp_dir)
+    Dir.mkdir(temp_dir)
+    
+    # create blank captions.yml if it doesn't already exist
+    create_captions_file(@pg.id)
+    
+    original_captions = YAML.load_file(File.join(gallery_dir, 'captions.yml')).to_a
+    captions = []
+    captions << original_captions[0]
+    
+    sorted_images.each_with_index do |img, i|
+      localfile = File.join(gallery_dir, img)
+      thumbfile = File.join(gallery_dir, img.split('.')[0] + '-thumb.jpg')
+      
+      temp_localfile = File.join(temp_dir, (i + 1).to_s + '.jpg')
+      temp_thumbfile = File.join(temp_dir, (i + 1).to_s + '-thumb.jpg')
+      
+      begin ; FileUtils.cp(localfile, temp_localfile) ; rescue ; end
+      begin ; FileUtils.cp(thumbfile, temp_thumbfile) ; rescue ; end
+      
+      captions[i + 1] = original_captions[img.split('.')[0].to_i] || ''
+    end
+    
+    File.open(File.join(gallery_dir, 'captions.yml'), 'w') { |f| YAML.dump(captions, f) }
+    
+    images = Dir.glob("#{gallery_dir}/*.{jpg,jpeg,png,gif}")
+    temp_images = Dir.glob("#{temp_dir}/*.{jpg,jpeg,png,gif}")
+    
+    images.each { |img| File.delete(img) }
+    temp_images.each { |img| FileUtils.cp(img, File.join(gallery_dir, File.basename(img))) }
+    
+    FileUtils.rm_rf(File.join(gallery_dir, 'management'))
+    create_preview_images(:force => 1)
+    
+    FileUtils.rm_rf(temp_dir)
+    session[:gallery_images_sorted] = nil
+    
+    redirect_to :action => 'gallery_management', :id => @pg, :gallery_id => params[:gallery_id]
+  end
+  
+  def image_details
+    gallery_dir = File.join(Rails.root, 'public', 'images', 'content', params[:path].to_s, params[:gallery_id])
+    
+    # create blank captions.yml if it doesn't already exist
+    create_captions_file(params[:id])
+    
+    captions = YAML.load(File.open(File.join(gallery_dir, 'captions.yml')).read)
+    image_id = params[:image].split('.')[0].to_i
+    @caption = captions[image_id]
+    
+    render :partial => 'image_details'
+  end
+  
+  def update_caption
+    if request.post?
+      gallery_dir = File.join(Rails.root, 'public', 'images', 'content', params[:path].to_s, params[:gallery_id])
+      
+      image_id = params[:image].split('.')[0].to_i
+      
+      # create blank captions.yml if it doesn't already exist
+      create_captions_file(params[:id])
+      
+      captions = YAML.load_file(File.join(gallery_dir, 'captions.yml')).to_a
+      captions[image_id] = params[:caption]
+      
+      File.open(File.join(gallery_dir, 'captions.yml'), "w") { |f| YAML.dump(captions, f) }
+    end
+    
+    redirect_to :action => 'gallery_management', :id => params[:id], :gallery_id => params[:gallery_id]
+  end
+  
+  def add_to_gallery
+    @pg = CmsPage.find_by_id(params[:id])
+    galleries_dir = File.join(Rails.root, 'public', 'images', 'content', @pg.path)
+    @galleries = Dir.entries(galleries_dir).sort
+    @gallery_dir = File.join(galleries_dir, params[:gallery_id])    
+    images = Dir.glob("#{@gallery_dir}/*-thumb.{jpg,jpeg,png,gif}")
+    
+    temp_location = File.join(@gallery_dir ,'temp')
+    FileUtils.rm_rf(temp_location)
+    Dir.mkdir(temp_location)
+    
+    data = params[:gallery_file][:data]
+    data_dest = File.join(temp_location, data.original_filename)
+    File.open(data_dest, "w") { |f| f.write(data.read) }
+    
+    last_id = images.size
+    ext = File.extname(data_dest).downcase
+    
+    if ext != '.zip'
+      localfile = File.join(@gallery_dir, (last_id + 1).to_s + ext)
+      thumbfile = File.join(@gallery_dir, (last_id + 1).to_s + '-thumb' + ext)
+      
+      File.open(localfile, "w") { |f| f.write(File.open(data_dest).read) }
+      
+      # create blank captions.yml if it doesn't already exist
+      create_captions_file(@pg.id)
+      
+      localfile = resize_image(localfile)
+      
+      small = MiniMagick::Image.from_file(localfile)
+      small.crop_resized(GalleryThumbWidth, GalleryThumbHeight)
+      small.write(thumbfile)
+      
+      File.chmod(0644, localfile, thumbfile)
+      
+      create_preview_images(:force => 1)
+      
+    elsif ext == '.zip'
+      require 'zip/zip'
+      
+      begin
+        Zip::ZipFile.foreach(data.path) do |zipentry|
+          next if ![ '.jpg', '.jpeg', '.png', '.gif' ].include?(File.extname(zipentry.name).downcase) || zipentry.size < 1000
+          upload_progress.message = "Extracting #{File.basename(zipentry.name)}"
+          localfile = File.join(temp_location, ((last_id+1).to_s + File.extname(zipentry.name)).downcase)
+          
+          begin
+            zipentry.extract(localfile)
+            last_id += 1
+          rescue Exception => e
+            log_error(e)
+          end
+        end
+      rescue Exception => e
+        logger.debug params.inspect
+        log_error(e)
+        finish_upload_status "''" and return
+      end
+      
+      @images = Dir.glob("#{temp_location}/*.{jpg,jpeg,png,gif}")
+      
+      @images.each do |img|
+        localfile = File.join(@gallery_dir, File.basename(img, File.extname(img))) + '.jpg'
+        tempfile = File.join(temp_location, File.basename(img, File.extname(img))) + File.extname(img)
+        thumbfile = File.join(@gallery_dir, File.basename(img, File.extname(img))) + '-thumb.jpg'
+        
+        small = MiniMagick::Image.from_file(tempfile)
+        small.crop_resized(GalleryThumbWidth, GalleryThumbHeight)
+        small.write(thumbfile)
+        
+        FileUtils.cp(tempfile, localfile)
+        resize_image(localfile)
+        
+        File.chmod(0644, localfile, thumbfile)
+      end
+      
+      # smaller images for gallery index
+      management_dir = File.join(@gallery_dir, 'management')
+      
+      preview_images = []
+      Dir.glob("#{@gallery_dir}/*.{jpg,jpeg,png,gif}").each { |img| preview_images << img unless File.basename(img).include?('thumb') }
+      
+      preview_images.each { |img| create_preview_image(img, management_dir, 1) }
+    end
+    
+    File.delete(data_dest)
+    
+    upload_progress.message = "File received successfully."
+    finish_upload_status "'#{File.basename(data_dest)}'" and return
+  end
+  
+  def delete_photo
+    if request.post?
+      gallery_dir = File.join(Rails.root, 'public', 'images', 'content', params[:path].to_s, params[:gallery_id])
+      
+      image_id = params[:image].split('.')[0].to_i
+      
+      begin ; File.delete(File.join(gallery_dir, image_id.to_s + '.jpg')) ; rescue ; end
+      begin ; File.delete(File.join(gallery_dir, image_id.to_s + '-thumb.jpg')) ; rescue ; end
+      begin ; File.delete(File.join(gallery_dir, 'management', image_id.to_s + '.jpg')) ; rescue ; end
+      
+      all_images = Dir.glob(File.join(gallery_dir, '*.{jpg,jpeg,png,gif}'))
+      images = []
+      all_images.each { |img| images << img if !File.basename(img).include?('thumb') and File.basename(img).split('.')[0].to_i > image_id }
+      
+      image_names = []
+      images.each_with_index { |img, index| image_names << File.basename(img).split('.')[0].to_i }
+      image_names.sort!
+      
+      # create blank captions.yml if it doesn't already exist
+      create_captions_file(params[:id])
+      captions = YAML.load(File.open(File.join(gallery_dir, 'captions.yml')).read).to_a
+      
+      new_captions = []
+      for i in 0...image_id do
+        new_captions[i] = captions[i] || ''
+      end
+      
+      image_names.each do |img|
+        FileUtils.mv(File.join(gallery_dir, img.to_s + '.jpg'), File.join(gallery_dir, image_id.to_s + '.jpg'))
+        FileUtils.mv(File.join(gallery_dir, img.to_s + '-thumb.jpg'), File.join(gallery_dir, image_id.to_s + '-thumb.jpg'))
+        FileUtils.mv(File.join(gallery_dir, 'management', img.to_s + '.jpg'), File.join(gallery_dir, 'management', image_id.to_s + '.jpg'))
+        
+        new_captions[image_id] = captions[img] || ''
+        
+        image_id += 1
+      end
+      
+      File.open(File.join(gallery_dir, 'captions.yml'), "w") { |f| f.write(YAML.dump(new_captions)) }
+    end
+    
+    redirect_to :action => 'gallery_management', :id => params[:id], :gallery_id => params[:gallery_id]
+  end
+  
+  def delete_gallery
+    @pg = CmsPage.find_by_id(params[:id])
+    galleries_dir = File.join(Rails.root, 'public', 'images', 'content', @pg.path)
+    gallery_dir = File.join(galleries_dir, params[:gallery_id])
+    
+    FileUtils.rm_rf(gallery_dir)
+    
+    redirect_to :action => 'select_gallery', :id => params[:id]
+  end
+  
+  
+  def upload_file
+    @pg = CmsPage.find_by_id(params[:id])
+    render :partial => 'upload_file'
+  end
+  
+  def receive_file
+    @pg = CmsPage.find_by_id(params[:id])
+    begin
+      data = params[:file][:data]
+      original_filename = data.original_filename.downcase.gsub(/[^\.\w\d]+/, '_')
+      target_dir = File.join(Rails.root, 'public', 'files', 'content', @pg.path)
+      localfile = File.join(target_dir, original_filename)
+      
+      begin
+        FileUtils.mkdir_p target_dir
+      rescue Exception => e
+        logger.debug "Exception: #{e}"
+        log_error(e)
+        finish_upload_status "''" and return
+      end
+      
+      unless params[:overwrite].to_i == 1
+        count = 0
+        while File.exists?(localfile)
+          count += 1
+          localfile = File.join(target_dir, File.basename(original_filename, File.extname(original_filename))) + "-#{count}" + File.extname(original_filename)
+        end
+      end
+      
+      begin
+        File.open(localfile, 'wb') { |f| f.write('test') }
+      rescue Exception => e
+        logger.debug "Exception: #{e}"
+        log_error(e)
+        finish_upload_status "''" and return
+      end
+      
+      begin
+        File.open(localfile, 'wb') { |f| f.write(data.read) }
+      rescue Exception => e
+        logger.debug "Exception: #{e}"
+        log_error(e)
+        finish_upload_status "''" and return
+      end
+    rescue Exception => e
+      logger.debug params.inspect
+      # logger.debug "Exception: #{e}"
+      log_error(e)
+      finish_upload_status "''" and return
+    end
+    
+    upload_progress.message = "File received successfully."
+    finish_upload_status "'#{File.basename(localfile)}'" and return
+  end
+  
+  def create_file_link
+    @pg = CmsPage.find_by_id(params[:id])
+    target_dir = File.join('files', 'content', @pg.path)
+    @filename = File.join(target_dir, File.basename(params[:filename]))
+    render :partial => 'create_file_link'
+  end
+  
+  
+  def upload_thumb
+    @pg = CmsPage.find_by_id(params[:id])
+    render :partial => 'upload_thumb'
+  end
+  
+  def crop_thumb
+    @pg = CmsPage.find_by_id(params[:id])
+    localfile = File.basename(params[:filename])
+    
+    # get out now if user clicked finish
+    if params[:next_clicked].to_i != 1
+      @image_file = localfile
+      render :partial => 'crop_results_thumb' and return
+    end
+    
+    
+    # if we're still here... let's crop!
+    target_dir = File.join(Rails.root, 'public', 'images', 'content', @pg.path)
+    localfile = File.join(target_dir, localfile)
+    testfile = File.join(target_dir, File.basename(localfile, File.extname(localfile))) + '-croptest' + File.extname(localfile)
+    
+    # make a smaller version to help with cropping
+    im = MiniMagick::Image.from_file(localfile)
+    im.resize("500x400>")
+    im.write(testfile)
+    File.chmod(0644, testfile)
+    
+    @width = im[:width]
+    @height = im[:height]
+    @height = 1 if @height == 0
+    @image_file = File.basename(testfile)
+    @aspect_ratio = @width.to_f/@height
+    
+    render :partial => 'crop_thumb'
+  end
+  
+  def save_crop_thumb
+    @pg = CmsPage.find_by_id(params[:id])
+    target_dir = File.join(Rails.root, 'public', 'images', 'content', @pg.path)
+    testfile = File.join(target_dir, File.basename(params[:filename]))
+    localfile = testfile.split(/-croptest/).join('')
+    
+    # need to scale up requested position/dimensions based on how big test image
+    # is relative to original image
+    orig_im = MiniMagick::Image.from_file(localfile)
+    test_im = MiniMagick::Image::from_file(testfile)
+    scale = orig_im[:width].to_f / test_im[:width]
+    
+    x1 = params[:image][:x1].to_i * scale
+    y1 = params[:image][:y1].to_i * scale
+    # x2 = params[:image][:x2].to_i * scale
+    # y2 = params[:image][:y2].to_i * scale
+    width = params[:image][:width].to_i * scale
+    height = params[:image][:height].to_i * scale
+    
+    max_width = params[:image][:max_width].to_i
+    max_height = params[:image][:max_height].to_i
+    dirty = false
+    
+    # crop if user selected something
+    if params[:image][:width].to_i > 0
+      logger.debug "cropping @ (#{x1}, #{y1}) to size #{width} x #{height}"
+      orig_im.crop("#{width}x#{height}+#{x1}+#{y1}")
+      dirty = true
+    end
+    
+    # resize if the resultant image is bigger than max dims
+    if max_width > 0 && max_height > 0
+      if orig_im[:width] > max_width || orig_im[:height] > max_height
+        logger.debug "resizing to max dims #{max_width} x #{max_height}"
+        orig_im.resize("#{max_width}x#{max_height}>")
+        dirty = true
+      end
+    end
+    
+    orig_im.write(localfile) if dirty
+    File.chmod(0644, localfile)
+    
+    @image_file = localfile
+    File.unlink testfile
+    
+    render :partial => 'crop_results_thumb'
+  end
+  
+  def upload_feature_image
+    @pg = CmsPage.find_by_id(params[:id])
+    render :partial => 'upload_feature_image'
+  end
+  
+  def crop_feature_image
+    @pg = CmsPage.find_by_id(params[:id])
+    localfile = File.basename(params[:filename])
+    
+    # get out now if user clicked finish
+    if params[:next_clicked].to_i != 1
+      @image_file = localfile
+      render :partial => 'crop_results_feature_image' and return
+    end
+    
+    
+    # if we're still here... let's crop!
+    target_dir = File.join(Rails.root, 'public', 'images', 'content', @pg.path)
+    localfile = File.join(target_dir, localfile)
+    testfile = File.join(target_dir, File.basename(localfile, File.extname(localfile))) + '-croptest' + File.extname(localfile)
+    
+    # make a smaller version to help with cropping
+    im = MiniMagick::Image.from_file(localfile)
+    im.resize("500x400>")
+    im.write(testfile)
+    File.chmod(0644, testfile)
+    
+    @width = im[:width]
+    @height = im[:height]
+    @height = 1 if @height == 0
+    @image_file = File.basename(testfile)
+    @aspect_ratio = @width.to_f/@height
+    
+    render :partial => 'crop_feature_image'
+  end
+  
+  def save_crop_feature_image
+    @pg = CmsPage.find_by_id(params[:id])
+    target_dir = File.join(Rails.root, 'public', 'images', 'content', @pg.path)
+    testfile = File.join(target_dir, File.basename(params[:filename]))
+    localfile = testfile.split(/-croptest/).join('')
+    
+    # need to scale up requested position/dimensions based on how big test image
+    # is relative to original image
+    orig_im = MiniMagick::Image.from_file(localfile)
+    test_im = MiniMagick::Image::from_file(testfile)
+    scale = orig_im[:width].to_f / test_im[:width]
+    
+    x1 = params[:image][:x1].to_i * scale
+    y1 = params[:image][:y1].to_i * scale
+    # x2 = params[:image][:x2].to_i * scale
+    # y2 = params[:image][:y2].to_i * scale
+    width = params[:image][:width].to_i * scale
+    height = params[:image][:height].to_i * scale
+    
+    max_width = params[:image][:max_width].to_i
+    max_height = params[:image][:max_height].to_i
+    dirty = false
+    
+    # crop if user selected something
+    if params[:image][:width].to_i > 0
+      logger.debug "cropping @ (#{x1}, #{y1}) to size #{width} x #{height}"
+      orig_im.crop("#{width}x#{height}+#{x1}+#{y1}")
+      dirty = true
+    end
+    
+    # resize if the resultant image is bigger than max dims
+    if max_width > 0 && max_height > 0
+      if orig_im[:width] > max_width || orig_im[:height] > max_height
+        logger.debug "resizing to max dims #{max_width} x #{max_height}"
+        orig_im.resize("#{max_width}x#{max_height}>")
+        dirty = true
+      end
+    end
+    
+    orig_im.write(localfile) if dirty
+    File.chmod(0644, localfile)
+    
+    @image_file = localfile
+    File.unlink testfile
+    
+    render :partial => 'crop_results_feature_image'
+  end
+  
+  
+  private
+  
+  def load_page_objects
+    @page_objects = HashObject.new
+    @template_options = HashObject.new
+    
+    if @pg.new_record? && @parent
+      # This does not appear to be a beneficial feature any longer
+      # @tags = @parent.tags.collect { |t| t.name }.join(', ')
+      @parent.objects.find(:all, :conditions => [ "obj_type = 'attribute'" ]).each do |obj|
+        key = "obj-#{obj.obj_type.to_s}-#{obj.name}"
+        @page_objects[key] = obj.content
+      end
+      @parent.objects.find(:all, :conditions => [ "obj_type = 'option'" ]).each do |obj|
+        key = "obj-#{obj.obj_type.to_s}-#{obj.name}"
+        @page_objects[key] = obj.content
+      end
+    else
+      @tags = @pg.tags.collect { |t| t.name }.join(', ')
+      @pg.objects.find(:all, :conditions => [ "obj_type = 'attribute'" ]).each do |obj|
+        key = "obj-#{obj.obj_type.to_s}-#{obj.name}"
+        @page_objects[key] = obj.content
+      end
+      @pg.objects.find(:all, :conditions => [ "obj_type = 'option'" ]).each do |obj|
+        key = "obj-#{obj.obj_type.to_s}-#{obj.name}"
+        @page_objects[key] = obj.content
+      end
+    end
+  end
+  
+  def load_template_options
+    begin
+      render_to_string :inline => @pg.template.content
+    rescue Exception => e
+      logger.debug e
+    end
+  end
+  
+  def garbage_collect
+    GC.start
+  end
+  
+  def create_captions_file(pg_id, options = {})
+    gallery_id = (!options[:gallery_id] ? params[:gallery_id] : options[:gallery_id])
+    
+    @pg = CmsPage.find_by_id(pg_id)
+    galleries_dir = File.join(Rails.root, 'public', 'images', 'content', @pg.path)
+    gallery_dir = File.join(galleries_dir, gallery_id)
+    captions_location = File.join(gallery_dir, 'captions.yml')
+    
+    return if File.exists?(captions_location)
+    
+    File.open(captions_location, 'w') { |f| YAML.dump([0], f) }
+  end
+  
+  # prerequisites: @pg (CmsPage)
+  def load_gallery_settings_from_file(gallery_id, options = {})
+    galleries_dir = File.join(Rails.root, 'public', 'images', 'content', @pg.path)
+    gallery_dir = File.join(galleries_dir, gallery_id)
+    settings_location = File.join(gallery_dir, 'settings.yml')
+    
+    ret = {}
+    
+    if File.exists?(settings_location)
+      File.open(settings_location, 'r') { |f| ret = YAML.load(f.read) }
+    else
+      File.open(settings_location, 'w') { |f| YAML.dump({}, f) }
+    end
+    
+    # set a few defaults
+    ret[:slide_duration] ||= 0
+    ret[:show_thumbs] ||= true
+    
+    return HashObject.new(ret)
+  end
+  
+  # prerequisites: @pg (CmsPage)
+  def save_gallery_settings_to_file(gallery_id, settings_hash, options = {})
+    settings_hash = settings_hash.hash if settings_hash.kind_of?(HashObject)
+    
+    galleries_dir = File.join(Rails.root, 'public', 'images', 'content', @pg.path)
+    gallery_dir = File.join(galleries_dir, gallery_id)
+    settings_location = File.join(gallery_dir, 'settings.yml')
+    
+    File.open(settings_location, 'w') { |f| YAML.dump(settings_hash, f) }
+  end
+  
+  def resize_image(localfile)
+    ext = File.extname(localfile)
+    
+    # AKN: this would change all files to jpeg format... commenting out for now
+    # filename = File.join(File.dirname(localfile), File.basename(localfile, ext) + '.jpg')
+    filename = localfile
+    
+    im = MiniMagick::Image::from_file(localfile)
+    
+    if im[:width] > GalleryMaxWidth || im[:height] > GalleryMaxHeight
+      im.resize("#{GalleryMaxWidth}x#{GalleryMaxHeight}")
+      im.write(filename)
+    elsif filename != localfile
+      im.write(filename)
+    end
+    
+    File.unlink(localfile) unless localfile == filename
+    
+    filename
+  end
+  
+  def create_preview_image(src_file, dest, force = 0, overlay = 'gallery_small_overlay.png', thumb_size = 90)
+    require 'RMagick'
+    
+    dest = File.join(dest, File.basename(src_file)) if File.directory?(dest)
+    if !File.exists?(dest) || force == 1
+      im = Magick::Image::read(src_file)[0]
+      im_overlay = Magick::Image::read(File.join(Rails.root, 'public', 'images', 'management', overlay))[0]
+      
+      im.crop_resized!(thumb_size, thumb_size)
+      im = im.composite(im_overlay, Magick::CenterGravity, Magick::OverCompositeOp)
+      
+      im.write(dest)
+      File.chmod(0644, dest)
+      
+      im = im_overlay = nil
+      GC.start
+      
+      nil
+    end
+  end
+  
+  def create_preview_images(options = {})
+    # assumes @pg has already been set before calling
+    
+    galleries_dir = File.join(Rails.root, 'public', 'images', 'content', @pg.path)
+    session[:broken_galleries] = []
+    
+    # create preview images if not already made
+    Dir.glob("#{galleries_dir}/gallery_*").each do |g|
+      begin
+        management_dir = File.join(g, 'management')
+        FileUtils.mkdir_p(management_dir) unless File.exists?(management_dir)
+        
+        images = Dir.glob("#{g}/*.{jpg,jpeg,png,gif}")
+        preview_images = []
+        images.each { |img| preview_images << img unless File.basename(img).include?('thumb') }
+        
+        # gallery preview image
+        preview_image_location = File.join(management_dir, 'preview.jpg')
+        unless File.exists?(preview_image_location)
+          preview_image = preview_images.first
+          create_preview_image(preview_image, preview_image_location, options[:force], 'gallery_preview_overlay.png', 130)
+        end
+        
+        # photo preview images
+        preview_images.each { |img| create_preview_image(img, management_dir, options[:force]) }
+        
+      rescue Exception => e
+        # some error handling here
+        session[:broken_galleries] << File.basename(g)
+        
+        log_error(e)
+      end
+    end
+  end
+  
+end