cmis_server 1.0.3

data/lib/cmis_server/cmis_object.rb

@@ -0,0 +1,190 @@
+module CmisServer
+
+  class CmisObject
+
+    attr_reader :type
+    attr_reader :properties
+    attr_reader :secondary_types
+
+    class InvalidType < StandardError; end
+
+    def initialize(type:, properties: {}, secondary_types: [])
+      self.type = type
+      @secondary_types = []
+      initialize_properties
+      
+      # Ajouter les types secondaires s'ils sont fournis
+      secondary_types.each do |secondary_type|
+        add_secondary_type(secondary_type)
+      end
+
+      properties.to_h.each do |property, value|
+        self.send(property.to_s.gsub(/[^0-9a-z]/i, '_').underscore+"=", value)
+      end
+    end
+
+    def to_renderable_object
+      CmisServer::RenderableObject.new(base_object: self)
+    end
+
+    def copy_properties_values_of object
+      self.properties.each{|_k,property| property.value=object.send(property.property_definition.getter_method_name)}
+    end
+    
+    # CMIS 1.1: Méthodes pour gérer les types secondaires
+    def add_secondary_type(secondary_type)
+      # Vérifier que le type est bien un type secondaire
+      unless secondary_type.base_id == 'cmis:secondary'
+        raise InvalidType.new("#{secondary_type.id} is not a secondary type")
+      end
+      
+      # Vérifier que le type n'est pas déjà ajouté
+      if has_secondary_type?(secondary_type.id)
+        raise InvalidType.new("#{secondary_type.id} is already added")
+      end
+      
+      # Ajouter le type secondaire
+      @secondary_types << secondary_type
+      
+      # Ajouter les propriétés du type secondaire
+      add_secondary_type_properties(secondary_type)
+      
+      # Mettre à jour la propriété cmis:secondaryObjectTypeIds
+      update_secondary_type_ids
+      
+      secondary_type
+    end
+    
+    def remove_secondary_type(type_id)
+      # Trouver le type secondaire
+      secondary_type = @secondary_types.find { |st| st.id == type_id }
+      unless secondary_type
+        raise InvalidType.new("#{type_id} is not a secondary type of this object")
+      end
+      
+      # Supprimer le type secondaire
+      @secondary_types.delete(secondary_type)
+      
+      # Supprimer les propriétés associées à ce type secondaire
+      remove_secondary_type_properties(secondary_type)
+      
+      # Mettre à jour la propriété cmis:secondaryObjectTypeIds
+      update_secondary_type_ids
+      
+      true
+    end
+    
+    def has_secondary_type?(type_id)
+      @secondary_types.any? { |st| st.id == type_id }
+    end
+    
+    def update_properties(properties_hash)
+      properties_hash.each do |prop_id, value|
+        if @properties.key?(prop_id)
+          @properties[prop_id].value = value
+        else
+          # Vérifier si cette propriété appartient à un type secondaire que nous n'avons pas encore
+          property_def = find_property_definition(prop_id)
+          if property_def && property_def.owning_type && property_def.owning_type.base_id == 'cmis:secondary'
+            # Ajouter automatiquement le type secondaire
+            add_secondary_type(property_def.owning_type)
+            # Puis définir la valeur
+            @properties[prop_id].value = value
+          else
+            raise ArgumentError, "Property #{prop_id} does not exist for this object"
+          end
+        end
+      end
+    end
+    
+    def save
+      # À implémenter selon votre système de stockage
+      # Cette méthode devrait sauvegarder l'objet avec toutes ses propriétés
+      true
+    end
+    
+    def all_property_definitions
+      # Combine les définitions de propriétés du type principal et des types secondaires
+      all_defs = type.property_definitions.to_a
+      
+      @secondary_types.each do |secondary_type|
+        all_defs.concat(secondary_type.property_definitions.to_a)
+      end
+      
+      all_defs
+    end
+    
+    private
+    
+    def find_property_definition(prop_id)
+      # Chercher dans les types secondaires disponibles
+      CmisServer::TypeRegistry.types.values.each do |available_type|
+        if available_type.base_id == 'cmis:secondary'
+          prop_def = available_type.property_definitions.find { |pd| pd.id == prop_id }
+          return prop_def if prop_def
+        end
+      end
+      nil
+    end
+    
+    def add_secondary_type_properties(secondary_type)
+      secondary_type.property_definitions.each do |pd|
+        # Ajouter la propriété si elle n'existe pas déjà
+        unless @properties.key?(pd.id)
+          @properties[pd.id] = Property.new(pd, pd.default_value, self)
+          
+          # Ajouter les méthodes getter et setter
+          define_singleton_method(pd.getter_method_name) { @properties[pd.id].value }
+          define_singleton_method(pd.setter_method_name) { |v| @properties[pd.id].value = v }
+          define_singleton_method(pd.property_method_name) { @properties[pd.id] }
+        end
+      end
+    end
+    
+    def remove_secondary_type_properties(secondary_type)
+      secondary_type.self_property_definitions.each do |pd|
+        # Vérifier que la propriété n'est pas également définie par le type principal ou un autre type secondaire
+        unless property_defined_elsewhere?(pd.id, secondary_type.id)
+          @properties.delete(pd.id)
+          
+          # Supprimer les méthodes associées
+          singleton_class.send(:remove_method, pd.getter_method_name) if respond_to?(pd.getter_method_name)
+          singleton_class.send(:remove_method, pd.setter_method_name) if respond_to?(pd.setter_method_name)
+          singleton_class.send(:remove_method, pd.property_method_name) if respond_to?(pd.property_method_name)
+        end
+      end
+    end
+    
+    def property_defined_elsewhere?(prop_id, excluding_type_id)
+      # Vérifier si la propriété est définie par le type principal
+      return true if type.property_definitions.any? { |pd| pd.id == prop_id }
+      
+      # Vérifier si la propriété est définie par un autre type secondaire
+      @secondary_types.any? do |st| 
+        st.id != excluding_type_id && st.property_definitions.any? { |pd| pd.id == prop_id }
+      end
+    end
+    
+    def update_secondary_type_ids
+      # Mettre à jour la propriété cmis:secondaryObjectTypeIds avec les IDs des types secondaires
+      if @properties.key?('cmis:secondaryObjectTypeIds')
+        @properties['cmis:secondaryObjectTypeIds'].value = @secondary_types.map(&:id)
+      end
+    end
+    
+    def type=(type)
+      @type=type
+      type.property_definitions.each do |pd|
+        define_singleton_method(pd.getter_method_name) { @properties[pd.id].value }
+        define_singleton_method(pd.setter_method_name) { |v| @properties[pd.id].value=v }
+        define_singleton_method(pd.property_method_name) { @properties[pd.id] }
+      end
+    end
+
+    def initialize_properties
+      @properties=type.property_definitions.map do |pd|
+        [pd.id, Property.new(pd, pd.value, self)]
+      end.to_h
+    end
+  end
+end

