12 files changed, 313 insertions, 156 deletions

diff --git a/app/models/application_record.rb b/app/models/application_record.rb
new file mode 100644
index 0000000..10a4cba
--- /dev/null
+++ b/app/models/application_record.rb
@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end
diff --git a/app/models/asset.rb b/app/models/asset.rb
index 5bfea76..aca0ee8 100644
--- a/app/models/asset.rb
+++ b/app/models/asset.rb
@@ -1,39 +1,12 @@
-class Asset < ActiveRecord::Base
+class Asset < ApplicationRecord
+
+  include FileAttachment
   
   has_many :related_assets, :dependent => :destroy
   has_many :pages, :through => :related_assets
-  
-  has_attached_file(
-    :upload,
-    :styles => {
-      :medium   => "300x300",
-      :thumb    => "100x100",
-      :headline => "460x250#"
-    }
-  )
-  
-  named_scope :images, :conditions => {
-    :upload_content_type => [
-      "image/gif",
-      "image/jpeg",
-      "image/png"
-    ]
-  }
-  
-  named_scope :documents, :conditions => {
-    :upload_content_type => [
-      "application/pdf",
-      "text/plain",
-      "text/rtf"
-    ]
-  }
-  
-  named_scope :audio, :conditions => {
-    :upload_content_type => [
-      "audio/mpeg",
-      "audio/x-m4a",
-      "audio/wav",
-      "audio/x-wav"
-    ]
-  }
+
+  scope :images,    -> { where(:upload_content_type => ["image/gif", "image/jpeg", "image/png", "image/webp"]) }
+  scope :documents, -> { where(:upload_content_type => ["application/pdf", "text/plain", "text/rtf"]) }
+  scope :audio,     -> { where(:upload_content_type => ["audio/mpeg", "audio/x-m4a", "audio/wav", "audio/x-wav"]) }
+
 end
