cmis_server 1.2.1 → 1.3.0

data/lib/cmis_server/connectors/core_connector.rb

@@ -6,18 +6,18 @@ module CmisServer
       
       def find_documents(conditions = {})
         return [] unless search_service_available?
+        return [] unless core_user # Pas de recherche sans utilisateur valide
         
         begin
           # Convertir les conditions CMIS en paramètres Core search
           search_params = convert_cmis_to_docs_search_params(conditions)
           
-          # Créer le service de recherche avec les paramètres convertis et l'utilisateur
-          search = docs_search_class.new(search_params, user: user)
+          # Créer le service de recherche avec les paramètres convertis et l'utilisateur Core
+          search_service = docs_search_class.new(search_params, user: core_user)
           
-          # Exécuter la recherche et retourner les résultats paginés
-          documents = search.paginated_objects
+          # Exécuter la recherche et retourner les résultats paginés (query Mongo)
+          documents = search_service.search
           
-          Rails.logger.info "CoreConnector: Found #{documents.count} documents with params: #{search_params}"
           documents
         rescue => e
           Rails.logger.error "CoreConnector find_documents error: #{e.message}"
@@ -27,24 +27,31 @@ module CmisServer
       end
       
       def find_folders(conditions = {})
-        return [] unless search_service_available?
+        
+        return [] unless core_user # Pas de recherche sans utilisateur valide
         
         begin
+          # Cas spécial : recherche des sous-espaces d'un parent
+          if conditions['parent_id'] && defined?(::Tagset)
+            parent_id = conditions['parent_id']
+            
+            # Rechercher directement les Tagsets qui ont ce parent
+            tagsets = ::Tagset.where(parent_ids: parent_id, is_space: true)
+            return tagsets
+          end
+          
+          # Pour les autres cas, utiliser SpacesSearch si disponible
+          return [] unless search_service_available?
+          
           # Convertir les conditions CMIS en paramètres Core search
           search_params = convert_cmis_to_spaces_search_params(conditions)
           
-          # Pour les dossiers racines, utiliser les favoris si pas de conditions spécifiques
-          if search_params.empty?
-            search_params = { 'favorite' => true }
-          end
-          
-          # Créer le service de recherche avec les paramètres convertis et l'utilisateur
-          search = spaces_search_class.new(search_params, user: user)
+          # Créer le service de recherche avec les paramètres convertis et l'utilisateur Core
+          search_service = spaces_search_class.new(search_params, user: core_user)
           
-          # Exécuter la recherche et retourner les résultats paginés
-          folders = search.paginated_objects
+          # Exécuter la recherche et retourner les résultats paginés (query Mongo)
+          folders = search_service.search
           
-          Rails.logger.info "CoreConnector: Found #{folders.count} folders with params: #{search_params}"
           folders
         rescue => e
           Rails.logger.error "CoreConnector find_folders error: #{e.message}"
@@ -54,39 +61,32 @@ module CmisServer
       end
       
       def find_object_by_id(id)
-        Rails.logger.info "CoreConnector: Searching for object with ID: #{id}"
         
-        # Cas spécial pour le dossier racine CMIS
-        if id == 'core_root'
-          Rails.logger.info "CoreConnector: Returning root folder for ID: #{id}"
+        # Cas spécial pour le dossier racine CMIS (accepter plusieurs variantes)
+        if id == 'core_root' || id == 'root_folder' || id == 'root' || id == 'root_folder_id'
           return create_root_folder_object
         end
         
         # Essayer d'abord comme document
         doc = find_document_by_id(id)
         if doc
-          Rails.logger.info "CoreConnector: Found document with ID: #{id}"
           return doc
         end
         
         # Puis essayer comme dossier/espace
         folder = find_folder_by_id(id)
         if folder
-          Rails.logger.info "CoreConnector: Found folder with ID: #{id}"
           return folder
         end
         
         Rails.logger.warn "CoreConnector: No object found with ID: #{id}"
-        Rails.logger.info "CoreConnector: Available services - Doc: #{doc_class_available?}, Space: #{space_class_available?}, DocsSearch: #{docs_search_class}, SpacesSearch: #{spaces_search_class}"
         nil
       end
       
       def find_object_by_path(path)
