lines-engine 0.1.3

data/app/controllers/lines/admin/application_controller.rb

@@ -0,0 +1,19 @@
+# Parent controller for the whole admin area. All controllers for the +Admin+ namespace
+# inherit from <tt>Admin::ApplicationController</tt>
+# 
+# The +authorize+ before filter ensures that all inherited controllers and actions 
+# require a logged in user.
+require_dependency "lines/application_controller"
+
+module Lines
+
+  class Admin::ApplicationController < ApplicationController
+    protect_from_forgery
+
+    before_action :authorize
+
+    layout 'lines/admin'
+
+  end
+
+end

data/app/controllers/lines/admin/articles_controller.rb

@@ -0,0 +1,172 @@
+# Provides the CRUD operations for +Article+.
+# Also handles base64 encoded file uploads and toggling of 
+# published and featured state of an +Article+
+# 
+# Inherits from +Admin::ApplicationController+ to ensure authentication.
+
+require_dependency "lines/admin/application_controller"
+
+module Lines
+
+  class Admin::ArticlesController < Admin::ApplicationController
+
+    autocomplete :tag, :name, class_name: 'ActsAsTaggableOn::Tag'
+    before_action :process_base64_upload, only: [:create, :update]
+
+    # Lists all articles. Provides <tt>@articles_unpublished</tt> and 
+    # <tt>@articles_published</tt> to distinguish between published and
+    # unpublished articles
+    def index
+      @articles = Article.order('published ASC, featured DESC, published_at DESC').page(params[:page]).per(25)
+      @articles_unpublished = @articles.select{|a| a.published == false}
+      @articles_published = @articles.select{|a| a.published == true}
+      respond_to do |format|
+        format.html # index.html.erb
+      end
+    end
+
+    # GET /admin/articles/1
+    def show
+      @article = Article.find(params[:id])
+      @first_page = true
+
+      respond_to do |format|
+        format.html {render :show, layout: 'lines/preview'}
+      end
+    end
+
+    # GET /admin/articles/new
+    def new
+      @article = Lines::Article.new
+
+      respond_to do |format|
+        format.html # new.html.erb
+      end
+    end
+
+    # GET /admin/articles/1/edit
+    def edit
+      @article = Article.find(params[:id])
+    end
+
+    # POST /admin/articles
+    def create
+      @article = Article.new(article_params)
+
+      respond_to do |format|
+        if @article.save
+          format.html { redirect_to admin_article_path(@article), notice: 'Article was successfully created.' }
+        else
+          format.html { render action: "new" }
+        end
+      end
+    end
+
+    # PUT /admin/articles/1
+    # TODO: Very much is happening here. Move deletion of hero_image to the article model
+    def update
+      @article = Article.find(params[:id])
+      a_params = article_params
+
+      # replace picture_path with the new uploaded file
+      a_params[:hero_image] = @uploaded_file if @uploaded_file
+
+      # delete uploaded hero image when predifined image is selected
+      if !a_params[:hero_image_cache].present? && a_params[:short_hero_image].present?
+        @article.remove_hero_image! 
+        @article.remove_hero_image = true 
+        @article.save
+      end
+
+      respond_to do |format|
+        if @article.update_attributes(article_params)
+          ActionController::Base.new.expire_fragment(@article)
+          format.html { redirect_to admin_article_path(@article), notice: 'Article was successfully updated.' }
+        else
+          format.html { render action: "edit" }
+        end
+      end
+    end
+
+    # DELETE /admin/articles/1
+    def destroy
+      @article = Article.find(params[:id])
+      @article.destroy
+
+      respond_to do |format|
+        format.html { redirect_to admin_articles_url }
+      end
+    end
+
+    # Toggles published state of an article
+    def toggle_publish
+      @article = Article.find(params[:article_id])
+      @article.update_attributes(published: !@article.published)
+      redirect_to admin_articles_url, notice: 'Article updated!'
+    end
+
+    # Toggles featured state of an article
+    def toggle_feature
+      @article = Article.find(params[:article_id])
+      old_featured = Article.where(featured: true)
+      if old_featured.size > 0
+        old_featured.each do |article|
+          article.update_attributes(featured: false)
+        end
+      end
+      @article.update_attributes(featured: !@article.featured)
+      redirect_to admin_articles_url, notice: 'Article updated!'
+    end
+
+    # Handles base64 encoded file uploads
+    def process_base64_upload
+      @uploaded_file = nil
+      #check if file is given
+      if params[:article][:hero_image_file] != ""
+
+        picture_filename = "hero_image"
+        picture_original_filename = "hero_image"
+        picture_content_type = splitBase64(params[:article][:hero_image_file])[:type]
+        picture_data = splitBase64(params[:article][:hero_image_file])[:data]
+
+        #create a new tempfile named fileupload
+        tempfile = Tempfile.new("fileupload")
+        tempfile.binmode
+
+        #get the file and decode it with base64 then write it to the tempfile
+        tempfile.write(Base64.decode64(picture_data))
+
+        #create a new uploaded file
+        @uploaded_file = ActionDispatch::Http::UploadedFile.new(
+          tempfile: tempfile, 
+          filename: picture_filename,
+          original_filename: picture_original_filename
+        )
+        @uploaded_file.content_type = picture_content_type
+      end
+    end
+
+    def splitBase64(uri)
+      if uri.match(%r{^data:(.*?);(.*?),(.*)$})
+        return {
+          type:      $1, # "image/png"
+          encoder:   $2, # "base64"
+          data:      $3, # data string
+          extension: $1.split('/')[1] # "png"
+          }
+      end
+    end
+
+    private
+
+      # Allowed attribute with strong_params
+      def article_params
+        params.require(:article).permit(:content, :hero_image, :short_hero_image, :published, :published_at, 
+          :sub_title, :title, :pictures, :author_ids, :hero_image_cache, :tag_list, :gplus_url, :featured, 
+          :document, :document_cache, :hero_image_file, :remove_document, :pictures, :authors,
+          pictures_attributes: [:id, :image, :name, :article_id], author_ids: [] )
+      end
+
+  end
+
+end

