westarete-skylinecms 3.0.8.20100329

data/app/controllers/skyline/articles_controller.rb

@@ -0,0 +1,245 @@
+class Skyline::ArticlesController < Skyline::ApplicationController
+  
+  insert_before_filter_after :authentication, :find_article, :only => [:edit, :update, :destroy]
+  
+  authorize :index, :by => Proc.new{|user,controller,action| user.allow?(controller.article || controller.class_from_type, :index)  }
+  authorize :create, :by => Proc.new{|user,controller,action| user.allow?(controller.article || controller.class_from_type, :create)  }  
+  authorize :edit, :by => Proc.new{|user,controller,action| user.allow?(controller.article || controller.class_from_type, :show)  }  
+  authorize :update, :reorder, :by => Proc.new{|user,controller,action| user.allow?(controller.article || controller.class_from_type, :update)  }  
+  authorize :destroy, :by => Proc.new{|user,controller,action| user.allow?(controller.article || controller.class_from_type, :variant_delete)  }  
+    
+  layout :determine_layout
+  
+  self.default_menu_item = :content_library
+
+  def index
+    case params[:type] 
+    when "skyline/page" 
+      return redirect_to(edit_skyline_article_path(Skyline::Page.root))
+    when "skyline/page_fragment"
+      return redirect_to(edit_skyline_article_path(Skyline::PageFragment.first)) if Skyline::PageFragment.first.present?
+    end
+    @articles = class_from_type(params[:type]).all
+  end
+  
+  def create
+    if params[:type] == "skyline/page"
+      relative_to_page = Skyline::Page.find_by_id(params[:article_id])
+      return redirect_to(edit_skyline_article_path(Skyline::Page.root)) unless relative_to_page
+      article = relative_to_page.create_new!(params[:position].to_sym)
+    else
+      article = class_from_type(params[:type]).new(params[:article])
+      article.save
+    end
+    
+    if article.errors.any?
+      messages[:error] = t(:error, :errors => Array(article.errors.full_messages).to_sentence, :scope => [article.class, :create, :flashes])
+      if params[:type] == "skyline/page"
+        @target = edit_skyline_article_path(relative_to_page)
+      else
+        @target = skyline_articles_path(:type => params[:type])
+      end
+    else
+      @target = edit_skyline_article_path(article)
+      flash[:select_page_title] = true
+    end
+    
+    if request.xhr?
+      render :update do |p|
+  		  p.redirect_to @target
+      end
+    else
+		  redirect_to @target
+  	end
+  end
+
+  def edit  
+    case @article
+      when Skyline::Page,Skyline::PageFragment then self.current_menu_item = :pages
+    end
+    
+    if @variant.editable_by?(current_user)
+      @variant.edit_by!(current_user) 
+    else
+      messages.now[:error] = render_to_string(:partial => "currently_editing")      
+      return render(:action => "edit_preview_only")
+    end
+    
+    if flash[:show_errors_for_publication]
+      @variant.data.to_be_published = true
+      @variant.valid?
+    end
+    
+  end
+  
+  def update
+    return handle_unauthorized_user unless @article.editable_by?(current_user)
+    
+    case @article
+      when Skyline::Page,Skyline::PageFragment then self.current_menu_item = :pages
+    end
+        
+    # @page.attributes= with all variant_attributes will load all variants which in turn
+    #   will cause all versions of the variants to be increased by 1
+    # Solution is to save the one and only variant seperately
+    article_params = params[:article].dup if params[:article]
+    if variant_attributes = article_params.andand[:variants_attributes].andand["1"]
+      article_params.delete(:variants_attributes)
+      variant_id = variant_attributes.delete(:id)
+      @variant = @article.variants.find(variant_id)
+    elsif params[:variant_id]
+      @variant = @article.variants.find(params[:variant_id])
+    end    
+
+    if params["clone_variant"] == "1"
+      name = variant_attributes.andand[:name]
+      name = @variant.name + "_copy" if name.blank?
+      new_variant = @article.variants.create(:name => name, :current_editor_id => current_user.id)
+    end
+
+    
+    saved = false
+    begin
+      Skyline::Article.transaction do
+        if params["clone_variant"] == "1"
+          @variant = @variant.clone()
+          
+          # Dirty hack so AR thinks this object isn't new.
+          @variant.attributes = new_variant.attributes.except("version")
+          @variant.id = new_variant.id          
+          class << @variant; def new_record?; false; end; end
+          @variant.save!
+        else
+          @article.attributes = article_params          
+          @article.save!
+          
+          if variant_attributes
+            @variant.attributes = variant_attributes 
+            @variant.save!
+          end          
+        end
+        saved = true
+      end
+    rescue ActiveRecord::RecordInvalid
+      logger.debug "Article update failed: #{@article.errors.inspect}"
+      logger.debug "Variant update failed: #{@variant.errors.inspect}"
+    end
+    
+    if params[:article].has_key?(:move_behind)
+      # no notifications needed
+      render :update do |p|
+      end
+    elsif request.xhr?
+      render :update do |p|
+        if saved
+          if @article.locked?
+            p.notification :success, t(:locked, :scope => [@article.class, :update, :flashes])
+            p << "$$('#article_#{@article.id} span')[0].addClass('locked')" if @article.kind_of?(Skyline::Page)
+          else
+            p.notification :success, t(:unlocked, :scope => [@article.class, :update, :flashes])
+            p << "$$('#article_#{@article.id} span')[0].removeClass('locked')" if @article.kind_of?(Skyline::Page)
+          end
+        else
+          if @article.locked?
+            p.message :error, t(:lock_failed, :scope => [@article.class, :update, :flashes])
+          else
+            p.message :error, t(:unlock_failed, :scope => [@article.class, :update, :flashes])
+          end
+        end
+        p.replace "article_security", :partial => "security"
+      end
+    else
+      if saved
+        notifications[:success] = t(:success, :scope => [@article.class, :update, :flashes])
+        redirect_to edit_skyline_article_path(@article, :variant_id => @variant.id)
+      else
+        if @variant.errors.on(:version)
+          messages.now[:error] = @variant.errors.on(:version)
+        else
+          messages.now[:error] = t(:error, :scope => [@article.class, :update, :flashes])
+        end
+        render :action => :edit
+      end          
+    end
+    
+    logger.debug("------ article validation: #{@article.errors.full_messages.inspect}")
+  end  
+  
+  def destroy
+    return handle_unauthorized_user unless @article.editable_by?(current_user)
+
+    if @article.destroyable?
+      if @article.destroy
+        notifications[:success] = t(:success, :scope => [@article.class, :destroy, :flashes])
+        if @article.respond_to?(:parent) && @article.parent.present?
+          redirect_to edit_skyline_article_path(@article.parent)
+        else
+          redirect_to skyline_articles_path(:type => @article.class)
+        end
+      else
+        notifications[:error] = t(:error, :scope => [@article.class, :destroy, :flashes])
+        redirect_to edit_skyline_article_path(@article)
+      end
+    else
+      if @article.published?
+        notifications[:error] = t(:error_page_published, :scope => [@article.class, :destroy, :flashes])
+        redirect_to edit_skyline_article_path(@article)
+      elsif @article.persistent?
+        notifications[:error] = t(:error_page_persistent, :scope => [@article.class, :destroy, :flashes])
+        redirect_to edit_skyline_article_path(@article)
+      elsif @article.children.any?
+        notifications[:error] = t(:error_page_has_children, :scope => [@article.class, :destroy, :flashes])
+        redirect_to edit_skyline_article_path(@article)
+      else
+        notifications[:error] = t(:error, :scope => [@article.class, :destroy, :flashes])
+        redirect_to edit_skyline_article_path(@article)
+      end
+    end
+  end
+  
+	# expects:
+	#   params[:pages]  - Array of Page IDs in the new order
+  def reorder
+  	return unless request.xhr?
+  	Skyline::Page.reorder(params[:pages])
+  	# TODO: render....
+	end  
+
+  # =============================
+  # = Non action public methods =
+  # =============================
+  hide_action :article, :class_from_type
+  
+  def article
+    @article
+  end
+    
+  def class_from_type(type=params[:type])
+    raise "Cannot infer class from #{type.inspect}" if type.blank?
+    klass = type.camelcase.constantize
+    if klass.ancestors.include?(Skyline::Article)
+      return klass 
+    else
+      raise "Class #{klass.to_s} is not a subclass of Skyline::Article"
+    end
+  end
+
+  protected
+  
+  def find_article
+    @article = Skyline::Article.find_by_id(params[:id])
+    @variant = @article.variants.find_by_id(params[:variant_id]) if params[:variant_id]
+    @variant ||= @article.default_variant
+    @variant ||= @article.variants.first
+    @renderable_scope = @article.renderable_scope
+  end
+  
+  def determine_layout
+    if @article && (@article.kind_of?(Skyline::Page) || @article.kind_of?(Skyline::PageFragment)) || params[:type] == "skyline/page" || params[:type] == "skyline/page_fragment"
+      "skyline/layouts/pages"
+    else
+      "skyline/layouts/articles"
+    end
+  end
+
+end