-        Rails.logger.info "CoreConnector: Searching for object with path: #{path}"
         
         # Cas spécial pour le path racine
         if path == '/' || path.blank?
-          Rails.logger.info "CoreConnector: Returning root folder for path: #{path}"
           return create_root_folder_object
         end
         
@@ -96,56 +96,164 @@ module CmisServer
       end
       
       def find_root_folders
-        # Utiliser les favoris pour les dossiers racines
-        find_folders({})
+        # Retourner les espaces favoris comme enfants directs du root
+        find_folders({ 'favorite' => true })
       end
       
-      private
-      
-      def create_root_folder_object
-        # Créer un objet dossier racine virtuel avec l'interface CMIS attendue
-        root_object = OpenStruct.new(
-          id: 'core_root',
-          name: 'Core Repository Root',
-          path: '/',
-          description: 'Dossier racine du repository Core',
-          type: 'cmis:folder',
-          cmis_object_id: 'core_root'
-        )
+      def create_document(properties, folder_id: nil, content_stream: nil)
         
-        # Créer un type object qui simule le type CMIS
-        type_id = OpenStruct.new(path_sanitize: 'cmis_folder')
-        base_id = OpenStruct.new(path_sanitize: 'cmis_folder')
+        # Extraire les propriétés CMIS
+        # Les propriétés peuvent être soit des strings soit des objets Property
+        doc_name = properties['cmis:name']
+        doc_name = doc_name.respond_to?(:value) ? doc_name.value : doc_name
         
-        type_object = OpenStruct.new(
-          id: type_id,
-          base_id: base_id
-        )
+        doc_title = doc_name || 'Untitled'
         
-        # Créer un base_object qui simule l'objet CMIS sous-jacent
-        base_object = OpenStruct.new(
-          cmis_object_id: 'core_root',
-          type: type_object
-        )
-        root_object.base_object = base_object
+        doc_description = properties['cmis:description']
+        doc_description = doc_description.respond_to?(:value) ? doc_description.value : doc_description
+        doc_description ||= ''
+        
+        # Déterminer l'espace parent
+        space_id = if folder_id && folder_id != 'root_folder'
+          folder_id
+        else
+          # Si pas de folder_id ou si c'est le root, utiliser le premier espace favori
+          favorite_spaces = find_folders({ 'favorite' => true })
+          if favorite_spaces.any?
+            favorite_spaces.first.id.to_s
+          else
+            raise "No favorite space found to create document"
+          end
+        end
+        
+        
+        # Créer le document dans Core
+        if doc_class
+          doc = doc_class.new
+          doc.title = doc_title
+          doc.description = doc_description if doc.respond_to?(:description=)
+          doc.tagset_ids = [BSON::ObjectId(space_id)] if doc.respond_to?(:tagset_ids=)
+          doc.user = core_user
+          
+          # Gérer le contenu si présent
+          if content_stream && doc.respond_to?(:content=)
+            doc.content = content_stream.content
+            doc.content_type = content_stream.mime_type if doc.respond_to?(:content_type=)
+          end
+          
+          if doc.save
+            doc.id.to_s
+          else
+            Rails.logger.error "CoreConnector: Failed to save document: #{doc.errors.full_messages.join(', ')}"
+            raise "Failed to create document: #{doc.errors.full_messages.join(', ')}"
+          end
+        else
+          raise "Doc class not available in Core"
+        end
+      end
+      
+      def create_folder(properties, parent_folder_id: nil)
+        
+        # Extraire les propriétés CMIS
+        folder_name = properties['cmis:name']
+        folder_name = folder_name.respond_to?(:value) ? folder_name.value : folder_name
+        folder_name ||= 'Untitled Folder'
         
-        # Ajouter les propriétés CMIS (collection vide pour l'instant)
-        root_object.properties = []
+        folder_description = properties['cmis:description']
+        folder_description = folder_description.respond_to?(:value) ? folder_description.value : folder_description
+        folder_description ||= ''
         
