libis-tools 0.9.1

data/lib/libis/tools/parameter.rb

@@ -0,0 +1,172 @@
+# encoding: utf-8
+require 'date'
+require 'libis/tools/extend/struct'
+
+module Libis
+  module Tools
+
+    # noinspection RubyConstantNamingConvention
+    Parameter = ::Struct.new(:name, :default, :datatype, :description, :constraint, :options) do
+
+      VALID_PARAMETER_KEYS = [:name, :default, :datatype, :description, :constraint, :options]
+
+      def initialize(*args)
+        # noinspection RubySuperCallWithoutSuperclassInspection
+        super(*args)
+        self.options = {} unless self.options
+      end
+
+      TRUE_BOOL = %w'true yes t y 1'
+      FALSE_BOOL = %w'false no f n 0'
+
+      def parse(value = nil)
+        result = if value.nil?
+                   send(:default)
+                 else
+                     dtype = guess_datatype.to_s.downcase
+                     convert(dtype, value)
+                 end
+        check_constraint(result)
+        result
+      end
+
+      def valid_value?(value)
+        begin
+          parse(value)
+        rescue
+          return false
+        end
+        true
+      end
+
+      def guess_datatype
+        return send(:datatype) if send(:datatype)
+        case send(:default)
+          when TrueClass, FalseClass
+            'bool'
+          when NilClass
+            'string'
+          when Integer
+            'int'
+          when Float
+            'float'
+          when DateTime, Date, Time
+            'datetime'
+          else
+            send(:default).class.name.downcase
+        end
+      end
+
+      private
+
+      def convert(dtype, v)
+        case dtype.to_s.downcase
+          when 'boolean', 'bool'
+            return true if TRUE_BOOL.include?(v.to_s.downcase)
+            return false if FALSE_BOOL.include?(v.to_s.downcase)
+            raise ArgumentError, "No boolean information in '#{v.to_s}'. Valid values are: '#{TRUE_BOOL.join('\', \'')}' and '#{FALSE_BOOL.join('\', \'')}'."
+          when 'string'
+            return v.to_s.gsub('%s', Time.now.strftime('%Y%m%d%H%M%S'))
+          when 'int'
+            return Integer(v)
+          when 'float'
+            return Float(v)
+          when 'datetime'
+            return v.to_datetime if v.respond_to? :to_datetime
+            return DateTime.parse(v)
+          else
+            raise RuntimeError, "Datatype not supported: '#{dtype}'"
+        end
+      end
+
+      def check_constraint(v, constraint = nil)
+        constraint ||= send(:constraint)
+        return if constraint.nil?
+        raise ArgumentError, "Value '#{v}' is not allowed (constraint: #{constraint})." unless constraint_checker(v, constraint)
+      end
+
+      def constraint_checker(v, constraint)
+
+        case constraint
+          when Array
+            constraint.each do |c|
+              return true if (constraint_checker(v, c) rescue false)
+            end
+            return true if constraint.include? v
+          when Range
+            return true if constraint.cover? v
+          when Regexp
+            return true if v =~ constraint
+          else
+            return true if v == constraint
+        end
+        false
+      end
+
+    end # Parameter
+
+    module ParameterContainer
+
+      module ClassMethods
+
+        def parameter(options = {})
+          if options.is_a? Hash
+            return nil if options.keys.empty?
+            param_def = options.shift
+            name = param_def.first.to_s.to_sym
+            default = param_def.last
+            parameters[name] = Parameter.new(name, default) if parameters[name].nil?
+            VALID_PARAMETER_KEYS.each { |key| parameters[name][key] = options[key] if options[key] }
+          else
+            parameters[options]
+          end
+        end
+
+        protected
+
+        def parameters
+          @parameters ||= Hash.new
+        end
+
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      NO_VALUE = '##NAV##'
+
+      def parameter(name, value = NO_VALUE)
+        param_def = get_parameter_definition(name)
+        return NO_VALUE unless param_def
+        if value.equal? NO_VALUE
+          param_value = parameters[name]
+          param_def.parse(param_value)
+        else
+          return NO_VALUE unless param_def.valid_value?(value)
+          parameters[name] = value
+        end
+      end
+
+      def [](name)
+        parameter(name)
+      end
+
+      def []=(name, value)
+        parameter name, value
+      end
+
+      protected
+
+      def parameters
+        @parameters ||= Hash.new
+      end
+
+      def get_parameter_definition(name)
+        self.class.parameter(name)
+      end
+
+    end # ParameterContainer
+
+  end # Tools
+end # Libis