data/app/controllers/lines/admin/authors_controller.rb

@@ -0,0 +1,70 @@
+# Provides CRUD actions for +Author+ model.
+
+require_dependency "lines/admin/application_controller"
+
+module Lines
+
+  class Admin::AuthorsController < Admin::ApplicationController
+
+    # Listes all authroes
+    def index
+      @authors = Author.all
+    end
+
+    # Shows an author
+    def show
+      @author = Author.find(params[:id])
+    end
+
+    # New author
+    def new
+      @author = Lines::Author.new
+    end
+
+    # Edit an existing author
+    def edit
+      @author = Author.find(params[:id])
+    end
+
+    # Create a new author from params
+    def create
+      @author = Author.new(author_params)
+
+      if @author.save
+        redirect_to admin_author_path @author, notice: 'Author was successfully created.'
+      else
+        render action: "new"
+      end
+    end
+
+    # Update an existing author from params
+    def update
+      @author = Author.find(params[:id])
+
+      if @author.update_attributes(params[:author])
+        redirect_to admin_author_path @author, notice: 'Author was successfully updated.'
+      else
+        render action: "edit"
+      end
+    end
+
+    # Delete an author
+    def destroy
+      @author = Author.find(params[:id])
+      if @author.destroy
+        redirect_to admin_authors_url
+      else
+        @authors = Author.all
+        render "index" 
+      end
+    end
+
+    private
+
+      # Use strong_params
+      def author_params
+        params.require(:author).permit(:email, :name, :description, :gplus_profile)
+      end
+  end
+
+end

data/app/controllers/lines/admin/pictures_controller.rb

