iqvoc 4.12.1 → 4.13.0

data/app/helpers/rdf_helper.rb

@@ -15,6 +15,20 @@
 # limitations under the License.
 
 module RdfHelper
+  def render_scheme(document, scheme, top_concepts)
+
+    document << scheme.build_rdf_subject do |s|
+      scheme.pref_labels.each do |pl|
+        s.Dct::title pl.value, lang: pl.language
+      end
+
+      top_concepts.each do |top_concept|
+        s.Skos::hasTopConcept IqRdf.build_uri(top_concept.origin)
+      end
+    end
+
+  end
+
   def render_concept(document, concept, suppress_extra_labels = false)
     # You can not eager load polymorphic associations. That's why we're loading
     # the collections _one_ time and remember them for further _render_concept_

data/app/helpers/search_results_helper.rb

@@ -36,7 +36,7 @@ module SearchResultsHelper
     desc = if results.any?
       "(#{results.total_count})"
     else
-      t('txt.views.search_results.no_results_found')
+      ''
     end
 
     content_tag :h2 do

data/app/models/ability.rb

@@ -62,6 +62,9 @@ class Ability
 
         can :reset, :thesaurus
         can :sync, :triplestore
+
+        can :see, :exception
+        can :profile, :system
       end
     else # no user
       can :create, UserSession

data/app/models/abstract_user.rb

@@ -14,19 +14,31 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-class AbstractUser < ActiveRecord::Base
+class AbstractUser < ApplicationRecord
   self.table_name = 'users'
 
   delegate :can?, :cannot?, :to => :ability
 
-  validates_presence_of :email
-  validates_uniqueness_of :email
-  # validates_format_of :email, with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+  validates :email, uniqueness: { case_sensitive: false }
+
+  validates :password,
+            confirmation: {if: :require_password?},
+            length: {
+              minimum: 8,
+              if: :require_password?
+            }
+
+  validates :password_confirmation,
+            length: {
+              minimum: 8,
+              if: :require_password?
+            }
 
   acts_as_authentic do |config|
-    config.validate_email_field = false
-    config.maintain_sessions = false
-    config.crypto_provider = Authlogic::CryptoProviders::Sha512 # use authlogic's old crypto provider
+    config.log_in_after_create = false
+    config.log_in_after_password_change = false
+    config.transition_from_crypto_providers = [Authlogic::CryptoProviders::Sha512]
+    config.crypto_provider = Authlogic::CryptoProviders::SCrypt
   end
 
   def self.default_role

data/app/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/app/models/collection/base.rb

@@ -21,19 +21,23 @@ class Collection::Base < Concept::Base
   end
 
   has_many Note::SKOS::Definition.name.to_relation_name,
-      class_name: 'Note::SKOS::Definition',
-      as: :owner,
-      dependent: :destroy
+           class_name: 'Note::SKOS::Definition',
+           as: :owner,
+           dependent: :destroy,
+           inverse_of: :owner
 
   has_many :members,
       class_name: 'Collection::Member::Base',
       foreign_key: 'collection_id',
-      dependent: :destroy
+      dependent: :destroy,
+      inverse_of: :collection
 
   has_many :parent_collection_members,
       class_name: 'Collection::Member::Base',
       foreign_key: 'target_id',
-      dependent: :destroy
+      dependent: :destroy,
+      inverse_of: :target
+
   has_many :parent_collections,
       through: :parent_collection_members,
       source: 'collection'
@@ -95,10 +99,6 @@ class Collection::Base < Concept::Base
     members.map(&:target).compact.reject { |m| m.is_a?(::Collection::Base) }
   end
 
-  def additional_info
-    concepts.count
-  end
-
   def to_param
     origin
   end

data/app/models/collection/member/base.rb

@@ -14,15 +14,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-class Collection::Member::Base < ActiveRecord::Base
+class Collection::Member::Base < ApplicationRecord
   self.table_name = 'collection_members'
 
   class_attribute :rdf_namespace, :rdf_predicate
   self.rdf_namespace = nil
   self.rdf_predicate = nil
 