data/app/controllers/skyline/authentications_controller.rb

@@ -0,0 +1,34 @@
+class Skyline::AuthenticationsController < Skyline::ApplicationController
+  layout false
+  
+  def new
+
+  end
+  
+  def create
+    if user = Skyline::User.authenticate(params[:email], params[:password])      
+      reset_session      
+      session[:user_id] = user.id
+      redirect_to skyline_articles_path(:type => Skyline::Page)
+    else
+      messages.now[:error] = t(:error, :scope => [:authentication,:create,:flashes])
+      render :action => :new
+    end
+    
+  end
+  
+  def destroy 
+    session[:user_id] = nil 
+    if request.xhr?
+      render(:update){|p| p.redirect_to new_skyline_authentication_path }
+    else    
+      redirect_to new_skyline_authentication_path
+    end
+  end    
+  
+  protected
+  
+  def protect?
+    self.action_name == "destroy"
+  end
+end

data/app/controllers/skyline/browser/files_controller.rb

@@ -0,0 +1,18 @@
+class Skyline::Browser::FilesController < Skyline::ApplicationController
+  def index
+    @media_dirs = Skyline::MediaDir.group_by_parent_id
+    
+    if params[:referable_type].present? && params[:referable_id].present?
+      case params[:referable_type]
+        when "Skyline::MediaFile" then
+          @media_file = Skyline::MediaFile.find_by_id(params[:referable_id])
+          @media_dir = @media_file.directory if @media_file
+          @active_tab = "Skyline::MediaFile"
+      end
+    end
+    
+    @active_tab ||= "Skyline::MediaFile"
+    
+    render :partial => "index"
+  end
+end

