sinicum 0.5.0

data/lib/sinicum/imaging/max_size_converter.rb

@@ -0,0 +1,39 @@
+module Sinicum
+  module Imaging
+    # Internal: Resizes an image to a predefined maximum size.
+    class MaxSizeConverter
+      include Converter
+      include Sinicum::Logger
+
+      attr_reader :format
+
+      def initialize(configuration)
+        super(configuration)
+        @format = configuration['format'] || 'jpeg'
+      end
+
+      def convert(infile_path, outfile_path)
+        x = device_pixel_size(@x)
+        y = device_pixel_size(@y)
+        special = '-background transparent' if @format == 'png'
+        command = "convert #{infile_path} #{interlace_option(x, y)} #{special} " \
+          "#{quality_option} " +
+          "-resize #{x}x#{y} #{outfile_path}"
+        `#{command}`
+        optimize_png_outfile(outfile_path)
+      end
+
+      def converted_size
+        original_ratio = ratio(@document.width, @document.height)
+        x = @x.to_f
+        y = @y.to_f
+        if @y != '' && x / original_ratio > y
+          x = (y * original_ratio).round
+        else
+          y = (x / original_ratio).round
+        end
+        [x, y]
+      end
+    end
+  end
+end

data/lib/sinicum/imaging/resize_crop_converter.rb

@@ -0,0 +1,35 @@
+module Sinicum
+  module Imaging
+    # Internal: Resizes an image to an exact given size and crops anything
+    # else.
+    class ResizeCropConverter
+      include Converter
+      include Sinicum::Logger
+
+      attr_reader :format
+
+      def initialize(configuration)
+        if !configuration['format'] || !configuration['x'] || !configuration['y']
+          fail ArgumentError.new("Converter requires the arguments: format, x, y")
+        end
+        super(configuration)
+        @format = configuration['format'] || 'jpeg'
+      end
+
+      def convert(infile_path, outfile_path)
+        x = device_pixel_size(@x)
+        y = device_pixel_size(@y)
+        special = '-background transparent' if format == 'png'
+        cmd = "convert #{infile_path} #{interlace_option(x, y)} #{special} " \
+          "#{quality_option} " +
+          "-resize #{x}x#{y}^ -gravity center -extent #{x}x#{y} #{outfile_path}"
+        `#{cmd}`
+        optimize_png_outfile(outfile_path)
+      end
+
+      def converted_size
+        [@x, @y]
+      end
+    end
+  end
+end

data/lib/sinicum/jcr/api_client.rb

@@ -0,0 +1,50 @@
+module Sinicum
+  module Jcr
+    module ApiClient
+      include ::Sinicum::Logger
+      def api_get(path, *args, &block)
+        full_path = api_full_path(path)
+        log_get_path(full_path, args)
+
+        instrumentation_query = args[0] && args[0]["query"] ? args[0]["query"] : path
+
+        ActiveSupport::Notifications.instrument(
+          "jcr_query.sinicum",
+          query: instrumentation_query,
+          context: "Sinicum API GET:") do
+          start = Time.now
+          result = ApiQueries.http_client.get(full_path, *args, &block)
+          elapsed_time = ((Time.now - start).to_f * 1000).round(1)
+          logger.debug("      Completed request in #{elapsed_time}ms")
+          result
+        end
+      end
+
+      def api_post(path, *args, &block)
+        full_path = api_full_path(path)
+        log = "    Sinicum API POST: " + full_path
+        [:body, :query].each do |key|
+          if args[0] && args[0].respond_to?(:[]) && args[0][key]
+            log << "\n      Parameters (#{key.to_s.capitalize}): " + args[0][key].inspect
+          end
+        end
+        logger.debug(log)
+        ApiQueries.http_client.post(full_path, *args, &block)
+      end
+
+      private
+
+      def log_get_path(full_path, args)
+        log = "    Sinicum API GET: " + full_path
+        if args[0] && args[0].respond_to?(:[])
+          log << "\n      Parameters (Query): " + args[0].inspect
+        end
+        logger.debug(log)
+      end
+
+      def api_full_path(path)
+        ApiQueries.jcr_configuration.base_url + path
+      end
+    end
+  end
+end