-  belongs_to :collection, class_name: 'Collection::Base'
-  belongs_to :target, class_name: 'Concept::Base'
+  belongs_to :collection,
+             class_name: 'Collection::Base'
+
+  belongs_to :target,
+             class_name: 'Concept::Base'
 
   def self.view_section(obj)
     'main'

data/app/models/concept/base.rb

@@ -14,7 +14,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-class Concept::Base < ActiveRecord::Base
+class Concept::Base < ApplicationRecord
   attr_accessor :reverse_match_service
   self.table_name = 'concepts'
 
@@ -169,27 +169,66 @@ class Concept::Base < ActiveRecord::Base
 
   @nested_relations = [] # Will be marked as nested attributes later
 
-  has_many :relations, foreign_key: 'owner_id', class_name: 'Concept::Relation::Base', dependent: :destroy
-  has_many :related_concepts, through: :relations, source: :target
-  has_many :referenced_relations, foreign_key: 'target_id', class_name: 'Concept::Relation::Base', dependent: :destroy
+  has_many :relations,
+           foreign_key: 'owner_id',
+           class_name: 'Concept::Relation::Base',
+           dependent: :destroy,
+           inverse_of: :owner
+
+  has_many :related_concepts,
+           through: :relations,
+           source: :target
+
+  has_many :referenced_relations,
+           foreign_key: 'target_id',
+           class_name: 'Concept::Relation::Base',
+           dependent: :destroy,
+           inverse_of: :target
   include_to_deep_cloning(:relations, :referenced_relations)
 
-  has_many :labelings, foreign_key: 'owner_id', class_name: 'Labeling::Base', dependent: :destroy
-  has_many :labels, -> { order(:value) }, through: :labelings, source: :target
+  has_many :labelings,
+           foreign_key: 'owner_id',
+           class_name: 'Labeling::Base',
+           dependent: :destroy,
+           inverse_of: :owner
+
+  has_many :labels, -> { order(:value) },
+           through: :labelings,
+           source: :target
   # Deep cloning has to be done in specific relations. S. pref_labels etc
 
-  has_many :notes, class_name: 'Note::Base', as: :owner, dependent: :destroy
+  has_many :notes,
+           class_name: 'Note::Base',
+           as: :owner,
+           dependent: :destroy,
+           inverse_of: :owner
   include_to_deep_cloning({ notes: :annotations })
 
-  has_many :matches, foreign_key: 'concept_id', class_name: 'Match::Base', dependent: :destroy
+  has_many :matches,
+           foreign_key: 'concept_id',
+           class_name: 'Match::Base',
+           dependent: :destroy,
+           inverse_of: :concept
   include_to_deep_cloning(:matches)
 
-  has_many :collection_members, foreign_key: 'target_id', class_name: 'Collection::Member::Base', dependent: :destroy
-  has_many :collections, through: :collection_members, class_name: Iqvoc::Collection.base_class_name
+  has_many :collection_members,
+           foreign_key: 'target_id',
+           class_name: 'Collection::Member::Base',
+           dependent: :destroy,
+           inverse_of: :target
+
+  has_many :collections,
+           through: :collection_members,
+           class_name: Iqvoc::Collection.base_class_name
   include_to_deep_cloning(:collection_members)
 
-  has_many :notations, class_name: 'Notation::Base', foreign_key: 'concept_id', dependent: :destroy
+  has_many :notations,
+           class_name: 'Notation::Base',
+           foreign_key: 'concept_id',
+           dependent: :destroy,
+           inverse_of: :concept
   include_to_deep_cloning :notations
+
   @nested_relations << :notations
 
   # ************** "Dynamic"/configureable relations
@@ -203,7 +242,8 @@ class Concept::Base < ActiveRecord::Base
   has_many :broader_relations,
     foreign_key: :owner_id,
     class_name: Iqvoc::Concept.broader_relation_class_name,
-    extend: Concept::Relation::ReverseRelationExtension
+    extend: Concept::Relation::ReverseRelationExtension,
+    inverse_of: :owner
 
   # Narrower
   # FIXME: Actually this is not needed anymore.
@@ -212,7 +252,8 @@ class Concept::Base < ActiveRecord::Base
   has_many :narrower_relations,
     foreign_key: :owner_id,
     class_name: Iqvoc::Concept.broader_relation_class.narrower_class.name,
