cmis_server 1.0.3 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a06882af4391857d952ae571fe62d9cecd8b189448b7a74da1f9aedc7d936fb
-  data.tar.gz: defe5fdf0356330dccaaa0d7819f9f5f0fccda34315ae9d056980eb5b9b10bb9
+  metadata.gz: 3fd8e8b28a3d38e71270a181bd6817bb486492911bc2411344e88e6b70b9b4dd
+  data.tar.gz: a509fefe60180d876c152132e1aa7ea93a03d8261cb05b8a1d0c2d7cb1a8f873
 SHA512:
-  metadata.gz: e322038687939ec2b099c76366dd2bc646af018e803f60b35861c2d71ca5ddff14ff275d009de7977be59c2185e12aaed72e6c1bce3b8fa4df1191ad8aa65680
-  data.tar.gz: b2f428f15608eb7aa583f42a00271ccac21f8b0b19ba8c9c82f3202113ab56622b249d0fd9799c7329e6699c32da8ec2c0e59c9e2e3fa23af6eb7054389483af
+  metadata.gz: e5b50cf64970bb7f3777f56b05a76f6593637db0d1ce66cdc75aea61a786b910471e955183fd710196cf3d59c7786514170b772a28550da84d6bb67ac9bff201
+  data.tar.gz: 4f6ba22462abe9188d2c875ff4882c4e45be22d390c3de386e3ddd15eb85b259b520cb7907ab7d14c07d17bce490201002bfb2ba5335c039b33ae7a5f9026676

data/Rakefile

@@ -33,6 +33,20 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = false
 end
 
+# Ajouter RSpec pour les nouveaux tests
+begin
+  require 'rspec/core/rake_task'
+  
+  RSpec::Core::RakeTask.new(:spec) do |spec|
+    spec.pattern = FileList['spec/**/*_spec.rb']
+  end
+
+  task :default => [:parser, :spec, :test]
+rescue LoadError
+  # RSpec n'est pas disponible
+  task :default => [:parser, :test]
+end
+
 
 GENERATED_PARSER = 'lib/cmis_server/query/parser.racc.rb'
 GENERATED_LEXER = 'lib/cmis_server/query/parser.rex.rb'

data/app/controllers/cmis_server/atom_pub/base_controller.rb

@@ -1,3 +1,5 @@
+require_relative '../application_controller'
+
 module CmisServer
   module AtomPub
     class BaseController < CmisServer::ApplicationController
@@ -18,6 +20,47 @@ module CmisServer
 
         render xml: cmis_error.to_xml, content_type: 'application/xml', status: cmis_error.http_status_code
       end
+
+      protected
+
+      def repository_from_request
+        @repository ||= CmisServer::Repository.find(params[:repository_id] || 'default')
+      end
+
+      def current_repository
+        repository_from_request
+      end
+
+      def render_error(error)
+        render_standard_error(error)
+      end
+
+      def current_context
+        @current_context ||= CmisServer::Context.new(
+          current_user: current_user
+        )
+      end
+
+      def current_user
+        # Récupérer l'utilisateur depuis l'authentification HTTP Basic
+        # L'authentification retourne déjà l'objet utilisateur approprié
+        request.env['HTTP_AUTHORIZATION'] ? authenticated_user_from_auth : nil
+      end
+      
+      private
+      
+      def authenticated_user_from_auth
+        # Extraire les credentials de l'en-tête Authorization
+        auth_header = request.env['HTTP_AUTHORIZATION']
+        return nil unless auth_header&.start_with?('Basic ')
+        
+        encoded_credentials = auth_header.split(' ', 2).last
+        decoded_credentials = Base64.decode64(encoded_credentials)
+        username, password = decoded_credentials.split(':', 2)
+        
+        # Appeler la procédure d'authentification configurée
+        CmisServer.configuration.http_basic_auth_procedure.call(username, password)
+      end
     end
   end
 end

data/app/controllers/cmis_server/atom_pub/bulk_controller.rb

@@ -1,3 +1,5 @@
+require_relative 'base_controller'
+
 module CmisServer
   module AtomPub
     class BulkController < BaseController