data/app/controllers/skyline/browser/images_controller.rb

@@ -0,0 +1,20 @@
+class Skyline::Browser::ImagesController < Skyline::ApplicationController
+  def index
+    @media_dirs = Skyline::MediaDir.group_by_parent_id
+    
+    if params[:referable_type].present?
+      case params[:referable_type]
+        when "Skyline::MediaFile" then
+          @active_tab = "Skyline::MediaFile"
+          @media_file = Skyline::MediaFile.find_by_id(params[:referable_id])
+          @media_dir = @media_file.directory if @media_file
+        when "Skyline::ReferableUri" then
+          @active_tab = "Skyline::ReferableUri"
+      end
+    end
+    
+    @active_tab ||= "Skyline::MediaFile"
+    
+    render :partial => "index"
+  end
+end

data/app/controllers/skyline/browser/links_controller.rb

@@ -0,0 +1,26 @@
+class Skyline::Browser::LinksController < Skyline::ApplicationController
+  def index
+    @media_dirs = Skyline::MediaDir.group_by_parent_id
+    @pages = Skyline::Page.group_by_parent_id
+    
+    if params[:referable_type].present?
+      case params[:referable_type]
+        when "Skyline::MediaFile" then
+          @media_file = Skyline::MediaFile.find_by_id(params[:referable_id])
+          @media_dir = @media_file.directory if @media_file
+          @active_tab = "Skyline::MediaFile"
+        when "Skyline::Page" then
+          @page = Skyline::Page.find_by_id(params[:referable_id])
+          @active_tab = "Skyline::Page"          
+      end
+    end
+    
+    if @active_tab.nil? && params[:url].present?
+      @active_tab = "Skyline::ReferableUri"
+    else
+      @active_tab ||= "Skyline::Page"
+    end    
+    
+    render :partial => "index"
+  end
+end

