10 files changed, 471 insertions, 103 deletions

diff --git a/app/controllers/admin_controller.rb b/app/controllers/admin_controller.rb
index d671384..37fd78b 100644
--- a/app/controllers/admin_controller.rb
+++ b/app/controllers/admin_controller.rb
@@ -1,74 +1,74 @@
 class AdminController < ApplicationController
-  
+
   # Private
-  
+
   before_action :login_required
 
   def index
-    @drafts = Node.where("draft_id IS NOT NULL")
-      .limit(50).order("updated_at desc")
-
-    @drafts_count = Node.where("draft_id IS NOT NULL").count
-
-    @recent_changes = Node.where(
-      "updated_at < ? AND updated_at > ? AND parent_id IS NOT NULL",
-      Time.now, Time.now - 14.days
-    ).limit(50).order("updated_at desc")
-
-    all_nodes = Node.root.self_and_descendants
-    @sitemap_depth = {}
-    Node.each_with_level(all_nodes) do |node, level|
-      @sitemap_depth[node.id] = level
-    end
-    @sitemap = all_nodes.to_a.sort! { |node1,node2| node1.lft <=> node2.lft }.delete_if { |node| node.update? }
-
-    @mypages = Page.where("user_id = ? or editor_id = ?", @current_user, @current_user)
+    @drafts = Node.drafts_and_autosaves(current_user_id: current_user.id).limit(5)
+    @recent_changes = Node.recently_changed.limit(5)
+  end
 
-    @mynodes = Node.joins(:pages)
-              .where("pages.user_id = ? or pages.editor_id = ?", @current_user, @current_user)
-              .order("updated_at desc")
-              .uniq.first(50)
+  def conventions
+    @node_kinds = CccConventions::NODE_KINDS
   end
-  
+
   def search
-    @results = Node.search params[:search_term], :per_page => 1000
-    
+    @results = Node.editor_search(params[:search_term])
+
     respond_to do |format|
       format.html do
         render :template => 'admin/search_results'
       end
