publify_core 9.0.0.pre1

data/app/controllers/admin/dashboard_controller.rb

@@ -0,0 +1,87 @@
+require 'feedjira'
+
+class Admin::DashboardController < Admin::BaseController
+  require 'open-uri'
+  require 'time'
+  require 'rexml/document'
+
+  def index
+    t = Time.new
+    today = t.strftime('%Y-%m-%d 00:00')
+
+    # Since last venue
+    @newposts_count = Article.published_since(current_user.last_sign_in_at).count
+    @newcomments_count = Feedback.published_since(current_user.last_sign_in_at).count
+
+    # Today
+    @statposts = Article.published.where('published_at > ?', today).count
+    @statsdrafts = Article.drafts.where('created_at > ?', today).count
+    @statspages = Page.where('published_at > ?', today).count
+    @statuses = Note.where('published_at > ?', today).count
+    @statuserposts = Article.published.where('published_at > ?', today).where(user_id: current_user.id).count
+    @statcomments = Comment.where('created_at > ?', today).count
+    @presumedspam = Comment.presumed_spam.where('created_at > ?', today).count
+    @confirmed = Comment.ham.where('created_at > ?', today).count
+    @unconfirmed = Comment.unconfirmed.where('created_at > ?', today).count
+
+    @comments = Comment.last_published
+    @drafts = Article.drafts.where('user_id = ?', current_user.id).limit(5)
+
+    @statspam = Comment.spam.count
+    @inbound_links = inbound_links
+    @publify_links = publify_dev
+    publify_version
+  end
+
+  def publify_version
+    version = nil
+    begin
+      open(PUBLIFY_VERSION_URL) do |http|
+        publify_version = http.read[0..5]
+        version = publify_version.split('.')
+      end
+    rescue
+      return
+    end
+    if version[0].to_i > TYPO_MAJOR.to_i
+      flash[:error] = I18n.t('admin.dashboard.publify_version.error')
+    elsif version[1].to_i > TYPO_SUB.to_i
+      flash[:warning] = I18n.t('admin.dashboard.publify_version.warning')
+    elsif version[2].to_i > TYPO_MINOR.to_i
+      flash[:notice] = I18n.t('admin.dashboard.publify_version.notice')
+    end
+  end
+
+  private
+
+  def inbound_links
+    host = URI.parse(this_blog.base_url).host
+    return [] if Rails.env.development?
+    url = "http://www.google.com/search?q=link:#{host}&tbm=blg&output=rss"
+    fetch_rss(url).reverse.compact
+  end
+
+  def publify_dev
+    url = 'http://blog.publify.co/articles.rss'
+    fetch_rss(url)[0..2]
+  end
+
+  def fetch_rss(url)
+    open(url) do |http|
+      return parse_rss(http.read)
+    end
+  rescue
+    []
+  end
+
+  RssItem = Struct.new(:link, :title, :description, :description_link, :date, :author) do
+    def to_s
+      title
+    end
+  end
+
+  def parse_rss(body)
+    doc = Feedjira::Feed.parse(body)
+    doc.entries
+  end
+end

data/app/controllers/admin/feedback_controller.rb

