cmis_server 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c87c1fab52b4c8aa922033238d51f43d3c25a6e5f6c0092724cef97472578f31
-  data.tar.gz: 57d772e88f5289328d115f9db9639ad6e5d8a1a9a0dcab2a4f4306ac67c61104
+  metadata.gz: 9bc9d9ec2eaf839148dcb6721c119047890413d107a85595a74bc35cbb53bd84
+  data.tar.gz: 8872e2dd94ccc9012f78de2d1481b32efaccebe36dfa3f363d37f19b9f666ccd
 SHA512:
-  metadata.gz: 91a949552ebbbfdaf96ca799c81748883d12a0751451240683f374e0e389724a303d505823d694859a9bdcd6bda44184129ce303537b8343e6041312de99a972
-  data.tar.gz: 54a256c2f164ea708bcbbdad775abae2aca79bea1281e2f188c133e134f0fcbe0ef944c4913750b5753e20e174395f06e0bc75756552c8de397d6b5107c649c2
+  metadata.gz: ff9ac2fa277eac8327b9aa4e59b0756abdfc8df9a801dfd43d72419ecb202d8650403f0385bce7770b45536bf59380d214215cf2576ce4b7ab3e261640f407fd
+  data.tar.gz: 71165260bafa6571c3a0b85426c911cb01256e29573c0f2e8aba8206bcf5e5cf9fedc570798763b2d195b56cbfd9278909be6a3a116cf1317d38f8ce5433fdea

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

@@ -17,7 +17,8 @@ module CmisServer
       end
 
       def destroy
-
+        object_service.delete_object(id)
+        head :no_content
       end
 
       protected

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

@@ -9,56 +9,100 @@ module CmisServer
 
 
       def get_children
-        service =NavigationService.new(@repository, context)
-        response=service.get_children(params[:id], max_items: max_items_param, order_by: params[:orderBy])
+        
+        begin
+          service =NavigationService.new(@repository, current_context)
+          response=service.get_children(params[:id], max_items: max_items_param, order_by: params[:orderBy])
+          
+        rescue => e
+          Rails.logger.error "FolderCollectionController#get_children - Error: #{e.message}"
+          Rails.logger.error "FolderCollectionController#get_children - Backtrace: #{e.backtrace.first(10).join("\n")}"
+          raise e
+        end
 
-        @collection=RenderableCollection.new(base_object: CmisServer::FolderAdapter.class_adapter(context: @context).find(params[:id]),
-                                             items:       response[:objects])
+        # Utiliser le connecteur pour récupérer le dossier parent
+        connector = CmisServer::Connectors::ConnectorFactory.create_connector(
+          user: current_context.current_user
+        )
+        parent_object = connector.find_object_by_id(params[:id])
+        
+        # Gérer le cas spécial du root folder
+        if params[:id] == 'root_folder' || params[:id] == 'root_folder_id' || params[:id] == 'core_root' || params[:id] == 'root'
+          # Pour le root, utiliser directement nil comme parent_folder
+          # car c'est un dossier virtuel qui n'a pas besoin d'être dans la collection
+          parent_folder = nil
+        elsif parent_object
+          # C'est un objet Core normal, le convertir en objet CMIS
+          adapter = CmisServer::FolderAdapter.new(nil, context: current_context)
+          parent_folder = adapter.find(parent_object.id.to_s)
+        else
+          raise CmisServer::ObjectNotFound.new("Folder '#{params[:id]}' not found")
+        end
+        
+        # Si nous avons une erreur avec les objets, retourner une collection vide
+        items = response[:objects] || []
+        
+        
+        @collection=RenderableCollection.new(base_object: parent_folder,
+                                             items:       items)
         render 'cmis_server/atom_pub/feeds/feed', formats: :atom_feed
       end
 
       def create_children
         #Check if Document exists
         begin
+          
           if request_entry_parser.cmis_object_id
             #We move the document to the folder
 
           else
             #We create the document
             object_type=request_entry_parser.object_type
-            service    =ObjectService.new(@repository, context)
+            
+            # Protection si object_type est nil
+            if object_type.nil?
+              Rails.logger.error "Object type is nil, cannot determine type"
+              raise "Invalid object type in request"
+            end
+            
+            service    =ObjectService.new(@repository, current_context)
             case object_type.base_type.id
             when "cmis:document"
               id     =service.create_document(request_entry_parser.object_properties, folder_id: params[:id], content_stream: request_entry_parser.content_stream)
