goldencobra 1.4.27 → 2.3.3

data/app/assets/stylesheets/goldencobra/gc-grid.scss

@@ -0,0 +1,5 @@
+.index_as_grid #collection_selection_toggle_explaination { display: none; }
+
+.index_grid {
+  td { vertical-align: middle; }
+}

data/app/assets/stylesheets/goldencobra/gc-header.scss

@@ -0,0 +1,47 @@
+#header {
+  background: $dark-color;
+
+  h1 {
+    width: 100px;
+    height: 80px;
+    background: url("/assets/goldencobra/cobra.png") no-repeat scroll center top / auto auto rgba(0, 0, 0, 0);
+    text-indent: -9999px;
+    position: absolute;
+    left: 0;
+    z-index: 5000;
+    padding-top: 0 !important;
+    margin-right: 0;
+  }
+
+  ul#tabs.header-item { left: 160px; }
+  ul.tabs > li a { border-radius: 4px; }
+
+  ul.tabs > li.has_nested:hover > a {
+    border-color: #fff;
+    border-top-right-radius: 4px;
+    border-top-left-radius: 4px;
+  }
+
+  ul.tabs > li ul {
+    background: $dark-color;
+    border-top-right-radius: 4px;
+    border-top-left-radius: 0;
+    border-bottom-right-radius: 4px;
+    border-bottom-left-radius: 4px;
+    border-left: 1px solid #fff;
+    border-bottom: 1px solid #fff;
+    border-right: 1px solid #fff;
+  }
+
+  ul.tabs > li.has_nested.current > a,
+  ul.tabs > li.has_nested:hover > a,
+  ul.tabs > li:hover > a,
+  ul.tabs > li.current > a {
+    color: $dark-color;
+    background-color: #fff;
+    text-shadow: none;
+  }
+
+  ul.tabs > li ul li.current a { color: #fff; }
+  #utility_nav a:hover { color: $dark-color; }
+}

data/app/assets/stylesheets/goldencobra/gc-overview-tree.scss