data/app/controllers/cmis_server/atom_pub/content_controller.rb

@@ -1,3 +1,5 @@
+require_relative 'base_controller'
+
 module CmisServer
   module AtomPub
     class ContentController < CmisServer::AtomPub::BaseController

data/app/controllers/cmis_server/atom_pub/entries_controller.rb

@@ -1,3 +1,5 @@
+require_relative 'base_controller'
+
 module CmisServer
   module AtomPub
     class EntriesController < CmisServer::AtomPub::BaseController

data/app/controllers/cmis_server/atom_pub/folder_collection_controller.rb

@@ -1,3 +1,5 @@
+require_relative 'base_controller'
+
 module CmisServer
   module AtomPub
     class FolderCollectionController < CmisServer::AtomPub::BaseController
@@ -54,6 +56,12 @@ module CmisServer
         service=NavigationService.new(@repository, context)
         service.get_descendants(params[:id])
       end
+      
+      def destroy
+        service = ObjectService.new(@repository, context)
+        service.delete_object(params[:id])
+        head :no_content
+      end
 
       protected
 

data/app/controllers/cmis_server/atom_pub/query_controller.rb

@@ -1,3 +1,5 @@
+require_relative 'base_controller'
+
 module CmisServer
   module AtomPub
     class QueryController < BaseController
@@ -10,7 +12,7 @@ module CmisServer
         query_data = parse_query_request
         
         begin
