HornsAndHooves-publify_core 10.0.0

data/app/controllers/admin/content_controller.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module Admin; end
+
+class Admin::ContentController < Admin::BaseController
+  def index
+    @search = params[:search] || {}
+    @articles = this_blog.articles.search_with(@search).page(params[:page]).
+      per(this_blog.admin_display_elements)
+
+    if request.xhr?
+      respond_to do |format|
+        format.js {}
+      end
+    else
+      @article = Article.new(params[:article])
+    end
+  end
+
+  def new
+    @article = Article::Factory.new(this_blog, current_user).default
+    load_resources
+    render layout: "editor"
+  end
+
+  def edit
+    return unless access_granted?(params[:id])
+
+    @article = Article.find(params[:id])
+    @article.text_filter ||= default_text_filter
+    @article.keywords = Tag.collection_to_string @article.tags
+    load_resources
+    render layout: "editor"
+  end
+
+  def create
+    article_factory = Article::Factory.new(this_blog, current_user)
+    @article = article_factory.get_or_build_from(params[:article][:id])
+
+    update_article_attributes
+
+    if @article.draft
+      @article.state = "draft"
+    elsif @article.draft?
+      @article.publish!
+    end
+
+    if @article.save
+      flash[:success] = I18n.t("admin.content.create.success")
+      redirect_to action: "index"
+    else
+      @article.keywords = Tag.collection_to_string @article.tags
+      load_resources
+      render "new", layout: "editor"
+    end
+  end
+
+  def update
+    return unless access_granted?(params[:id])
+
+    id = params[:article][:id] || params[:id]
+    @article = Article.find(id)
+
+    if params[:article][:draft]
+      fetch_fresh_or_existing_draft_for_article
+    else
+      @article = Article.find(@article.parent_id) unless @article.parent_id.nil?
+    end
+
+    update_article_attributes
+
+    if @article.draft
+      @article.state = "draft"
+    elsif @article.draft?
+      @article.publish!
+    end
+
+    if @article.save
+      Article.where(parent_id: @article.id).map(&:destroy) unless @article.draft
+      flash[:success] = I18n.t("admin.content.update.success")
+      redirect_to action: "index"
+    else
+      @article.keywords = Tag.collection_to_string @article.tags
+      load_resources
+      render "edit"
+    end
+  end
+
+  def destroy
+    destroy_a(Article)
+  end
+
+  def auto_complete_for_article_keywords
+    @items = Tag.select(:display_name).order(:display_name).map(&:display_name)
+    render json: @items
+  end
+
+  def autosave
+    return false unless request.xhr?
+
+    id = params[:article][:id] || params[:id]
+
+    article_factory = Article::Factory.new(this_blog, current_user)
+    @article = article_factory.get_or_build_from(id)
+
+    fetch_fresh_or_existing_draft_for_article
+
+    @article.attributes = params[:article].permit!
+
+    @article.id = nil if @article.new_record?
+    @article.author = current_user
+    @article.save_attachments!(params[:attachments])
+    @article.state = "draft" unless @article.withdrawn?
+    @article.text_filter_name ||= current_user.text_filter.name
+
+    if @article.title.blank?
+      lastid = Article.order("id desc").first.id
+      @article.title = "Draft article " + lastid.to_s
+    end
+
+    if @article.save
+      flash[:success] = I18n.t("admin.content.autosave.success")
+      @must_update_calendar =
+        (params[:article][:published_at] and
+         params[:article][:published_at].to_time.to_i < Time.zone.now.to_time.to_i and
+         @article.parent_id.nil?)
+      respond_to do |format|
+        format.js
+      end
+    end
+  end
+
+  protected
+
+  def fetch_fresh_or_existing_draft_for_article
+    return unless @article.published? && @article.id
+
+    parent_id = @article.id
+    @article =
+      this_blog.articles.drafts.child_of(parent_id).first || this_blog.articles.build
+    @article.allow_comments = this_blog.default_allow_comments
+    @article.allow_pings = this_blog.default_allow_pings
+    @article.parent_id = parent_id
+  end
+
+  attr_accessor :resources, :resource
+
+  private
+
+  def load_resources
+    @post_types = PostType.all
+    @macros = TextFilterPlugin.macro_filters
+  end
+
+  def access_granted?(article_id)
+    article = Article.find(article_id)
+    if article.access_by? current_user
+      true
+    else
+      flash[:error] = I18n.t("admin.content.access_granted.error")
+      redirect_to action: "index"
+      false
+    end
+  end
+
+  def update_article_attributes
+    @article.assign_attributes(update_params)
+    @article.author = current_user
+    @article.save_attachments!(params[:attachments])
+    @article.text_filter_name ||= default_text_filter
+  end
+
+  def update_params
+    params.
+      require(:article).
+      permit(:allow_comments,
+             :allow_pings,
+             :body,
+             :body_and_extended,
+             :resource_id,
+             :draft,
+             :extended,
+             :permalink,
+             :published_at,
+             :title,
+             :keywords)
+  end
+
+  def default_text_filter
+    current_user.text_filter || this_blog.text_filter
+  end
+end