-      format.js do 
-        render( :json => @results.map do |node| 
+      format.js do
+        render( :json => @results.map do |node|
             if node
               { :id => node.id, :title => node.title, :unique_name => node.unique_name, :node_path => node_path(node) }
             end
           end
         )
-        
-      end 
+
+      end
+    end
+  end
+
+  def dashboard_search
+    term = params[:search_term]
+
+    if term.blank?
+      render json: { tags: [], nodes: [] }
+      return
     end
+
+    render json: {
+      tags: ActsAsTaggableOn::Tag.named_like(term).limit(5).map { |tag|
+        { name: tag.name, tag_path: tags_nodes_path(tags: tag.name) }
+      },
+      nodes: Node.editor_search(term).limit(10).map { |node|
+        { node_id: node.id, title: node.title, unique_name: node.unique_name, node_path: node_path(node) }
+      }
+    }
   end
-  
+
   def menu_search
     if params[:search_term] == "Root"
       @results = [Node.root]
     else
-      @results = Node.search params[:search_term]
+      @results = Node.editor_search(params[:search_term])
     end
-    
+
     respond_to do |format|
       format.html do
         render :partial => 'admin/menu_search_results'
       end
-      
-      format.js do 
-        render( :json => @results.map do |node| 
-          {:node_id => node.id, :title => node.title, :unique_name => node.unique_name} 
+
+      format.js do
+        render( :json => @results.map do |node|
+          {:node_id => node.id, :title => node.title, :unique_name => node.unique_name, :node_path => node_path(node)}
           end
         )
-        
-      end 
+
+      end
     end
   end
-  
 end
diff --git a/app/controllers/application_controller.rb b/app/controllers/application_controller.rb
index 75f92c3..cbeb40d 100644
--- a/app/controllers/application_controller.rb
+++ b/app/controllers/application_controller.rb
@@ -5,6 +5,8 @@ class ApplicationController < ActionController::Base
 
   before_action :set_locale
 
+  helper_method :safe_return_to
+
   protected
 
   def set_locale
@@ -18,4 +20,14 @@ class ApplicationController < ActionController::Base
   def default_url_options
     { locale: I18n.locale == I18n.default_locale ? nil : I18n.locale }
   end
+
+  def safe_return_to(url)
+    return events_path if url.blank?
+    uri = URI.parse(url)
+    return events_path if uri.host.present?
+    return events_path unless url.start_with?('/')
+    url
+  rescue URI::InvalidURIError
+    events_path
+  end
 end
diff --git a/app/controllers/events_controller.rb b/app/controllers/events_controller.rb
index f50da3e..be3f547 100644
--- a/app/controllers/events_controller.rb
+++ b/app/controllers/events_controller.rb
@@ -9,18 +9,24 @@ class EventsController < ApplicationController
   # GET /events
   # GET /events.xml
   def index
-    @events = Event.all
+    @events = Event.order(:id)
 
     respond_to do |format|
-      format.html # index.html.erb
+      format.html { @events = @events.paginate(page: params[:page], per_page: 25) }
       format.xml  { render :xml => @events }
     end
   end
 
+  # GET /events/without_node
+  def without_node
+    @events = Event.where(node_id: nil).order(:start_time).paginate(page: params[:page], per_page: 25)
+  end
+
   # GET /events/1
   # GET /events/1.xml
   def show
     @event = Event.find(params[:id])
+    @return_to = params[:return_to] || events_path
 
     respond_to do |format|
       format.html # show.html.erb
@@ -31,7 +37,14 @@ class EventsController < ApplicationController
   # GET /events/new
   # GET /events/new.xml
   def new
-    @event = Event.new(:node_id => params[:node_id])
+    @event = Event.new(
+      node_id:  params[:node_id],
+      tag_list: params[:tag_list]
+    )
+
+    if params[:tag_list].present? && params[:auto_tag_source].present?
+      flash.now[:notice] = "Tag '#{params[:tag_list]}' was pre-filled because this page is tagged '#{params[:auto_tag_source]}'. You can remove it below."
+    end
 
     respond_to do |format|
       format.html # new.html.erb
@@ -53,7 +66,7 @@ class EventsController < ApplicationController
     respond_to do |format|
       if @event.save
         flash[:notice] = 'Event was successfully created.'
-        format.html { redirect_to(@event.node ? edit_node_path(@event.node) : edit_event_path(@event)) }
+        format.html { redirect_to(safe_return_to(params[:return_to] || (@event.node ? edit_node_path(@event.node) : edit_event_path(@event)))) }
         format.xml  { render :xml => @event, :status => :created, :location => @event }
       else
         format.html { render :action => "new" }
@@ -94,6 +107,6 @@ class EventsController < ApplicationController
   private
 
     def event_params
-      params.require(:event).permit(:start_time, :end_time, :rrule, :custom_rrule, :allday, :url, :latitude, :longitude, :node_id, :location)
+      params.require(:event).permit(:title, :description, :start_time, :end_time, :rrule, :allday, :url, :latitude, :longitude, :node_id, :location, :tag_list)
     end
 end
diff --git a/app/controllers/menu_items_controller.rb b/app/controllers/menu_items_controller.rb
index 1b1eb59..314d1ea 100644
--- a/app/controllers/menu_items_controller.rb
+++ b/app/controllers/menu_items_controller.rb
@@ -14,7 +14,7 @@ class MenuItemsController < ApplicationController
   end
 
   def new
-    @menu_item = MenuItem.new menu_item_params
+    @menu_item = MenuItem.new
   end
 
   def create
diff --git a/app/controllers/nodes_controller.rb b/app/controllers/nodes_controller.rb
index 494887d..bff1733 100644
--- a/app/controllers/nodes_controller.rb
+++ b/app/controllers/nodes_controller.rb
@@ -1,19 +1,23 @@
 class NodesController < ApplicationController
-  
+
   # Private
-  
+
   layout 'admin'
-  
+
   before_action :login_required
   before_action :find_node, :only => [
-                              :show, 
-                              :edit, 
-                              :update, 
+                              :show,
+                              :edit,
+                              :update,
                               :destroy,
                               :publish,
-                              :unlock
+                              :unlock,
+                              :autosave,
+                              :revert
                             ]
 
+  around_action :pin_to_default_locale, :only => [:show, :edit, :update, :autosave]
+
   def index
     @nodes = Node.root.descendants.includes(:head, :draft)
       .order('id DESC')
@@ -22,90 +26,203 @@ class NodesController < ApplicationController
 
   def new
     @node = Node.new node_params
+    @selected_kind = CccConventions::NODE_KINDS.key?(params[:kind]) ? params[:kind] : "generic"
     if params.has_key?(:parent_id)
       @parent_id = params[:parent_id]
       @parent_name = Node.find(@parent_id).title
     end
   end
-  
+
   def create
     params[:title] ||= ""
-    
+
     @node = Node.new
     @node.parent_id = find_parent
-    @node.slug = params[:title].parameterize.to_s
-   
+    @node.slug = slug_for(params[:title])
+
+    config = CccConventions::NODE_KINDS[params[:kind]]
+
     if @node.save
       @node.draft.update(:title => params[:title])
-      case params[:kind]
-        when "update"
-          @node.draft.tag_list.add("update")
-        when "press_release"
-          @node.draft.tag_list.add("update", "pressemitteilung")
-      end
+      Array(config && config[:tags]).each { |t| @node.draft.tag_list.add(t) }
       @node.draft.save!
+
+      @node.update!(default_template_name: config[:template]) if config && config[:template]
+
       redirect_to(edit_node_path(@node))
     else
+      @selected_kind = CccConventions::NODE_KINDS.key?(params[:kind]) ? params[:kind] : "generic"
+      if params[:parent_id].present?
+        @parent_id = params[:parent_id]
+        @parent_name = Node.find(@parent_id).title
+      end
       render :new
     end
   end
-  
+
   def show
-    node = Node.find(params[:id])
-    node.wipe_draft!
-    @page = node.draft || node.head
+    @page = @node.draft || @node.head
+    @translations = @page.translation_summary
   end
 
   def edit
-    begin
-      @draft = @node.find_or_create_draft( current_user )
-    rescue LockedByAnotherUser => e
-      flash[:error] = e.message
-      if request.referer
-        redirect_to request.referer || node_path(@node)
-      else
-        redirect_to node_path(@node)
-      end
+    freshly_locked = @node.lock_owner != current_user
+    @node.lock_for_editing!( current_user )
+    @page = @node.autosave || @node.draft || @node.head
+
+    if @node.autosave
+      flash.now[:notice] =
+        "This page has unsaved changes from a previous session, shown below. " \
+        "Save to keep them, or use \"Discard Autosave\" below to go back to the last saved version."
+    elsif freshly_locked
+      flash.now[:notice] = "Node locked and ready to edit"
     end
+  rescue LockedByAnotherUser => e
+    flash[:error] = e.message
+    redirect_to(request.referer || node_path(@node))
   end
 
   def update
     @node.update(node_params)
-    @draft = @node.find_or_create_draft current_user
-    @draft.tag_list = params[:tag_list]
-    if @draft.update( page_params )
-      flash[:notice] = "Draft has been saved: #{Time.now}"
-      respond_to do |format|
-        format.html { redirect_to edit_node_path(@node) }
-        format.js
+    @node.autosave!( page_params.merge(:tag_list => params[:tag_list]), current_user )
+    @node.save_draft!(current_user)
+
+    flash[:notice] = "Draft saved. Publish your changes in the Status section once you're done."
+    flash[:status_path] = node_path(@node)
+
+    if @node.draft.translated_locales.size > 1
+      stale_locale = @node.draft.translated_locales.find do |locale|
+        @node.draft.outdated_translations?(locale: locale)
       end
+      if stale_locale
+        flash[:stale_locale] = stale_locale
+        flash[:stale_locale_path] = edit_node_path(@node, locale: stale_locale)
+      end
+    end
+
+    if params[:commit] == "Save + Unlock + Exit"
+      @node.unlock!
+      redirect_to node_path(@node)
+    else
+      redirect_to edit_node_path(@node)
+    end
+  rescue LockedByAnotherUser => e
+    flash[:error] = e.message
+    redirect_to node_path(@node)
+  rescue ActiveRecord::RecordInvalid
+    @page = @node.autosave || @node.draft || @node.head
+    render :action => :edit
+  end
+
+  def autosave
+    @node.update(node_params)
+    @node.autosave!( page_params.merge(:tag_list => params[:tag_list]), current_user )
+    head :ok
+  rescue LockedByAnotherUser => e
+    render plain: e.message, status: :locked
+  rescue ActiveRecord::RecordInvalid => e
+    render plain: e.message, status: :unprocessable_entity
+  rescue StandardError => e
+    render plain: "Autosave failed", status: :internal_server_error
+  end
+
+  def revert
+    @node.lock_for_editing!(current_user)
+    @node.revert!(current_user)
+
+    if params[:return_to].present?
+      redirect_to safe_return_to(params[:return_to])
+    elsif @node.draft
+      redirect_to edit_node_path(@node)
     else
-      render :action => :edit
+      redirect_to node_path(@node)
     end
+  rescue LockedByAnotherUser => e
+    flash[:error] = e.message
+    redirect_to node_path(@node)
   end
 
   def destroy
     @node.destroy
   end
-  
+
   def publish
     @node.publish_draft!
     flash[:notice] = "Draft has been published"
     redirect_to node_path(@node)
   end
-  
+
   def unlock
     if @node.unlock!
       flash[:notice] = "Node unlocked"
     else
       flash[:notice] = "Already unlocked"
     end
-    
+
+    redirect_to node_path(@node)
+  end
+
+  def generate_shared_preview
+    @node = Node.find(params[:id])
+    if @node.draft
+      @node.draft.ensure_preview_token!
+      flash[:notice] = "Shareable preview link created - see below."
+    else
+      flash[:notice] = "Create or edit a draft first - shared preview links are only available for pages with an active draft."
+    end
+    redirect_to node_path(@node)
+  end
+
+  def revoke_shared_preview
+    @node = Node.find(params[:id])
+    @node.draft.revoke_preview_token! if @node.draft
+    flash[:notice] = "Shareable preview link revoked."
     redirect_to node_path(@node)
   end
-  
+
+  def parameterize_preview
+    render plain: slug_for(params[:title])
+  end
+
+  # Filter functions for admin views
+  def drafts
+    @nodes = index_matching(Node.drafts_and_autosaves)
+  end
+
+  def recent
+    @nodes = index_matching(Node.recently_changed)
+  end
+
+  def mine
+    base = Node.joins(:pages)
+      .where("pages.user_id = ? or pages.editor_id = ?", current_user, current_user)
+      .distinct
+    @nodes = index_matching(base)
+  end
+
+  def chapters
+    @kind_keys = Array(params[:kinds]) & %w[erfa chaostreff]
+    @kind_keys = %w[erfa chaostreff] if @kind_keys.empty?
+    tags = @kind_keys.flat_map { |key| CccConventions::NODE_KINDS[key][:tags] }
+    @nodes = nodes_matching_tags(tags)
+  end
+
+  def tags
+    tags = params[:tags].to_s.split(',').map(&:strip).reject(&:blank?)
+    @nodes = nodes_matching_tags(tags)
+  end
+
+  def sitemap
+    @sitemap = Node.root.self_and_descendants_ordered_with_level
+    @sitemap_descendant_counts = descendant_counts_for(@sitemap)
+  end
+
   private
 
+    def slug_for(title)
+      title.to_s.parameterize
+    end
+
     def node_params
       params.fetch(:node, {}).permit(:slug, :parent_id, :staged_slug, :staged_parent_id)
     end
@@ -113,25 +230,56 @@ class NodesController < ApplicationController
     def page_params
       params.fetch(:page, {}).permit(:title, :abstract, :body, :template_name, :published_at, :user_id)
     end
-  
+
     def find_node
       @node = Node.find(params[:id])
     end
-    
+
     def find_parent
       case params[:kind]
-      when "top_level"
-        Node.root.id
-      when "update"
-        Update.find_or_create_parent.id
-      when "press_release"
-        Update.find_or_create_parent.id
       when "generic"
         if params[:parent_id] && Node.find(params[:parent_id])
           params[:parent_id]
         else
           nil
         end
+      else
+        config = CccConventions::NODE_KINDS[params[:kind]]
+        config && config[:parent] ? config[:parent].call.id : nil
+      end
+    end
+
+    def pin_to_default_locale
+      Globalize.with_locale(I18n.default_locale) { yield }
+    end
+
+    def descendant_counts_for(ordered_with_level)
+      counts = Hash.new(0)
+      stack = [] # [node, level, index]
+      ordered_with_level.each_with_index do |(node, level), index|
+        while stack.any? && stack.last[1] >= level
+          ancestor_node, _ancestor_level, ancestor_index = stack.pop
+          counts[ancestor_node.id] = index - ancestor_index - 1
+        end
+        stack << [node, level, index]
+      end
+      total = ordered_with_level.length
+      while stack.any?
+        ancestor_node, _ancestor_level, ancestor_index = stack.pop
+        counts[ancestor_node.id] = total - ancestor_index - 1
       end
+      counts
+    end
+
+    def nodes_matching_tags(tags)
+      matching_pages = Page.tagged_with(tags, any: true).reselect(:id)
+      base = Node.where(head_id: matching_pages).or(Node.where(draft_id: matching_pages))
+      index_matching(base)
+    end
+
+    def index_matching(base_scope)
+      scope = base_scope.includes(:head, :draft)
+      scope = scope.merge(Node.editor_search(params[:q])) if params[:q].present?
+      scope.order("nodes.updated_at desc").paginate(page: params[:page], per_page: 25)
     end
 end
diff --git a/app/controllers/page_translations_controller.rb b/app/controllers/page_translations_controller.rb
new file mode 100644
index 0000000..9446cd2
--- /dev/null
+++ b/app/controllers/page_translations_controller.rb
@@ -0,0 +1,109 @@
+class PageTranslationsController < ApplicationController
+  layout 'admin'
+
+  before_action :login_required
+  before_action :find_node
+  before_action :find_locale, :only => [:show, :edit, :update, :autosave, :destroy]
+
+  def index
+    page = @node.draft || @node.head
+    @translations = page ? page.translation_summary : []
+  end
+
+  def show
+    @page = @node.draft || @node.head
+    @translation         = @page.translations.find_by(:locale => @locale)
+    @default_translation = @page.translations.find_by(:locale => I18n.default_locale)
+  end
+
+  def edit
+    @node.lock_for_editing!(current_user)
+    @page = @node.draft || @node.head
+    @translation = @page.translations.find_by(:locale => @locale)
+  rescue LockedByAnotherUser => e
+    flash[:error] = e.message
+    redirect_to node_path(@node)
+  end
+
+  def update
+    Globalize.with_locale(@locale) { @node.autosave!(translation_params, current_user) }
+    @node.save_draft!(current_user)
+    flash[:notice] = "#{@locale.upcase} translation saved. Publish the draft to make it live."
+
+    if params[:commit] == "Save + Unlock + Exit"
+      @node.unlock!
+      redirect_to node_path(@node)
+    else
+      redirect_to edit_node_translation_path(@node, @locale)
+    end
+  rescue LockedByAnotherUser => e
+    flash[:error] = e.message
+    redirect_to node_path(@node)
+  end
+
+  def autosave
+    Globalize.with_locale(@locale) { @node.autosave!(translation_params, current_user) }
+    head :ok
+  rescue LockedByAnotherUser => e
+    render plain: e.message, status: :locked
+  rescue ActiveRecord::RecordInvalid => e
+    render plain: e.message, status: :unprocessable_entity
+  rescue StandardError => e
+    render plain: "Autosave failed", status: :internal_server_error
+  end
+
+  def destroy
+    base = @node.draft || @node.head
+    unless base && base.translated_locales.include?(@locale)
+      flash[:error] = "No #{@locale.to_s.upcase} translation exists to remove."
+      return redirect_to node_path(@node)
+    end
+
+    if (base.translated_locales - [@locale]).empty?
+      flash[:error] = "Can't remove the only remaining translation."
+      return redirect_to node_path(@node)
+    end
+
+    draft = ensure_editable_draft
+    draft.translations.where(:locale => @locale).delete_all
+    draft.reload
+
+    flash[:notice] = "#{@locale.upcase} translation removed from the draft. Publish to make this permanent."
+    redirect_to node_path(@node)
+  rescue LockedByAnotherUser => e
+    flash[:error] = e.message
+    redirect_to node_path(@node)
+  end
+
+  private
+
+    def find_node
+      @node = Node.find(params[:node_id])
+    end
+
+    # Every remaining action's :translation_locale is already
+    # router-constrained to non-default locales, so this should never
+    # actually fire in practice -- it's a deliberate second check, kept
+    # as a drift detector in case the route constraint and this list
+    # (both driven by Page.non_default_locales) ever disagree.
+    def find_locale
+      candidate = params[:translation_locale].to_s.to_sym
+      unless Page.non_default_locales.include?(candidate)
+        raise ActionController::RoutingError, "Unknown or default locale"
+      end
+      @locale = candidate
+    end
+
+    # Never mutates head directly. Locks first (same guard as the
+    # primary editor), then reuses an existing draft or creates one --
+    # deliberately not going through the autosave buffer: this is a
+    # plain, explicit Save, not a live-typing surface.
+    def ensure_editable_draft
+      @node.lock_for_editing!(current_user)
+      @node.draft || @node.create_new_draft(current_user)
+    end
+
+    def translation_params
+      params.fetch(:page, {}).permit(:title, :abstract, :body)
+    end
+end
diff --git a/app/controllers/related_assets_controller.rb b/app/controllers/related_assets_controller.rb
new file mode 100644
index 0000000..479ebec
--- /dev/null
+++ b/app/controllers/related_assets_controller.rb
@@ -0,0 +1,49 @@
+class RelatedAssetsController < ApplicationController
+  before_action :login_required
+  before_action :find_node
+
+  def search
+    term = params[:search_term].to_s.strip
+    attached_ids = @node.editable_page.related_assets.pluck(:asset_id)
+    scope = Asset.images.where.not(id: attached_ids)
+
+    results = if term.present?
+      scope.where("name ILIKE ?", "%#{term}%").limit(10)
+    else
+      scope.order(created_at: :desc).limit(5)
+    end
+
+    render json: results.map { |a|
+      { id: a.id, name: a.name, thumb_url: a.upload.url(:thumb) }
+    }
+  end
+
+  def create
+    asset = Asset.find(params[:asset_id])
+    related = @node.editable_page.related_assets.find_or_create_by!(asset: asset)
+
+    render json: {
+      id: related.id,
+      asset_id: asset.id,
+      name: asset.name,
+      thumb_url: asset.upload.url(:thumb),
+      url: node_related_asset_path(@node, related)
+    }
+  end
+
+  def destroy
+    @node.editable_page.related_assets.find(params[:id]).destroy
+    head :ok
+  end
+
+  def update
+    @node.editable_page.related_assets.find(params[:id]).insert_at(params[:position].to_i)
+    head :ok
+  end
+
+  private
+
+    def find_node
+      @node = Node.find(params[:node_id])
+    end
+end
diff --git a/app/controllers/revisions_controller.rb b/app/controllers/revisions_controller.rb
index 42d667e..0aed243 100644
--- a/app/controllers/revisions_controller.rb
+++ b/app/controllers/revisions_controller.rb
@@ -13,16 +13,31 @@ class RevisionsController < ApplicationController
 
   def diff
     @node = Node.find(params[:node_id])
-    
+
     if @node.pages.length > 1
       params[:start_revision]  ||= @node.pages.all[-2].revision
       params[:end_revision]    ||= @node.pages.all[-1].revision
     else
-      params[:start], params[:end] = 1, 1
+      params[:start_revision], params[:end_revision] = 1, 1
+    end
+
+    @start = @node.resolve_page_reference(params[:start_revision])
+    @end   = @node.resolve_page_reference(params[:end_revision])
+
+    if @start.nil? || @end.nil?
+      flash[:error] = "That comparison is no longer available."
+      redirect_to(node_path(@node)) and return
     end
-    
-    @start  = @node.pages.find_by_revision( params[:start_revision] )
-    @end    = @node.pages.find_by_revision( params[:end_revision] )
+
+    @locale_summary  = @end.locale_diff_summary(@start)
+    requested_locale = params[:locale].presence&.to_sym
+    default_locale    = @locale_summary.find { |s| s[:changed] }&.dig(:locale) || I18n.default_locale
+    @locale = @locale_summary.any? { |s| s[:locale] == requested_locale } ? requested_locale : default_locale
+
+    @diff_view              = params[:view] == "side_by_side" ? :side_by_side : :inline
+    @diff                   = @end.diff_against(@start, view: @diff_view, locale: @locale)
+    @available_layer_pairs  = @node.available_layer_pairs
+    @locked_by_other        = @node.locked? && @node.lock_owner != current_user
   end
 
   def show
diff --git a/app/controllers/shared_previews_controller.rb b/app/controllers/shared_previews_controller.rb
new file mode 100644
index 0000000..f6fb45a
--- /dev/null
+++ b/app/controllers/shared_previews_controller.rb
@@ -0,0 +1,22 @@
+class SharedPreviewsController < ApplicationController
+  def show
+    @page = Page.find_by!(preview_token: params[:token])
+    node  = @page.node
+
+    if node
+      is_head  = node.head_id  == @page.id
+      is_draft = node.draft_id == @page.id
+
+      currently_public = is_head && @page.public?
+      superseded        = !is_head && !is_draft
+
+      if superseded || currently_public
+        redirect_to @page.public_link
+        return
+      end
+    end
+
+    response.headers['X-Robots-Tag'] = 'noindex'
+    render template: @page.valid_template, layout: "application"
+  end
+end
diff --git a/app/controllers/users_controller.rb b/app/controllers/users_controller.rb
index f01691f..6572b7a 100644
--- a/app/controllers/users_controller.rb
+++ b/app/controllers/users_controller.rb
@@ -15,7 +15,7 @@ class UsersController < ApplicationController
   end
 
   def new
-    @user = User.new
+    @user = User.new(admin: params[:admin].present?)
   end
 
   def create