diff --git a/app/models/concerns/file_attachment.rb b/app/models/concerns/file_attachment.rb
new file mode 100644
index 0000000..0e99fa2
--- /dev/null
+++ b/app/models/concerns/file_attachment.rb
@@ -0,0 +1,139 @@
+# FileAttachment — minimal drop-in replacement for Paperclip's has_attached_file.
+#
+# Provides the same interface used throughout this codebase:
+#   asset.upload.url              -> "/system/uploads/:id/original/:filename"
+#   asset.upload.url(:thumb)      -> "/system/uploads/:id/thumb/:filename"
+#   asset.upload.content_type     -> string
+#   asset.upload.size             -> integer (bytes)
+#
+# Files are stored at:
+#   Rails.root/public/system/uploads/:id/:style/:filename
+#
+# Image variants are generated via ImageMagick (convert) on upload.
+# Non-image files get only an original, no variants.
+#
+# To replace an asset: assign a new file to asset.upload= and save.
+# The filename is fixed on first upload and preserved on replacement,
+# keeping all public URLs stable.
+#
+# Future: if more sophisticated asset management is needed (versioning,
+# S3, on-demand resizing), replace this module and keep the interface.
+
+module FileAttachment
+  extend ActiveSupport::Concern
+
+  STYLES = {
+    medium:   { geometry: "300x300>",  format: nil },
+    thumb:    { geometry: "100x100>",  format: nil },
+    headline: { geometry: "460x250!",  format: nil }
+  }.freeze
+
+  IMAGE_CONTENT_TYPES    = %w[image/jpeg image/gif image/png image/webp].freeze
+  VECTOR_CONTENT_TYPES   = %w[image/svg+xml].freeze
+  DISPLAYABLE_AS_IMAGE   = IMAGE_CONTENT_TYPES + VECTOR_CONTENT_TYPES
+
+  included do
+    attr_reader :upload
+
+    after_initialize :build_upload_proxy
+    after_save       :process_upload
+    before_destroy   :delete_upload_files
+  end
+
+  def upload=(uploaded_file)
+    return if uploaded_file.blank?
+    @pending_upload = uploaded_file
+    # Populate the database columns immediately so validations can use them
+    self.upload_file_name    = sanitize_filename(uploaded_file.original_filename)
+    self.upload_content_type = uploaded_file.content_type.to_s.split(';').first.strip
+    self.upload_file_size    = uploaded_file.size
+    self.upload_updated_at   = Time.current
+    build_upload_proxy
+  end
+
+  private
+
+  def build_upload_proxy
+    @upload = UploadProxy.new(self)
+  end
+
+  def process_upload
+    return unless @pending_upload
+    uploaded_file = @pending_upload
+    @pending_upload = nil
+
+    old_dir = Rails.root.join("public", "system", "uploads", id.to_s)
+    FileUtils.rm_rf(old_dir) if Dir.exist?(old_dir)
+
+    original_path = file_path(:original)
+    FileUtils.mkdir_p(File.dirname(original_path))
+    FileUtils.cp(uploaded_file.tempfile.path, original_path)
+
+    if IMAGE_CONTENT_TYPES.include?(upload_content_type)
+      generate_variants(original_path)
+    elsif VECTOR_CONTENT_TYPES.include?(upload_content_type)
+      generate_svg_variants(original_path)
+    end
+  end
+
+  def generate_variants(original_path)
+    STYLES.each do |style, options|
+      dest_path = file_path(style)
+      FileUtils.mkdir_p(File.dirname(dest_path))
+      system("magick", original_path, "-resize", options[:geometry], dest_path)
+    end
+  end
+
+  def generate_svg_variants(original_path)
+    STYLES.each do |style, _|
+      dest_path = file_path(style)
+      FileUtils.mkdir_p(File.dirname(dest_path))
+      FileUtils.cp(original_path, dest_path)
+    end
+  end
+
+  def delete_upload_files
+    dir = Rails.root.join("public", "system", "uploads", id.to_s)
+    FileUtils.rm_rf(dir) if Dir.exist?(dir)
+  end
+
+  def file_path(style)
+    Rails.root.join(
+      "public", "system", "uploads",
+      id.to_s, style.to_s, upload_file_name
+    ).to_s
+  end
+
+  def sanitize_filename(filename)
+    File.basename(filename).gsub(/[^\w\.\-]/, '_')
+  end
+
+  # Proxy object returned by asset.upload, providing the Paperclip-compatible
+  # interface used in views: .url, .url(:style), .content_type, .size
+  class UploadProxy
+    def initialize(record)
+      @record = record
+    end
+
+    def url(style = :original)
+      return "" if @record.upload_file_name.blank?
+      "/system/uploads/#{@record.id}/#{style}/#{@record.upload_file_name}"
+    end
+
+    def content_type
+      @record.upload_content_type.to_s
+    end
+
+    def size
+      @record.upload_file_size.to_i
+    end
+
+    def present?
+      @record.upload_file_name.present?
+    end
+
+    def blank?
+      !present?
+    end
+  end
+end
diff --git a/app/models/event.rb b/app/models/event.rb
index 60b8521..94a22e3 100644
--- a/app/models/event.rb
+++ b/app/models/event.rb
@@ -1,4 +1,4 @@
-class Event < ActiveRecord::Base
+class Event < ApplicationRecord
   
   # Associations
   
@@ -12,14 +12,12 @@ class Event < ActiveRecord::Base
   # Instance Methods
   
   def occurrences_in_range start_time, end_time