-              @object=CmisServer::DocumentAdapter::ClassAdapter.new(context: @context).find(id).to_renderable_object
+              @object=CmisServer::DocumentAdapter.class_adapter(context: current_context).find(id).to_renderable_object
               render 'cmis_server/atom_pub/entries/object_entry', formats: :atom_entry, status: :created
             when "cmis:folder"
-              id     =service.create_folder(request_entry_parser.object_properties)
-              @object=CmisServer::FolderAdapter.class_adapter(context: @context).find(id).to_renderable_object
+              id     =service.create_folder(request_entry_parser.object_properties, parent_folder_id: params[:id])
+              @object=CmisServer::FolderAdapter.class_adapter(context: current_context).find(id).to_renderable_object
               render 'cmis_server/atom_pub/entries/object_entry', formats: :atom_entry, status: :created
             when "cmis:policy"
               # Implémentation future de la gestion des politiques
             when "cmis:item"
               id     =service.create_item(request_entry_parser.object_properties)
-              @object=CmisServer::ItemAdapter.class_adapter(context: @context).find(id).to_renderable_object
+              @object=CmisServer::ItemAdapter.class_adapter(context: current_context).find(id).to_renderable_object
               render 'cmis_server/atom_pub/entries/object_entry', formats: :atom_entry, status: :created
             else
               raise "Unknown type #{object_type.base_type.id}"
             end
           end
         rescue CmisServer::ObjectService::DuplicateFile => e
+          Rails.logger.error "DuplicateFile error: #{e.message}"
           @object=e.duplicate.to_renderable_object
           render 'cmis_server/atom_pub/entries/object_entry', formats: :atom_entry, status: :conflict
+        rescue => e
+          Rails.logger.error "Error in create_children: #{e.message}"
+          Rails.logger.error "Backtrace: #{e.backtrace.first(10).join("\n")}"
+          raise e
         end
       end
 
       def get_descendants
-        service=NavigationService.new(@repository, context)
+        service=NavigationService.new(@repository, current_context)
         service.get_descendants(params[:id])
       end
       
       def destroy
-        service = ObjectService.new(@repository, context)
+        service = ObjectService.new(@repository, current_context)
         service.delete_object(params[:id])
         head :no_content
       end

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

@@ -13,8 +13,9 @@ module CmisServer
         
         begin
           discovery_service = CmisServer::DiscoveryService.new(@repository, current_context)
+          
           results = discovery_service.query(
-            statement: query_data[:statement],
+            query_data[:statement],
             search_all_versions: query_data[:search_all_versions],
             include_allowable_actions: query_data[:include_allowable_actions],
             include_relationships: query_data[:include_relationships],
@@ -23,19 +24,31 @@ module CmisServer
             skip_count: query_data[:skip_count]
           )
           
+          
           respond_to do |format|
             format.atom_feed { render "cmis_server/atom_pub/query_results_feed", locals: { results: results } }
             format.json { render json: format_query_results_for_json(results) }
           end
         rescue => e
-          render_error(e)
+          Rails.logger.error "QueryController#query: Error occurred: #{e.class} - #{e.message}"
+          Rails.logger.error "QueryController#query: Backtrace:\n#{e.backtrace.join("\n")}"
+          
+          # Add detailed error message to response
+          respond_to do |format|
+            format.atom_feed do
+              render xml: { error: { type: e.class.name, message: e.message, backtrace: e.backtrace[0..5] } }.to_xml(root: 'error'), status: 500
+            end
+            format.json do
+              render json: { error: { type: e.class.name, message: e.message, backtrace: e.backtrace[0..5] } }, status: 500
+            end
+          end
         end
       end
       
       # GET /query/types
       def queryable_types
         repository = repository_from_request
-        queryable_types = repository.types.select { |_, type| type.queryable }
+        queryable_types = CmisServer::TypeRegistry.types.select { |_, type| type.queryable }
         
         respond_to do |format|
           format.atom_feed { render "cmis_server/atom_pub/queryable_types_feed", locals: { types: queryable_types } }