@@ -0,0 +1,159 @@
+class Admin::FeedbackController < Admin::BaseController
+  cache_sweeper :blog_sweeper
+  ONLY_DOMAIN = %w(unapproved presumed_ham presumed_spam ham spam).freeze
+
+  def index
+    scoped_feedback = this_blog.feedback
+
+    if params[:only].present?
+      @only_param = ONLY_DOMAIN.dup.delete(params[:only])
+      scoped_feedback = scoped_feedback.send(@only_param) if @only_param
+    end
+
+    params.delete(:page) if params[:page].blank? || params[:page] == '0'
+
+    @feedback = scoped_feedback.paginated(params[:page], this_blog.admin_display_elements)
+  end
+
+  def destroy
+    @record = Feedback.find params[:id]
+
+    unless @record.article.user_id == current_user.id
+      return redirect_to admin_feedback_index_url unless current_user.admin?
+    end
+
+    begin
+      @record.destroy
+      flash[:success] = I18n.t('admin.feedback.destroy.success')
+    rescue ActiveRecord::RecordNotFound
+      flash[:error] = I18n.t('admin.feedback.destroy.error')
+    end
+    redirect_to action: 'article', id: @record.article.id
+  end
+
+  def create
+    @article = Article.find(params[:article_id])
+    @comment = @article.comments.build(comment_params)
+    @comment.user_id = current_user.id
+
+    if request.post? && @comment.save
+      # We should probably wave a spam filter over this, but for now, just mark it as published.
+      @comment.mark_as_ham
+      @comment.save!
+      flash[:success] = I18n.t('admin.feedback.create.success')
+    end
+    redirect_to action: 'article', id: @article.id
+  end
+
+  def edit
+    @comment = Comment.find(params[:id])
+    @article = @comment.article
+    unless @article.access_by? current_user
+      redirect_to admin_feedback_index_url
+      return
+    end
+  end
+
+  def update
+    comment = Comment.find(params[:id])
+    unless comment.article.access_by? current_user
+      redirect_to admin_feedback_index_url
+      return
+    end
+    comment.attributes = comment_params
+    if request.post? && comment.save
+      flash[:success] = I18n.t('admin.feedback.update.success')
+      redirect_to action: 'article', id: comment.article.id
+    else
+      redirect_to action: 'edit', id: comment.id
+    end
+  end
+
+  def article
+    @article = this_blog.articles.find(params[:id])
+    @feedback = @article.comments.ham if params[:ham] && params[:spam].blank?
+    @feedback = @article.comments.spam if params[:spam] && params[:ham].blank?
+    @feedback ||= @article.comments
+  end
+
+  def change_state
+    return unless request.xhr?
+
+    @feedback = Feedback.find(params[:id])
+    template = @feedback.change_state!
+
+    respond_to do |format|
+      if params[:context] != 'listing'
+        @comments = Comment.last_published
+        page.replace_html('commentList', partial: 'admin/dashboard/comment')
+      elsif template == 'ham'
+        format.js { render 'ham' }
+      else
+        format.js { render 'spam' }
+      end
+    end
+  end
+
+  def bulkops
+    ids = (params[:feedback_check] || {}).keys.map(&:to_i)
+    items = Feedback.find(ids)
+    @unexpired = true
+
+    bulkop = (params[:bulkop_top] || {}).empty? ? params[:bulkop_bottom] : params[:bulkop_top]
+
+    case bulkop
+    when 'Delete Checked Items'
+      count = 0
+      ids.each do |id|
+        count += Feedback.delete(id)
+      end
+      flash[:success] = I18n.t('admin.feedback.bulkops.success_deleted', count: count)
+
+      if items.any(&:invalidates_cache?)
+        flush_cache
+        return
+      end
+    when 'Mark Checked Items as Ham'
+      update_feedback(items, :mark_as_ham!)
+      flash[:success] = I18n.t('admin.feedback.bulkops.success_mark_as_ham', count: ids.size)
+    when 'Mark Checked Items as Spam'
+      update_feedback(items, :mark_as_spam!)
+      flash[:success] = I18n.t('admin.feedback.bulkops.success_mark_as_spam', count: ids.size)
+    when 'Confirm Classification of Checked Items'
+      update_feedback(items, :confirm_classification!)
+      flash[:success] = I18n.t('admin.feedback.bulkops.success_classification', count: ids.size)
+    when 'Delete all spam'
+      if request.post?
+        Feedback.delete_all(['state = ?', 'spam'])
+        flash[:success] = I18n.t('admin.feedback.bulkops.success_deleted_spam')
+      end
+    else
+      flash[:error] = I18n.t('admin.feedback.bulkops.error')
+    end
+
+    if params[:article_id]
+      redirect_to action: 'article', id: params[:article_id], confirmed: params[:confirmed], published: params[:published]
+    else
+      redirect_to action: 'index', page: params[:page], search: params[:search], confirmed: params[:confirmed], published: params[:published]
+    end
+  end
+
+  private
+
+  def comment_params
+    params.require(:comment).permit(:author, :email, :url, :body)
+  end
+
+  def update_feedback(items, method)
+    items.each do |value|
+      value.send(method)
+      @unexpired && value.invalidates_cache? or next
+      flush_cache
+    end
+  end
+
+  def flush_cache
+    @unexpired = false
+    PageCache.sweep_all
+  end
+end