-        # Ajouter les méthodes attendues par les vues CMIS
-        def root_object.atompub_entry_properties
-          {
-            id: self.id,
-            title: self.name,
-            summary: self.description,
-            updated: Time.current.iso8601,
-            edited: Time.current.iso8601,
-            author: 'Core System',
-            content: nil
-          }
+        # Créer un Tagset (espace) dans Core
+        if ::Tagset
+          tagset = ::Tagset.new
+          tagset.title = folder_name
+          tagset.description = folder_description if tagset.respond_to?(:description=)
+          tagset.is_space = true if tagset.respond_to?(:is_space=)
+          tagset.responsible = core_user.id.to_s if tagset.respond_to?(:responsible=) && core_user
+          
+          # Gérer la hiérarchie si un parent est spécifié
+          if parent_folder_id && parent_folder_id != 'root_folder'
+            tagset.parent_ids = [BSON::ObjectId(parent_folder_id)] if tagset.respond_to?(:parent_ids=)
+          end
+          
+          if tagset.save
+            tagset.id.to_s
+          else
+            Rails.logger.error "CoreConnector: Failed to save folder: #{tagset.errors.full_messages.join(', ')}"
+            raise "Failed to create folder: #{tagset.errors.full_messages.join(', ')}"
+          end
+        else
+          raise "Tagset class not available in Core"
         end
+      end
+      
+      def delete_object(object_id)
         
-        root_object
+        # Essayer de trouver l'objet
+        object = find_object_by_id(object_id)
+        unless object
+          raise CmisServer::ObjectNotFound.new("Object '#{object_id}' not found")
+        end
+        
+        # Supprimer selon le type
+        if doc_class && object.is_a?(doc_class)
+          # Définir l'utilisateur courant pour la traçabilité
+          object.current_user_id = core_user.id if object.respond_to?(:current_user_id=) && core_user
+          object.destroy
+        elsif object.respond_to?(:destroy) && object.class.name == 'Doc'
+          # Fallback si doc_class n'est pas trouvé mais que c'est bien un Doc
+          object.current_user_id = core_user.id if object.respond_to?(:current_user_id=) && core_user
+          object.destroy
+        elsif object.is_a?(::Tagset) || (object.respond_to?(:is_space) && object.is_space)
+          # Pour les espaces/tagsets aussi si nécessaire
+          object.current_user_id = core_user.id if object.respond_to?(:current_user_id=) && core_user
+          object.destroy
+        else
+          raise "Cannot delete object of type #{object.class}"
+        end
+      end
+      
+      private
+      
+      # Méthode pour obtenir un utilisateur Core à partir du user CMIS
+      def core_user
+        @core_user ||= begin
+          if @user.is_a?(::User)
+            # Déjà un utilisateur Core
+            @user
+          elsif @user.respond_to?(:id)
+            # Si on a un ID, essayer de charger l'utilisateur Core
+            begin
+              Rails.logger.debug "CoreConnector: Trying to find User with ID #{@user.id}"
+              user = ::User.find(@user.id)
+              Rails.logger.debug "CoreConnector: Found Core user: #{user.id}"
+              user
+            rescue => e
+              Rails.logger.error "CoreConnector: Cannot find Core user with ID #{@user.id}: #{e.message}"
+              # Pas de fallback - retourner nil pour des raisons de sécurité
+              nil
+            end
+          else
+            Rails.logger.error "CoreConnector: Invalid user object: #{@user.inspect}"
+            nil
+          end
+        end
+      end
+      
+      def create_root_folder_object
+        # Créer un objet racine virtuel qui représente la collection des espaces favoris
+        # Ce n'est pas un vrai dossier dans Core, mais un conteneur virtuel pour CMIS
+        OpenStruct.new(
+          id: 'root_folder',
+          title: 'Mes espaces favoris',
+          description: 'Collection des espaces favoris dans Core',
+          responsible: core_user&.name || 'Utilisateur Core',
+          parent_ids: [],
+          created_at: Time.now,
+          updated_at: Time.now,
+          is_space: true,
+          is_virtual: true  # Marquer comme virtuel pour indiquer que ce n'est pas un vrai espace Core
+        )
       end
       
       def find_document_by_id(id)