@@ -0,0 +1,145 @@
+//TODO styling: http://odyniec.net/articles/turning-lists-into-trees/
+
+#active_admin_content ul.item_tree {
+  background: url(vline.png) repeat-y;
+  margin: 5px 0;
+  padding: 0;
+
+  a.member_link.edit_link{
+    text-decoration: none;
+  }
+
+  ul {
+    margin: 0;
+    margin-left: 10px;
+    padding: 0;
+    background: url(vline.png) repeat-y;
+  }
+
+  li {
+    margin: 0;
+    padding: 0 12px;
+    list-style: none;
+    background: url(node.png) no-repeat;
+
+    li { padding-right: 0;}
+  }
+
+  li:last-child { background: #fff url(lastnode.png) no-repeat; }
+
+  div.tree_item_options {
+    display: none;
+    overflow: hidden;
+    float: right;
+  }
+
+  div.tree_item_options > div {
+    display: inline-block;
+    padding-bottom: 10px;
+  }
+
+  div.tree_item_title {
+    display: inline-block;
+    font-size: 1.4em
+  }
+
+  div.tree_item_value {
+    font-weight: bold;
+    margin-left: 15px;
+  }
+
+  div.tree_item:hover { 
+    color: #29c172; 
+    a { color: #29c172; }
+  }
+  div.tree_item:hover > .tree_item_options { display: inline-block; }
+}
+
+
+body.active_admin .sidebar_section > div div.overview-sidebar {
+  margin: 0 0 0 -30px;
+  padding: 0 0 0 0px;
+
+  ul {
+    list-style: none;
+    margin: 0 0 0 0;
+    padding: 0;
+
+    li {
+      margin: 0 0 0 0;
+      padding: 0 0 0 0;
+
+      div.item {
+        width: 92%;
+        padding: 0 0 0 8%;
+
+        div.folder {
+          background: url("/assets/goldencobra/tree.png") no-repeat -6px;
+          height: 12px;
+          width: 12px;
+          display: inline-block;
+          cursor: pointer;
+        }
+
+        div.last_folder {
+          background: url("/assets/goldencobra/tree.png") no-repeat -9px;
+          height: 12px;
+          width: 12px;
+          display: inline-block;
+        }
+
+        div.secured {
+          width: 9px;
+          height: 9px;
+          background: url("/assets/goldencobra/icons/16/locked.png");
+          display: inline-block;
+          @include background-size(9px);
+        }
+
+        div.title {
+          display: inline-block;
+          overflow: hidden;
+          width: 200px;
+          height: 16px;
+          line-height: 16px;
+
+          ul { display: none; }
+
+          a {
+            text-decoration: none;
+            cursor: pointer;
+          }
+        }
+
+        div.title ~ ul li div.title { width: 175px; }
+
+        div.title ~ ul li div.title ~ ul li div.title {width: 145px;}
+        div.title ~ ul li div.title ~ ul li div.title ~ ul li div.title { width: 130px;}
+
+        div.options {
+          display: inline-block;
+          float: right;
+
+           a {
+            display: inline-block;
+            text-indent: -9999px;
+          }
+
+          a.new_link,
+          a.edit_link {
+            width: 16px;
+            height: 16px;
+            @include background-size(14px);
+          }
+
+          a.new_link { background: url("/assets/goldencobra/icons/16/plus.png"); }
+
+          a.edit_link {
+            background: url("/assets/goldencobra/icons/16/compose-3.png");
+            margin-right: 3px;
+          }
+        }
+      }
+    }
+  }
+}

data/app/assets/stylesheets/goldencobra/gc-settings.scss

@@ -0,0 +1,52 @@
+#goldencobra_settings_wrapper {
+  .settings_category {
+    padding-left: 10px;
+    padding-top: 10px;
+    padding-right: 10px;
+    border: 1px solid grey;
+    border-radius: 5px 5px 5px 5px;
+    background-color: rgb(244, 244, 244);
+    width: 40%;
+    margin: 10px;
+    float: left;
+
+    .settings_level {
+      overflow: hidden;
+      clear: both;
+
+      .settings_group_title {
+        padding: 5px;
+        font-weight: bold;
+        font-size: 1.1em;
+        cursor: pointer;
+      }
+
+      .settings_sub_group {
+        display: none;
+      }
+
+      .setting_key_value {
+        color: rgb(50, 53, 55);
+        overflow: hidden;
+        margin-left: 15px;
+        margin-right: 10px;
+        clear: both;
+        padding: 2px;
+
+        &:hover{
+          @include background(linear-gradient(left, rgb(244, 244, 244) 0%, #E6E6E6 50%));
+        }
+
+        .setting_title {
+          float: left;
+          width: 60%;
+        }
+
+        .setting_value {
+          width: 40%;
+          float: left;
+        }
+      }
+    }
+  }
+}

data/app/assets/stylesheets/goldencobra/ikusei_active_admin.scss

@@ -1,21 +1,12 @@
-@import "/compass";
-@import "/compass/css3";
-
-
 $light_color: #EFC;
 $dark_color: #800080;
 
 #header {
 	text-shadow: $dark_color 0 1px 0;
 	@include background(linear-gradient($light_color, $dark_color));
-	
-	h1 {
-		color: $dark_color;
-	}
 
-	ul#tabs > li a {
-		color: darken($dark_color, 15%);
-	}
+	h1 { color: $dark_color; }
+	ul#tabs > li a { color: darken($dark_color, 15%);	}
 
 	ul#tabs > li.current a {
 		background-color: $dark_color;
@@ -26,47 +17,38 @@ $dark_color: #800080;
 		background-color: $dark_color;
 		color: $light_color;
 	}
-	
+
 	ul#tabs > li.has_nested:hover a {
 		background-color: $dark_color;
 		color: $light_color;
 		border-bottom: 5px solid $dark_color;
 	}