data/app/controllers/admin/dashboard_controller.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Admin::DashboardController < Admin::BaseController
+  require "open-uri"
+  require "time"
+  require "rexml/document"
+
+  def index
+    today = Time.zone.now.strftime("%Y-%m-%d 00:00")
+
+    # Since last visit
+    last_sign_in = current_user.last_sign_in_at
+    @newposts_count = Article.published_since(last_sign_in).count
+    @newcomments_count = Feedback.created_since(last_sign_in).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
+  end
+end

data/app/controllers/admin/feedback_controller.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+class Admin::FeedbackController < Admin::BaseController
+  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
+      nil
+    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
+    @feedback = @feedback.ham if params[:ham] && params[:spam].blank?
+    @feedback = @feedback.spam if params[:spam] && params[:ham].blank?
+  end
+
+  # TODO: Replace with actions that move to a specified state
+  def change_state
+    return unless request.xhr?
+
+    @feedback = Feedback.find(params[:id])
+    template = @feedback.change_state!
+
+    respond_to do |format|
+      # TODO: Make this special case not necessary
+      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 = if (params[:bulkop_top] || {}).empty?
+               params[:bulkop_bottom]
+             else
+               params[:bulkop_top]
+             end
+
+    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)
+    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.where("state = ?", "spam").delete_all
+        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)
+    end
+  end
+end

data/app/controllers/admin/notes_controller.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+class Admin::NotesController < Admin::BaseController
+  layout "administration"
+
+  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.state = "published"
+    note.attributes = params[:note].permit!
+    note.text_filter ||= default_text_filter
+    note.published_at ||= Time.zone.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_name: default_text_filter)
+  end
+
+  def default_text_filter
+    current_user.text_filter_name || this_blog.text_filter
+  end
+end

data/app/controllers/admin/pages_controller.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "base64"
+
+class Admin::PagesController < Admin::BaseController
+  before_action :set_macro, only: [:new, :edit]
+  before_action :set_page, only: [:edit, :update, :destroy]
+
+  def index
+    @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_name ||= default_text_filter
+    @page.user_id = current_user.id
+    @page.state = "published"
+    render layout: "editor"
+  end
+
+  def edit
+    @page.text_filter_name ||= default_text_filter
+    render layout: "editor"
+  end
+
+  def create
+    @page = Page.new(page_params)
+    @page.published_at = Time.zone.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, layout: "editor"
+    end
+  end
+
+  def update
+    @page.text_filter_name ||= default_text_filter
+    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_text_filter
+    current_user.text_filter_name || this_blog.text_filter
+  end
+
+  def set_macro
+    @macros = TextFilterPlugin.macro_filters
+  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, :state, :text_filter_name)
+  end
+end

data/app/controllers/admin/post_types_controller.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class Admin::PostTypesController < Admin::BaseController
+  before_action :set_post_type, only: [:edit, :update, :destroy]
+
+  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,57 @@
+# frozen_string_literal: true
+
+# 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(update_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.zone.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,
+                                 :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
+
+  def update_params
+    if user_params[:password].blank? && user_params[:password_confirmation].blank?
+      user_params.except(:password_confirmation, :password)
+    else
+      user_params
+    end
+  end
+end

data/app/controllers/admin/redirects_controller.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+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