data/lib/cmis_server/configuration.rb

@@ -0,0 +1,43 @@
+module CmisServer
+  class Configuration
+
+    attr_accessor :http_basic_auth_procedure
+    attr_accessor :arguments_for_root_folder
+    attr_accessor :default_page_size
+    attr_accessor :debug
+    attr_accessor :repository_info
+    attr_accessor :optimizations
+
+    def initialize
+
+      #defines default values
+
+      @http_basic_auth_procedure = Proc.new do |user, password|
+        puts "Set your identification procedure in the CmisServer gem configuration with key http_basic_auth_procedure."
+        puts "example : config.http_basic_auth_procedure = Proc.new{|user,password| User.find_by(username: user)&.valid_password?(password)}"
+        raise "http_basic_auth_procedure configuration not set"
+      end
+
+      @arguments_for_root_folder={
+          type: FolderType.base,
+          properties:{
+            cmis_object_id:              'cmis:root_folder',
+            cmis_name:                   "Root Folder",
+            cmis_last_modification_date: DateTime.now,
+            cmis_creation_date:          DateTime.now,
+            cmis_created_by:             'unknown'
+          }
+      }
+
+      @default_page_size = 10
+
+      @debug=false
+
+      @repository_info = {}
+
+      @optimizations = {}
+
+    end
+
+  end
+end

data/lib/cmis_server/constants.rb

@@ -0,0 +1,8 @@
+module CmisServer
+
+  CMIS_NAMESPACE          ="http://docs.oasis-open.org/ns/cmis/core/201107/"
+  CMIS_REST_ATOM_NAMESPACE="http://docs.oasis-open.org/ns/cmis/restatom/201107/"
+  CMIS_VERSION_SUPPORTED  ="1.1"
+
+end
+

