cardboard_cms 0.1.4

data/app/assets/stylesheets/cardboard/admin.css.scss

@@ -0,0 +1,63 @@
+//Only for Cardboard Admin Area
+
+@import "variables";
+
+@import "cardboard/framework";
+@import "cardboard/rich_text";
+@import "font-awesome";
+@import "select2";
+
+@import "main_topbar";
+@import "main_sidebar";
+@import "content";
+@import "content_sidebar";
+@import "resources";
+
+html, body{
+  min-height: 100%;
+  height:100%;
+}
+body{
+  font-family: $font;
+  -webkit-font-smoothing: antialiased;
+  font-weight: 300;
+  overflow-x: hidden;
+}
+
+#main_content{
+  min-height:100%;
+  overflow: hidden;
+  width: 100%;
+}
+#main_sidebar, #content_sidebar{
+  margin-bottom: -9999px; 
+  padding-bottom: 9999px;
+  float:left;
+}
+
+.center{
+  text-align: center;
+}
+
+.nested-fields{
+  margin-bottom: 20px;
+  padding: 20px;
+  background: #EFEFEF;
+}
+
+.header{
+  margin-top: 20px;
+  margin-bottom: 60px;
+
+  h1,h2,h3,h4{
+    float: left;
+    margin-top: 5px;
+    margin: 0;
+    line-height: inherit;
+  }
+}
+
+.icon-margin{
+  margin-right: 4px;
+}
+

data/app/controllers/cardboard/application_controller.rb

@@ -0,0 +1,45 @@
+module Cardboard
+  class ApplicationController < ActionController::Base
+
+    before_filter do #:authenticate_admin_user!
+      self.send(Cardboard.application.authentication_method)
+    end
+    before_filter :for_gon
+    protect_from_forgery
+    
+  private
+
+    def cardboard_user_can_manage?(resource)
+      if cardboard_user.respond_to?(:can_manage_cardboard?)
+        cardboard_user.can_manage_cardboard?(resource.to_sym)
+      else
+        true
+      end
+    end
+    helper_method :cardboard_user_can_manage?
+
+    # def active_resource_controller?
+    #   for c in Cardboard.resource_controllers
+    #     return true if current_admin_user.can_manage_cardboard?(c.controller_name.to_sym)
+    #   end
+    #   false
+    # end
+    # helper_method :active_resource_controller?
+
+    def cardboard_user
+      @cardboard_user ||= self.send(Cardboard.application.current_admin_user_method)
+    end
+    helper_method :cardboard_user
+
+    def for_gon
+      gon.rich_text_links_modal = render_to_string(:partial => "cardboard/rich_editor/links_modal", :layout => false)
+    end
+
+    def strong_params
+      return params if request.get? || params.blank? || params.class.to_s != "ActionController::Parameters"
+      # #remove once conversion to strong params is complete
+      params.permit!
+    end
+
+  end
+end

data/app/controllers/cardboard/dashboard_controller.rb

@@ -0,0 +1,9 @@
+require_dependency "cardboard/application_controller"
+
+module Cardboard
+  class DashboardController < ApplicationController
+    def index
+      @page = Cardboard::Page.root
+    end
+  end
+end

data/app/controllers/cardboard/my_account_controller.rb