@@ -105,23 +118,38 @@ module CmisServer
       end
       
       def parse_atom_pub_query_request
-        doc = Nokogiri::XML(request.body.read)
-        doc.remove_namespaces!
-        
-        {
-          statement: doc.at_xpath("//statement")&.text || params[:q],
-          search_all_versions: doc.at_xpath("//searchAllVersions")&.text == "true",
-          include_allowable_actions: doc.at_xpath("//includeAllowableActions")&.text == "true", 
-          include_relationships: doc.at_xpath("//includeRelationships")&.text || "none",
-          rendition_filter: doc.at_xpath("//renditionFilter")&.text || "",
-          max_items: (doc.at_xpath("//maxItems")&.text || params[:maxItems] || 100).to_i,
-          skip_count: (doc.at_xpath("//skipCount")&.text || params[:skipCount] || 0).to_i
-        }
+        # Rails parse automatiquement le JSON et le met dans params
+        if params[:query]
+          # Les données sont déjà parsées par Rails
+          {
+            statement: params[:query][:statement] || params[:statement],
+            search_all_versions: params[:query][:searchAllVersions] == true,
+            include_allowable_actions: params[:query][:includeAllowableActions] == true,
+            include_relationships: params[:query][:includeRelationships] || "none",
+            rendition_filter: params[:query][:renditionFilter] || "",
+            max_items: (params[:query][:maxItems] || 100).to_i,
+            skip_count: (params[:query][:skipCount] || 0).to_i
+          }
+        else
+          # Fallback pour le XML si nécessaire
+          doc = Nokogiri::XML(request.body.read)
+          doc.remove_namespaces!
+          
+          {
+            statement: doc.at_xpath("//statement")&.text || params[:q],
+            search_all_versions: doc.at_xpath("//searchAllVersions")&.text == "true",
+            include_allowable_actions: doc.at_xpath("//includeAllowableActions")&.text == "true", 
+            include_relationships: doc.at_xpath("//includeRelationships")&.text || "none",
+            rendition_filter: doc.at_xpath("//renditionFilter")&.text || "",
+            max_items: (doc.at_xpath("//maxItems")&.text || params[:maxItems] || 100).to_i,
+            skip_count: (doc.at_xpath("//skipCount")&.text || params[:skipCount] || 0).to_i
+          }
+        end
       end
       
       def format_query_results_for_json(results)
         {
-          results: results[:objects].map { |obj| obj.to_json },
+          results: (results[:query_results] || results[:objects] || []).map { |obj| obj.to_json },
           hasMoreItems: results[:has_more_items],
           numItems: results[:num_items]
         }

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

@@ -8,7 +8,7 @@ module CmisServer
 
 
       def service_document
-        @repository=Repository.find('my_repo')
+        @repository=Repository.find('core_repository')
         render 'cmis_server/atom_pub/service_documents/service_document', formats: :atom_service
       end
 

data/app/services/cmis_server/discovery_service.rb

@@ -1,3 +1,5 @@
+require 'ostruct'
+
 module CmisServer
   class DiscoveryService
 
@@ -8,23 +10,70 @@ module CmisServer
 
 
     def query(statement, search_all_versions: false, include_relationships: :none, rendition_filter: "cmis:none", include_allowable_actions: false, max_items: 10, skip_count: 0)
-
-      query_statement=CmisServer::Query::Parser.parse(statement)
+      
+      begin
+        
+        query_statement=CmisServer::Query::Parser.parse(statement)
+        
+      rescue => e
+        Rails.logger.error "Error in DiscoveryService.query: #{e.class} - #{e.message}"
+        Rails.logger.error e.backtrace.join("\n")
+        raise
+      end
 
       #Verify that there is only one Table
       table=query_statement.query_expression.from.tables.first
-      raise "Join are not supported" unless table.is_a? CmisServer::Query::Statement::Table
-      target_klass=TypeAdapter.find(table.name)
+      # La vérification est déjà faite dans le lambda is_a?
+      raise "Join are not supported" unless table.is_a?.call(CmisServer::Query::Statement::Table)
+      
+      # Récupérer le type CMIS
+      target_type=CmisServer::TypeRegistry.get_type(table.name)
+      unless target_type
+        raise ::CmisServer::InvalidArgument.new("Type '#{table.name}' not found")
+      end
 