data/lib/cmis_server/content_stream.rb

@@ -0,0 +1,52 @@
+require 'mime/types'
+require 'tempfile'
+require 'base64'
+
+module CmisServer
+  class ContentStream
+
+    attr_accessor :media_type
+    attr_accessor :base64
+    attr_accessor :filename
+    attr_accessor :id
+
+    def initialize(id: nil, base64: nil, media_type: nil, filename: nil)
+      @media_type=media_type
+      @base64    =base64
+      @id        =id
+      @filename  =filename
+    end
+
+    def length
+      content.bytesize
+    end
+
+    def default_extensions
+      MIME::Types[self.media_type].first&.extensions&.first||'txt'
+    end
+
+    def content
+      Base64.decode64(self.base64)
+    end
+
+    def tempfile(name='tempfile')
+      t=Tempfile.new([name, ".#{default_extensions}"])
+      t.binmode
+      t.write(self.content)
+      t.close
+      t.open
+      t
+    end
+
+    def with_tempfile(&block)
+      temp_file=self.tempfile
+      begin
+        block.call(temp_file)
+      ensure
+        temp_file.close
+        temp_file.unlink
+      end
+    end
+
+  end
+end

data/lib/cmis_server/context.rb

@@ -0,0 +1,11 @@
+module CmisServer
+  class Context
+
+    attr_accessor :current_user
+
+    def initialize(current_user: nil)
+      @current_user= current_user
+    end
+
+  end
+end

data/lib/cmis_server/document_object.rb

@@ -0,0 +1,12 @@
+module CmisServer
+  class DocumentObject < CmisServer::CmisObject
+
+    attr_accessor :content_stream
+
+    def initialize(type:, properties: {})
+      raise InvalidType unless type.base_id == 'cmis:document'
+      super
+    end
+
+  end
+end

data/lib/cmis_server/document_type.rb

@@ -0,0 +1,67 @@
+module CmisServer
+  class DocumentType < Type
+
+    attr_accessor :versionable,
+                  :content_stream_allowed
+    # notallowed
+    # A content stream MUST NOT be included.
+    #     allowed
+    # A content stream MAY be included.
+    #     required
+    # A content stream MUST be included (i.e. MUST be included when the object is created, and MUST NOT be deleted).
+
+    def initialize(attrs={})
+      @versionable            = attrs.fetch(:versionable, false)
+      @content_stream_allowed = attrs.fetch(:content_stream_allowed, :allowed)
+      super
+    end
+
+    def adapter_class
+      DocumentAdapter
+    end
+
+
+    def self.base
+      @base||=new(id:                   'cmis:document',
+          parent_type:          nil,
+          description:          "A CMIS document",
+          display_name:         'Document',
+          creatable:            true,
+          fileable:             true,
+          queryable:            true,
+          property_definitions: [
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:name'.freeze, type: String, required: true, updatability: :readwrite}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:description'.freeze, type: String, required: false, updatability: :readwrite}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:objectId'.freeze, type: CmisServer::Id, required: true, updatability: :readonly}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:baseTypeId'.freeze, type: CmisServer::Id, required: true, updatability: :readonly, value: ->(obj) { obj.type.base_id }}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:objectTypeId'.freeze, type: CmisServer::Id, required: true, updatability: :oncreate, value: ->(obj) { obj.type.id }}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:createdBy'.freeze, type: String, required: false, updatability: :readonly, queryable: true, orderable: true}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:creationDate'.freeze, type: DateTime, required: false, updatability: :readonly, queryable: true, orderable: true}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:lastModifiedBy'.freeze, type: String, required: false, updatability: :readonly, queryable: true, orderable: true}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:lastModificationDate'.freeze, type: DateTime, required: false, updatability: :readonly, queryable: true, orderable: true}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:changeToken'.freeze, type: String, required: false, updatability: :readonly}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:isImmutable'.freeze, type: Boolean, required: false, updatability: :readonly, default: false}),
+
+                                    # Versionning properties
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:isLatestVersion'.freeze, type: Boolean, required: false, updatability: :readonly}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:isMajorVersion'.freeze, type: Boolean, required: false, updatability: :readonly}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:isLatestMajorVersion'.freeze, type: Boolean, required: false, updatability: :readonly}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:isPrivateWorkingCopy'.freeze, type: Boolean, required: false, updatability: :readonly}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:versionLabel'.freeze, type: String, required: false, cardinality: :single, updatability: :readonly}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:versionSeriesId'.freeze, type: CmisServer::Id, required: false, cardinality: :single, updatability: :readonly}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:isVersionSeriesCheckedOut'.freeze, type: Boolean, required: false, cardinality: :single, updatability: :readonly}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:versionSeriesCheckedOutBy'.freeze, type: String, required: false, cardinality: :single, updatability: :readonly}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:versionSeriesCheckedOutId'.freeze, type: Id, required: false, cardinality: :single, updatability: :readonly}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:checkinComment'.freeze, type: String, required: false, cardinality: :single, updatability: :readonly}),
+
+                                    # ContentStream properties
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:contentStreamLength'.freeze, type: Integer, required: false, cardinality: :single, updatability: :readonly, value: ->(obj) { obj.content_stream&.length }}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:contentStreamMimeType'.freeze, type: String, required: false, cardinality: :single, updatability: :readonly, value: ->(obj) { obj.content_stream&.media_type }}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:contentStreamFileName'.freeze, type: String, required: false, cardinality: :single, updatability: :readonly, value: ->(obj) { obj.content_stream&.filename }}),
+                                    CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:contentStreamId'.freeze, type: String, required: false, cardinality: :single, updatability: :readonly, value: ->(obj) { obj.content_stream&.id }}),
+                                ])
+    end
+
+
+  end
+end