data/lib/sinicum/jcr/api_queries.rb

@@ -0,0 +1,37 @@
+require 'httpclient'
+
+module Sinicum
+  module Jcr
+    # Private: Encapsulates the functionality to run queries on the server.
+    class ApiQueries
+      @@http_client_mutex = Mutex.new
+      class << self
+        attr_reader :jcr_configuration
+
+        def configure_jcr=(config_hash)
+          @http_client = nil
+          if config_hash
+            @jcr_configuration = JcrConfiguration.new(config_hash.dup.with_indifferent_access)
+            if @jcr_configuration.username.present? || @jcr_configuration.password.present?
+              http_client.set_auth(nil, @jcr_configuration.username, @jcr_configuration.password)
+              http_client.www_auth.basic_auth.challenge(@jcr_configuration.base_proto_host_port)
+            end
+            if @jcr_configuration.protocol == "https"
+              http_client.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+            end
+          end
+        end
+
+        def http_client
+          # Thread Safety?
+          return @http_client if @http_client
+          @@http_client_mutex.synchronize do
+            return @http_client if @http_client
+            @http_client ||= HTTPClient.new
+          end
+          @http_client
+        end
+      end
+    end
+  end
+end

data/lib/sinicum/jcr/cache/global_cache.rb

@@ -0,0 +1,26 @@
+module Sinicum
+  module Jcr
+    module Cache
+      # Public: Fetches the global cache key from the JCR server.
+      class GlobalCache
+        API_PATH = "/_cache/global"
+        JSON_CACHE_KEY = "cacheKey"
+        include ::Sinicum::Jcr::ApiClient
+
+        def current_key
+          result = nil
+          response = api_get(API_PATH)
+          if response.ok?
+            begin
+              json = MultiJson.load(response.body)
+              result = json[JSON_CACHE_KEY]
+            rescue => e
+              Rails.logger.error("Cannot load global cache key: " + e.message)
+            end
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/sinicum/jcr/dam/document.rb

@@ -0,0 +1,57 @@
+module Sinicum
+  module Jcr
+    module Dam
+      # Public: Wrapper around documents stored in Magnolia's DAM workspace.
+      class Document < ::Sinicum::Jcr::Node
+        FINGERPRINT_VERSION = "2"
+
+        %w(name subject description type).each do |field|
+          define_method(field) { self[field.to_sym] }
+        end
+
+        # Returns a node, which contains the properties of the document
+        def properties
+          self[:'jcr:content'] if self[:'jcr:content']
+        end
+
+        def path(options = {})
+          converter_name = options[:converter].presence ||
+            ::Sinicum::Imaging.default_converter_name
+          path = "#{::Sinicum::Imaging.path_prefix}/#{converter_name}#{super}-#{fingerprint}"
+          if properties && properties[:extension].present?
+            path << ".#{properties[:extension]}"
+          end
+          path
+        end
+
+        def file_size
+          properties[:size].to_i if properties
+        end
+
+        def file_name
+          [properties[:fileName], properties[:extension]].join(".") if properties
+        end
+
+        def mime_type
+          properties[:'jcr:mimeType'] if properties
+        end
+
+        def date
+          self[:date1] || updated_at
+        end
+
+        private
+
+        def fingerprint
+          unless @fingerprint
+            attributes = [
+              FINGERPRINT_VERSION, jcr_path, id, properties[:'jcr:lastModified'],
+              properties[:'jcr:lastModifiedBy'], properties[:size]]
+            @fingerprint = Digest::MD5.hexdigest(attributes.join("-"))
+          end
+          @fingerprint
+        end
+      end
+    end
+  end
+end

data/lib/sinicum/jcr/dam/image.rb