-	
-	p#utility_nav {
-		color: darken($dark_color, 15%);
-	}
+
+	p#utility_nav { color: darken($dark_color, 15%); }
 
 	a, a:link {
 		color: $light_color;
 		display: block;
 	}
 
-	ul#tabs > li ul {
-		background-color: $dark_color;
-	}
+	ul#tabs > li ul { background-color: $dark_color; }
 }
 
 #title_bar {
 	@include background(linear-gradient(lighten($light_color, 50%), $light_color));
-	
-	h2 {
-		color: $dark_color;
-	}
+
+	h2 { color: $dark_color; }
 }
 
-.breadcrumb a, .breadcrumb a:link {
+.breadcrumb a,
+.breadcrumb a:link {
 	color: lighten($dark_color, 25%);
 }
 
-div#title_bar.title_bar div#titlebar_left span.breadcrumb{
-  margin-left: 100px;
-}
+div#title_bar.title_bar div#titlebar_left span.breadcrumb { margin-left: 100px; }
 
-table.dashboard .dashboard_section{
-	background-color:$light_color;
-	
-	h3 
-		@include background(linear-gradient($light_color, lighten($dark_color,20%)));	
-	}
-}
+table.dashboard .dashboard_section {
+	background-color: $light_color;
+
+	h3 { @include background(linear-gradient($light_color, lighten($dark_color,20%))); }
+}

data/app/controllers/goldencobra/api/v1/tokens_controller.rb

@@ -30,6 +30,16 @@ module Goldencobra
             render status: 401, json: { error: "Invalid email or password." }
           end
         end
+
+        def show
+          unless current_user.present?
+            render status: 400, json: { error: 'You are not logged in' }
+            return
+          end
+          current_user.ensure_authentication_token!
+          render status: 200, json: { token: current_user.authentication_token }
+        end
+
       end
     end
   end

data/app/controllers/goldencobra/api/v2/articles_controller.rb

@@ -1,220 +1,290 @@
-# encoding: utf-8
-
 module Goldencobra
   module Api
     module V2
       class ArticlesController < ActionController::Base
         skip_before_filter :verify_authenticity_token
+        before_action :get_article,            only: [:show, :breadcrumb]
+        before_action :find_article,           only: [:update]
+        before_action :check_for_current_user, only: [:create, :update]
+        before_action :check_for_article,      only: [:create, :update]
+        before_action :check_for_referee,      only: [:create, :update]
 
         respond_to :json
 
         # /api/v2/articles/search[.json]
-        # ---------------------------------------------------------------------------------------
+        # ----------------------------------------------------------------------
         def search
-
           # Check if we have an argument.
           unless params[:q]
-            render status: 200, json: { :status => 200 }
+            render status: 200, json: { status: 200 }
             return
           end
 
           # Check if the query string contains something.
           if params[:q].length == 0
-            render status: 200, json: { :status => 200 }
+            render status: 200, json: { status: 200 }
           else
             # Search and return the result array.
             render status: 200, json: Goldencobra::Article.simple_search(
-                ActionController::Base.helpers.sanitize(params[:q])
+              ActionController::Base.helpers.sanitize(params[:q])
             ).to_json
           end
         end
 
 
         # /api/v2/articles[.json]
-        # 
-        # @return [json] Liefert Alle Artikel :id,:title, :ancestry
-        # map{|c| [c.parent_path, c.id]}
+        #
+        # @return [json] Liefert Alle Artikel :id, :title, :parent_path
+        # map{ |c| [c.parent_path, c.id] }
         def index
