iqvoc_skosxl 1.1.4

data/app/controllers/rdf_controller.rb

@@ -0,0 +1,23 @@
+require_dependency Iqvoc::Engine.find_root_with_flag("app").join("app/controllers/rdf_controller").to_s
+class RdfController
+
+  def show_with_labels
+    scope = params[:published] == "0" ? Iqvoc::XLLabel.base_class.scoped.unpublished : Iqvoc::XLLabel.base_class.scoped.published
+    if @label = scope.by_origin(params[:id]).with_associations.last
+      respond_to do |format|
+        format.html {
+          redirect_to label_url(:id => @label.origin, :published => params[:published])
+        }
+        format.any {
+          authorize! :read, @label
+          render "show_label"
+        }
+      end
+    else
+      show_without_labels
+    end
+  end
+
+  alias_method_chain(:show, :labels)
+
+end

data/app/helpers/iqvoc_skosxl_helper.rb

@@ -0,0 +1,18 @@
+module IqvocSkosxlHelper
+
+  def iqvoc_skosxl_default_rdf_namespaces
+    {
+    }
+  end
+
+  def render_label(label)
+    if label.new_record?
+      "-"
+    elsif label.is_a?(Label::SKOSXL::Base)
+      link_to(label.to_s, label_path(:id => label))
+    else
+      label.to_s
+    end
+  end
+
+end

data/app/helpers/labels_helper.rb

@@ -0,0 +1,68 @@
+module LabelsHelper
+
+  def render_label_rdf(document, label)
+    document << label.build_rdf_subject(document, controller) do |c|
+
+      c.Schema::expires(label.expired_at) if label.expired_at
+
+      c.Owl::deprecated(true) if label.expired_at and label.expired_at <= Date.new
+
+      c.Skosxl::literalForm(label.value, :lang => label.language)
+
+      label.relations.each do |relation|
+        relation.build_rdf(document, c)
+      end
+
+      label.notes.each do |note|
+        note.build_rdf(document, c)
+      end
+
+      Iqvoc::XLLabel.additional_association_class_names.keys.each do |class_name|
+        label.send(class_name.to_relation_name).each do |additional_object|
+          additional_object.build_rdf(document, c)
+        end
+      end
+
+=begin
+      concept.matches.each do |match|
+        match.build_rdf(document, c)
+      end
+
+
+=end
+    end
+  end
+
+  def render_label_association(hash, label, association_class, further_options = {})
+    return unless association_class.partial_name(label)
+    ((hash[association_class.view_section(label)] ||= {})[association_class.view_section_sort_key(label)] ||= "") <<
+      render(association_class.partial_name(label), further_options.merge(:label => label, :klass => association_class))
+  end
+
+  def label_view_data(label)
+    res = {'main' => {}}
+
+    res['main'][10] = render 'labels/value_and_language', :label => label
+
+    res['main'][1000] = render 'labels/details', :label => label
+
+    Iqvoc::Concept.labeling_classes.keys.each do |labeling_class|
+      render_label_association(res, label, labeling_class)
+    end
+
+    Iqvoc::XLLabel.relation_classes.each do |relation_class|
+      render_label_association(res, label, relation_class)
+    end
+
+    Iqvoc::XLLabel.note_classes.each do |note_class|
+      render_label_association(res, label, note_class)
+    end
+
+    Iqvoc::XLLabel.additional_association_classes.keys.each do |assoc_class|
+      render_label_association(res, label, assoc_class)
+    end
+
+    res
+  end
+
+end

data/app/models/concept/skosxl/extension.rb