-      objects=target_klass.adapter_class.class_adapter(context: @context).where(query_statement.query_expression.where.to_h, limit: 10, offset: 0)
+      # Utiliser le connecteur pour faire la recherche
+      connector = CmisServer::Connectors::ConnectorFactory.create_connector(
+        user: @context.current_user
+      )
+      
+      # Convertir les conditions WHERE en conditions de recherche
+      conditions = query_statement.query_expression.where ? query_statement.query_expression.where.to_h : {}
+      
+      # Rechercher selon le type
+      objects = case target_type.base_id.to_s
+      when 'cmis:document'
+        connector.find_documents(conditions.merge(page: (skip_count / max_items) + 1, per_page: max_items))
+      when 'cmis:folder'
+        connector.find_folders(conditions.merge(page: (skip_count / max_items) + 1, per_page: max_items))
+      else
+        []
+      end
+
+      # Convertir en objets renderable
+      renderable_objects = objects.map do |obj|
+        # Utiliser les adapters pour créer les objets CMIS correctement
+        if target_type.base_id.to_s == 'cmis:document' && obj.is_a?(::Doc)
+          adapter = CmisServer::DocumentAdapter.new(nil, context: @context)
+          cmis_doc = adapter.find(obj.id.to_s)
+          cmis_doc.to_renderable_object
+        elsif target_type.base_id.to_s == 'cmis:folder' && (obj.is_a?(::Tagset) || (obj.respond_to?(:is_space) && obj.is_space))
+          adapter = CmisServer::FolderAdapter.new(nil, context: @context)
+          cmis_folder = adapter.find(obj.id.to_s)
+          cmis_folder.to_renderable_object
+        else
+          # Fallback pour les types non supportés
+          Rails.logger.warn "DiscoveryService: Unsupported object type for query result: #{obj.class}"
+          nil
+        end
+      end.compact
 
       {
-          query_results:  objects.map { |o| o.to_renderable_object },
-          has_more_items: false, #ToDO
-          num_items: nil, #ToDO
+          query_results:  renderable_objects,
+          has_more_items: objects.count == max_items, # Si on a le max, il y en a peut-être d'autres
+          num_items: nil, # Non supporté pour l'instant
       }
 
-
     end
 
   end

data/app/services/cmis_server/navigation_service.rb

@@ -8,11 +8,70 @@ module CmisServer
 
     def get_children(folder_id, max_items: 10, skip_count: 0, order_by: {'cmis:creationDate' => :asc}, filter: [], include_relationships: :none, rendition_filter: "cmis:none", include_allowable_actions: false, include_path_segment: false, with_object: false)
 