@@ -160,10 +268,19 @@ module CmisServer
       end
       
       def find_folder_by_id(id)
-        return nil unless space_class_available?
-        
         begin
-          space_class.find_by(id: id)
+          # Chercher d'abord dans les Tagsets (qui sont les espaces/dossiers)
+          if defined?(::Tagset)
+            tagset = ::Tagset.find_by(id: id)
+            return tagset if tagset
+          end
+          
+          # Fallback sur space_class si disponible
+          if space_class_available?
+            space_class.find_by(id: id)
+          else
+            nil
+          end
         rescue => e
           Rails.logger.error "CoreConnector find_folder_by_id error: #{e.message}"
           nil
@@ -226,6 +343,9 @@ module CmisServer
           when 'cmis:parentId', 'parent_id', 'space_id'
             # Filtrage par espace parent
             params['space_id'] = value
+          when 'space_ids'
+            # Filtrage par espaces parents (array) - utiliser tagset_ids dans Core
+            params['tagset_ids'] = value
           when 'cmis:objectTypeId', 'type_id', 'object_type'
             # Filtrage par type d'objet (peut correspondre aux templates)
             params['template_id'] = value

data/lib/cmis_server/constants.rb

@@ -1,7 +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 1.1 namespaces
+  CMIS_NAMESPACE          ="http://docs.oasis-open.org/ns/cmis/core/201103/"
+  CMIS_REST_ATOM_NAMESPACE="http://docs.oasis-open.org/ns/cmis/restatom/201103/"
   CMIS_VERSION_SUPPORTED  ="1.1"
 
 end

data/lib/cmis_server/document_adapter.rb