data/lib/libis/tools/sharepoint_mapping.rb

@@ -0,0 +1,118 @@
+# coding: utf-8
+
+require 'csv'
+require 'yaml'
+
+require 'libis/tools/extend/hash'
+
+module Libis
+  module Tools
+
+    class SharepointMapping < Hash
+
+      def initialize(mapping_file)
+
+
+        CSV.foreach(mapping_file, headers: true, skip_blanks: true) do |row|
+          next unless row[1]
+          # next unless (row[2] || row[3])
+
+          # compensation for bug in library that reads the Excel data
+          0.upto(5) { |i| row[i] = row[i].gsub(/_x005F(_x[0-9a-fA-F]{4}_)/, '\1') if row[i] }
+
+          name = row[0] ? row[0].strip : nil
+          label = row[1].strip.to_sym
+          dc_tag = row[2] ? row[2].strip : ''
+          db_column = row[3] ? row[3].strip : nil
+          db_datatype = row[4] ? row[4].strip.upcase.to_sym : nil
+          db_valuemask = row[5] ? row[5] : nil
+          #      scope_tag = row[6] ? row[6].strip : nil
+          #      scope_id = (row[7] and row[7] =~ /[0-9]+/ ? Integer(row[7].strip) : nil)
+
+
+          mapping = {}
+          mapping[:fancy_name] = name if name
+          mapping[:db_column] = db_column if db_column
+          mapping[:db_datatype] = :STRING
+          mapping[:db_datatype] = db_datatype if db_datatype
+          mapping[:db_valuemask] = (mapping[:db_datatype] == :STRING ? "'@@'" : '@@')
+          mapping[:db_valuemask] = db_valuemask if db_valuemask
+          #      mapping[:scope_tag] = scope_tag if scope_tag
+          #      mapping[:scope_id] = scope_id if scope_id
+
+          if dc_tag.match(/^\s*"(.*)"\s*(<.*)$/)
+            mapping[:dc_prefix] = $1
+            dc_tag = $2
+          end
+
+          if dc_tag.match(/^\s*<dc:[^.]+\.([^.>]+)>(.*)$/)
+            mapping[:dc_tag] = "dcterms:#{$1}"
+            dc_tag = $2
+
+          elsif dc_tag.match(/^\s*<dc:([^.>]+)>(.*)$/)
+            mapping[:dc_tag] = "dc:#{$1}"
+            dc_tag = $2
+          end
+
+          if dc_tag.match(/^\s*"(.*)"\s*$/)
+            mapping[:dc_postfix] = $1
+          end
+
+          self[label] = mapping.empty? ? nil : mapping
+
+        end
+
+        File.open('mapping.yml', 'wt') { |fp|
+          fp.puts self.to_yaml
+        }
+        super nil
+
+      end
+
+      def name(label)
+        mapping = self[label]
+        mapping = mapping[:fancy_name] if mapping
+        mapping || label
+      end
+
+      def fancy_label(label)
+        mapping = self[label]
+        mapping = mapping[:fancy_name] if mapping
+        "#{label}#{mapping ? '(' + mapping + ')' : ''}"
+      end
+
+      def dc_tag(label)
+        mapping = self[label]
+        mapping = mapping[:dc_tag] if mapping
+        mapping
+      end
+
+      def dc_prefix(label)
+        mapping = self[label]
+        mapping = mapping[:dc_prefix] if mapping
+        mapping
+      end
+
+      def dc_postfix(label)
+        mapping = self[label]
+        mapping = mapping[:dc_postfix] if mapping
+        mapping
+      end
+
+      def db_column(label)
+        mapping = self[label]
+        mapping = mapping[:db_column] if mapping
+        mapping
+      end
+
+      def db_value(label, value)
+        mapping = self[label]
+        return nil unless mapping
+        mask = mapping[:db_valuemask]
+        mask.gsub('@@', value.to_s)
+      end
+
+    end
+
+  end
+end