data/app/controllers/skyline/browser/pages_controller.rb

@@ -0,0 +1,10 @@
+class Skyline::Browser::PagesController < Skyline::ApplicationController
+  def index
+    @pages = Skyline::Page.group_by_parent_id
+    
+    @active_tab = "Skyline::Page"
+    @page = Skyline::Page.find_by_id(params[:referable_id]) if params[:referable_id].present?
+    
+    render :partial => "index"
+  end
+end

data/app/controllers/skyline/browser/tabs/media_library/media_files_controller.rb

@@ -0,0 +1,31 @@
+class Skyline::Browser::Tabs::MediaLibrary::MediaFilesController < Skyline::ApplicationController
+  def index
+    @media_dir = Skyline::MediaDir.find(params[:media_dir_id])
+    @media_file = @media_dir.files.find_by_id(params[:media_file_id])
+    
+    render :update do |p|
+      # if !params[:listonly]
+      #   p.replace_html("browserUploadPanel", :partial => "new", :locals => {:media_dir => @media_dir})
+      # end
+    	    	
+    	p.replace("browserFilelist", :partial => "index")
+    end    
+  end
+  
+  # show
+  # Renders the requested image with specified size parameters and stores the image in the cache. 
+  # If the image is already in the cache then 304 Not Modified is rendered.
+  #
+  # ==== Parameters
+  # size <String> WidthxHeight
+  
+  def show
+    @media_file = Skyline::MediaFile.find(params[:id])
+    @media_dir = @media_file.directory
+
+    render :update do |p|
+      p.replace("browserFileInfo", :partial => "show")
+    end 
+  end
+
+end

data/app/controllers/skyline/content/editors/editable_list_controller.rb

@@ -0,0 +1,23 @@
+class Skyline::Content::Editors::EditableListController < Skyline::Skyline2Controller
+
+  helper "skyline/content"
+  before_filter :get_classes
+  
+  def new
+    @object = @source_object.send(@assoc.name).build
+    render :update do |p|
+      editor = Skyline::Editors::EditableList.new(["element"],@source_object,@source_klass.fields[params[:association].to_sym],@template)
+      p.insert_html :bottom, editor.js_object_name, editor.render_row(@object)
+    end
+  end
+  
+  protected
+  
+  def get_classes
+    @source_klass = @implementation.content_class(params[:source_type])
+    @source_object = @source_klass.find_by_id(params[:source_id]) || @source_klass.new    
+    @assoc = @source_klass.reflect_on_association(params[:association].to_sym)
+    @target_klass = @assoc.klass
+  end
+  
+end

data/app/controllers/skyline/content/editors/joinable_list_controller.rb

@@ -0,0 +1,73 @@
+class Skyline::Content::Editors::JoinableListController < Skyline::Skyline2Controller
+
+  helper "skyline/content"
+  before_filter :get_classes
+  
+  def index
+    @filter = filter_from_params_or_default
+    @elements = @target_klass.paginate_for_cms(:all,:page => params[:page], :per_page => 10, :self_referential => false, :filter => @filter)
+    @title_field = @target_klass.fields[@target_klass.settings.title_field]
+    render :update do |p|
+      p.replace_html "element_#{params[:association]}_browser", :partial => "list"
+    end
+  end
+  
+  def new
+    if @assoc.through_reflection
+      @target = @target_klass.find(params[:target_id])
+      @object = @source_object.send(@assoc.through_reflection.name).build(@assoc.source_reflection.name => @target)
+    else
+      @object = @target_klass.find(params[:target_id])
+    end
+    render :update do |p|
+      editor = Skyline::Editors::JoinableList.new(["element"],@source_object,@source_klass.fields[params[:association].to_sym],@template)
+      p.insert_html :bottom, editor.js_object_name, editor.render_row(@object)
+#      p << "#{editor.js_object_name}.afterUpdate();"
+      if params[:add_multiple] != "true"
+        p.replace_html "element_#{params[:association]}_browser",
+          :partial => "add", 
+          :locals => {:source_object => @source_object,:target_class => @target_klass,:association => @assoc.name}        
+      end
+    end
+  end
+  
+  def cancel
+    render :update do |p|
+      p.replace_html "element_#{params[:association]}_browser", 
+        :partial => "add", 
+        :locals => {:source_object => @source_object,:target_class => @target_klass,:association => @assoc.name}
+    end
+  end
+
+  protected
+  
+  def get_classes
+    @source_klass = @implementation.content_class(params[:source_type])
+    @source_object = @source_klass.find_by_id(params[:source_id]) || @source_klass.new    
+    @assoc = @source_klass.reflect_on_association(params[:association].to_sym)
+    @target_klass = @assoc.klass    
+  end
+  
+  def default_url_options(options)
+    options.update(:source_type => params[:source_type], :source_id => params[:source_id], :association => params[:association])
+  end
+
+  # GEt filter from params, or use default if defined
+  def filter_from_params_or_default
+    # First priority is params
+    return params[:filter] if params.has_key?(:filter) || params.has_key?("filter")
+    
+    # Field
+    field = @source_klass.fields[@assoc.name]
+    return {} if !field || field.default_filter.blank?
+    
+    if field.default_filter.kind_of?(Proc)
+      filter = field.default_filter.call(@source_object)
+    else
+      filter = field.default_filter
+    end
+    filter || {}
+  end
+    
+  
+end