-          render status: 200, json: Goldencobra::Article.select([:id,:title, :ancestry]).sort{ |a, b| 
-              a[0] <=> b[0]
-            }.map{ |a| 
-              a.as_json(:only => [:id, :title], :methods => [:parent_path])
-            }
+          if params[:article_ids].present?
+            index_with_ids
+          else
+            @articles = cached_articles
+
+            respond_to do |format|
+              format.json do
+                render json: Oj.dump(
+                  { articles: articles_as_json },
+                  mode: :compat
+                )
+              end
+              # Returns all publicly visible, active Articles
+              format.xml do
+                @articles = Goldencobra::Article.
+                            new.
+                            filter_with_permissions(
+                              Goldencobra::Article.active,
+                              nil
+                            )
+              end
+            end
+          end
         end
 
-
-        # /api/v2/articles/create[.json]
-        # ---------------------------------------------------------------------------------------
-        def create
-          # Check if a user is currently logged in.
-          unless current_user
-            render status: 403, json: { :status => 403 }
-            return
+        # /api/v2/articles/:url[.json]
+        #
+        # @param methods [String] "beliebe Attribute des Artikels im JSON
+        #                         einfuegen"
+        #
+        # @return [json] Liefert Artikel mit einer bestimmten URL
+        #                Im JSON Response befinden sich entweder alle Attribute,
+        #                oder nur die mit params[:methods] definierten
+        def show
+          respond_to do |format|
+            format.json do
+              if params[:methods].present?
+                render json: Oj.dump(
+                  @article.as_json,
+                  serializer: Goldencobra::ArticleCustomSerializer,
+                  scope: params[:methods]
+                )
+              else
+                render json: Oj.dump(@article.as_json)
+              end
+            end
           end
+        end
 
-          # Check if we do have an article passed by the parameters.
-          unless params[:article]
-            render status: 400, json: { :status => 400, :error => "article data missing" }
-            return
+        # /api/v2/articles/index_with_id[.json]
+        #
+        # @param methods [String] "beliebe Attribute des Artikels im JSON
+        #                         einfuegen"
+        #
+        # @return [json] liefert für Artikel mit einer bestimmten URL
+        #                Kinderartikel zurück, die wiederum per IDs angefragt
+        #                wurden
+        #
+        #                im JSON Response befinden sich entweder alle Attribute,
+        #                oder nur die mit params[:methods] definierten
+        def index_with_ids
+          article_ids = params[:article_ids]
+          cache_key ||= ["indexarticles", article_ids]
+
+          articles = Rails.cache.fetch(cache_key) do
+            Goldencobra::Article.where("id IN (?)", article_ids)
           end
-
-          #check if an external referee is passed by the parameters
-          unless params[:referee_id]
-            render status: 400, json: { :status => 400, :error => "referee_id missing"  }
-            return
+          respond_to do |format|
+            format.json do
+              if params[:methods].present?
+                render json: Oj.dump(
+                  articles,
+                  each_serializer: Goldencobra::ArticleCustomSerializer,
+                  scope: params[:methods]
+                )
+              else
+                render json: Oj.dump(articles)
+              end
+            end
           end
+        end
 
-          #check if Article already exists by comparing external referee and current user of caller
-          existing_articles = Goldencobra::Article.where(:creator_id => current_user.id, :external_referee_id => params[:referee_id])
+        # /api/v2/articles/create[.json]
+        # ----------------------------------------------------------------------
+        def create
           if existing_articles.any?
-            render status: 423, json: { :status => 423, :error => "article already exists", :id => existing_articles.first.id  }
-            return
+            render status: 423, json: {
+              status: 423,
+              error: "article already exists",
+              id: existing_articles.first.id
+            } and return
           end
 
           # Try to save the article
           response = create_article(params[:article])
           if response.id.present?
-            render status: 200, json: { :status => 200, :id => response.id }
+            render status: 200, json: { status: 200, id: response.id }
           else
-            render status: 500, json: { :status => 500, :error => response.errors, :id => nil }
+            render status: 500, json: {
+              status: 500,
+              error: response.errors,
+              id: nil
+            }
           end
-
         end
 
 
         def update