-    extend: Concept::Relation::ReverseRelationExtension
+    extend: Concept::Relation::ReverseRelationExtension,
+    inverse_of: :owner
 
   # Relations
   # e.g. 'concept_relation_skos_relateds'
@@ -222,14 +263,16 @@ class Concept::Base < ActiveRecord::Base
     has_many relation_class_name.to_relation_name,
       foreign_key: :owner_id,
       class_name: relation_class_name,
-      extend: Concept::Relation::ReverseRelationExtension
+      extend: Concept::Relation::ReverseRelationExtension,
+      inverse_of: :owner
   end
 
   # *** Labels/Labelings
 
   has_many :pref_labelings,
     foreign_key: 'owner_id',
-    class_name: Iqvoc::Concept.pref_labeling_class_name
+    class_name: Iqvoc::Concept.pref_labeling_class_name,
+    inverse_of: :owner
 
   has_many :pref_labels,
     -> { order(:value) },
@@ -238,7 +281,8 @@ class Concept::Base < ActiveRecord::Base
 
   has_many :alt_labelings,
     foreign_key: 'owner_id',
-    class_name: Iqvoc::Concept.alt_labeling_class_name
+    class_name: Iqvoc::Concept.alt_labeling_class_name,
+    inverse_of: :owner
 
   has_many :alt_labels,
     -> { order(:value) },
@@ -248,7 +292,9 @@ class Concept::Base < ActiveRecord::Base
   Iqvoc::Concept.labeling_class_names.each do |labeling_class_name, languages|
     has_many labeling_class_name.to_relation_name,
       foreign_key: 'owner_id',
-      class_name: labeling_class_name
+      class_name: labeling_class_name,
+      inverse_of: :owner
+
     # Only clone superclass relations
     unless Iqvoc::Concept.labeling_classes.keys.detect { |klass| labeling_class_name.constantize < klass }
       # When a Label has only one labeling (the "no skosxl" case) we'll have to
@@ -266,7 +312,8 @@ class Concept::Base < ActiveRecord::Base
   Iqvoc::Concept.match_class_names.each do |match_class_name|
     has_many match_class_name.to_relation_name,
       class_name: match_class_name,
-      foreign_key: 'concept_id'
+      foreign_key: 'concept_id',
+      inverse_of: :concept
 
     # Serialized setters and getters (\r\n or , separated) -- TODO: use InlineDataHelper?
     define_method("inline_#{match_class_name.to_relation_name}".to_sym) do
@@ -285,14 +332,20 @@ class Concept::Base < ActiveRecord::Base
 
   Iqvoc::Concept.note_class_names.each do |class_name|
     relation_name = class_name.to_relation_name
-    has_many relation_name, class_name: class_name, as: :owner
+    has_many relation_name,
+             class_name: class_name,
+             as: :owner,
+             inverse_of: :owner
     @nested_relations << relation_name
   end
 
   # *** Further association classes (could be ranks or stuff like that)
 
   Iqvoc::Concept.additional_association_classes.each do |association_class, foreign_key|
-    has_many association_class.name.to_relation_name, class_name: association_class.name, foreign_key: foreign_key, dependent: :destroy
+    has_many association_class.name.to_relation_name,
+             class_name: association_class.name,
+             foreign_key: foreign_key,
+             dependent: :destroy # TODO: add inverse_of???
     include_to_deep_cloning(association_class.deep_cloning_relations)
     association_class.referenced_by(self)
   end
@@ -313,7 +366,7 @@ class Concept::Base < ActiveRecord::Base
     includes(:narrower_relations, :pref_labels).
     where(concept_relations: { id: nil },
       labelings: { type: Iqvoc::Concept.pref_labeling_class_name }).
-    order("LOWER(#{Label::Base.table_name}.value)")
+    order(Arel.sql("LOWER(#{Label::Base.table_name}.value)"))
   end
 
   def self.with_associations
@@ -324,7 +377,7 @@ class Concept::Base < ActiveRecord::Base
 
   def self.with_pref_labels
     includes(:pref_labels).