data/app/controllers/admin/migrations_controller.rb

@@ -0,0 +1,20 @@
+class Admin::MigrationsController < Admin::BaseController
+  cache_sweeper :blog_sweeper
+  skip_before_action :look_for_needed_db_updates
+
+  def show
+    @current_version = migrator.current_schema_version
+    @needed_migrations = migrator.pending_migrations
+  end
+
+  def update
+    migrator.migrate
+    redirect_to admin_migrations_url
+  end
+
+  private
+
+  def migrator
+    @migrator ||= Migrator.new
+  end
+end

data/app/controllers/admin/notes_controller.rb

@@ -0,0 +1,69 @@
+class Admin::NotesController < Admin::BaseController
+  layout 'administration'
+  cache_sweeper :blog_sweeper
+
+  before_action :load_existing_notes, only: [:index, :edit]
+  before_action :find_note, only: [:edit, :update, :show, :destroy]
+
+  def index
+    @note = new_note
+  end
+
+  def show
+    unless @note.access_by?(current_user)
+      flash[:error] = I18n.t('admin.base.not_allowed')
+      redirect_to admin_notes_url
+    end
+  end
+
+  def edit
+  end
+
+  def create
+    note = new_note
+
+    note.published = true
+    note.attributes = params[:note].permit!
+    note.text_filter ||= current_user.default_text_filter
+    note.published_at ||= Time.now
+    if note.save
+      if params[:push_to_twitter] && note.twitter_id.blank?
+        unless note.send_to_twitter
+          flash[:error] = I18n.t('errors.problem_sending_to_twitter')
+          flash[:error] += " : #{note.errors.full_messages.join(' ')}"
+        end
+      end
+      flash[:notice] = I18n.t('notice.note_successfully_created')
+    else
+      flash[:error] = note.errors.full_messages
+    end
+    redirect_to admin_notes_url
+  end
+
+  def update
+    @note.attributes = params[:note].permit!
+    @note.save
+    redirect_to admin_notes_url
+  end
+
+  def destroy
+    @note.destroy
+    flash[:notice] = I18n.t('admin.base.successfully_deleted', name: 'note')
+    redirect_to admin_notes_url
+  end
+
+  private
+
+  def load_existing_notes
+    @notes = Note.page(params[:page]).per(this_blog.limit_article_display)
+  end
+
+  def find_note
+    @note = Note.find(params[:id])
+  end
+
+  def new_note
+    this_blog.notes.build(author: current_user,
+                          text_filter: current_user.text_filter)
+  end
+end

data/app/controllers/admin/pages_controller.rb

@@ -0,0 +1,88 @@
+# coding: utf-8
+require 'base64'
+
+class Admin::PagesController < Admin::BaseController
+  before_action :set_images, only: [:new, :edit]
+  before_action :set_macro, only: [:new, :edit]
+  before_action :set_page, only: [:show, :edit, :update, :destroy]
+
+  layout :get_layout
+  cache_sweeper :blog_sweeper
+
+  def index
+    @search = params[:search] ? params[:search] : {}
+    @pages = Page.search_with(@search).page(params[:page]).per(this_blog.admin_display_elements)
+  end
+
+  def new
+    @page = Page.new
+    @page.text_filter ||= default_textfilter
+    @page.published = true
+    @page.user_id = current_user.id
+  end
+
+  def edit
+    @page.text_filter ||= default_textfilter
+  end
+
+  def create
+    @page = Page.new(page_params)
+    @page.published_at = Time.now
+    @page.blog = this_blog
+    @page.user_id = current_user.id
+
+    if @page.save
+      redirect_to admin_pages_url, notice: I18n.t('admin.pages.new.success')
+    else
+      render :new
+    end
+  end
+
+  def update
+    @page.text_filter ||= default_textfilter
+    if @page.update(page_params)
+      redirect_to admin_pages_url, notice: I18n.t('admin.pages.edit.success')
+    else
+      render :edit
+    end
+  end
+
+  def destroy
+    destroy_a(Page)
+  end
+
+  private
+
+  def default_textfilter
+    current_user.text_filter || blog.text_filter
+  end
+
+  def set_macro
+    @macros = TextFilterPlugin.macro_filters
+  end
+
+  def set_images
+    @images = Resource.images.by_created_at.page(1).per(10)
+  end
+
+  def get_layout
+    case action_name
+    when 'new', 'edit', 'create'
+      'editor'
+    when 'show'
+      nil
+    else
+      'administration'
+    end
+  end
+
+  # Use callbacks to share common setup or constraints between actions.
+  def set_page
+    @page = Page.find(params[:id])
+  end
+
+  # Never trust parameters from the scary internet, only allow the white list through.
+  def page_params
+    params.require(:page).permit(:title, :body, :name, :published, :text_filter)
+  end
+end