@@ -0,0 +1,43 @@
+# Handles file uploads for content pictures.
+require_dependency "lines/admin/application_controller"
+
+module Lines
+
+
+  class Admin::PicturesController < Admin::ApplicationController
+    def create
+      @picture = Picture.create(picture_params)
+    end
+
+    # PUT /admin/pictures/1
+    def update
+      @picture = Picture.find(params[:id])
+
+      respond_to do |format|
+        if @picture.update_attributes(picture_params[:picture])
+          format.html { redirect_to @picture, notice: 'Picture was successfully updated.' }
+        else
+          format.html { render action: "edit" }
+        end
+      end
+    end
+
+    # Deletes a picture. Only responds to JS requests.
+    def destroy
+      @picture = Picture.find(params[:id])
+      @picture.destroy
+
+      respond_to do |format|
+        format.js
+      end
+    end
+
+    private
+
+      # strong_params
+      def picture_params
+        params.fetch(:picture, {}).permit(:image)
+      end
+  end
+
+end

data/app/controllers/lines/application_controller.rb

@@ -0,0 +1,18 @@
+module Lines
+  class ApplicationController < ActionController::Base
+
+    private
+
+      # sets the current_user if one exists in session
+      def current_user
+        @current_user ||= User.find(session[:user_id]) if session[:user_id]
+      end
+      helper_method :current_user
+
+      # checks if current user is authorized. Redirects to login_url if not
+      def authorize
+        redirect_to login_url, alert: "Not authorized" if current_user.nil?
+      end
+
+  end
+end

data/app/controllers/lines/articles_controller.rb

@@ -0,0 +1,62 @@
+# Lists all Articles and shows specific ones.
+# Responds either to HTML and ATOM requests.
+require_dependency "lines/application_controller"
+
+module Lines
+
+  class ArticlesController < ApplicationController
+
+    layout 'lines/application'
+
+    KEYWORDS = CONFIG[:keywords]
+    SITE_TITLE = CONFIG[:title]
+
+    # Lists all published articles.
+    # Responds to html and atom
+    def index
+      respond_to do |format|
+        format.html {
+          @first_page = (params[:page] and params[:page].to_i > 0) ? false : true
+          if params[:tag]
+            @articles = Article.published.tagged_with(params[:tag]).page(params[:page].to_i)
+          else
+            @articles = Article.published.page(params[:page].to_i).padding(1)
+          end
+          @first_article = Article.published.first if @articles.first_page?
+          set_meta_tags title: SITE_TITLE,
+                        description: CONFIG[:meta_description],
+                        keywords: KEYWORDS,
+                        open_graph: { title: SITE_TITLE,
+                                        type: 'website',
+                                        url: 'meta_og_url',
+                                        site_name: SITE_TITLE,
+                                        image: CONFIG[:og_logo]
+                                      }
+
+        }
+        format.atom{
+          @articles = Article.published
+        }
+      end
+    end
+
+    # Shows specific article
+    def show
+      @first_page = true
+      @article = Article.published.find(params[:id])
+      set_meta_tags title: @article.title,
+                    keywords: KEYWORDS + @article.tag_list.to_s,
+                    open_graph: { title: SITE_TITLE,
+                                     type: 'article',
+                                     url: 'meta_og_url',
+                                     site_name: SITE_TITLE,
+                                     image: CONFIG[:host] + @article.image_url
+                                   }
+      if request.path != article_path(@article)
+        return redirect_to @article, status: :moved_permanently
+      end
+    end
+
+  end
+
+end

data/app/controllers/lines/sessions_controller.rb

@@ -0,0 +1,34 @@
+# Creates (login) and destroys (logout) sessions
+require_dependency "lines/application_controller"
+
+module Lines
+
+  class SessionsController < ApplicationController
+
+    layout "lines/admin"
+
+    
+    # Renders form for creating a new article 
+    def new
+    end
+
+    # Authenticate user and create a new session.
+    def create
+      user = User.find_by(email: params[:email])
+      if user && user.authenticate(params[:password])
+        session[:user_id] = user.id
+        redirect_to admin_root_url, notice: "Logged in!"
+      else
+        flash.now.alert = "Email or password is invalid"
+        render "new"
+      end
+    end
+
+    # Destroys the current session (logout)
+    def destroy
+      session[:user_id] = nil
+      redirect_to root_url, notice: "Logged out!"
+    end
+  end
+
+end