-          discovery_service = CmisServer::DiscoveryService.new(context: context)
+          discovery_service = CmisServer::DiscoveryService.new(@repository, current_context)
           results = discovery_service.query(
             statement: query_data[:statement],
             search_all_versions: query_data[:search_all_versions],
@@ -46,7 +48,7 @@ module CmisServer
         query_data = parse_query_request
         
         begin
-          discovery_service = CmisServer::DiscoveryService.new(context: context)
+          discovery_service = CmisServer::DiscoveryService.new(@repository, current_context)
           validation_result = discovery_service.validate_query(query_data[:statement])
           
           respond_to do |format|
@@ -83,6 +85,10 @@ module CmisServer
           parse_atom_pub_query_request
         end
       end
+
+      def supports_browser_binding?
+        request.content_type&.include?('application/json')
+      end
       
       def parse_browser_binding_query_request
         json_data = JSON.parse(request.body.read)

data/app/controllers/cmis_server/atom_pub/repository_controller.rb

@@ -1,3 +1,5 @@
+require_relative 'base_controller'
+
 module CmisServer
   module AtomPub
     class RepositoryController < BaseController
@@ -56,7 +58,9 @@ module CmisServer
       private
       
       def enhance_capabilities_for_cmis_1_1(capabilities)
-        capabilities.merge({
+        capabilities_hash = capabilities.respond_to?(:to_h) ? capabilities.to_h : capabilities
+        
+        capabilities_hash.merge({
           # Nouvelles capabilities CMIS 1.1
           type_management: capabilities[:create_type] || false,
           bulk_update: capabilities[:bulk_update] || false,

data/app/controllers/cmis_server/atom_pub/secondary_types_controller.rb

@@ -1,3 +1,5 @@
+require_relative 'base_controller'
+
 module CmisServer
   module AtomPub
     class SecondaryTypesController < BaseController

data/app/controllers/cmis_server/atom_pub/service_documents_controller.rb

@@ -1,7 +1,10 @@
+require_relative 'base_controller'
+
 module CmisServer
   module AtomPub
     class ServiceDocumentsController < CmisServer::AtomPub::BaseController
-      require 'atom/service'
+      # Supprimé la dépendance "require 'atom/service'" qui cause des problèmes
+      # Si nécessaire, vous pouvez ajouter d'autres bibliothèques ici
 
 
       def service_document

data/app/controllers/cmis_server/atom_pub/types_controller.rb

@@ -1,3 +1,5 @@
+require_relative 'base_controller'
+
 module CmisServer
   module AtomPub
     class TypesController < BaseController

data/app/controllers/cmis_server/atom_pub/uri_templates_controller.rb

@@ -1,3 +1,5 @@
+require_relative 'base_controller'
+
 module CmisServer
   module AtomPub
     class UriTemplatesController < CmisServer::AtomPub::BaseController
@@ -8,40 +10,49 @@ module CmisServer
 
 
       def object_by_id
-        service=ObjectService.new(@repository, context)
-        @object=service.get_object(params[:id], with_object: true, filter: @filter)
+        service = CmisServer::ObjectService.new(@repository, current_context)
+        @object = service.get_object(params[:id], with_object: true, filter: @filter)
         render 'cmis_server/atom_pub/entries/object_entry', formats: :atom_entry
       end
 
       def object_by_path
-        service=ObjectService.new(@repository, context)
-        @object=service.get_object_by_path(params[:path], with_object: true, filter: @filter)
+        service = CmisServer::ObjectService.new(@repository, current_context)
+        @object = service.get_object_by_path(params[:path], with_object: true, filter: @filter)
         render 'cmis_server/atom_pub/entries/object_entry', formats: :atom_entry
       end
 
       def type_by_id
-        service=RepositoryService.new(@repository)
-        @type  =service.get_type_definition(params[:id])
-
-
-        return render 'cmis_server/atom_pub/entries/type_entry', formats: :atom_entry
+        service = CmisServer::RepositoryService.new(@repository)
+        @type = service.get_type_definition(params[:id])
+        render 'cmis_server/atom_pub/entries/type_entry', formats: :atom_entry
       end
 
       def query
-        query_params=Hash.from_xml(raw_post_body)["query"].slice("statement", "searchAllVersions", "includeAllowableActions", "includeRelationships", "renditionFilter", "maxItems", "skipCount")
-
-        service =DiscoveryService.new(@repository, @context)
-        response=service.query(query_params['statement'],
-                               search_all_versions:       (query_params['searchAllVersions']=='true'),
-                               rendition_filter:          (query_params['renditionFilter']||'cmis:none'),
-                               include_relationships:     (query_params['includeRelationships']&.to_sym||:none),
-                               include_allowable_actions: (query_params['includeAllowableActions']=='true'),
-                               max_items:                 (query_params['maxItems']||10).to_i,
-                               skip_count:                (query_params['skipCount']||0).to_i
+        if request.post?
+          # POST query with XML/JSON body
+          if request.content_type =~ /xml/
+            query_params = Hash.from_xml(raw_post_body)["query"].slice("statement", "searchAllVersions", "includeAllowableActions", "includeRelationships", "renditionFilter", "maxItems", "skipCount")
+          else
+            # JSON body
+            query_params = JSON.parse(raw_post_body)
+          end
+        else
+          # GET query with URL parameters
+          query_params = params.slice(:statement, :searchAllVersions, :includeAllowableActions, :includeRelationships, :renditionFilter, :maxItems, :skipCount)
+        end
+
+        service = CmisServer::DiscoveryService.new(@repository, current_context)
+        response = service.query(query_params['statement'] || query_params[:statement],
+                               search_all_versions:       (query_params['searchAllVersions'] == 'true' || query_params[:searchAllVersions] == 'true'),
+                               rendition_filter:          (query_params['renditionFilter'] || query_params[:renditionFilter] || 'cmis:none'),
+                               include_relationships:     ((query_params['includeRelationships'] || query_params[:includeRelationships])&.to_sym || :none),
+                               include_allowable_actions: (query_params['includeAllowableActions'] == 'true' || query_params[:includeAllowableActions] == 'true'),
+                               max_items:                 ((query_params['maxItems'] || query_params[:maxItems]) || 10).to_i,
+                               skip_count:                ((query_params['skipCount'] || query_params[:skipCount]) || 0).to_i
         )
 
-        @collection=RenderableCollection.new(base_object:        nil,
-                                             items:              response[:query_results],
+        @collection = CmisServer::RenderableCollection.new(base_object: nil,
+                                             items: response[:query_results],
                                              atompub_properties: {title: "Query"})
         render 'cmis_server/atom_pub/feeds/feed', formats: :atom_feed, status: :created
       end

data/app/services/cmis_server/object_service.rb

@@ -64,11 +64,17 @@ module CmisServer
     end
 
     def get_object(id, filter: [], include_relationships: :none, include_policy_ids: false, rendition_filter: "cmis:none", include_acl: false, include_allowable_actions: false, with_object: false)
-      record = DocumentAdapter.class_adapter(context: @context).find(id) || 
-               FolderAdapter.class_adapter(context: @context).find(id) || 
-               ItemAdapter.class_adapter(context: @context).find(id)
+      # Utiliser le nouveau connecteur pour récupérer l'objet
+      connector = CmisServer::Connectors::ConnectorFactory.create_connector(
+        user: @context[:current_user] || @context.current_user
+      )
+      
+      record = connector.find_object_by_id(id)
       raise CmisServer::ObjectNotFound unless record
-      return record.to_renderable_object
+      
+      # Pour l'instant, retourner l'objet tel quel
+      # TODO: implémenter la conversion en renderable_object
+      record
     end
 
     def get_properties(id, filter: [])
@@ -76,13 +82,17 @@ module CmisServer
     end
 
     def get_object_by_path(path, filter: [], include_relationships: :none, include_policy_ids: false, rendition_filter: "cmis:none", include_acl: false, include_allowable_actions: false, with_object: false)
-      record=CmisServer::FolderObject.root_folder
-      path.split('/')[1..-1].to_a.each do |slug|
-        adapter=record.adapter(context: @context)
-        record =adapter.find_slug_in_children(slug)
-        raise CmisServer::ObjectNotFound unless record
-      end
-      return record.to_renderable_object
+      # Utiliser le nouveau connecteur pour récupérer l'objet par path
+      connector = CmisServer::Connectors::ConnectorFactory.create_connector(
+        user: @context[:current_user] || @context.current_user
+      )
+      
+      record = connector.find_object_by_path(path)
+      raise CmisServer::ObjectNotFound unless record
+      
+      # Pour l'instant, retourner l'objet tel quel
+      # TODO: implémenter la conversion en renderable_object
+      record
     end
 
     def get_content_stream

data/app/services/cmis_server/repository_service.rb

@@ -6,7 +6,7 @@ module CmisServer
     end
 
     def get_repositories
-      raise NotImplemented
+      raise CmisServer::NotSupported.new("get_repositories not implemented")
     end
 
     def get_repository_info
@@ -14,27 +14,29 @@ module CmisServer
     end
 
     def get_type_children
-      raise NotImplemented
+      raise CmisServer::NotSupported.new("get_type_children not implemented")
     end
 
     def get_type_descendants
-      raise NotImplemented
+      raise CmisServer::NotSupported.new("get_type_descendants not implemented")
     end
 
-    def get_type_definition(type_id)
-      type=CmisServer::TypeAdapter.find!(type_id)
+    def get_type_definition(type_id)
+      type = CmisServer::TypeRegistry.get_type(type_id)
+      raise CmisServer::ObjectNotFound.new("Type '#{type_id}' not found") unless type
+      type
     end
 
     def create_type(type)
-      raise NotImplemented
+      raise CmisServer::NotSupported.new("create_type not implemented")
     end
 
     def update_type(type)
-      raise NotImplemented
+      raise CmisServer::NotSupported.new("update_type not implemented")
     end
 
     def delete_type(type)
-      raise NotImplemented
+      raise CmisServer::NotSupported.new("delete_type not implemented")
     end
   end
 end

data/app/views/cmis_server/atom_pub/entries/_cmis_folder_links.atom_entry.builder

@@ -1,3 +1,3 @@
 xml.link(rel:  'down',
-         href: atom_pub_folder_collection_url(id: object.cmis_object_id),
+         href: url_for(controller: 'cmis_server/atom_pub/folder_collection', action: 'get_children', id: object.cmis_object_id, only_path: false),
          type: "application/atomsvc+xml")

data/app/views/cmis_server/atom_pub/entries/_object_entry.atom_entry.builder

@@ -12,10 +12,10 @@ xml.tag!('entry', 'xmlns:atom' => 'http://www.w3.org/2005/Atom',
   end
 
   if cs=object.atompub_entry_properties[:content]
-    xml.content type: cs.media_type.to_s, src: atom_pub_content_url(id: cs.id)
+    xml.content type: cs.media_type.to_s, src: url_for(controller: 'cmis_server/atom_pub/content', action: 'show', id: cs.id, only_path: false)
   end
-  xml.link(rel: 'service', href: atom_pub_url, type: 'application/atomsvc+xml')
-  xml.link(rel: 'self', href: atom_pub_entry_url(id: object.base_object.cmis_object_id), type: 'application/atomsvc+xml')
+  xml.link(rel: 'service', href: url_for(controller: 'cmis_server/atom_pub/service_documents', action: 'service_document', only_path: false), type: 'application/atomsvc+xml')
+  xml.link(rel: 'self', href: url_for(controller: 'cmis_server/atom_pub/entries', action: 'show', id: object.base_object.cmis_object_id, only_path: false), type: 'application/atomsvc+xml')
   xml<<links_for(object.base_object)
 
 

data/app/views/cmis_server/atom_pub/entries/type_entry.atom_entry.builder

@@ -13,7 +13,7 @@ xml.tag!('entry', 'xmlns:atom' => 'http://www.w3.org/2005/Atom',
   end
 
   xml.link(rel: 'service', href: atom_pub_url, type: 'application/atomsvc+xml')
-  xml.link(rel: 'self', href: atom_pub_type_by_id_url(id: @type.id), type: 'application/atomsvc+xml')
+  xml.link(rel: 'self', href: url_for(controller: 'cmis_server/atom_pub/uri_templates', action: 'type_by_id', id: @type.id, only_path: false), type: 'application/atomsvc+xml')
 
   xml.tag!("app:edited", DateTime.now)
 

data/app/views/cmis_server/atom_pub/feeds/feed.atom_feed.builder

@@ -12,7 +12,7 @@ xml.tag!('atom:feed', 'xmlns:atom' => 'http://www.w3.org/2005/Atom',
 
   if @collection.base_object
     xml << render(partial: 'cmis_server/atom_pub/shared/collection', formats: [:xml], locals: {
-        href:   atom_pub_folder_collection_url(id: @collection.base_object.cmis_object_id),
+        href:   url_for(controller: 'cmis_server/atom_pub/folder_collection', action: 'get_children', id: @collection.base_object.cmis_object_id, only_path: false),
         title:  "Folder Collection",
         accept: "application/cmisatom+xml",
     })

data/app/views/cmis_server/atom_pub/service_documents/_workspace.atom_service.builder

@@ -33,56 +33,36 @@ xml.tag!('app:workspace') do
 
   xml << render(partial: 'cmis_server/atom_pub/shared/collection', formats: [:xml], locals: {
       type:   "root",
-      href:   atom_pub_folder_collection_url(repository.id, CmisServer::FolderObject.root_folder.cmis_object_id),
+      href:   url_for(controller: 'cmis_server/atom_pub/folder_collection', action: 'get_children', repository_id: repository.id, id: CmisServer::FolderObject.root_folder.cmis_object_id, only_path: false),
       title:  "Root Collection",
       accept: "application/atom+xml;type=entry",
   })
 
   xml << render(partial: 'cmis_server/atom_pub/shared/collection', formats: [:xml], locals: {
       type:   "query",
-      href:   atom_pub_query_url(repository.id),
+      href:   url_for(controller: 'cmis_server/atom_pub/query', action: 'query', repository_id: repository.id, only_path: false),
       title:  "Query Collection",
       accept: "application/cmisquery+xml",
   })
 
   xml << render(partial: 'cmis_server/atom_pub/service_documents/uri_template', locals: {
       type:      "objectbyid",
-      template:  URI.unescape(atom_pub_object_by_id_url(repository.id, {id:                        '{id}',
-                                                                        filter:                    '{filter}',
-                                                                        include_allowable_actions: '{includeAllowableActions}',
-                                                                        include_acl:               "{includeACL}",
-                                                                        include_policy_ids:        "{includePolicyIds}",
-                                                                        include_relationships:     "{includeRelationships}",
-                                                                        rendition_filter:          "{renditionFilter}"
-      })),
+      template:  request.base_url + "/cmis/atom_pub/#{repository.id}/id?id={id}&filter={filter}&includeAllowableActions={includeAllowableActions}&includeACL={includeACL}&includePolicyIds={includePolicyIds}&includeRelationships={includeRelationships}&renditionFilter={renditionFilter}",
       mediatype: 'application/atom+xml;type=entry'
   })
   xml << render(partial: 'cmis_server/atom_pub/service_documents/uri_template', locals: {
       type:      "objectbypath",
-      template:  URI.unescape(atom_pub_object_by_path_url(repository.id, {path:                      '{path}',
-                                                                          filter:                    '{filter}',
-                                                                          include_allowable_actions: '{includeAllowableActions}',
-                                                                          include_acl:               "{includeACL}",
-                                                                          include_policy_ids:        "{includePolicyIds}",
-                                                                          include_relationships:     "{includeRelationships}",
-                                                                          rendition_filter:          "{renditionFilter}"
-      })),
+      template:  request.base_url + "/cmis/atom_pub/#{repository.id}/path?path={path}&filter={filter}&includeAllowableActions={includeAllowableActions}&includeACL={includeACL}&includePolicyIds={includePolicyIds}&includeRelationships={includeRelationships}&renditionFilter={renditionFilter}",
       mediatype: 'application/atom+xml;type=entry'
   })
   xml << render(partial: 'cmis_server/atom_pub/service_documents/uri_template', locals: {
       type:      "typebyid",
-      template:  URI.unescape(atom_pub_type_by_id_url(repository.id, {id: '{id}'})),
+      template:  request.base_url + "/cmis/atom_pub/#{repository.id}/type?id={id}",
       mediatype: 'application/atom+xml;type=entry'
   })
   xml << render(partial: 'cmis_server/atom_pub/service_documents/uri_template', locals: {
       type:      "query",
-      template:  URI.unescape(atom_pub_query_url(repository.id, {q:                         '{q}',
-                                                                 search_all_versions:       '{searchAllVersions}',
-                                                                 include_allowable_actions: '{includeAllowableActions}',
-                                                                 include_relationships:     "{includeRelationships}",
-                                                                 max_items:                 "{maxItems}",
-                                                                 skip_count:                "{skipCount}",
-      })),
+      template:  request.base_url + "/cmis/atom_pub/#{repository.id}/query?q={q}&searchAllVersions={searchAllVersions}&includeAllowableActions={includeAllowableActions}&includeRelationships={includeRelationships}&maxItems={maxItems}&skipCount={skipCount}",
       mediatype: 'application/atom+xml;type=entry'
   })
 

data/config/initializers/cmis_base_types.rb

@@ -0,0 +1,95 @@
+# Initialisation des types CMIS de base
+# Ce fichier configure les types CMIS standards requis par la spécification
+
+Rails.application.config.after_initialize do
+  # Enregistrer les types CMIS de base seulement s'ils n'existent pas déjà
+  unless CmisServer::TypeRegistry.get_type('cmis:document')
+    # Type de base Document
+    document_type = CmisServer::DocumentType.new(
+      id: 'cmis:document',
+      local_name: 'document',
+      display_name: 'Document',
+      query_name: 'cmis:document',
+      description: 'Base type for all documents',
+      base_id: 'cmis:document',
+      parent_type: nil,
+      creatable: true,
+      fileable: true,
+      queryable: true,
+      controllable_policy: false,
+      controllable_acl: true,
+      fulltext_indexed: false,
+      included_in_supertype_query: true,
+      property_definitions: []
+    )
+    CmisServer::TypeRegistry.register_type('cmis:document', document_type)
+  end
+
+  unless CmisServer::TypeRegistry.get_type('cmis:folder')
+    # Type de base Folder
+    folder_type = CmisServer::FolderType.new(
+      id: 'cmis:folder',
+      local_name: 'folder',
+      display_name: 'Folder',
+      query_name: 'cmis:folder',
+      description: 'Base type for all folders',
+      base_id: 'cmis:folder',
+      parent_type: nil,
+      creatable: true,
+      fileable: true,
+      queryable: true,
+      controllable_policy: false,
+      controllable_acl: true,
+      fulltext_indexed: false,
+      included_in_supertype_query: true,
+      property_definitions: []
+    )
+    CmisServer::TypeRegistry.register_type('cmis:folder', folder_type)
+  end
+
+  unless CmisServer::TypeRegistry.get_type('cmis:item')
+    # Type de base Item (CMIS 1.1)
+    item_type = CmisServer::ItemType.new(
+      id: 'cmis:item',
+      local_name: 'item',
+      display_name: 'Item',
+      query_name: 'cmis:item',
+      description: 'Base type for all items',
+      base_id: 'cmis:item',
+      parent_type: nil,
+      creatable: true,
+      fileable: true,
+      queryable: true,
+      controllable_policy: false,
+      controllable_acl: true,
+      fulltext_indexed: false,
+      included_in_supertype_query: true,
+      property_definitions: []
+    )
+    CmisServer::TypeRegistry.register_type('cmis:item', item_type)
+  end
+
+  unless CmisServer::TypeRegistry.get_type('cmis:secondary')
+    # Type de base Secondary (CMIS 1.1)
+    secondary_type = CmisServer::SecondaryType.new(
+      id: 'cmis:secondary',
+      local_name: 'secondary',
+      display_name: 'Secondary Type',
+      query_name: 'cmis:secondary',
+      description: 'Base type for all secondary types',
+      base_id: 'cmis:secondary',
+      parent_type: nil,
+      creatable: false,
+      fileable: false,
+      queryable: true,
+      controllable_policy: false,
+      controllable_acl: false,
+      fulltext_indexed: false,
+      included_in_supertype_query: true,
+      property_definitions: []
+    )
+    CmisServer::TypeRegistry.register_type('cmis:secondary', secondary_type)
+  end
+
+  Rails.logger.info "CMIS base types initialized: #{CmisServer::TypeRegistry.types.keys.join(', ')}"
+end

data/config/initializers/cmis_core_configuration.rb

@@ -0,0 +1,60 @@
+# Configuration CMIS pour l'application Core
+# Ce fichier configure les paramètres spécifiques pour l'utilisation du gem CMIS Server dans l'app core
+
+Rails.application.config.after_initialize do
+  # Configuration du repository CMIS
+  CmisServer.configure do |config|
+    # Informations du repository principal
+    config.repository_info = {
+      id: 'core_repository',
+      name: 'Core Application Repository',
+      description: 'Repository CMIS pour l\'application Core',
+      vendor_name: 'Core Team',
+      product_name: 'Core Application',
+      product_version: '1.0.0'
+    }
+    
+    # Configuration de base
+    config.debug = false
+    config.default_page_size = 100
+    
+    # Configuration du dossier racine pour Core
+    config.arguments_for_root_folder = {
+      type: CmisServer::TypeRegistry.get_type('cmis:folder'),
+      properties: {
+        cmis_object_id: 'core_root',
+        cmis_name: 'Core Repository Root', 
+        cmis_description: 'Dossier racine du repository Core',
+        cmis_last_modification_date: DateTime.now,
+        cmis_creation_date: DateTime.now,
+        cmis_created_by: 'core_system'
+      }
+    }
+    
+    # Configuration de l'authentification HTTP Basic - intégration avec le core
+    config.http_basic_auth_procedure = proc do |username, password|
+      # Utiliser les credentials du core et retourner un objet utilisateur
+      if username == 'oMkdOcS9qZhkHXoX2qO8u22vxlZij2me' && password == 'fGDmji2IMgIKd35pFwZ0Tm1lNQsm1O6z'
+        # Retourner un utilisateur simple - le connecteur se chargera de l'accès aux données
+        OpenStruct.new(
+          id: username,
+          name: 'Core User'
+        )
+      else
+        false
+      end
+    end
+    
+    # Configuration des optimisations
+    config.optimizations = {
+      cache_types: true,
+      lazy_loading: true,
+      bulk_operations: true
+    }
+    
+    # Configuration du connecteur pour Core
+    config.connector_class = 'CmisServer::Connectors::CoreConnector'
+  end
+  
+  Rails.logger.info "CMIS Core configuration initialized for repository: #{CmisServer.configuration.repository_info[:id]}"
+end