data/app/controllers/admin/post_types_controller.rb

@@ -0,0 +1,56 @@
+class Admin::PostTypesController < Admin::BaseController
+  before_action :set_post_type, only: [:edit, :update, :destroy]
+  cache_sweeper :blog_sweeper
+
+  def index
+    @post_types = PostType.all
+    @post_type = PostType.new
+  end
+
+  def edit
+    @post_types = PostType.all
+  end
+
+  def create
+    @post_type = PostType.new(post_type_params)
+
+    if @post_type.save
+      redirect_to admin_post_types_url, notice: 'Post type was successfully created.'
+    else
+      render :index
+    end
+  end
+
+  def update
+    if @post_type.update(post_type_params)
+      redirect_to admin_post_types_url, notice: 'Post type was successfully updated.'
+    else
+      render :edit
+    end
+  end
+
+  def destroy
+    # Reset all Articles from the PostType we're destroying to the default PostType
+    # Wrap it in a transaction for safety
+    @post_type.transaction do
+      Article.where('post_type = ?', @post_type.permalink).each do |article|
+        article.post_type = 'read'
+        article.save
+      end
+      @post_type.destroy
+    end
+    redirect_to admin_post_types_url, notice: 'Post was successfully destroyed.'
+  end
+
+  private
+
+  # Use callbacks to share common setup or constraints between actions.
+  def set_post_type
+    @post_type = PostType.find(params[:id])
+  end
+
+  # Never trust parameters from the scary internet, only allow the white list through.
+  def post_type_params
+    params.require(:post_type).permit(:name, :description)
+  end
+end

data/app/controllers/admin/profiles_controller.rb

@@ -0,0 +1,48 @@
+# This controller handles updating your own user data.
+class Admin::ProfilesController < Admin::BaseController
+  before_action :set_user, only: [:index, :update]
+
+  def index
+  end
+
+  def update
+    @user.resource = upload_avatar if params[:user][:filename]
+
+    if @user.update(user_params)
+      redirect_to admin_profiles_url, notice: I18n.t('admin.profiles.index.success')
+    else
+      render :index
+    end
+  end
+
+  private
+
+  def upload_avatar
+    file = params[:user][:filename]
+
+    mime = if file.content_type
+             file.content_type.chomp
+           else
+             'text/plain'
+           end
+
+    Resource.create(upload: file, mime: mime, created_at: Time.now)
+  end
+
+  # Use callbacks to share common setup or constraints between actions.
+  def set_user
+    @user = current_user
+  end
+
+  # Never trust parameters from the scary internet, only allow the white list through.
+  def user_params
+    params.require(:user).permit(:login, :password, :password_confirmation,
+                                 :email, :firstname, :lastname, :nickname,
+                                 :display_name, :notify_via_email,
+                                 :notify_on_new_articles, :notify_on_comments,
+                                 :text_filter_id, :state,
+                                 :twitter_account, :twitter_oauth_token,
+                                 :twitter_oauth_token_secret, :description,
+                                 :url, :msn, :yahoo, :jabber, :aim, :twitter)
+  end
+end