@@ -0,0 +1,135 @@
+module CmisServer
+  class DocumentAdapter
+    attr_reader :object, :context
+    
+    def initialize(object, context:)
+      @object = object
+      @context = context
+    end
+    
+    def self.class_adapter(context:)
+      new(nil, context: context)
+    end
+    
+    def find(id)
+      connector = CmisServer::Connectors::ConnectorFactory.create_connector(
+        user: @context.is_a?(Hash) ? @context[:current_user] : @context.current_user
+      )
+      core_doc = connector.find_object_by_id(id)
+      
+      # Convertir le document Core en objet CMIS
+      if core_doc
+        # Créer un DocumentObject CMIS à partir du Doc Core
+        doc_type = CmisServer::TypeRegistry.get_type('cmis:document')
+        properties = {
+          'cmis:objectId' => CmisServer::Property.new(id: 'cmis:objectId', value: core_doc.id.to_s),
+          'cmis:objectTypeId' => CmisServer::Property.new(id: 'cmis:objectTypeId', value: 'cmis:document'),
+          'cmis:name' => CmisServer::Property.new(id: 'cmis:name', value: core_doc.title),
+          'cmis:createdBy' => CmisServer::Property.new(id: 'cmis:createdBy', value: core_doc.user&.full_name || 'Unknown'),
+          'cmis:creationDate' => CmisServer::Property.new(id: 'cmis:creationDate', value: core_doc.created_at),
+          'cmis:lastModificationDate' => CmisServer::Property.new(id: 'cmis:lastModificationDate', value: core_doc.updated_at)
+        }
+        
+        cmis_doc = CmisServer::DocumentObject.new(type: doc_type, properties: properties)
+        cmis_doc.cmis_object_id = core_doc.id.to_s
+        
+        self.class.new(cmis_doc, context: @context)
+      else
+        raise CmisServer::ObjectNotFound.new("Document with ID #{id} not found")
+      end
+    end
+    
+    def add_to_folder(folder)
+      # Store folder ID for when we save
+      @parent_folder_id = folder.respond_to?(:cmis_object_id) ? folder.cmis_object_id : folder
+    end
+    
+    def add_content_stream(content_stream)
+      @content_stream = content_stream
+    end
+    
+    def save!
+      
+      # Créer un document Core
+      doc = ::Doc.new
+      
+      # Mapper les propriétés CMIS vers Core
+      if @object && @object.properties
+        # Extraire les valeurs des objets Property
+        name_value = @object.properties['cmis:name']
+        name_value = name_value.value if name_value.respond_to?(:value)
+        doc.title = name_value || 'Untitled'
+        doc.labels = ['cmis']
+        
+        # Mapper les autres propriétés CMIS vers superfields
+        superfields = {}
+        @object.properties.each do |key, value|
+          unless ['cmis:name', 'cmis:objectTypeId'].include?(key)
+            # Extraire la valeur si c'est un objet Property
+            actual_value = value.respond_to?(:value) ? value.value : value
+            # Nettoyer la clé pour MongoDB (remplacer . et : par _)
+            clean_key = key.gsub(/[.:]/, '_')
+            # Convertir les IDs en string
+            if actual_value.respond_to?(:to_s)
+              superfields[clean_key] = actual_value.to_s
+            else
+              superfields[clean_key] = actual_value
+            end
+          end
+        end
+        doc.superfields = superfields unless superfields.empty?
+      end
+      
+      # Ajouter le contenu si présent
+      if @content_stream
+        require 'base64'
+        if @content_stream.base64
+          doc.blob = Base64.decode64(@content_stream.base64)
+        end
+      end
+      
+      # Définir le responsable (obligatoire)
+      if @context.current_user
+        # Si l'utilisateur est déjà un objet User de Core, l'utiliser directement
+        if @context.current_user.is_a?(::User)
+          doc.responsible = @context.current_user.id.to_s
+          Rails.logger.debug "Setting document responsible to Core user: #{doc.responsible}"
+        else
+          Rails.logger.error "Current user is not a Core User: #{@context.current_user.class.name}"
+          raise "Invalid user type for document creation"
+        end
+      else
+        Rails.logger.warn "No current_user available in context!"
+        raise "No authenticated user for document creation"
+      end
+      
+      # Ajouter aux espaces (folders)
+      if @parent_folder_id
+        # Si c'est root_folder, on ne fait rien
+        unless @parent_folder_id == 'root_folder'
+          # Sinon on ajoute le document à l'espace correspondant
+          doc.tagset_ids = [@parent_folder_id]
+        end
+      end
+      
+      
+      # Sauvegarder le document
+      if doc.save
+        # Mettre à jour l'objet CMIS avec l'ID du document créé
+        @object.cmis_object_id = doc.id.to_s if @object
+        true
+      else
+        Rails.logger.error "DocumentAdapter#save! - Failed to save document: #{doc.errors.full_messages.join(', ')}"
+        raise "Failed to save document: #{doc.errors.full_messages.join(', ')}"
+      end
+    rescue => e
+      Rails.logger.error "DocumentAdapter#save! - Exception: #{e.class.name} - #{e.message}"
+      Rails.logger.error e.backtrace.first(5).join("\n")
+      raise e
+    end
+    
+    def to_renderable_object
+      CmisServer::RenderableObject.new(base_object: @object)
+    end
+  end
+end

data/lib/cmis_server/document_object.rb

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

data/lib/cmis_server/engine.rb

@@ -15,5 +15,100 @@ module CmisServer
       Mime::Type.register "application/atom+xml;type=entry", :atom_entry unless Mime::Type.lookup_by_extension(:atom_entry)
       Mime::Type.register "application/atomsvc+xml", :atom_service unless Mime::Type.lookup_by_extension(:atom_service)
     end
+    
+    # Load CMIS base types
+    initializer "cmis_server.load_base_types" do
+      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
+
+      end
+    end
   end
 end

data/lib/cmis_server/exceptions.rb

@@ -182,4 +182,23 @@ module CmisServer
     end
   end
 
+  class InvalidArgument < CmisStandardError
+    def initialize(message = nil, attrs = {})
+      super(attrs)
+      @message = message
+    end
+
+    def title
+      "Invalid Argument"
+    end
+
+    def summary
+      @message || "One or more arguments are invalid."
+    end
+
+    def http_status_code
+      400
+    end
+  end
+
 end