data/app/helpers/lines/application_helper.rb

@@ -0,0 +1,95 @@
+require 'redcarpet'
+require 'pygments'
+# encoding: utf-8
+# Provides helper methods for views.
+module Lines
+  module ApplicationHelper
+    
+    # Highlights and formats code fragments with Pygments 
+    class HTMLwithPygments < Redcarpet::Render::XHTML
+      def block_code(code, language)
+        sha = Digest::SHA1.hexdigest(code)
+        Rails.cache.fetch ["code", language, sha].join('-') do
+          Pygments.highlight(code, lexer: language)
+        end
+      end
+    end
+
+    # Returns formatted and highlighted code fragments
+    def markdown(text)
+      renderer = HTMLwithPygments.new(hard_wrap: true, filter_html: true, with_toc_data: false)
+      options = {
+        autolink: true,
+        no_intra_emphasis: true,
+        fenced_code_blocks: true,
+        lax_html_blocks: true,
+        tables: true,
+        strikethrough: true,
+        superscript: true,
+        xhtml: true
+      }
+      Redcarpet::Markdown.new(renderer, options).render(text).html_safe
+    end
+
+    # Returns links in active or inactive state for highlighting current page
+    def nav_link(link_text, link_path)
+      recognized = Rails.application.routes.recognize_path(link_path)
+      class_name = recognized[:controller] == params[:controller] ? 'active' : ''
+      content_tag(:li, class: class_name) do
+        link_to link_text, link_path
+      end
+    end
+
+    # Returns HTML with all authors of an article
+    def display_article_authors(article, with_info=false)
+      authors = article.authors.map{|author| author.gplus_profile.blank? ? author.name : link_to(author.name, author.gplus_profile)}.to_sentence(two_words_connector: " & ", last_word_connector: " & ").html_safe
+      if with_info
+        authors += (" - " + article.authors.map{|author| content_tag(:span, "#{author.description}", class: 'author_description') }.join(" -- ")).html_safe
+      end
+      authors
+    end
+
+    # Renders the navigation bar for logged in users
+    def render_navbar(&block)
+      action_link = get_action_link
+      if !action_link
+        action_link = CONFIG[:title_short]
+      end
+      html = content_tag(:div, id: 'navbar') do
+        content_tag(:div, class: 'navbar-inner') do
+          if current_user
+            content_tag(:span, link_to('', admin_articles_path), class: 'backlink', title: 'Dashboard') + content_tag(:span, action_link, class: 'actionlink') + content_tag(:span, class: 'buttons', &block) + content_tag(:span, link_to('Logout', logout_path), class: 'logout') + content_tag(:span, "Logged in as #{current_user.email}", class: 'logged-in-as')
+          else
+            content_tag(:span, link_to('', lines.root_path), class: 'backlink') + content_tag(:span, action_link, class: 'actionlink')
+          end
+        end
+      end
+      html    
+    end
+
+    # Returns site name for actionbar, dependend on current site
+    def get_action_link
+      if controller_path == 'admin/articles'
+        case action_name
+          when 'index' then 'All articles'
+          when 'new' then 'New article'
+          when 'edit' then 'Edit article'
+          when 'show' then "Preview"
+        end
+      elsif controller_path == 'admin/authors'
+        case action_name
+          when 'index' then 'All authors'
+          when 'new' then 'New author'
+          when 'edit' then 'Edit author'
+          when 'show' then "Author"
+        end
+      end
+    end
+
+    # Returns HTML for code blocks formatted with Pygment
+    def format_code(text)
+      simple_format( truncate( Sanitize.clean(markdown(text)), length: 300, separator: ' ', omission: ' ...' ))
+    end
+
+  end
+end