data/lib/cmis_server/engine.rb

@@ -0,0 +1,60 @@
+module CmisServer
+  class Engine < ::Rails::Engine
+    config.autoload_paths << File.expand_path("../../app/services", __FILE__)
+    isolate_namespace CmisServer
+    
+    # Enregistrement des types MIME selon les conventions de Rails 7+
+    initializer "cmis_server.register_mime_types" do
+      Mime::Type.register "application/atom+xml", :atom_xml
+      Mime::Type.register "application/atom+xml;type=feed", :atom_feed
+      Mime::Type.register "application/atom+xml;type=entry", :atom_entry
+      Mime::Type.register "application/atomsvc+xml", :atom_service
+    end
+  end
+end
+
+require 'cmis_server/version'
+require 'cmis_server/constants'
+require 'cmis_server/configuration'
+
+require 'cmis_server/exceptions'
+
+#CMIS special types
+require 'cmis_server/id'
+require 'cmis_server/content_stream'
+
+require 'cmis_server/repository'
+require 'cmis_server/property_definition'
+require 'cmis_server/property'
+
+# Charger BaseType en premier
+require 'cmis_server/base_objects/base_type'
+
+require 'cmis_server/type'
+require 'cmis_server/base_types'
+require 'cmis_server/type_registry'
+require 'cmis_server/cmis_object'
+require 'cmis_server/document_type'
+require 'cmis_server/document_object'
+require 'cmis_server/folder_type'
+require 'cmis_server/folder_object'
+require 'cmis_server/item_type'
+require 'cmis_server/item_object'
+require 'cmis_server/secondary_type'
+# require 'cmis_server/type_registry'
+
+
+require 'cmis_server/object_adapter'
+require 'cmis_server/item_adapter'
+require 'cmis_server/base_objects/base_type'
+require 'cmis_server/base_objects/document'
+require 'cmis_server/base_objects/folder'
+require 'cmis_server/base_objects/item'
+
+require 'cmis_server/atom_pub/entry_parser'
+
+require 'cmis_server/context'
+
+require 'cmis_server/query'
+require 'cmis_server/renderable_object'
+require 'cmis_server/renderable_collection'

data/lib/cmis_server/exceptions.rb