@@ -0,0 +1,62 @@
+module Concept
+  module SKOSXL
+    module Extension
+
+      extend ActiveSupport::Concern
+
+      included do
+        validate :valid_label_language
+
+        after_save do |concept|
+          # Labelings
+          (@labelings_by_id ||= {}).each do |labeling_relation_name, origin_mappings|
+            # Remove all associated labelings of the given type
+            concept.send(labeling_relation_name).destroy_all
+
+            # (Re)create labelings reflecting a widget's parameters
+            origin_mappings.each do |language, new_origins|
+              new_origins = new_origins.
+                  split(Iqvoc::InlineDataHelper::Splitter).map(&:squish)
+
+              # Iterate over all labels to be added and create them
+              Iqvoc::XLLabel.base_class.by_origin(new_origins).each do |l|
+                concept.send(labeling_relation_name).create!(:target => l)
+              end
+            end
+          end
+
+        end
+
+        def valid_label_language
+          (@labelings_by_id || {}).each { |labeling_class_name, origin_mappings|
+            origin_mappings.each { |language, new_origins|
+              new_origins = new_origins.split(Iqvoc::InlineDataHelper::Splitter)
+              Iqvoc::XLLabel.base_class.by_origin(new_origins).each do |label|
+                if label.language != language.to_s
+                  errors.add(:base,
+                      I18n.t("txt.controllers.versioned_concept.label_error") % label)
+                end
+              end
+            }
+          }
+        end
+
+      end
+
+      module InstanceMethods
+
+        def labelings_by_id=(hash)
+          @labelings_by_id = hash
+        end
+
+        def labelings_by_id(relation_name, language)
+          (@labelings_by_id && @labelings_by_id[relation_name] && @labelings_by_id[relation_name][language]) ||
+            self.send(relation_name).by_label_language(language).
+                map { |l| l.target.origin }.join(Iqvoc::InlineDataHelper::Joiner)
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+class Label::Relation::Base < ActiveRecord::Base
+
+  class_attribute :rdf_namespace, :rdf_predicate
+  self.rdf_namespace = nil
+  self.rdf_predicate = nil
+
+  set_table_name 'label_relations'
+
+  belongs_to :domain, :class_name => "Label::Base"
+  belongs_to :range,  :class_name => "Label::Base"
+
+  scope :by_domain, lambda { |domain|
+    where(:domain_id => domain)
+  }
+
+  scope :by_range, lambda { |range|
+    where(:range_id => range)
+  }
+
+  scope :by_range_origin, lambda { |origin|
+    includes(:range).merge(Label::Base.by_origin(origin))
+  }
+
+  scope :range_editor_selectable, lambda {
+   # includes(:range) & Iqvoc::XLLabel.base_class.editor_selectable # Doesn't work correctly (kills label_relations.type condition :-( )
+   includes(:range).where("labels.published_at IS NOT NULL OR (labels.published_at IS NULL AND labels.published_version_id IS NULL) ")
+  }
+
+  scope :range_in_edit_mode, lambda {
+    joins(:range).merge(Iqvoc::XLLabel.base_class.in_edit_mode)
+  }
+
+
+  def self.view_section(obj)
+    "relations"
+  end
+
+  def self.view_section_sort_key(obj)
+    100
+  end
+
+  def self.partial_name(obj)
+    "partials/label/relation/base"
+  end
+
+  def self.edit_partial_name(obj)
+    "partials/label/relation/edit_base"
+  end
+
+  def self.only_one_allowed?
+    false
+  end
+
+end

data/app/models/label/relation/skosxl/base.rb

@@ -0,0 +1,12 @@
+class Label::Relation::SKOSXL::Base < Label::Relation::Base
+
+  self.rdf_namespace = 'skosxl'
+
+  def build_rdf(document, subject)
+    pred = self.class == Label::Relation::SKOSXL::Base ? :labelRelation : self.rdf_predicate
+    raise "Match::SKOS::Base#build_rdf: Class #{self.class.name} needs to define self.rdf_namespace and self.rdf_predicate." unless pred
+
+    subject.send(self.rdf_namespace.camelcase).send(pred, IqRdf.build_uri(range.origin))
+  end
+
+end

data/app/models/label/skosxl/base.rb