-      folder=CmisServer::FolderAdapter.class_adapter(context: @context).find(folder_id)
+      # Utiliser le connecteur pour récupérer le dossier et ses enfants
+      connector = CmisServer::Connectors::ConnectorFactory.create_connector(
+        user: @context.current_user
+      )
+      
+      # Récupérer le dossier parent
+      folder = connector.find_object_by_id(folder_id)
+      unless folder
+        raise CmisServer::ObjectNotFound.new(debug_data: "Folder '#{folder_id}' not found")
+      end
+      
+      # Déterminer quels enfants récupérer selon le type de dossier
+      children = []
+      
+      # Si c'est le dossier racine, retourner les espaces favoris de l'utilisateur
+      if folder_id == 'core_root' || folder_id == 'root_folder' || folder_id == 'root_folder_id' || folder_id == 'root'
+        # Les espaces favoris sont les "dossiers racines" de l'utilisateur dans Core
+        children = connector.find_root_folders()
+      else
+        # Pour un espace spécifique, récupérer:
+        # 1. Les documents dans cet espace
+        documents = connector.find_documents({'space_ids' => [folder_id]})
+        # 2. Les sous-espaces (si applicable)
+        sub_spaces = connector.find_folders({'parent_id' => folder_id})
+        
+        children = documents + sub_spaces
+      end
+      
+      # Convertir en objets renderable
+      renderable_objects = children.map do |obj|
+        begin
+          
+          # Déterminer le type d'objet et créer l'adaptateur approprié
+          if obj.is_a?(::Doc)
+            # Document Core -> CMIS Document
+            adapter = CmisServer::DocumentAdapter.new(nil, context: @context)
+            cmis_doc = adapter.find(obj.id.to_s)
+            cmis_doc.to_renderable_object
+          elsif obj.is_a?(::Tagset) || (obj.respond_to?(:is_space) && obj.is_space)
+            # Tagset/Space Core -> CMIS Folder
+            adapter = CmisServer::FolderAdapter.new(nil, context: @context)
+            cmis_folder = adapter.find(obj.id.to_s)
+            cmis_folder.to_renderable_object
+          else
+            # Fallback: créer un document CMIS générique
+            doc_type = CmisServer::TypeRegistry.get_type('cmis:document') || CmisServer::DocumentType.base
+            properties = {
+              'cmis:objectId' => CmisServer::Property.new(id: 'cmis:objectId', value: obj.id.to_s),
+              'cmis:name' => CmisServer::Property.new(id: 'cmis:name', value: obj.respond_to?(:title) ? obj.title : 'Unknown')
+            }
+            cmis_doc = CmisServer::DocumentObject.new(type: doc_type, properties: properties)
+            cmis_doc.cmis_object_id = obj.id.to_s
+            cmis_doc.to_renderable_object
+          end
+        rescue => e
+          Rails.logger.error "NavigationService: Error converting object: #{e.message}"
+          Rails.logger.error "NavigationService: Backtrace: #{e.backtrace.first(5).join("\n")}"
+          raise e
+        end
+      end
 
       {
-          objects:        folder.adapter(context: @context).children(depth=1, limit: max_items, offset: skip_count, order_by: order_by).map { |o| o.to_renderable_object },
-          has_more_items: true,
+          objects:        renderable_objects,
+          has_more_items: children.count == max_items,
       }
     end
 

data/app/services/cmis_server/object_service.rb

@@ -16,11 +16,23 @@ module CmisServer
     end
 
     def create_document(properties, folder_id: nil, content_stream: nil, versionning_state: :none, policies: [], add_aces: [], remove_aces: [])
-      doc    =CmisServer::DocumentObject.new(type: DocumentType.base, properties: properties)
+      # Utiliser le connecteur pour créer le document
+      connector = CmisServer::Connectors::ConnectorFactory.create_connector(
+        user: @context[:current_user] || @context.current_user
+      )
+      
+      # Si le connecteur supporte la création directe
+      if connector.respond_to?(:create_document)
+        return connector.create_document(properties, folder_id: folder_id, content_stream: content_stream)
+      end
+      
+      # Sinon, utiliser l'ancien système d'adapters
+      doc    =CmisServer::DocumentObject.new(type: CmisServer::DocumentType.base, properties: properties)
       adapter=CmisServer::DocumentAdapter.new(doc, context: @context)
 
-      if folder_id&&folder=CmisServer::FolderAdapter.class_adapter(context: @context).find(folder_id)
-        adapter.add_to_folder(folder)
+      if folder_id
+        folder_adapter = CmisServer::FolderAdapter.class_adapter(context: @context).find(folder_id)
+        adapter.add_to_folder(folder_adapter)
       end
 
       if content_stream
@@ -35,8 +47,23 @@ module CmisServer
       raise NotImplemented
     end
 
-    def create_folder(properties, add_aces: [], remove_aces: [])
-      raise NotImplemented
+    def create_folder(properties, parent_folder_id: nil, add_aces: [], remove_aces: [])
+      # Utiliser le connecteur pour créer le dossier
+      connector = CmisServer::Connectors::ConnectorFactory.create_connector(
+        user: @context[:current_user] || @context.current_user
+      )
+      
+      # Si le connecteur supporte la création directe
+      if connector.respond_to?(:create_folder)
+        return connector.create_folder(properties, parent_folder_id: parent_folder_id)
+      end
+      
+      # Sinon, utiliser l'ancien système d'adapters
+      folder = CmisServer::FolderObject.new(type: CmisServer::TypeRegistry.get_type('cmis:folder'), properties: properties)
+      adapter = CmisServer::FolderAdapter.new(folder, context: @context)
+      
+      adapter.save!
+      adapter.object.cmis_object_id
     end
 
     def create_relationship