@@ -0,0 +1,185 @@
+module CmisServer
+
+  class CmisStandardError < StandardError
+
+    attr_reader :http_status_code, :debug_data, :trigger, :title
+
+    def initialize(attrs= {})
+      self.http_status_code = attrs.fetch(:http_status, 500)
+      @debug_data           = attrs.fetch(:debug_data, nil)
+      @trigger              = attrs.fetch(:trigger, nil)
+      @title                = attrs.fetch(:title, nil)
+    end
+
+    def http_status
+      Rack::Utils::HTTP_STATUS_CODES[self.http_status_code]
+    end
+
+    def title
+      @title||self.class.name
+    end
+
+    def summary
+      "A #{self.title} error occured."
+    end
+
+    def message(debug: CmisServer.configuration.debug)
+      message=self.summary
+      message+= " It was initially triggered by : #{@trigger}" if @trigger&&debug
+      message
+    end
+
+    def to_h(debug: CmisServer.configuration.debug)
+      h={
+          title:            self.title,
+          summary:          self.summary,
+          http_status_code: self.http_status_code,
+          http_status:      self.http_status,
+      }
+      if debug
+        h[:debug_data]= self.debug_data.to_h
+        h[:backtrace] =self.backtrace&.join("\n")
+        h[:trigger]   ={
+            name:      self.trigger,
+            backtrace: self.trigger&.backtrace&.join("\n")
+        }
+      end
+      h
+    end
+
+    def to_xml(debug: CmisServer.configuration.debug)
+      formated_hash=self.to_h(debug: debug).map { |k, v| [k.to_s.camelcase(:lower), v] }.to_h
+      formated_hash.to_xml(:root => 'error', :skip_instruct => true)
+    end
+
+    def log(logger)
+      logger.error "#{self.class.to_s} (#{self.summary})"
+      logger.info self.backtrace.join("\n") if self.backtrace
+      if self.trigger
+        logger.error "Initialy triggered by : #{self.trigger.class.to_s} (#{self.trigger.message})"
+        logger.info self.trigger.backtrace.join("\n") if self.trigger.backtrace
+      end
+    end
+
+    protected
+
+    def http_status_code=(value)
+      if value.is_a? Integer
+        @http_status_code=value
+      else
+        @http_status_code=Rack::Utils::SYMBOL_TO_STATUS_CODE[value]||value.to_i
+      end
+    end
+  end
+
+  class RuntimeError < CmisStandardError
+    def title
+      "Runtime Error"
+    end
+
+    def summary
+      "An unhandled error occurred on the CMIS server."
+    end
+  end
+
+  class ObjectNotFound < CmisStandardError
+    def title
+      "Object Not Found"
+    end
+
+    def summary
+      "The requested object could not be found in this CMIS repository or you don't have permissions to access it"
+    end
+
+    def http_status_code
+      404
+    end
+  end
+
+  # Exceptions pour CMIS 1.1
+  class InvalidType < CmisStandardError
+    def title
+      "Invalid Type"
+    end
+
+    def summary
+      "The specified type is invalid or does not exist."
+    end
+
+    def http_status_code
+      400
+    end
+  end
+
+  class InvalidTypeDefinition < CmisStandardError
+    def initialize(message = nil, attrs = {})
+      super(attrs)
+      @message = message
+    end
+
+    def title
+      "Invalid Type Definition"
+    end
+
+    def summary
+      @message || "The type definition is invalid."
+    end
+
+    def http_status_code
+      400
+    end
+  end
+
+  class InvalidOperation < CmisStandardError
+    def initialize(message = nil, attrs = {})
+      super(attrs)
+      @message = message
+    end
+
+    def title
+      "Invalid Operation"
+    end
+
+    def summary
+      @message || "The requested operation cannot be performed."
+    end
+
+    def http_status_code
+      400
+    end
+  end
+
+  class NotSupported < CmisStandardError
+    def title
+      "Not Supported"
+    end
+
+    def summary
+      "The requested operation is not supported by this CMIS repository."
+    end
+
+    def http_status_code
+      405
+    end
+  end
+
+  class ConstraintViolation < CmisStandardError
+    def initialize(message = nil, attrs = {})
+      super(attrs)
+      @message = message
+    end
+
+    def title
+      "Constraint Violation"
+    end
+
+    def summary
+      @message || "A constraint has been violated."
+    end
+
+    def http_status_code
+      409
+    end
+  end
+
+end

data/lib/cmis_server/folder_object.rb

@@ -0,0 +1,18 @@
+module CmisServer
+  class FolderObject < CmisServer::CmisObject
+
+    def self.root_folder
+      unless @root
+        @root=new(CmisServer.configuration.arguments_for_root_folder)
+        @root.define_singleton_method :is_root?,(lambda { true })
+      end
+      @root
+    end
+
+    def initialize(type:, properties: {})
+      raise InvalidType unless type.base_id == 'cmis:folder'
+      super
+    end
+
+  end
+end