-    self.occurrences.find(
-      :all, :conditions => [
-        "start_time > ? AND end_time < ?", 
-        start_time, end_time
-      ]
+    self.occurrences.where(
+      "start_time > ? AND end_time < ?",
+      start_time, end_time
     )
-  end
-  
+  end 
+
   private
     def generate_occurences
       Occurrence.generate self
diff --git a/app/models/locked_by_another_user.rb b/app/models/locked_by_another_user.rb
new file mode 100644
index 0000000..6f9e272
--- /dev/null
+++ b/app/models/locked_by_another_user.rb
@@ -0,0 +1 @@
+class LockedByAnotherUser < StandardError; end
diff --git a/app/models/menu_item.rb b/app/models/menu_item.rb
index 054e7ee..7769b7f 100644
--- a/app/models/menu_item.rb
+++ b/app/models/menu_item.rb
@@ -1,6 +1,6 @@
-class MenuItem < ActiveRecord::Base
-  
-  default_scope :conditions => {:type => "MenuItem"}
+class MenuItem < ApplicationRecord
+ 
+  default_scope -> { where(:type => "MenuItem") }
   
   translates    :title
   
@@ -24,5 +24,5 @@ end
 
 
 class FeaturedArticle < MenuItem
-  default_scope :conditions => {:type => "FeaturedArticle"}
-end
\ No newline at end of file
+  default_scope -> { where(:type => "FeaturedArticle") }
+end
diff --git a/app/models/node.rb b/app/models/node.rb
index 6c11fed..92ecc12 100644
--- a/app/models/node.rb
+++ b/app/models/node.rb
@@ -1,14 +1,14 @@
-class Node < ActiveRecord::Base
+class Node < ApplicationRecord
   # Mixins and Plugins
   acts_as_nested_set
 
   # Associations
-  has_many    :pages, :order => "revision ASC"
-  belongs_to  :head,  :class_name => "Page",  :foreign_key => :head_id
-  belongs_to  :draft, :class_name => "Page",  :foreign_key => :draft_id
-  has_many    :permissions
-  has_one     :event
-  belongs_to  :lock_owner, :class_name => "User", :foreign_key => :locking_user_id
+  has_many    :pages, -> { order("revision ASC") }, :dependent => :destroy
+  belongs_to  :head,  :class_name => "Page",  :foreign_key => :head_id, :dependent => :destroy, optional: true
+  belongs_to  :draft, :class_name => "Page",  :foreign_key => :draft_id, :dependent => :destroy, optional: true
+  has_many    :permissions, :dependent => :destroy
+  has_one     :event, :dependent => :destroy
+  belongs_to  :lock_owner, :class_name => "User", :foreign_key => :locking_user_id, optional: true
 
   # Callbacks
   after_create  :initialize_empty_page
@@ -16,20 +16,20 @@ class Node < ActiveRecord::Base
   after_save    :update_unique_names_of_children
 
   # Validations
-  validates_length_of     :slug, :within => 1..255,    :unless => "parent_id.nil?"
-  validates_presence_of   :slug,                       :unless => "parent_id.nil?"
-  validates_uniqueness_of :slug, :scope => :parent_id, :unless => "parent_id.nil?"
-  validates_presence_of   :parent_id,                  :unless => "Node.root.nil?"
+  validates_length_of     :slug, :within => 1..255,    :unless => -> { parent_id.nil? }
+  validates_presence_of   :slug,                       :unless => -> { parent_id.nil? }
+  validates_uniqueness_of :slug, :scope => :parent_id, :unless => -> { parent_id.nil? }
+  validates_presence_of   :parent_id,                  :unless => -> { Node.root.nil? }
 
   validate :borders       # This should never ever happen.
 
   # Index for Fulltext Search
-  define_index do
-    indexes head.translations.title
-    indexes slug
-    indexes unique_name
-    indexes head.translations.body
-  end
+  # define_index do
+  #   indexes head.translations.title
+  #   indexes slug
+  #   indexes unique_name
+  #   indexes head.translations.body
+  # end
 
   # Class methods
 
@@ -39,8 +39,8 @@ class Node < ActiveRecord::Base
   # revision with -1. It raises an Argument error if the revision is not a
   # Fixnum
   def self.find_page path, revision = -1
-    unless revision.class == Fixnum
-      raise ArgumentError, "revision must be a Fixnum"
+    unless revision.is_a?(Integer)
+      raise ArgumentError, "revision must be a Integer"
     end
 
     node = Node.find_by_unique_name(path)
@@ -60,6 +60,7 @@ class Node < ActiveRecord::Base
   # Instance Methods
 
   def find_or_create_draft current_user
+    self.wipe_draft!
     if draft && self.lock_owner == current_user
       draft
     elsif draft && self.lock_owner.nil?
@@ -72,7 +73,7 @@ class Node < ActiveRecord::Base
       raise(
         LockedByAnotherUser,
         "Page is locked by another user who is working on it! " \
-        "Last modification: #{draft.updated_at.to_s(:db)}"
+        "Last modification: #{draft.updated_at.to_fs(:db)}"
       )
     else
       lock_for! current_user
@@ -94,25 +95,55 @@ class Node < ActiveRecord::Base
   end
 
   def publish_draft!
+    # Return nil if nothing to publish and no staged changes
+    return nil unless self.draft || staged_slug || staged_parent_id
+
     if self.draft
       self.head = self.draft
       self.head.published_at ||= Time.now
       self.head.save!
-
       self.draft = nil
+    end
 
-      if staged_slug && (staged_slug != slug)
-        self.slug = staged_slug
-      end
+    if staged_slug && (staged_slug != slug)
+      self.slug = staged_slug
+      self.staged_slug = nil
+    end
 
-      if staged_parent_id && (staged_parent_id != parent_id)
-        self.parent_id = staged_parent_id
+    if staged_parent_id && (staged_parent_id != parent_id)
+      new_parent = Node.find(staged_parent_id)
+      self.staged_parent_id = nil
+      self.save!
+      self.move_to_child_of(new_parent)
+    else
+      unless self.save
+        raise ActiveRecord::RecordInvalid.new(self)
       end
+    end
 
-      self.save!
+    self.reload
+    self.update_unique_name
+    self.send(:update_unique_names_of_children)
+    self.unlock!
+    self
+  end
+
+  # removes a draft and the lock if it is older than a day and still
+  # identical to head
+  def wipe_draft!
+    unless self.draft
       self.unlock!
-      self
+      return
     end
+    return unless self.head
+    return unless self.draft.updated_at < 1.day.ago
+    return if self.head.has_changes_to? self.draft
+
+    self.draft.destroy
+    self.draft_id = nil
+    self.unlock!
+    self.save!
+    self.reload
   end
 
   def restore_revision! revision
@@ -126,7 +157,7 @@ class Node < ActiveRecord::Base
 
   # returns an array with all parts of a unique_name rather than a string
   def unique_path
-    unique_name.split("/") rescue [unique_name]
+    unique_name.to_s.split("/")
   end
 
   # returns array with pages up to root excluding root
@@ -180,6 +211,15 @@ class Node < ActiveRecord::Base
     self.created_at < new_id_format_date ? unique_path : id
   end
 
+  # Full-text search across all locale translations using PostgreSQL tsvector.
+  # Uses 'simple' dictionary (no stemming, no stopwords) so queries work
+  # across German and English content without language detection.
+  def self.search(term, _ = {})
+    joins(head: :translations)
+      .where("page_translations.search_vector @@ plainto_tsquery('simple', ?)", term)
+      .distinct
+  end
+
   protected
     def lock_for! current_user
       self.lock_owner = current_user
@@ -208,8 +248,12 @@ class Node < ActiveRecord::Base
     # Hopefully until no childrens occur
     def update_unique_names_of_children
       unless root?
-        self.descendants.each do |descendant|
-          descendant.update_unique_name
+        # Use parent_id-based traversal instead of lft/rgt descendants
+        # due to awesome_nested_set not refreshing parent lft/rgt in memory
+        Node.where(:parent_id => self.id).each do |child|
+          child.reload
+          child.update_unique_name
+          child.send(:update_unique_names_of_children)
         end
       end
     end
@@ -220,7 +264,3 @@ class Node < ActiveRecord::Base
       end
     end
 end
-
-class LockedByAnotherUser < StandardError; end
-
-
diff --git a/app/models/occurrence.rb b/app/models/occurrence.rb
index 591e1e0..3baf447 100644
--- a/app/models/occurrence.rb
+++ b/app/models/occurrence.rb
@@ -1,7 +1,7 @@
 # TODO Make a gem out of the c wrapper
 require 'chaos_calendar'
 
-class Occurrence < ActiveRecord::Base
+class Occurrence < ApplicationRecord
   
   # Associations
   
@@ -11,29 +11,22 @@ class Occurrence < ActiveRecord::Base
   # Class Methods
   
   def self.find_in_range start_time, end_time
-    find(
-      :all,
-      :include => :node, 
-      :conditions => [
-        "start_time > ? AND end_time < ?", start_time, end_time 
-      ]
-    )
+    includes(:node)
+      .where("start_time > ? AND end_time < ?", start_time, end_time)
+      .order("start_time")
   end
-  
+
   def self.find_next
-    find(
-      :all,
-      :limit => 1,
-      :include => :node,
-      :conditions => ["start_time > ?", Time.now]
-    )
+    includes(:node)
+      .where("start_time > ?", Time.now)
+      .limit(1)
   end
-  
+
   # Deletes all Occurrences which belong to the given event. Afterwards a few
   # variables are set to save repetitive queries. The occurrences of the given
   # event are then calculated and created.
   def self.generate event
-    self.delete_all(:event_id => event.id)
+    self.where(:event_id => event.id).delete_all
     
     node        = event.node
     duration    = (event.end_time - event.start_time)
diff --git a/app/models/page.rb b/app/models/page.rb
index c5da386..e6baf20 100644
--- a/app/models/page.rb
+++ b/app/models/page.rb
@@ -1,25 +1,9 @@
 require 'xml'
 
-class Page < ActiveRecord::Base
+class Page < ApplicationRecord
 
   PUBLIC_TEMPLATE_PATH = File.join(%w(custom page_templates public))
-  FULL_PUBLIC_TEMPLATE_PATH = File.join(RAILS_ROOT, 'app', 'views', PUBLIC_TEMPLATE_PATH)
-
-  # named scopes
-
-  named_scope(
-    :drafts,
-    :joins => :node,
-    :include => [:translations],
-    :conditions => ["nodes.draft_id = pages.id"]
-  )
-
-  named_scope(
-    :heads,
-    :joins => :node,
-    :include => [:translations],
-    :conditions => ["nodes.head_id = pages.id"]
-  )
+  FULL_PUBLIC_TEMPLATE_PATH = Rails.root.join('app', 'views', PUBLIC_TEMPLATE_PATH)
 
   # Mixins and Plugins
   acts_as_taggable
@@ -28,20 +12,21 @@ class Page < ActiveRecord::Base
   translates :title, :abstract, :body # Globalize2
 
   # Associations
-  belongs_to :node
-  belongs_to :user
-  belongs_to :editor, :class_name => "User"
+  belongs_to :node, optional: true
+  belongs_to :user, optional: true
+  belongs_to :editor, :class_name => "User", optional: true
   has_many   :related_assets
-  has_many   :assets, :through => :related_assets, :order => "position ASC"
+  has_many   :assets, -> { order("position ASC") }, :through => :related_assets
+
+  # Named scopes
+  scope :drafts, -> { joins(:node).includes(:translations).where("nodes.draft_id = pages.id") }
+  scope :heads,  -> { joins(:node).includes(:translations).where("nodes.head_id = pages.id") }
 
   # Filter
   before_create :set_page_title
   before_create :set_template
   before_save   :rewrite_links_in_body
 
-  # Security
-  attr_accessible :title, :abstract, :body, :template_name, :published_at, :user_id
-
   # Class Methods
 
   # This method is most likely called from the ContentHelper.render_collection
@@ -51,8 +36,8 @@ class Page < ActiveRecord::Base
   # partially or entirely overwritten by the options hash. Afterwards the merged
   # parameters are used to query the DB for Pages matching these parameters.
   # The aggregation only takes published pages into account.
-  def self.aggregate options, page=1
 
+  def self.aggregate options, page=1
     defaults = {
       :tags             => "",
       :limit            => 25,
@@ -62,15 +47,24 @@ class Page < ActiveRecord::Base
 
     options = defaults.merge options
 
-    Page.heads.paginate(
-      find_options_for_find_tagged_with(
-        options[:tags].gsub(/\s/, ","), :match_all => true
-      ).merge(
-        :page     => page,
-        :per_page => options[:limit],
-        :order    => "#{options[:order_by]} #{options[:order_direction]}"
-      )
-    )
+    scope = Page.heads
+    unless options[:tags].blank?
+      tag_names = options[:tags].gsub(/\s/, ",").split(",").map(&:strip).map(&:downcase).uniq.reject(&:blank?)
+
+      unless tag_names.empty?
+        scope = scope
+          .joins("JOIN taggings ON taggings.taggable_id = pages.id
+                  AND taggings.taggable_type = 'Page'
+                  AND taggings.context = 'tags'")
+          .joins("JOIN tags ON tags.id = taggings.tag_id")
+          .where("LOWER(tags.name) IN (?)", tag_names)
+          .group("pages.id")
+          .having("COUNT(DISTINCT tags.id) = ?", tag_names.length)
+      end
+    end
+
+    scope.order("#{options[:order_by]} #{options[:order_direction]}")
+      .paginate(:page => page, :per_page => options[:limit])
   end
 
   def self.custom_templates
@@ -89,11 +83,24 @@ class Page < ActiveRecord::Base
   # outdated_translations? for more information.
   # Takes :locale => <locale> and :delta_time => 12.hours as options
   def self.find_with_outdated_translations options = {}
-    Page.all(:include => :translations).select do |page|
+    Page.includes(:translations).select do |page|
       page.outdated_translations? options
     end
   end
 
+  # Is used to compare a node's head with the node's draft
+
+  def has_changes_to? draft
+    return true unless node == draft.node
+    return true unless assets == draft.assets
+    return true unless tag_list == draft.tag_list
+    return true unless template_name == draft.template_name
+    return true unless translated_locales.sort_by(&:to_s) == draft.translated_locales.sort_by(&:to_s)
+    changed = false
+    translated_locales.each { |locale| I18n.with_locale(locale) { changed = true unless title == draft.title && abstract == draft.abstract && body == draft.body } }
+    return changed
+  end
+
   # Instance Methods
 
   def public_template_path
@@ -105,7 +112,7 @@ class Page < ActiveRecord::Base
   end
 
   def template_exists?
-    File.exists? "#{full_public_template_path}.html.erb"
+    File.exist? "#{full_public_template_path}.html.erb"
   end
 
   def valid_template
@@ -136,7 +143,7 @@ class Page < ActiveRecord::Base
 
     # Clone translated attributes
     page.translations.each do |translation|
-      self.translations.create!(translation.attributes)
+      self.translations.create!(translation.attributes.except("id", "page_id", "created_at", "updated_at"))
     end
 
     # Clone asset references
@@ -149,6 +156,16 @@ class Page < ActiveRecord::Base
     published_at.nil? ? true : published_at < Time.now
   end
 
+  def effective_lang
+    if translated_locales.empty?
+      return 'de'
+    elsif translated_locales.include?(I18n.locale)
+      return I18n.locale
+    else
+      return translated_locales.first
+    end
+  end
+
   # Returns true if a page has translations where one of them is significantly
   # older than the other.
   # Takes the I18n.default locale and a second :locale to test if the
@@ -165,8 +182,8 @@ class Page < ActiveRecord::Base
 
     translations = self.translations
 
-    default = *(translations.select {|x| x.locale == I18n.default_locale})
-    custom  = *(translations.select {|x| x.locale == options[:locale]})
+    default = translations.find {|x| x.locale.to_s == I18n.default_locale.to_s }
+    custom  = translations.find {|x| x.locale.to_s == options[:locale].to_s }
 
     if translations.size > 1 && default && custom
       difference = (default.updated_at - custom.updated_at).to_i.abs
@@ -215,11 +232,6 @@ class Page < ActiveRecord::Base
           links       = links.reject { |l| l[:href] =~ /system\/uploads/ }
           locales     = I18n.available_locales.reject {|l| l == :root}
 
-          if xml_doc.find("//p/aggregate")[0]
-            aggregate_tags   = xml_doc.find("//aggregate")
-            aggregate_tags[0].parent.replace_with aggregate_tags[0]
-          end
-
           links.each do |link|
             unless locales.include? link[:href].slice(1,2).to_sym
               unless link[:href] =~ /sytem\/uploads/
@@ -238,4 +250,4 @@ class Page < ActiveRecord::Base
       end
     end
 
-end
\ No newline at end of file
+end
diff --git a/app/models/permission.rb b/app/models/permission.rb
index 438538e..1383a4b 100644
--- a/app/models/permission.rb
+++ b/app/models/permission.rb
@@ -1,4 +1,4 @@
-class Permission < ActiveRecord::Base
+class Permission < ApplicationRecord
   # Validations
   validates_presence_of   :user_id, :node_id, :granted
   validates_inclusion_of  :granted, :in => [true, false]
@@ -8,6 +8,6 @@ class Permission < ActiveRecord::Base
   belongs_to :node
   
   # Named scopes
-  named_scope :for_node, lambda { |node| { :conditions => ['node_id = ?', (node.is_a? Node ? node.id : node)] } }
-  named_scope :for_user, lambda { |user| { :conditions => ['user_id = ?', (user.is_a? User ? user.id : user)] } }
+  scope :for_node, ->(node) { where('node_id = ?', (node.is_a?(Node) ? node.id : node)) }
+  scope :for_user, ->(user) { where('user_id = ?', (user.is_a?(User) ? user.id : user)) }
 end
diff --git a/app/models/related_asset.rb b/app/models/related_asset.rb
index af09420..8f16460 100644
--- a/app/models/related_asset.rb
+++ b/app/models/related_asset.rb
@@ -1,8 +1,8 @@
-class RelatedAsset < ActiveRecord::Base
+class RelatedAsset < ApplicationRecord
   belongs_to :page
   belongs_to :asset
   
   acts_as_list :scope => :page_id
-  
-  default_scope :order => "position ASC"
-end
\ No newline at end of file
+
+  default_scope -> { order("position ASC") }
+end
diff --git a/app/models/user.rb b/app/models/user.rb
index ce5503f..92ac33a 100644
--- a/app/models/user.rb
+++ b/app/models/user.rb
@@ -1,6 +1,6 @@
 require 'digest/sha1'
 
-class User < ActiveRecord::Base
+class User < ApplicationRecord
   # Mixins and Plugins
   include Authentication
   include Authentication::ByPassword
@@ -21,8 +21,6 @@ class User < ActiveRecord::Base
   validates_format_of       :email, :with => Authentication.email_regex,
                             :message => Authentication.bad_email_message
 
-  attr_accessible :login, :email, :password, :password_confirmation, :admin
-
   # Authenticates a user by their login name and unencrypted password. Returns the user or nil.
   def self.authenticate(login, password)
     return nil if login.blank? || password.blank?