data/app/controllers/admin/redirects_controller.rb

@@ -0,0 +1,47 @@
+class Admin::RedirectsController < Admin::BaseController
+  before_action :set_redirect, only: [:edit, :update, :destroy]
+
+  def index
+    @redirects = Redirect.where(content_id: nil).order('id desc').page(params[:page]).per(this_blog.admin_display_elements)
+    @redirect = Redirect.new
+  end
+
+  def edit
+    @redirects = Redirect.where(content_id: nil).order('id desc').page(params[:page]).per(this_blog.admin_display_elements)
+  end
+
+  def create
+    @redirect = this_blog.redirects.build(redirect_params)
+
+    if @redirect.save
+      redirect_to admin_redirects_url, notice: 'Redirect was successfully created.'
+    else
+      render :index
+    end
+  end
+
+  def update
+    if @redirect.update(redirect_params)
+      redirect_to admin_redirects_url, notice: 'Redirect was successfully updated.'
+    else
+      render :edit
+    end
+  end
+
+  def destroy
+    @redirect.destroy
+    redirect_to admin_redirects_url, notice: I18n.t('admin.redirects.destroy.success')
+  end
+
+  private
+
+  # Use callbacks to share common setup or constraints between actions.
+  def set_redirect
+    @redirect = Redirect.find(params[:id])
+  end
+
+  # Never trust parameters from the scary internet, only allow the white list through.
+  def redirect_params
+    params.require(:redirect).permit(:from_path, :to_path)
+  end
+end

data/app/controllers/admin/resources_controller.rb

@@ -0,0 +1,30 @@
+class Admin::ResourcesController < Admin::BaseController
+  cache_sweeper :blog_sweeper
+
+  def upload
+    file = params[:upload]
+
+    @up = Resource.new(blog: this_blog, upload: file)
+    @up.mime = @up.upload.content_type
+
+    if @up.save
+      flash[:success] = I18n.t('admin.resources.upload.success')
+    else
+      flash[:warning] = I18n.t('admin.resources.upload.warning')
+    end
+
+    redirect_to admin_resources_url
+  end
+
+  def index
+    @r = Resource.new
+    @resources = Resource.order('created_at DESC').page(params[:page]).per(this_blog.admin_display_elements)
+  end
+
+  def destroy
+    @record = Resource.find(params[:id])
+    @record.destroy
+    flash[:notice] = I18n.t('admin.resources.destroy.notice')
+    redirect_to admin_resources_url
+  end
+end

data/app/controllers/admin/seo_controller.rb

@@ -0,0 +1,45 @@
+class Admin::SeoController < Admin::BaseController
+  cache_sweeper :blog_sweeper
+  before_action :set_setting
+  before_action :set_section
+
+  def show
+    if @setting.permalink_format != '/%year%/%month%/%day%/%title%' &&
+        @setting.permalink_format != '/%year%/%month%/%title%' &&
+        @setting.permalink_format != '/%title%'
+      @setting.custom_permalink = @setting.permalink_format
+      @setting.permalink_format = 'custom'
+    end
+  end
+
+  def update
+    if settings_params[:permalink_format] == 'custom'
+      settings_params[:permalink_format] = settings_params[:custom_permalink]
+    end
+    if @setting.update_attributes(settings_params)
+      flash[:success] = I18n.t('admin.settings.update.success')
+      redirect_to admin_seo_path(section: @section)
+    else
+      flash[:error] = I18n.t('admin.settings.update.error',
+                             messages: this_blog.errors.full_messages.join(', '))
+      render :show
+    end
+  end
+
+  private
+
+  def settings_params
+    @settings_params ||= params.require(:setting).permit!
+  end
+
+  VALID_SECTIONS = %w(general titles permalinks).freeze
+
+  def set_section
+    section = params[:section]
+    @section = VALID_SECTIONS.include?(section) ? section : 'general'
+  end
+
+  def set_setting
+    @setting = this_blog
+  end
+end