@@ -0,0 +1,27 @@
+require_dependency "cardboard/application_controller"
+
+module Cardboard
+  class MyAccountController < ApplicationController
+
+    def edit
+      @user =  cardboard_user
+    end
+
+    def update
+      admin_user_method = Cardboard.user_class.to_s.underscore.gsub(/\//,'_').to_sym
+      @user =  cardboard_user
+      if params[admin_user_method][:password].blank?
+        params[admin_user_method].delete("password")
+        params[admin_user_method].delete("password_confirmation")
+      end
+
+      if @user.update_attributes(strong_params[admin_user_method])
+        request.env['warden'].session_serializer.store(@user, admin_user_method)
+        flash[:success] = "User information updated successfully"
+        redirect_to my_account_path
+      else
+        render :edit
+      end
+    end
+  end
+end

data/app/controllers/cardboard/pages_controller.rb

@@ -0,0 +1,34 @@
+require_dependency "cardboard/application_controller"
+
+module Cardboard
+  class PagesController < ApplicationController
+    before_filter :check_ability
+
+    def edit
+      @page = Cardboard::Page.find(params[:id])
+    end
+
+    def update
+      @page = Cardboard::Page.find(params[:id])
+
+      if @page.update_attributes(strong_params[:page])
+        flash[:success] = "Your page was updated successfully"
+        redirect_to edit_page_path(@page)
+      else
+        render :edit
+      end
+    end
+
+    def sort
+      Page.find(params[:id]).update_attribute(:position_position, params[:index])
+      render nothing: true
+    end
+
+  private
+    def check_ability
+      unless cardboard_user_can_manage?(:pages)
+        render :text => "You are not authorized to edit pages.", :status => :unauthorized 
+      end
+    end
+  end
+end

data/app/controllers/cardboard/resource_controller.rb

@@ -0,0 +1,61 @@
+require_dependency "cardboard/application_controller"
+
+class Cardboard::ResourceController <  Cardboard::ApplicationController
+  inherit_resources
+
+  defaults :route_prefix => 'cardboard'
+
+  before_filter :check_ability
+
+  def collection
+    @q ||= end_of_association_chain.search(params[:q])
+
+    @q.sorts = self.class.default_order if @q.sorts.empty?
+    get_collection_ivar || begin
+      set_collection_ivar((@q.respond_to?(:scoped) ? @q.scoped.result : @q.result).page(params[:page]))
+    end
+  end
+
+private
+
+  def self.default_order(val = nil)
+    @default_order ||= 'updated_at desc'
+    return @default_order if val.nil?
+    @default_order = val.to_s
+  end
+
+  def self.menu(hash = nil)
+    @menu = {priority: 999, label: self.controller_name.to_s.titleize} if @menu.nil? #menu might be false, so no ||=
+    return @menu if hash.nil?
+    @menu = hash.is_a?(Hash) ? @menu.merge(hash) : hash
+  end
+
+  def check_ability
+    unless cardboard_user_can_manage?(resource_collection_name)
+      render :text => "You are not authorized to access this resource.", :status => :unauthorized 
+    end
+  end
+
+  def permitted_strong_parameters
+    :all   # bypass strong_parameters (unless overwritten in controller)
+  end
+
+  def resource_params
+    return [] if request.get? || permitted_strong_parameters.nil?
+    return super if params && params.class.to_s != "ActionController::Parameters"
+
+    if permitted_strong_parameters == :all
+      [ params.require(resource_instance_name.to_sym).permit! ]
+    else
+      [ params.require(resource_instance_name.to_sym).permit(*permitted_strong_parameters)]
+    end
+  end
+
+  def self.inherited(base)
+    # https://github.com/josevalim/inherited_resources/issues/256
+    base.resource_class = nil
+    super(base)
+  end
+
+end
+

data/app/controllers/cardboard/settings_controller.rb

@@ -0,0 +1,28 @@
+require_dependency "cardboard/application_controller"
+
+module Cardboard
+  class SettingsController < ApplicationController
+    before_filter :check_ability
+
+    def index
+      @setting = Setting.first
+    end
+
+    def update
+      @setting = params[:id].present? ? Setting.find(params[:id]) : Setting.first
+      if @setting.update_attributes(strong_params[:setting])
+        flash[:success] = "Settings updated successfully"
+        redirect_to settings_path
+      else
+        render :index
+      end
+    end
+
+  private
+    def check_ability
+      unless cardboard_user_can_manage?(:settings)
+        render :text => "You are not authorized to edit settings.", :status => :unauthorized 
+      end
+    end
+  end
+end

data/app/controllers/cardboard/super_user_controller.rb

@@ -0,0 +1,8 @@
+require_dependency "cardboard/application_controller"
+
+module Cardboard
+  class SuperUserController < ApplicationController
+    def index
+    end
+  end
+end

data/app/controllers/pages_controller.rb

@@ -0,0 +1,29 @@
+class PagesController < ApplicationController
+  def show
+
+    raise ActionController::RoutingError.new("Page Not Found") if current_page.nil?
+
+    if current_page.using_slug_backup?
+      redirect_to current_page.url, status: :moved_permanently
+    else
+      # call controller hook
+      self.send(current_page.identifier) if self.respond_to? current_page.identifier
+
+      render "cardboard/pages/show", layout: @layout || "layouts/application"
+    end
+  end
+
+private
+
+  # def edit_link
+  #   cardboard.edit_page_path(@page)
+  # end
+  # helper_method :edit_link
+
+  def current_page
+    @page ||= Cardboard::Page.find_by_url(params[:id]) || 
+              Cardboard::Page.root || 
+              raise(ActionController::RoutingError.new("No root page, make sure to run `rake cardboard:seed`"))
+  end
+
+end

data/app/decorators/controllers/application_controller_decorator.rb

@@ -0,0 +1,9 @@
+ApplicationController.class_eval do
+  # helper Cardboard::Engine.helpers
+  # helper Cardboard::PublicHelper
+
+  def current_page
+    nil #this will be overwritten only for cardboard pages
+  end
+  helper_method :current_page
+end

data/app/decorators/lib/cardboard/user_class_decorator.rb

@@ -0,0 +1,32 @@
+if Cardboard.user_class
+  Cardboard.user_class.class_eval do
+
+    # has_many :cardboard_blog_posts, :class_name => "CardboardBlog::Post", :foreign_key => "user_id"
+
+    # User class should overwrite these methods with his own
+    # ['pages', 'settings'].each do |m|
+    #   method = "can_manage_cardboard_#{m}?"
+    #   unless method_defined?(method.to_sym)
+    #     define_method method do
+    #       true
+    #     end
+    #   end
+    # end
+    unless method_defined?(:can_manage_cardboard_pages?)
+      def can_manage_cardboard_pages?
+        true
+      end
+    end
+    unless method_defined?(:can_manage_cardboard_settings?)
+      def can_manage_cardboard_settings?
+        true
+      end
+    end
+    unless method_defined?(:can_manage_cardboard_resource?)
+      def can_manage_cardboard_resource?(resource)
+        true
+      end
+    end
+
+  end
+end

data/app/helpers/cardboard/application_helper.rb

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

data/app/helpers/cardboard/public_helper.rb

@@ -0,0 +1,53 @@
+module Cardboard
+  module PublicHelper
+
+    # Example: 
+    #  link_to_page 123, class: "btn" do |page|
+    #    "hello #{page.title}"
+    #  end
+    #
+    # link_to_page "home"
+    #   
+    def link_to_page(page_id, html_options={}, &block)  
+      page = if page_id.is_a?(Integer)
+        Cardboard::Page.where(id: page_id).first 
+      else #if page_id.is_a? String
+        Cardboard::Page.where(identifier: page_id).first 
+      end
+      return nil if page.blank?
+
+      title = if block_given?
+        capture(page, &block)
+      else
+        page.title
+      end
+      link_to(title, page.url, html_options)
+    end
+
+    # Example 1:
+    # = nested_pages Cardboard::Page.arrange do |page, subpages|
+    #   .indent
+    #     = link_to(page.title, page.url) if page.in_menu?
+    #     = subpages
+    # end
+    # Example 2:
+    # %ul
+    #   = nested_pages do |page, subpages|
+    #     %li
+    #       = link_to page.title, edit_page_path(page)
+    #       = content_tag(:ul, subpages) if subpages.present?
+    def nested_pages(page = nil, &block)
+      raise ArgumentError, "Missing block" unless block_given?
+      inner_nested_pages(Cardboard::Page.arrange(page), &block).try(:html_safe)
+    end
+
+    private
+
+    def inner_nested_pages(pages, &block)
+      return unless pages
+      pages.map do |page, sub_pages|
+        capture(page, sub_pages.present? ? inner_nested_pages(sub_pages, &block) : nil, &block)
+      end.join.html_safe
+    end
+  end
+end

data/app/helpers/cardboard/resource_helper.rb

@@ -0,0 +1,80 @@
+module Cardboard
+  module ResourceHelper
+
+    def l(val, options = {})
+      return nil if val.blank?
+      val = val.to_date if val.is_a? String
+      super(val, options)
+    end
+
+    # ActionView::Helpers::FormBuilder.class_eval do
+    #   def date_field(conf,opts = {})
+    #     options = opts.dup
+    #     options[:class] = "#{options[:class]} datepicker" 
+    #     text_field(conf, options)
+    #   end
+    # end
+
+    # .item
+    #     = link_to dashboard_path, id:"nav_dashboard_link" do
+    #       i.icon-dashboard
+    #       span Dashboard
+    def main_sidebar_nav_link(text, link, options={})
+      options[:class] = "#{options[:class]} active" if request.path["#{link}/"] || request.path == link
+      out = content_tag(:div, class:"item") do
+        link_to("<span>#{text}</span>".html_safe, link, options)
+      end
+      out.html_safe
+    end
+
+  #    "q"=>
+  # {"id_lt"=>"1",
+  #  "id_gteq"=>"1",
+  #  "color_cont"=>"1",
+  #  "flavor_cont"=>"",
+  #  "size_lt"=>"",
+  #  "size_gteq"=>"",
+  #  "created_at_lt"=>"",
+  #  "created_at_gteq"=>"",
+  #  "updated_at_lt"=>"",
+  #  "updated_at_gteq"=>""},
+
+    def cardboard_filters(klass, main_element, options={})
+      raise "First argument needs to be a class" unless klass.is_a? Class
+
+      options[:new_button] = Hash.new if options[:new_button].nil? #careful for false
+
+      if main_element
+        # valid main elements:
+        # false (don't show the search form)
+        # :column_name
+        # "column_name_cont"
+        main_element = main_element.to_s
+
+        case type = klass.columns_hash[main_element].try(:type)
+        when :string, :text
+          main_element = "#{main_element}_cont"
+        when :integer, :decimal, :float
+          main_element = "#{main_element}_eq"
+        when :date, :datetime, :timestamp, :time, :binary, :boolean, :references
+          raise "Main search element cannot be of type #{type}. Use a custom ransack form."
+        else
+          main_element = "#{main_element}_cont" unless %w[cont eq lt gt gteq lteq matches in cont_any start end].include?(main_element.split("_").last)
+        end
+      end
+      
+      render "cardboard/resources/search_helper", klass: klass.to_s.demodulize.underscore, options: options, main_element: main_element #,elements: elements
+    end
+
+
+    def ransack_options 
+      { 
+        string: [["Contains","cont"],["Does not contain","not_cont"], ["Starts with","start"], ["Ends with","end"]], 
+        datetime: [["On","eq"],["Before","lt"],["After","gt"]],
+        integer: [["Greater than","gt"],["Equals","eq"],["Less than","lt"]],
+        boolean: [["is False","blank"],["is True","true"]]
+      }
+    end
+
+  end
+end