-    order("LOWER(#{Label::Base.table_name}.value)").
+    order(Arel.sql("LOWER(#{Label::Base.table_name}.value)")).
     where(labelings: { type: Iqvoc::Concept.pref_labeling_class_name }) # This line is just a workaround for a Rails Bug. TODO: Delete it when the Bug is fixed
   end
 
@@ -412,13 +465,26 @@ class Concept::Base < ActiveRecord::Base
   # If no prefLabel for the requested language exists, a new label will be returned
   # (if you modify it, don't forget to save it afterwards!)
   def pref_label
-    lang = I18n.locale.to_s == 'none' ? nil : I18n.locale.to_s
-    @cached_pref_labels ||= pref_labels.published.each_with_object({}) do |label, hash|
-      if hash[label.language]
-        Rails.logger.warn("Two pref_labels (#{hash[label.language]}, #{label}) for one language (#{label.language}). Taking the second one.")
+    if pref_labels.loaded?
+      # use select if association is already loaded
+      @cached_pref_labels ||= pref_labels.select(&:published?).each_with_object({}) do |label, hash|
+        if hash[label.language]
+          Rails.logger.warn("Two pref_labels (#{hash[label.language]}, #{label}) for one language (#{label.language}). Taking the second one.")
+        end
+        hash[label.language] = label
+      end
+    else
+      # use scope otherwise
+      @cached_pref_labels ||= pref_labels.published.each_with_object({}) do |label, hash|
+        if hash[label.language]
+          Rails.logger.warn("Two pref_labels (#{hash[label.language]}, #{label}) for one language (#{label.language}). Taking the second one.")
+        end
+        hash[label.language] = label
       end
-      hash[label.language] = label
     end