@@ -0,0 +1,40 @@
+module Sinicum
+  module Jcr
+    module Dam
+      # Public: Wrapper around image files stored in Magnolia's DAM workspace.
+      class Image < Document
+        def width(converter_name = nil)
+          fetch_value(:width, converter_name)
+        end
+
+        def height(converter_name = nil)
+          fetch_value(:height, converter_name)
+        end
+
+        def alt
+          self[:subject] || ""
+        end
+
+        private
+
+        def image_size_converter(converter_name)
+          @conv_cache ||= {}
+          unless @conv_cache[converter_name]
+            @conv_cache[converter_name] =
+              Sinicum::Imaging::ImageSizeConverter.new(self, converter_name, workspace: "dam")
+          end
+          @conv_cache[converter_name]
+        end
+
+        def fetch_value(dimension, converter_name)
+          value = nil
+          if properties && properties[dimension]
+            value = properties[dimension].to_i
+            value = image_size_converter(converter_name).send(dimension) if converter_name
+          end
+          value
+        end
+      end
+    end
+  end
+end

data/lib/sinicum/jcr/jcr_configuration.rb

@@ -0,0 +1,67 @@
+module Sinicum
+  module Jcr
+    # Public: Handles the configuration for accessing the JCR server.
+    class JcrConfiguration
+      attr_accessor :host, :protocol, :path_prefix, :username, :password
+      DEFAULT_HOST = "localhost"
+      DEFAULT_PORT = "8080"
+      DEFAULT_PROTOCOL = "http"
+      DEFAULT_PREFIX = "/sinicum-rest"
+
+      def initialize(params = {})
+        [:host, :port, :protocol, :path_prefix, :username, :password].each do |param|
+          send("#{param}=", params[param]) if params.key?(param)
+        end
+      end
+
+      def path_prefix=(path_prefix)
+        path_prefix = "/" + path_prefix if path_prefix.size > 0 && path_prefix[0] != "/"
+        @path_prefix = path_prefix
+      end
+
+      def port=(port)
+        @port = port.to_s
+      end
+
+      def port
+        port = @port
+        unless port
+          if protocol == "http"
+            port = "80"
+          elsif protocol == "https"
+            port = "443"
+          else
+            port = ""
+          end
+        end
+        port
+      end
+
+      def protocol
+        @protocol || DEFAULT_PROTOCOL
+      end
+
+      def base_url
+        unless defined?(@base_url)
+          base_url = base_proto_host_port.dup
+          base_url << (path_prefix || DEFAULT_PREFIX)
+          @base_url = base_url
+        end
+        @base_url
+      end
+
+      def base_proto_host_port
+        unless defined?(@base_proto_host_port)
+          base_proto_host_port = protocol.dup
+          base_proto_host_port << "://"
+          base_proto_host_port << (host || DEFAULT_HOST)
+          unless (port.to_i == 80 && protocol == "http") || port.to_i == 443 && protocol == "https"
+            base_proto_host_port << ":" << port
+          end
+          @base_proto_host_port = base_proto_host_port
+        end
+        @base_proto_host_port
+      end
+    end
+  end
+end

data/lib/sinicum/jcr/mgnl4_compatibility.rb

@@ -0,0 +1,11 @@
+module Sinicum
+  module Jcr
+    module Mgnl4Compatibility
+      def mgnl_authorid
+      end
+
+      def mgnl_activatorid
+      end
+    end
+  end
+end

data/lib/sinicum/jcr/node.rb