-          unless current_user
-            render status: 403, json: { :status => 403 }
-            return
-          end
-
-          # Check if we do have an article passed by the parameters.
-          unless params[:article]
-            render status: 400, json: { :status => 400, :error => "article data missing" }
-            return
+          if @article.update_attributes(params[:article])
+            render status: 200, json: { status: 200, id: @article.id }
+            # Erst render Ergebnis dann den Rest machen
+            create_images(@article, params[:images])
+          else
+            render_error(response.errors, 500)
           end
+        end
 
-          #check if an external referee is passed by the parameters
-          unless params[:referee_id]
-            render status: 400, json: { :status => 400, :error => "referee_id missing"  }
-            return
+        def breadcrumb
+          breadcrumb = []
+          @article.path.each do |art|
+            breadcrumb << {
+              title: art.breadcrumb_name,
+              url: art.public_url
+            }
           end
-
-          #check if Article already exists by comparing external referee and current user of caller
-          existing_articles = Goldencobra::Article.where(:creator_id => current_user.id, :external_referee_id => params[:referee_id])
-          if existing_articles.blank?
-            render status: 423, json: { :status => 423, :error => "article not found", :id => nil  }
-            return
-          end
-
-          # Try to save the article
-          response = update_article(params[:article])
-          if response.id.present?
-            render status: 200, json: { :status => 200, :id => response.id }
-
-            #Erst render ergebnis dann den rest machen
-            if params[:images].present?
-              params[:images].each do |key,value|
-                existing_images = Goldencobra::Upload.where(:image_remote_url => value[:image][:image_url])
-                if existing_images.blank?
-                  img = Goldencobra::Upload.create(value[:image])
-                else
-                  img = existing_images.first
-                end
-                image_position = Goldencobra::Setting.for_key("goldencobra.article.image_positions").to_s.split(",").map(&:strip).first
-                existing_articles.first.article_images.create(:image => img, :position => image_position)
-              end
-            end
-
-          else
-            render status: 500, json: { :status => 500, :error => response.errors, :id => nil }
+          respond_to do |format|
+            format.json { render json: breadcrumb.to_json }
           end
         end
 
 
-        protected
 
-        # Creates an article from the given article array.
-        # ---------------------------------------------------------------------------------------
-        def create_article(article_param)
+        private
 
-          # Input validation
-          return nil unless article_param
-          return nil unless params[:article]
-          return nil unless current_user
-          return nil unless params[:referee_id]
+        def find_article
+          attrs = {
+            creator_id: current_user.id,
+            external_referee_id: params[:referee_id]
+          }.delete_if { |_k, v| v.blank? }
+          @article = Goldencobra::Article.where(attrs).first
 
-          # Create a new article
-          new_article = Goldencobra::Article.new(params[:article])
-          new_article.creator_id = current_user.id
+          render_error("article not found", 423) and return unless @article
+        end
 
-          if params[:article][:article_type]
-            new_article.article_type = params[:article][:article_type]
-          else
-            new_article.article_type = 'Default Show'
-          end
+        def setup_params(old_params)
+          old_params.merge(
+            creator_id: current_user.id,
+            article_type: old_params.fetch(:article_type, "Default Show"),
+            external_referee_id: params[:referee_id],
+            external_referee_ip: request.env["REMOTE_ADDR"]
+          ).merge(author.present? ? { author: author } : {})
+        end
 
+        def author
           if params[:author].present? && params[:author][:lastname].present?
-            author = Goldencobra::Author.find_or_create_by_lastname(params[:author][:lastname])
-            new_article.author = author
-          end
-
-          if params[:images].present?
-            params[:images].each do |i|
-              img = Goldencobra::Upload.create(i[:image])
-              article.images << img
-            end
+            Goldencobra::Author.find_or_create_by_lastname(
+              params[:author][:lastname]
+            )
           end
+        end
 