data/app/controllers/skyline/content_controller.rb

@@ -0,0 +1,201 @@
+require 'enumerator'
+
+class Skyline::ContentController < Skyline::Skyline2Controller
+  
+  layout "skyline/layouts/content"
+    
+  self.default_menu_item = :content_library   
+    
+  def index
+    if request.xhr?
+      render :update do |p|
+        p.replace_html "leftContentContentPanel", :partial => "types"
+      end
+    else
+      if first_element = (Skyline::Configuration.articles + Skyline::Configuration.content_classes).first
+		    if first_element.ancestors.include?(Skyline::Article)
+		      redirect_to skyline_articles_path(:type => first_element)
+		    else
+		      redirect_to object_url(first_element, :controller => "skyline/content", :action => "list") 
+	      end
+	    end
+    end
+  end
+    
+  def list
+    list_elements!
+  end
+  
+  def show
+    @element = stack.last
+    render :layout => "popup"
+  end
+  
+  def edit
+    @element = stack.last
+    
+    # Just redirect away from here like we would have done after a save.
+    return redirect_after(:save, @element) if params[:discard]
+    
+    if request.post?        
+      begin
+        @element.attributes = params[:element]
+        @element.from_version = params[:version].to_i
+      rescue ActiveRecord::RecordInvalid
+        @element.keep_version!
+        messages.now[:error] = l(:content,:flashes,:invalid_record)
+        return
+      end
+
+      if !@element.matching_versions?
+        # Failed version
+        show_url = object_url(@element,{:action => "show"})
+        messages.now[:notice] = l(:version_conflict, 
+                                :scope => [:content, :flashes],
+                                :current_version => @element.current_version, 
+                                :your_version => params[:version], 
+                                :current_author => @element.current_author,
+                                :show_link => "<a href='#{show_url}' onclick=\"popup('#{show_url}',800,800,'scrollbars=yes'); return false\">#{t(:see_changes_by, :scope => [:content, :edit], :current_author => @element.current_author)}</a>")
+      else
+        if @element.save
+          notifications[:success] = t(:successfully_saved, :scope => [:content, :flashes], :class => @element.class.singular_name)
+          redirect_after :save, @element
+        else
+          @element.keep_version!
+          messages.now[:error] = t(:validation_error, :scope => [:content, :flashes], :class => @element.class.singular_name)
+        end        
+      end
+    end    
+  end
+  
+  def delete
+    @element = stack.last
+    if request.post?
+      if @element.destroy
+        notifications[:success] = t(:successfully_deleted, :scope => [:content, :flashes], :class => @element.class.singular_name)
+      else
+        messages[:error] = t(:fail_deleted, :scope => [:content, :flashes], :class => @element.class.singular_name)
+      end
+    end
+    respond_to do |format|
+      format.html{ redirect_after(:delete) }
+      format.js do
+        render(:update){|p| p.redirect_to controller.send(:redirect_url_after,:delete) }
+      end
+    end
+  end
+  
+  def order
+    if request.xhr? && stack.klass.orderable? && params[:order]
+      ids = params[:order].split(",").collect{|s| s.to_i}
+      if ids.size > 1 && stack.klass.reorder(ids)
+        render(:update){|p| p.call "Application.addOddEven", "list"}
+      elsif ids.size <= 1
+        render :nothing => true        
+      else
+        list_elements!
+        render :update do |p|
+          p.replace "list-wrapper", presenter_for(@elements,stack.klass)
+        end
+      end
+    end  
+    redirect_to :action => "list", :types => stack.url_types(:up => 1, :collection => true) if !request.xhr?
+  end
+  
+  def create
+    @element = stack.last    
+    @element.attributes = params[:element]
+            
+    if request.post?
+      @element.relate_to(stack.parent) if stack.has_parent?
+      if @element.save
+        notifications[:success] = t(:successfully_saved, :scope => [:content,:flashes], :class => @element.class.singular_name)
+        redirect_after :save, @element
+      else
+        messages.now[:error] = t(:validation_error, :scope => [:content, :flashes], :class => @element.class.singular_name)
+      end
+    end
+  end
+  
+  def export
+    if stack.size > 1
+      exportfile = stack.parent_collection.send("export")
+    else
+      exportfile = stack.klass.send("export")
+    end
+    content_type = "application/octet-stream"
+    filename = "export_#{Time.now.strftime('%Y-%m-%d')}.xml"
+    send_data exportfile.to_s, :type => content_type, :filename => filename
+  end
+    
+  def import
+    if request.xhr?
+      if stack.size > 1
+        klass = stack.parent_collection.to_s
+      else
+        klass = stack.klass.to_s
+      end
+      
+      url = object_url(stack.current, {:action => "import"})
+          
+      render :update do |p|
+        p << dialog(t(:dialog_title, :scope => [:content, :import]), :partial => "import", :locals => {:url => url, :klass => klass},  :width => 400)
+      end
+    end  
+    
+    if request.post?
+      if params[:xml_file].present?
+        xml = params[:xml_file].read
+        errors = stack.klass.import(xml)
+        if errors === true || errors.empty?
+          notifications[:success] = t(:successfully_imported, :scope => [:content, :flashes])
+        else
+          notifications[:error] = t(:import_failed, :scope => [:content, :flashes], :errors => "<br /><br />\n <ul><li>#{errors.join("</li>\n<li>")}</li></ul>")
+        end          
+      else
+        notifications[:error] = t(:no_import_file_selected, :scope => [:content, :flashes])
+      end
+      redirect_to params[:return_to]
+    end  
+  end
+  
+  # Editor can only be called on editors and when params[:field] is set
+  verify :xhr => true, :only => [:field]
+  def field
+    @element = stack.last
+    @element.attributes = params[:element]
+    render :update do |p|
+      p.replace input_id("field","element",params[:field]), content_field(@element.class, 'element', @element.class.fields[params[:field].to_sym] || Field.new(:name => params[:field]), @element)
+    end
+  end
+  
+  def error
+  end  
+  
+  protected
+  
+  def redirect_after(method,object=nil)
+    redirect_to redirect_url_after(method,object)
+  end
+  
+  def redirect_url_after(method,object=nil)
+    if method == :save && params[:return_to] == "self"
+      types = stack.url_types
+      types << object.id if object && !stack.url_types.last.kind_of?(Fixnum)
+      {:action => "edit", :types => types}
+    else
+      params[:return_to] || {:action => "list", :types => stack.url_types(:up => 1, :collection => true)}
+    end    
+  end
+  
+  # Create the @elements array according to stack
+  def list_elements!
+    if stack.size > 1
+      @elements = stack.parent && stack.parent_collection.find_for_cms(:all, :filter => params[:filter])
+    else
+      @count = stack.last.class.count_for_cms(:all,:self_referential => false, :filter => params[:filter])
+      @elements = stack.last.class.paginate_for_cms :all, :page => params[:page], :per_page => 30, :self_referential => false, :filter => params[:filter]
+    end    
+  end  
+
+end