data/lib/libis/tools/sharepoint_record.rb

@@ -0,0 +1,260 @@
+# coding: utf-8
+
+require 'uri'
+
+require 'libis/tools/extend/hash'
+require 'libis/tools/xml_document'
+
+module Libis
+  module Tools
+
+    # noinspection RubyTooManyMethodsInspection
+    class SharepointRecord < Hash
+
+      attr_accessor :node
+
+      def initialize
+        @node = nil
+        self[:label_prefix] = ''
+        super nil
+      end
+
+      def label_prefix
+        self[:label_prefix]
+      end
+
+      def label_prefix=(value)
+        self[:label_prefix] = value
+      end
+
+      def label
+        (self[:ows_Title1] || self[:ows_BaseName] || file_name).to_s
+      end
+
+      def title
+        self[:label_prefix] + ' ' + self.label
+      end
+
+      def content_type
+        self[:ows_ContentType]
+      end
+
+      def file_name
+        self[:ows_FileLeafRef]
+      end
+
+      def file_path
+        self[:ows_FileRef]
+      end
+
+      def file_size
+        self[:ows_FileSizeDisplay]
+      end
+
+      def url
+#    self[:ows_EncodedAbsUrl]
+#    'https://www.groupware.kuleuven.be' + URI.escape(self[:ows_ServerUrl], Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+#    'https://www.groupware.kuleuven.be' + URI.escape(self[:ows_ServerUrl])
+        URI.escape(URI.unescape(self[:ows_EncodedAbsUrl]))
+      end
+
+      def relative_path
+        return file_path.gsub(/^sites\/lias\/Gedeelde documenten\//, '') if file_path
+        nil
+      end
+
+      def local_path(sub_dir)
+        return relative_path unless sub_dir
+        sub_dir += '/' unless sub_dir[-1] == '/'
+        return relative_path.gsub(/^#{sub_dir}/, '') if relative_path
+        nil
+      end
+
+      def is_file?
+        return true if [:file, :mfile].include? simple_content_type
+        false
+      end
+
+      def is_described?
+=begin
+    self[:ows_Title1] and
+        (   self[:ows_Creation_x0020_date_x0028_s_x0029_] or
+            self[:ows_Startdate] or
+            self[:ows_Enddate]
+        )
+=end
+        self[:ows_Unit_of_description]
+      end
+
+      def simple_content_type
+        case content_type
+          when /^Archief/i
+            return :archive
+          when /^Bestanddeel \(folder\)/i
+            return :map
+          when /^Bestanddeel of stuk \(document\)/i
+            return :file
+          when /^Meervoudige beschrijving \(folder\)/i
+            return :mmap
+          when /^Meervoudige beschrijving \(document\)/i
+            return :mfile
+          when /^Tussenniveau/i
+            return :map
+          when /^Film/i
+            return :file
+          when /^Object/i
+            return :file
+          when /^Document/i
+            return :file
+          else
+            # type code here
+        end
+        :unknown
+      end
+
+      def content_code
+        case simple_content_type
+          when :archive
+            'a'
+          when :map
+            'm'
+          when :file
+            'f'
+          when :mmap
+            'v'
+          when :mfile
+            '<'
+          when :unknown
+            '-'
+          else
+            ' '
+        end + (is_described? ? '*' : ' ')
+      end
+
+      def ingest_model
+        return self[:ows_Ingestmodel] if self[:ows_Ingestmodel]
+        return self.node.parent.content.ingest_model if node and node.parent and node.parent.content
+        nil
+      end
+
+      def accessright_model
+        return self[:ows_Access_x0020_rights_x0020_model] if self[:ows_Access_x0020_rights_x0020_model]
+        return self.node.parent.content.accessright_model if node and node.parent and node.parent.content
+        nil
+      end
+
+      def to_raw
+        self
+      end
+
+      def to_xml
+
+        xml_doc = Libis::Tools::XmlDocument.new
+
+        xml_doc.root = xml_doc.create_node('record')
+
+        self.each do |label, value|
+
+          unless label == :node
+            #noinspection RubyResolve
+            xml_doc.root << xml_doc.create_text_node(label.to_s, value.to_s)
+          end
+
+        end
+
+        xml_doc
+
+      end
+
+      def self.from_xml(xml_node)
+
+        record = Libis::Tools::SharepointRecord.new
+
+        xml_node.element_children.each do |node|
+          record[node.name.to_sym] = node.content
+        end
+
+        record
+
+      end
+
+      # @param [Libis::Tools::SharepointMapping] mapping
+      def to_dc(mapping)
+
+        return nil unless mapping and mapping.is_a? Hash
+
+        xml_doc = Libis::Tools::XmlDocument.new
+
+        #noinspection RubyStringKeysInHashInspection
+        xml_doc.root = xml_doc.create_node(
+            'record',
+            namespaces: {
+                'dc' => 'http://purl.org/dc/elements/1.1/',
+                'xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+                'dcterms' => 'http://purl.org/dc/terms/'})
+
+        self.each do |label, value|
+          dc_tag = mapping.dc_tag(label)
+          next unless dc_tag
+          dc_value = (mapping.dc_prefix(label) || '') + value.to_s + (mapping.dc_postfix(label) || '')
+          #noinspection RubyResolve
+          xml_doc.root << xml_doc.create_text_node(dc_tag, dc_value)
+        end
+
+        if xml_doc.xpath('//dc:title').size == 0
+          xml_doc.root << xml_doc.create_text_node('dc:title', self[:ows_BaseName])
+        end
+
+        xml_doc
+
+      end
+
+      # @param [Libis::Tools::SharepointMapping] mapping
+      def to_sql(mapping)
+        sql_fields = []
+        sql_values = []
+
+        self.each do |label, value|
+          db_column = mapping.db_column(label)
+          next unless db_column
+          db_value = mapping.db_value(label, value)
+          next unless db_value and db_value != "''"
+          sql_fields << db_column
+          sql_values << db_value.escape_for_sql
+        end
+
+        sql_fields.each_with_index { |element, index| (index % 10 == 0) && (sql_fields[index] = "\n    " + element)
+        }
+        sql_values.each_with_index { |element, index| (index % 10 == 0) && (sql_values[index] = "\n    " + element)
+        }
+
+        'INSERT INTO @TABLE_NAME@ (' + sql_fields.join(',') + ")\n  VALUES (" + sql_values.join(',') + ');'
+
+      end
+
+      def create_dc(dir, mapping)
+        xml_doc = to_dc mapping
+        dc_file = "#{dir}/dc_#{self[:index].to_s}.xml"
+        xml_doc.save dc_file
+        dc_file
+      end
+
+      def to_s
+        super
+      end
+
+      def print_metadata(f, mapping)
+        f.printf "%6d -------------------------------------------------------------------------\n", self[:index].to_i
+        self.each do |label, value|
+          next if label == :node
+#      next if label == :index
+          name = mapping.fancy_label(label)
+          f.printf " %40s : %s\n", name, value
+        end
+
+      end
+
+    end
+
+  end
+end