+        def create_article(article_params)
+          new_params = setup_params(article_params)
+          new_article = Goldencobra::Article.new(new_params)
+          # TODO: Does not work atm.
+          # article_params.each do |i|
+          #   new_article.images << Goldencobra::Upload.create(i[:image])
+          # end
+          new_article.save
+          new_article
+        end
 
-          #Set externel Referee
-          new_article.external_referee_id = params[:referee_id]
-          new_article.external_referee_ip = request.env['REMOTE_ADDR']
+        def check_for_current_user
+          render_error(nil, 403) and return unless current_user
+        end
 
-          # Try to save the article
-          new_article.save
-          return new_article
+        def check_for_article
+          render_error("article data missing") and return unless params[:article]
         end
 
+        def check_for_referee
+          render_error("referee_id missing") and return unless params[:referee_id]
+        end
 
-        def update_article(article_param)
-          # Input validation
-          return nil unless article_param
-          return nil unless params[:article]
-          return nil unless current_user
-          return nil unless params[:referee_id]
+        def render_error(message, status = 400)
+          if message
+            render status: status, json: { status: status, error: message }
+          else
+            render status: status, json: { status: status }
+          end
+        end
 
-          # Get existing article
-          article = Goldencobra::Article.where(:creator_id => current_user.id).find_by_external_referee_id(params[:referee_id])
+        def existing_articles
+          attrs = {
+            creator_id: current_user.id,
+            external_referee_id: params[:referee_id]
+          }.delete_if { |_k, v| v.blank? }
+          Goldencobra::Article.where(attrs)
+        end
 
-          if params[:author].present? && params[:author][:lastname].present?
-            author = Goldencobra::Author.find_or_create_by_lastname(params[:author][:lastname])
-            article.author = author
-            article.save
-          end
-
-          # if params[:images].present?
-          #   params[:images].each do |key,value|
-          #     existing_images = Goldencobra::Upload.where(:image_remote_url => value[:image][:image_url])
-          #     if existing_images.blank?
-          #       img = Goldencobra::Upload.create(value[:image])
-          #     else
-          #       img = existing_images.first
-          #     end
-          #     image_position = Goldencobra::Setting.for_key("goldencobra.article.image_positions").to_s.split(",").map(&:strip).first
-          #     article.article_images.create(:image => img, :position => image_position)
-          #   end
-          # end
+        def create_images(article, images)
+          images.each do |key,value|
+            existing_images = Goldencobra::Upload.where(
+              image_remote_url: value[:image][:image_url]
+            )
+            if existing_images.blank?
+              img = Goldencobra::Upload.create(value[:image])
+            else
+              img = existing_images.first
+            end
+            image_position = Goldencobra::Upload.default_position
+            article.article_images.create(image: img, position: image_position)
+          end
+        end
 
-          # Update existing article
-          article.update_attributes(params[:article])
+        def get_article
+          url = params[:url].present? ? "/#{params[:url]}" : "/"
 
-          # Try to save the article
-          return article
+          @article = Goldencobra::Article.where(url_path: url).first
+          unless @article
+            raise "Article not found with url: #{url}"
+          end
+        end
 
+        def articles_as_json
+          if params[:react_select] && params[:react_select] == "true"
+            # Die React Select Liste braucht das JSON in diesem Format. -hf
+            @articles.map { |a| { "value" => a.id, "label" => a.parent_path } }
+                     .sort { |a, b| a["label"] <=> b["label"] }
+          else
+            @articles.to_a.map do |a|
+              a.as_json(only: [:id, :title], methods: [:parent_path])
+            end
+          end
         end
 
+        def cached_articles
+          cache_key = [
+            "index-articles", "v2",
+            Goldencobra::Article.order("updated_at DESC").limit(1).first.cache_key
+          ]
 
+          Rails.cache.fetch(cache_key) do
+            Goldencobra::Article.select([:id, :title, :ancestry]).sort do |a, b|
+              a[0] <=> b[0]
+            end
+          end
+        end
       end
     end
   end