@@ -48,7 +75,7 @@ module CmisServer
     end
 
     def create_item(properties, folder_id: nil, policies: [], add_aces: [], remove_aces: [])
-      item = CmisServer::ItemObject.new(type: ItemType.base, properties: properties)
+      item = CmisServer::ItemObject.new(type: CmisServer::ItemType.base, properties: properties)
       adapter = CmisServer::ItemAdapter.new(item, context: @context)
 
       if folder_id && folder = CmisServer::FolderAdapter.class_adapter(context: @context).find(folder_id)
@@ -72,9 +99,39 @@ module CmisServer
       record = connector.find_object_by_id(id)
       raise CmisServer::ObjectNotFound unless record
       
-      # Pour l'instant, retourner l'objet tel quel
-      # TODO: implémenter la conversion en renderable_object
-      record
+      # Convertir l'objet Core en objet CMIS avec RenderableObject
+      if record.is_a?(::Doc)
+        adapter = CmisServer::DocumentAdapter.new(nil, context: @context)
+        cmis_obj = adapter.find(record.id.to_s)
+        cmis_obj.to_renderable_object
+      elsif record.is_a?(::Tagset) || (record.respond_to?(:is_space) && record.is_space)
+        adapter = CmisServer::FolderAdapter.new(nil, context: @context)
+        cmis_obj = adapter.find(record.id.to_s)
+        cmis_obj.to_renderable_object
+      else
+        # Pour les objets déjà CMIS (comme root folder OpenStruct), créer un RenderableObject
+        # directement à partir de l'objet
+        if record.respond_to?(:to_renderable_object)
+          record.to_renderable_object
+        else
+          # Fallback : créer un folder CMIS basique
+          folder_type = CmisServer::TypeRegistry.get_type('cmis:folder') || CmisServer::FolderType.base
+          properties = {
+            'cmis:objectId' => CmisServer::Property.new(id: 'cmis:objectId', value: record.id.to_s),
+            'cmis:name' => CmisServer::Property.new(id: 'cmis:name', value: record.respond_to?(:title) ? record.title : record.respond_to?(:name) ? record.name : 'Unknown'),
+            'cmis:baseTypeId' => CmisServer::Property.new(id: 'cmis:baseTypeId', value: 'cmis:folder'),
+            'cmis:objectTypeId' => CmisServer::Property.new(id: 'cmis:objectTypeId', value: 'cmis:folder'),
+            'cmis:createdBy' => CmisServer::Property.new(id: 'cmis:createdBy', value: record.respond_to?(:responsible) ? record.responsible : 'System'),
+            'cmis:creationDate' => CmisServer::Property.new(id: 'cmis:creationDate', value: record.respond_to?(:created_at) ? record.created_at : Time.now),
+            'cmis:lastModifiedBy' => CmisServer::Property.new(id: 'cmis:lastModifiedBy', value: record.respond_to?(:responsible) ? record.responsible : 'System'),
+            'cmis:lastModificationDate' => CmisServer::Property.new(id: 'cmis:lastModificationDate', value: record.respond_to?(:updated_at) ? record.updated_at : Time.now),
+            'cmis:parentId' => CmisServer::Property.new(id: 'cmis:parentId', value: nil)
+          }
+          folder = CmisServer::FolderObject.new(type: folder_type, properties: properties)
+          folder.cmis_object_id = record.id.to_s
+          folder.to_renderable_object
+        end
+      end
     end
 
     def get_properties(id, filter: [])
@@ -90,9 +147,39 @@ module CmisServer
       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