@@ -0,0 +1,219 @@
+# encoding: UTF-8
+
+class Label::SKOSXL::Base < Label::Base
+
+  include Iqvoc::Versioning
+
+  class_attribute :rdf_namespace, :rdf_class
+  self.rdf_namespace = "skosxl"
+  self.rdf_class = "Label"
+
+  # ********** Validations
+
+  validate :two_versions_exist, :on => :create
+  validate :origin_has_to_be_escaped
+
+  # ********** Hooks
+  
+  after_initialize do
+    @full_validation = false
+  end
+
+  after_save do |label|
+    # Handle save or destruction of inline relations for use with widgets
+    (@inline_assigned_relations ||= {}).each do |relation_class_name, origins|
+      # Remove all associated labelings of the given type
+      label.send(relation_class_name.to_relation_name).destroy_all
+
+      # Recreate relations reflecting the widget's parameters
+      Iqvoc::XLLabel.base_class.by_origin(origins).each do |l|
+        label.send(relation_class_name.to_relation_name).create(:range => l)
+      end
+    end
+  end
+
+  # ********** "Static"/unconfigureable relations
+
+  @nested_relations = [] # Will be marked as nested attributes later
+
+  has_many :labelings, :class_name => 'Labeling::Base', :foreign_key => 'target_id', :dependent => :destroy
+  has_many :concepts, :through => :labelings, :source => :owner
+  include_to_deep_cloning(:labelings)
+
+  has_many :relations, :foreign_key => 'domain_id', :class_name => 'Label::Relation::Base', :dependent => :destroy
+  # Which references are pointing to this label?
+  has_many :referenced_by_relations, :foreign_key => 'range_id', :class_name => 'Label::Relation::Base', :dependent => :destroy
+  include_to_deep_cloning(:relations, :referenced_by_relations)
+
+  has_many :notes, :as => :owner, :class_name => 'Note::Base', :dependent => :destroy
+  has_many :annotations, :through => :notes, :source => :annotations
+  include_to_deep_cloning(:notes => :annotations)
+
+  # ************** "Dynamic"/configureable relations
+
+  Iqvoc::XLLabel.note_class_names.each do |note_class_name|
+    has_many note_class_name.to_relation_name, :as => :owner, :class_name => note_class_name, :dependent => :destroy
+    @nested_relations << note_class_name.to_relation_name
+  end
+
+  Iqvoc::XLLabel.relation_class_names.each do |relation_class_name|
+    has_many relation_class_name.to_relation_name,
+      :foreign_key => 'domain_id',
+      :class_name  => relation_class_name,
+      :dependent   => :destroy
+
+    # Serialized setters and getters (\r\n or , separated)
+    define_method("inline_#{relation_class_name.to_relation_name}".to_sym) do
+      (@inline_assigned_relations && @inline_assigned_relations[relation_class_name]) ||
+        self.send(relation_class_name.to_relation_name).map { |r| r.range.origin }.uniq
+    end
+
+    define_method("inline_#{relation_class_name.to_relation_name}=".to_sym) do |value|
+      # write to instance variable and write it on after_save
+      (@inline_assigned_relations ||= {})[relation_class_name] = value.
+        split(/\r\n|, */).map(&:strip).reject(&:blank?).uniq # XXX: use Iqvoc::InlineDataHelper?
+    end
+  end
+
+  Iqvoc::XLLabel.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
+    include_to_deep_cloning(association_class.deep_cloning_relations)
+    association_class.referenced_by(self)
+  end
+
+  # ********** Relation Stuff
+
+  @nested_relations.each do |relation|
+    accepts_nested_attributes_for relation, :allow_destroy => true, :reject_if => Proc.new {|attrs| attrs[:value].blank? }
+  end
+
+  # ********** Scopes
+
+  scope :by_origin, lambda { |origin|
+    where(:origin => origin)
+  }
+
+  scope :with_associations, lambda { includes(:labelings => :owner) }
+
+  scope :for_dashboard, lambda {
+    unpublished_or_follow_up.
+      includes(:locking_user)
+  }
+
+  # ********** Methods
+
+  # def self.single_query(params = {})
+  #   query_str = build_query_string(params)
+  #
+  #   by_query_value(query_str).
+  #   by_language(params[:languages].to_a).
+  #   published.
+  #   order("LOWER(#{Label::Base.table_name}.value)")
+  # end
+
+  # def self.search_result_partial_name
+  #   'partials/labeling/skosxl/search_result'
+  # end
+
+  def self.new_link_partial_name
+    "partials/label/skosxl/new_link_base"
+  end
+
+  def self.edit_link_partial_name
+    "partials/label/skosxl/edit_link_base"
+  end
+
+  def self.from_rdf(str)
+    h = Iqvoc::RdfHelper.split_literal(str)
+    self.new(:value => h[:value], :language => h[:language])
+  end
+
+  def self.from_rdf!(str)
+    self.from_rdf(str).save!
+  end
+
+  def build_rdf_subject(document, controller, &block)
+    ns = IqRdf::Namespace.find_namespace_class(self.rdf_namespace.to_sym)
+    raise "Namespace '#{rdf_namespace}' is not defined in IqRdf document." unless ns
+    IqRdf.build_uri(self.origin, ns.build_uri(self.rdf_class), &block)
+  end
+
+  def concepts_for_labeling_class(labeling_class)
+    labeling_class = labeling_class.name if labeling_class < ActiveRecord::Base # Use the class name string
+    labelings.select{ |l| l.class.name == labeling_class.to_s }.map(&:owner)
+  end
+
+  def related_labels_for_relation_class(relation_class)
+    relation_class = relation_class.name if relation_class < ActiveRecord::Base # Use the class name string
+    relations.select{ |rel| rel.class.name == relation_class }.map(&:range)
+  end
+
+  def notes_for_class(note_class)
+    note_class = note_class.name if note_class < ActiveRecord::Base # Use the class name string
+    notes.select{ |note| note.class.name == note_class }
+  end
+
+  def from_rdf(str)
+    h = Iqvoc::RdfHelper.split_literal(str)
+    self.value    = h[:value]
+    self.language = h[:language]
+    self
+  end
+
+  def from_rdf!(str)
+    from_rdf(str)
+    save(:validate => false)
+  end
+
+  def to_param
+    origin
+  end
+
+  def has_concept_or_label_relations?
+    # Check if one of the additional association methods return elements
+    Iqvoc::XLLabel.additional_association_classes.each do |association_class, foreign_key|
+      return true if send(association_class.name.to_relation_name).count > 0
+    end
+  end
+
+  def save_with_full_validation!
+    @full_validation = true
+    save!
+  end
+
+  # FIXME: should not @full_validation be set back to the value it had before??? This method changes the state!
+  def valid_with_full_validation?
+    @full_validation = true
+    valid?
+  end
+
+  def invalid_with_full_validation?
+    @full_validation = true
+    invalid?
+  end
+
+  # Responsible for displaying a warning message about
+  # associated objects which are currently edited y another user.
+  def associated_objects_in_editing_mode
+    {
+      :label_relations => Label::Relation::Base.by_domain(id).range_in_edit_mode
+    }
+  end
+
+  protected
+
+  # Validations
+
+  def origin_has_to_be_escaped
+    if origin != OriginMapping.merge(origin)
+      errors.add :origin, I18n.t("txt.models.label.origin_invalid")
+    end
+  end
+
+  def two_versions_exist
+    if Label::SKOSXL::Base.by_origin(origin).count >= 2
+      errors.add :base, I18n.t("txt.models.label.version_error")
+    end
+  end
+
+end