skylinecms 3.0.7

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

data/app/controllers/skyline/content_items_controller.rb

@@ -0,0 +1,14 @@
+class Skyline::ContentItemsController < Skyline::ApplicationController
+  def new
+    return unless request.xhr?
+    render :update do |page|
+      if params[:content_item_type].present?
+        @content_item_class = params[:content_item_type].constantize
+        page.replace_html("section-#{params[:guid]}-content-item-id", :partial => "content_item", :locals => {:guid => params[:guid], :sectionable => Skyline::Sections::ContentItemSection.new})
+      else
+        page.replace_html("section-#{params[:guid]}-content-item-id", :text => "")
+        page << "var myFx = new Fx.Scroll(\"contentEditPanel\").toBottom();"        
+      end
+    end
+  end
+end

data/app/controllers/skyline/content_sections_controller.rb

@@ -0,0 +1,15 @@
+class Skyline::ContentSectionsController < Skyline::ApplicationController
+  def new
+    return unless request.xhr?
+    render :update do |page|
+      if params[:taggable_type].present?
+        taggable = params[:taggable_type].constantize
+        @tags = taggable.available_tags
+        page.replace("section-#{params[:guid]}-tags", :partial => "tags", :locals => {:guid => params[:guid], :sectionable => taggable.new})
+      else
+        page.replace("section-#{params[:guid]}-tags", :text => "")
+        page << "var myFx = new Fx.Scroll(\"contentEditPanel\").toBottom();"        
+      end
+    end
+  end
+end

data/app/controllers/skyline/link_section_links_controller.rb

@@ -0,0 +1,14 @@
+class Skyline::LinkSectionLinksController < Skyline::ApplicationController
+  def new
+    return unless request.xhr?
+    render :update do |page|
+      link = Skyline::LinkSectionLink.new
+      link_guid = Guid.new
+      
+      fields_for params[:object_name], link do |sectionable_form|
+        page.insert_html(:bottom, "section-#{params[:guid]}-links", :partial => "form", :locals => {:sectionable_form => sectionable_form, :link => link, :guid => params[:guid], :link_guid => link_guid})
+        page << "linkSectionLinksSortable#{params[:guid].to_s.gsub("-","")}.addItem('link_section_#{link_guid}');"
+      end
+    end
+  end
+end

data/app/controllers/skyline/locales_controller.rb

@@ -0,0 +1,15 @@
+class Skyline::LocalesController < Skyline::ApplicationController
+
+  def show
+    locale = params[:id]
+    unless @locale = I18n.t("tinymce", :locale => (locale || I18n.locale))
+      render :nothing => true, :status => :not_found
+    end
+  end
+  
+  protected
+  
+  def protect?
+    false
+  end
+end

data/app/controllers/skyline/media_dirs_controller.rb

@@ -0,0 +1,56 @@
+class Skyline::MediaDirsController < Skyline::ApplicationController
+
+  layout "skyline/layouts/media"
+  
+  self.default_menu_item = :media_library
+  
+  authorize :create, :by => "media_dir_create"
+  authorize :edit, :update, :by => "media_dir_update"
+  authorize :destroy, :by => "media_dir_delete"
+  
+  def index
+    @media_dirs = Skyline::MediaDir.group_by_parent_id 
+  end
+  
+  def create
+    parent_id = params[:parent_id] || 0        
+    
+    @parent = Skyline::MediaDir.find_by_id(parent_id)
+    if @parent
+      @directory = @parent.subdirectories.build()
+    else
+      @directory = Skyline::MediaDir.new()
+    end
+    @directory.save
+        
+    render :update do |p|
+      p.replace("dirtree", 
+      		:partial => "skyline/media_dirs/index", 
+      		:locals => {:media_dirs => Skyline::MediaDir.group_by_parent_id, :selected_node => @directory})
+    end
+  end
+    
+  def update    
+    media_dir = Skyline::MediaDir.find(params[:id])
+    
+    if params[:skyline_media_dir]
+      media_dir.name = params[:skyline_media_dir][:name] if !params[:skyline_media_dir][:name].blank?
+      media_dir.parent_id = (params[:skyline_media_dir][:parent_id] == "0") ? nil : params[:skyline_media_dir][:parent_id]
+    
+      media_dir.save
+    end
+    
+    render :update do |p|
+      p.replace( "dirtree", :partial => "index", :locals => {:media_dirs => Skyline::MediaDir.group_by_parent_id, :selected_node => media_dir})
+    end
+  end
+  
+  def destroy
+    media_dir = Skyline::MediaDir.find(params[:id])    
+    media_dir.destroy
+    
+    render :update do |p|
+      p.replace( "dirtree", :partial => "index", :locals => {:media_dirs => Skyline::MediaDir.group_by_parent_id, :selected_node => media_dir.directory})
+    end
+  end
+end