+
+    lang = I18n.locale.to_s == 'none' ? nil : I18n.locale.to_s
+
     if @cached_pref_labels[lang].nil?
       # Fallback to the main language
       @cached_pref_labels[lang] = pref_labels.select{ |l|
@@ -436,7 +502,7 @@ class Concept::Base < ActiveRecord::Base
     elsif lang
       lang = lang.to_s
     end
-    labeling_class = labeling_class.name if labeling_class < ActiveRecord::Base # Use the class name string
+    labeling_class = labeling_class.name if labeling_class < ApplicationRecord # Use the class name string
     @labels ||= labelings.each_with_object({}) do |labeling, hash|
       ((hash[labeling.class.name.to_s] ||= {})[labeling.target.language] ||= []) << labeling.target if labeling.target
     end
@@ -444,23 +510,23 @@ class Concept::Base < ActiveRecord::Base
   end
 
   def related_concepts_for_relation_class(relation_class, only_published = true)
-    relation_class = relation_class.name if relation_class < ActiveRecord::Base # Use the class name string
+    relation_class = relation_class.name if relation_class < ApplicationRecord # Use the class name string
     relations.select { |rel| rel.class.name == relation_class }.map(&:target).
         select { |c| c.published? || !only_published }.sort_by(&:pref_label)
   end
 
   def matches_for_class(match_class)
-    match_class = match_class.name if match_class < ActiveRecord::Base # Use the class name string
+    match_class = match_class.name if match_class < ApplicationRecord # Use the class name string
     matches.select{ |match| match.class.name == match_class }
   end
 
   def notes_for_class(note_class)
-    note_class = note_class.name if note_class < ActiveRecord::Base # Use the class name string
+    note_class = note_class.name if note_class < ApplicationRecord # Use the class name string
     notes.select{ |note| note.class.name == note_class }
   end
 
   def notations_for_class(notation_class)
-    notation_class = notation_class.name if notation_class < ActiveRecord::Base # Use the class name string
+    notation_class = notation_class.name if notation_class < ApplicationRecord # Use the class name string
     notations.select{ |notation| notation.class.name == notation_class }
   end
 
@@ -489,6 +555,10 @@ class Concept::Base < ActiveRecord::Base
     Delayed::Backend::ActiveRecord::Job.where(delayed_global_reference_id: gid)
   end
 
+  def expired?
+    self.expired_at && self.expired_at < Date.today
+  end
+
   private
 
   # checks if provided uri is defined as a federation source

data/app/models/concept/relation/base.rb

@@ -14,7 +14,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-class Concept::Relation::Base < ActiveRecord::Base
+class Concept::Relation::Base < ApplicationRecord
   # ATTENTION:
   # This class (and the inheriting subclasses) should not reference the
   # Concept::Base class directly at load time!
@@ -87,11 +87,11 @@ class Concept::Relation::Base < ActiveRecord::Base
   end
 
   def self.view_section(obj)
-    'relations'
+    'main'
   end
 
   def self.view_section_sort_key(obj)
-    100
+    200
   end
 
   def self.partial_name(obj)

data/app/models/concept/skos/base.rb

@@ -40,4 +40,14 @@ class Concept::SKOS::Base < Concept::Base
     col = arel_table[:expired_at]
     where((col.eq(nil)).or(col.gteq(time)))
   end
+
+  def self.recent(limit = 5)
+    self
+    .published
+    .not_expired
+    .joins(:notes => :annotations)
+    .where(note_annotations: { predicate: 'created' })
+    .order('note_annotations.value DESC')
+    .limit(limit)
+  end
 end

data/app/models/concerns/search_extension.rb

@@ -44,7 +44,7 @@ module SearchExtension
     end
 
     def build_query_string(params = {})
-      query_str = params[:query]
+      query_str = params[:query].strip
       query_str = "%#{query_str}" if ['contains', 'ends_with'].include?(params[:query_type].to_s)
       query_str = "#{query_str}%" if ['contains', 'begins_with'].include?(params[:query_type].to_s)
       # Note that 'contains' will add an '%' to the beginning AND to the end

data/app/models/concerns/versioning.rb

@@ -20,8 +20,15 @@ module Versioning
   included do
     alias_method :draft?, :unpublished?
 
-    belongs_to :published_version, foreign_key: 'published_version_id', class_name: name
-    belongs_to :locking_user, foreign_key: 'locked_by', class_name: 'AbstractUser'
+    belongs_to :published_version,
+               foreign_key: 'published_version_id',
+               class_name: name,
+               optional: true
+
+    belongs_to :locking_user,
+               foreign_key: 'locked_by',
+               class_name: 'AbstractUser',
+               optional: true
 
     after_initialize do
       disable_validations_for_publishing
@@ -34,7 +41,7 @@ module Versioning
     end
 
     def published
-      where(arel_table[:published_at].not_eq(nil))
+      where.not(published_at: nil)
     end
 
     def unpublished
@@ -93,7 +100,7 @@ module Versioning
   end # module ClassMethods
 
   def branch(user)
-    new_version = self.dup(include: self.class.includes_to_deep_cloning)
+    new_version = self.deep_clone(include: self.class.includes_to_deep_cloning)
     new_version.lock_by_user(user.id)
     new_version.increment(:rev)
     new_version.published_version_id = self.id

data/app/models/configuration_setting.rb

@@ -15,6 +15,6 @@
 # limitations under the License.
 
 # NB: not to be used directly, but only through InstanceConfiguration
-class ConfigurationSetting < ActiveRecord::Base # TODO: make private, somehow?
+class ConfigurationSetting < ApplicationRecord # TODO: make private, somehow?
   validates :key, uniqueness: true
 end

data/app/models/dataset/iqvoc_dataset.rb

@@ -1,4 +1,5 @@
 require 'linkeddata'
+require "rdf/vocab"
 require 'timeout'
 
 class Dataset::IqvocDataset
@@ -14,7 +15,7 @@ class Dataset::IqvocDataset
       @repository = Timeout::timeout(DEFAULT_TIMEOUT) do
         RDF::Repository.load(dataset_url)
       end
-    rescue Errno::ECONNREFUSED, Timeout::Error => e
+    rescue IOError, Errno::ECONNREFUSED, Timeout::Error => e
       Rails.logger.error("Iqvoc source couldn't be resolved: #{@url}, message: #{e.message}")
     ensure
       @name = fetch_name
@@ -42,7 +43,7 @@ class Dataset::IqvocDataset
     return @url.to_s if @repository.nil?
 
     void = RDF::Vocabulary.new('http://rdfs.org/ns/void#')
-    query = RDF::Query.new({ dataset: { RDF.type => void.Dataset, RDF::DC.title => :title } })
+    query = RDF::Query.new({ dataset: { RDF.type => void.Dataset, RDF::Vocab::DC.title => :title } })
     results = Timeout::timeout(DEFAULT_TIMEOUT) do
       query.execute(@repository)
     end

data/app/models/export.rb

@@ -1,4 +1,4 @@
-class Export < ActiveRecord::Base
+class Export < ApplicationRecord
   belongs_to :user
 
   enum file_type: [:ttl, :nt, :xml]
@@ -27,6 +27,6 @@ class Export < ActiveRecord::Base
   private
 
   def delete_dump_file
-    File.delete(build_filename)
+    File.delete(build_filename) if File.exists?(build_filename)
   end
 end

data/app/models/import.rb

@@ -1,4 +1,4 @@
-class Import < ActiveRecord::Base
+class Import < ApplicationRecord
   belongs_to :user
   mount_uploader :import_file, RdfUploader
   validates_presence_of :import_file, :default_namespace

data/app/models/label/base.rb

@@ -14,19 +14,38 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-class Label::Base < ActiveRecord::Base
+class Label::Base < ApplicationRecord
   self.table_name = 'labels'
 
   # ********** Associations
 
-  has_many :labelings, foreign_key: 'target_id', class_name: 'Labeling::Base'
-  has_many :concepts, through: :labelings, source: :owner
+  has_many :labelings,
+           foreign_key: 'target_id',
+           class_name: 'Labeling::Base',
+           inverse_of: :target
 
-  has_many :pref_labelings, foreign_key: 'target_id', class_name: Iqvoc::Concept.pref_labeling_class_name
-  has_many :pref_labeled_concepts, through: :pref_labelings, source: :owner
+  has_many :concepts,
+           through: :labelings,
+           source: :owner
+
+  has_many :pref_labelings,
+           foreign_key: 'target_id',
+           class_name: Iqvoc::Concept.pref_labeling_class_name,
+           inverse_of: :target
+
+  has_many :pref_labeled_concepts,
+           through: :pref_labelings,
+           source: :owner
+
+  has_many :alt_labelings,
+           foreign_key: 'target_id',
+           class_name: Iqvoc::Concept.alt_labeling_class_name,
+           inverse_of: :target
+
+  has_many :alt_labeled_concepts,
+           through: :alt_labelings,
+           source: :owner
 
-  has_many :alt_labelings, foreign_key: 'target_id', class_name: Iqvoc::Concept.alt_labeling_class_name
-  has_many :alt_labeled_concepts, through: :alt_labelings, source: :owner
   # ********* Scopes
 
   def self.by_language(lang_code)

data/app/models/labeling/base.rb

@@ -14,7 +14,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-class Labeling::Base < ActiveRecord::Base
+class Labeling::Base < ApplicationRecord
   self.table_name = 'labelings'
 
   class_attribute :rdf_namespace, :rdf_predicate

data/app/models/labeling/skos/alt_label.rb

@@ -16,4 +16,8 @@
 
 class Labeling::SKOS::AltLabel < Labeling::SKOS::Base
   self.rdf_predicate = 'altLabel'
+
+  def self.view_section_sort_key(obj)
+    60
+  end
 end

data/app/models/labeling/skos/base.rb

@@ -44,7 +44,7 @@ class Labeling::SKOS::Base < Labeling::Base
   def self.single_query(params = {})
     query_str = build_query_string(params)
 
-    scope = includes(:target).order("LENGTH(#{Label::Base.table_name}.value)")
+    scope = includes(:target).order(Arel.sql("LENGTH(#{Label::Base.table_name}.value), #{Label::Base.table_name}.value ASC"))
     languages = Array(params[:languages])
 
     if params[:query].present?

data/app/models/labeling/skos/hidden_label.rb

@@ -17,7 +17,7 @@
 class Labeling::SKOS::HiddenLabel < Labeling::SKOS::Base
   self.rdf_predicate = 'hiddenLabel'
 
-  def self.view_section(obj)
-    'hidden'
+  def self.view_section_sort_key(obj)
+    70
   end
 end