+      # Utiliser la même logique que get_object pour convertir en RenderableObject
+      if record.is_a?(::Doc)
+        adapter = CmisServer::DocumentAdapter.new(nil, context: @context)
+        cmis_obj = adapter.find(record.id.to_s)
+        cmis_obj.to_renderable_object
+      elsif record.is_a?(::Tagset) || (record.respond_to?(:is_space) && record.is_space)
+        adapter = CmisServer::FolderAdapter.new(nil, context: @context)
+        cmis_obj = adapter.find(record.id.to_s)
+        cmis_obj.to_renderable_object
+      else
+        # Pour les objets déjà CMIS (comme root folder OpenStruct), créer un RenderableObject
+        if record.respond_to?(:to_renderable_object)
+          record.to_renderable_object
+        else
+          # Fallback : créer un folder CMIS basique
+          folder_type = CmisServer::TypeRegistry.get_type('cmis:folder') || CmisServer::FolderType.base
+          properties = {
+            'cmis:objectId' => CmisServer::Property.new(id: 'cmis:objectId', value: record.id.to_s),
+            'cmis:name' => CmisServer::Property.new(id: 'cmis:name', value: record.respond_to?(:title) ? record.title : record.respond_to?(:name) ? record.name : 'Unknown'),
+            'cmis:path' => CmisServer::Property.new(id: 'cmis:path', value: path),
+            'cmis:baseTypeId' => CmisServer::Property.new(id: 'cmis:baseTypeId', value: 'cmis:folder'),
+            'cmis:objectTypeId' => CmisServer::Property.new(id: 'cmis:objectTypeId', value: 'cmis:folder'),
+            'cmis:createdBy' => CmisServer::Property.new(id: 'cmis:createdBy', value: record.respond_to?(:responsible) ? record.responsible : 'System'),
+            'cmis:creationDate' => CmisServer::Property.new(id: 'cmis:creationDate', value: record.respond_to?(:created_at) ? record.created_at : Time.now),
+            'cmis:lastModifiedBy' => CmisServer::Property.new(id: 'cmis:lastModifiedBy', value: record.respond_to?(:responsible) ? record.responsible : 'System'),
+            'cmis:lastModificationDate' => CmisServer::Property.new(id: 'cmis:lastModificationDate', value: record.respond_to?(:updated_at) ? record.updated_at : Time.now),
+            'cmis:parentId' => CmisServer::Property.new(id: 'cmis:parentId', value: nil)
+          }
+          folder = CmisServer::FolderObject.new(type: folder_type, properties: properties)
+          folder.cmis_object_id = record.id.to_s
+          folder.to_renderable_object
+        end
+      end
     end
 
     def get_content_stream
@@ -156,7 +243,19 @@ module CmisServer
       raise NotImplemented
     end
 
-    def delete_object
+    def delete_object(id, all_versions: true)
+      # Utiliser le connecteur pour supprimer l'objet
+      connector = CmisServer::Connectors::ConnectorFactory.create_connector(
+        user: @context[:current_user] || @context.current_user
+      )
+      
+      # Si le connecteur supporte la suppression directe
+      if connector.respond_to?(:delete_object)
+        connector.delete_object(id)
+        return
+      end
+      
+      # Sinon, utiliser l'ancien système
       raise NotImplemented
     end
 

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

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

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

@@ -15,8 +15,8 @@ xml.tag!('entry', 'xmlns:atom' => 'http://www.w3.org/2005/Atom',
     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: 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)
+  xml.link(rel: 'self', href: url_for(controller: 'cmis_server/atom_pub/entries', action: 'show', id: object.respond_to?(:cmis_object_id) ? object.cmis_object_id : object.base_object.cmis_object_id, only_path: false), type: 'application/atomsvc+xml')
+  xml<<links_for(object.respond_to?(:type) ? object : object.base_object)
 
 
   # Non-AtomPub elements must be put at the end to validate XSD schema
@@ -57,7 +57,8 @@ xml.tag!('entry', 'xmlns:atom' => 'http://www.w3.org/2005/Atom',
   end
 
   if try(:with_path_segment)
-    xml.tag!('cmisra:pathSegment', object.base_object.path_segment)
+    path_segment_object = object.respond_to?(:path_segment) ? object : object.base_object
+    xml.tag!('cmisra:pathSegment', path_segment_object.path_segment)
   end
 
 end

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

@@ -12,7 +12,7 @@ xml.tag!('entry', 'xmlns:atom' => 'http://www.w3.org/2005/Atom',
     xml.name 'unknown'
   end
 
-  xml.link(rel: 'service', href: atom_pub_url, 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/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

@@ -16,6 +16,9 @@ xml.tag!('atom:feed', 'xmlns:atom' => 'http://www.w3.org/2005/Atom',
         title:  "Folder Collection",
         accept: "application/cmisatom+xml",
     })
+  else
+    # Pour le root folder virtuel, pas de collection link
+    # Car il n'a pas de parent
   end
 
   if @collection.total_items_count