data/app/controllers/skyline/media_files_controller.rb

@@ -0,0 +1,87 @@
+class Skyline::MediaFilesController < Skyline::ApplicationController    
+  layout "skyline/layouts/media"
+  # to avoid error 422 on authentication/session management
+  skip_before_filter :verify_authenticity_token, :only => :create
+  
+  self.default_menu_item = :media_library  
+      
+  authorize :create, :by => "media_file_create"
+  authorize :edit, :update, :by => "media_file_update"
+  authorize :destroy, :by => "media_file_delete"
+    
+  def index    
+    media_dir = Skyline::MediaDir.find(params[:media_dir_id])
+    selected_file = params[:selected_file_id].nil? || params[:selected_file_id] == "0" ? nil : Skyline::MediaFile.find(params[:selected_file_id])
+    
+    render :update do |p|
+    	if !params[:listonly]
+    	  p.replace_html("contentHeaderPanel", "<span class=\"content\">#{t(:files_in, :directory => media_dir.name, :scope => [:media_file,:index])}</span>")
+    		p.replace_html("uploadPanel", :partial => "new", :locals => {:media_dir => media_dir})
+    		p.replace_html("metaHeaderPanel", "<span class=\"content directory\">#{media_dir.name}</span>")      
+    		p.replace_html("metaBodyPanel", :partial => "skyline/media_dirs/edit", :locals => {:media_dir => media_dir})
+    	end
+    	    	
+    	p.replace_html("filelist", :partial => "index", :locals => {:media_dir => media_dir, :show_meta_data => params[:show_meta_data], :selected_file => selected_file})
+      
+    end
+  end
+  
+  def create
+    @parent = Skyline::MediaDir.find_by_id(params[:media_dir_id])
+    
+    @media_file = Skyline::MediaFile.new(:name => params[:Filename], :parent_id => params[:media_dir_id], :data => params[:Filedata])
+    @parent.files << @media_file if @parent
+    
+    if @media_file.save
+      render :json => {:result => "success"}
+    else
+      render :json => {:result => "failed"}
+    end
+    
+  end
+    
+  def edit
+    @tags = Skyline::MediaFile.available_tags   
+    media_file = Skyline::MediaFile.find(params[:id])
+    
+    render :update do |p|
+    	p.replace_html("metaHeaderPanel", :partial => "skyline/media_files/header", :locals => {:media_file => media_file} )      
+      p.replace_html("metaBodyPanel", :partial => "skyline/media_files/edit", :locals => {:media_file => media_file} )      
+    end
+  end
+  
+  def update
+    @tags = Skyline::MediaFile.available_tags   
+    media_file = Skyline::MediaFile.find(params[:id])
+    original_media_file = media_file.clone
+    media_file.attributes = params[:skyline_media_file]
+    
+    @saved = media_file.save
+    
+    render :update do |p|
+      if @saved
+        p.notification :success, t(:success, :scope => [:media_file,:update,:flashes])
+      else
+        p.message :failed, t(:failed, :scope => [:media_file,:update,:flashes])
+      end
+      if original_media_file.directory.id == media_file.directory.id
+        # just a normal edit of the media_file
+      	p.replace_html("filelist", :partial => "index", :locals => {:media_dir => media_file.directory, :selected_file => media_file})
+      else
+        # file was moved to another directory
+      	p.replace_html("filelist", :partial => "index", :locals => {:media_dir => original_media_file.directory})
+      	p.replace_html("metaHeaderPanel", "<span class=\"content folder\">#{original_media_file.directory.name}</span>")      
+        p.replace_html("metaBodyPanel", :partial => "skyline/media_dirs/edit", :locals => {:media_dir => original_media_file.directory})
+      end    
+    end    
+  end
+
+  
+  def destroy
+    media_file = Skyline::MediaFile.find(params[:id])
+    media_file.destroy
+    
+    redirect_to :action=>:index, :media_dir_id=> params[:media_dir_id]
+  end
+      
+end