@@ -0,0 +1,268 @@
+module Sinicum
+  module Jcr
+    # Public: Base class to handle objects from the JCR store.
+    class Node
+      extend ActiveSupport::Inflector
+      include ActiveModel::Conversion
+      extend ActiveModel::Naming
+      extend ActiveModel::Translation
+      include ActiveModel::Validations
+      include ActiveModel::AttributeMethods
+
+      include NodeQueries
+      include Mgnl4Compatibility
+
+      ISO_8601_REGEX = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}[+-]\d{2}:\d{2}/
+      ISO_8601_DATE_REGEX = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z/
+      IMPLICIT_ARRAY_REGEX = /^\d+$/
+      BOOL_TRUE_STRING_VALUE = "true"
+      BOOL_FALSE_STRING_VALUE = "false"
+      METADATA_NODE_NAME = "MetaData"
+      META_KEY = "meta"
+      PROPERTIES_KEY = "properties"
+      NODES_KEY = "nodes"
+      ARRAY_CHILD_NODE_PATTERN = /^\d+$/
+
+      SETABLE_JCR_PROPERTIES = :jcr_path, :jcr_name, :jcr_primary_type, :jcr_primary_type,
+        :jcr_super_types, :jcr_workspace, :jcr_mixin_node_types
+      PROHIBITED_JCR_PROPERTIES = :uuid, :jcr_depth, :created_at, :updated_at, :lastaction_at
+      SETABLE_MGNL_PROPERTIES = [:mgnl_template, :mgnl_created_by]
+      PROHIBITED_MGNL_PROPERTIES = :mgnl_authorid, :mgnl_activatorid
+
+      attr_reader *SETABLE_JCR_PROPERTIES, *PROHIBITED_JCR_PROPERTIES,
+        *SETABLE_MGNL_PROPERTIES, *PROHIBITED_MGNL_PROPERTIES
+
+      def initialize(params = {})
+        if params.key?(:json_response)
+          @__json_response = params[:json_response]
+          initialize_properties_from_json
+        else
+          initialize_from_hash(params)
+        end
+      end
+
+      def id
+        uuid
+      end
+
+      def path(options = {})
+        jcr_path
+      end
+
+      def to_model
+        self
+      end
+
+      def persisted?
+        !!@persisted
+      end
+
+      def [](property_name)
+        result = nil
+        property_key = property_name.to_s
+        if jcr_properties && jcr_properties.key?(property_key)
+          result = transform_jcr_types(jcr_properties[property_key])
+        elsif node_cache.key?(property_key) || (jcr_nodes && jcr_nodes.key?(property_key))
+          result = return_child_node(property_key)
+        end
+        result
+      end
+
+      def children
+        children = []
+        jcr_nodes.each do |child|
+          next if child && child[0] == "MetaData"
+          children << NodeInitializer.initialize_node_from_json(child[1])
+        end
+        children
+      end
+
+      def parent
+        fetch_from_parent_cache do
+          current_node_path = path.split("/")
+          current_node_path.slice!(-1) if current_node_path.size > 1
+          Sinicum::Jcr::Node.find_by_path(jcr_workspace, current_node_path.join("/"))
+        end
+      end
+
+      def to_s
+        "#{self.class.name}, uuid: '#{uuid}', path: '#{jcr_path}'"
+      end
+
+      def inspect
+        properties = []
+        jcr_properties.each_key { |key| properties << key } if jcr_properties
+        nodes = []
+        jcr_nodes.each_key { |key| nodes << key } if jcr_nodes
+        to_s + ", properties: #{properties}, nodes: #{nodes}\n"
+      end
+
+      protected
+
+      def jcr_properties
+        @__json_response[PROPERTIES_KEY] if @__json_response
+      end
+
+      def jcr_nodes
+        @__json_response[NODES_KEY] if @__json_response
+      end
+
+      private
+
+      def initialize_properties_from_json
+        meta_info = @__json_response[META_KEY]
+        @uuid = meta_info["jcr:uuid"].freeze
+        @jcr_path = meta_info["path"].freeze
+        @jcr_name = meta_info["name"].freeze
+        @jcr_primary_type = meta_info["jcr:primaryType"].freeze
+        @jcr_super_types = meta_info["superTypes"].freeze
+        @jcr_mixin_node_types = meta_info["mixinNodeTypes"].freeze
+        @jcr_workspace = meta_info["workspace"].freeze
+        @jcr_depth = meta_info["depth"].freeze
+        @created_at = jcr_time_string_to_datetime(meta_info["mgnl:created"]).freeze
+        @updated_at = jcr_time_string_to_datetime(meta_info["mgnl:lastModified"]).freeze
+        @mgnl_template = meta_info["mgnl:template"].freeze
+        @mgnl_created_by = meta_info["mgnl:createdBy"].freeze
+        @persisted = true
+        initialize_from_mgnl4_meta_data_node(meta_info)
+      end
+
+      def initialize_from_mgnl4_meta_data_node(meta_info)
+        @created_at = jcr_time_string_to_datetime(meta_info["jcr:created"]).freeze
+      end
+
+      def initialize_from_hash(hash)
+        @__json_response = { PROPERTIES_KEY => {} }
+        hash.each do |key, value|
+          check_for_allowed_properties(key)
+          unless set_system_property(key, value)
+            @__json_response[PROPERTIES_KEY][key.to_s] = value
+          end
+        end
+      end
+
+      def check_for_allowed_properties(key)
+        key_sym = key.to_sym
+        if PROHIBITED_JCR_PROPERTIES.include?(key_sym) ||
+            PROHIBITED_MGNL_PROPERTIES.include?(key_sym)
+          fail Error.new("Property '#{key_sym}' cannot be set manually. It has to be generated " +
+            "when fetching a node from the JCR repository")
+        end
+      end
+
+      def set_system_property(key, value)
+        key_sym = key.to_sym
+        if SETABLE_JCR_PROPERTIES.include?(key_sym) || SETABLE_MGNL_PROPERTIES.include?(key_sym)
+          instance_variable_set(:"@#{key}", value)
+          return true
+        end
+        false
+      end
+
+      def return_child_node(node_key)
+        fetch_from_node_cache(node_key) do
+          value = nil
+          child_node = jcr_nodes[node_key]
+          if implicit_array?(node_key)
+            value = convert_implicit_array(node_key)
+          else
+            value = Node.new(json_response: child_node)
+          end
+          value
+        end
+      end
+
+      def transform_jcr_types(value)
+        result = jcr_time_string_to_datetime(value)
+        result = mgnl_boolean_string_to_boolean(result)
+        result
+      end
+
+      def implicit_array?(node_key)
+        has_array_pattern = false
+        child_node = jcr_nodes[node_key]
+        primary_type = nil
+        if child_node && child_node["meta"]
+          primary_type = child_node["meta"]["jcr:primaryType"]
+        end
+        if child_node && child_node[NODES_KEY] && child_node[NODES_KEY].size > 0 &&
+            primary_type != "mgnl:area"
+          child_nodes = child_node[NODES_KEY]
+          child_nodes.each_key do |key|
+            next if key == METADATA_NODE_NAME
+            if key =~ IMPLICIT_ARRAY_REGEX
+              has_array_pattern = true
+            else
+              has_array_pattern = false
+              break
+            end
+          end
+        end
+        has_array_pattern
+      end
+
+      def convert_implicit_array(node_key)
+        result = []
+        child_node = jcr_nodes.delete(node_key)
+        child_node[NODES_KEY].each_key do |key|
+          next if key == METADATA_NODE_NAME
+          child = child_node[NODES_KEY].delete(key)
+          result << Node.new(json_response: child)
+        end
+        result
+      end
+
+      def jcr_time_string_to_datetime(value)
+        result = nil
+        if value && value =~ ISO_8601_REGEX
+          result = DateTime.parse(value)
+        elsif value && value =~ ISO_8601_DATE_REGEX
+          result = Date.parse(value)
+        else
+          result = value
+        end
+        result
+      end
+
+      def fetch_from_node_cache(node_key, &block)
+        result = nil
+        if node_cache.key?(node_key)
+          result = node_cache[node_key]
+        else
+          result = yield
+          node_cache[node_key] = result
+        end
+        result
+      end
+
+      def node_cache
+        @__node_cache ||= {}
+      end
+
+      def fetch_from_parent_cache(&block)
+        result = nil
+        if parent_cache
+          result = parent_cache
+        else
+          result = yield
+          @__parent_cache = result
+        end
+        result
+      end
+
+      def parent_cache
+        @__parent_cache
+      end
+
+      def mgnl_boolean_string_to_boolean(value)
+        result = value
+        if value == BOOL_TRUE_STRING_VALUE
+          result = true
+        elsif value == BOOL_FALSE_STRING_VALUE
+          result = false
+        end
+        result
+      end
+    end
+  end
+end