cmis_server 1.2.1 → 1.3.0

data/app/views/cmis_server/atom_pub/query_results_feed.atom_feed.builder

@@ -0,0 +1,59 @@
+xml.feed(xmlns: 'http://www.w3.org/2005/Atom',
+         'xmlns:cmis' => 'http://docs.oasis-open.org/ns/cmis/core/200908/',
+         'xmlns:cmisra' => 'http://docs.oasis-open.org/ns/cmis/restatom/200908/') do
+  
+  xml.id url_for(controller: 'cmis_server/atom_pub/query', action: 'query', only_path: false)
+  xml.title "Query Results"
+  xml.updated Time.now.iso8601
+  
+  xml.author do
+    xml.name "CMIS Server"
+  end
+  
+  # Add numItems if available
+  if results[:num_items]
+    xml.tag!('cmisra:numItems', results[:num_items])
+  end
+  
+  # Add entries for each result
+  results[:query_results].each do |object|
+    xml.entry do
+      if object.respond_to?(:atompub_entry_properties)
+        props = object.atompub_entry_properties
+        xml.id props[:id]
+        xml.title props[:title]
+        xml.summary props[:summary]
+        xml.updated props[:updated]
+        
+        xml.author do
+          xml.name props[:author]
+        end
+      else
+        # Fallback for objects without atompub_entry_properties
+        xml.id object.try(:id) || "unknown"
+        xml.title object.try(:name) || "Untitled"
+        xml.summary object.try(:description) || ""
+        xml.updated Time.now.iso8601
+        
+        xml.author do
+          xml.name "CMIS Server"
+        end
+      end
+      
+      # Add object properties
+      if object.respond_to?(:properties)
+        xml.tag!('cmisra:object') do
+          xml.tag!('cmis:properties') do
+            object.properties.each do |property|
+              unless property.value.nil?
+                xml.tag!("cmis:property#{property.type.capitalize}", propertyDefinitionId: property.id) do
+                  xml.tag!('cmis:value', property.value)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/views/cmis_server/atom_pub/queryable_types_feed.atom_feed.builder

@@ -0,0 +1,35 @@
+xml.feed(xmlns: 'http://www.w3.org/2005/Atom',
+         'xmlns:cmis' => 'http://docs.oasis-open.org/ns/cmis/core/200908/',
+         'xmlns:cmisra' => 'http://docs.oasis-open.org/ns/cmis/restatom/200908/') do
+  
+  xml.id url_for(controller: 'cmis_server/atom_pub/query', action: 'queryable_types', only_path: false)
+  xml.title "Queryable Types"
+  xml.updated Time.now.iso8601
+  
+  xml.author do
+    xml.name "CMIS Server"
+  end
+  
+  types.each do |id, type|
+    xml.entry do
+      xml.id id
+      xml.title type.display_name
+      xml.summary type.description
+      xml.updated Time.now.iso8601
+      
+      xml.author do
+        xml.name "CMIS Server"
+      end
+      
+      xml.tag!('cmisra:type') do
+        xml.tag!('cmis:id', id)
+        xml.tag!('cmis:localName', type.local_name)
+        xml.tag!('cmis:displayName', type.display_name)
+        xml.tag!('cmis:queryName', type.query_name)
+        xml.tag!('cmis:description', type.description)
+        xml.tag!('cmis:baseId', type.base_id)
+        xml.tag!('cmis:queryable', type.queryable)
+      end
+    end
+  end
+end

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

@@ -33,7 +33,7 @@ xml.tag!('app:workspace') do
 
   xml << render(partial: 'cmis_server/atom_pub/shared/collection', formats: [:xml], locals: {
       type:   "root",
-      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),
+      href:   url_for(controller: 'cmis_server/atom_pub/folder_collection', action: 'get_children', repository_id: repository.id, id: 'root_folder', only_path: false),
       title:  "Root Collection",
       accept: "application/atom+xml;type=entry",
   })

data/config/initializers/cmis_core_configuration.rb

@@ -33,14 +33,37 @@ Rails.application.config.after_initialize do
     
     # 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
+      begin
+        # username = uuid du device
+        # password = auth_token du device
+        Rails.logger.info "CMIS Auth: Starting authentication with username=#{username}"
+        
+        # Vérifier que la classe Device existe
+        unless defined?(::Device)
+          Rails.logger.error "CMIS Auth: Device class not found!"
+          return false
+        end
+        
+        # Rechercher le device avec ce couple uuid/auth_token
+        Rails.logger.info "CMIS Auth: Looking for Device with uuid=#{username}"
+        device = ::Device.find_by(uuid: username, auth_token: password)
+        
+        if device
+          Rails.logger.info "CMIS Auth: Found device #{device.id}"
+          if device.user
+            Rails.logger.info "CMIS Auth: Found user #{device.user.id} (#{device.user.email})"
+            device.user
+          else
+            Rails.logger.warn "CMIS Auth: Device has no associated user"
+            false
+          end
+        else
+          Rails.logger.warn "CMIS Auth: No device found for uuid=#{username}"
+          false
+        end
+      rescue => e
+        Rails.logger.error "CMIS Auth error: #{e.class.name} - #{e.message}"
+        Rails.logger.error e.backtrace.first(5).join("\n") if e.backtrace
         false
       end
     end

data/lib/cmis_server/atom_pub/entry_parser.rb

@@ -1,3 +1,8 @@
+require 'nokogiri'
+require_relative '../constants'
+require_relative '../content_stream'
+require_relative '../type_registry'
+
 module CmisServer
   class EntryParser
     attr_reader :raw_body
@@ -13,9 +18,13 @@ module CmisServer
     def content_stream
       if content_element
         unless @stream
-          base64=content_element.get_elements('cmisra:base64').first&.text
-          media_type=content_element.get_elements('cmisra:mediatype').first&.text
-          @stream=CmisServer::ContentStream.new(base64: base64, media_type: media_type)
+          base64 = content_element.at_xpath('.//cmisra:base64', {
+            'cmisra' => CMIS_REST_ATOM_NAMESPACE
+          })&.text
+          media_type = content_element.at_xpath('.//cmisra:mediatype', {
+            'cmisra' => CMIS_REST_ATOM_NAMESPACE
+          })&.text
+          @stream = CmisServer::ContentStream.new(base64: base64, media_type: media_type)
         end
         @stream
       else
@@ -24,7 +33,23 @@ module CmisServer
     end
 
     def object_type
-      TypeAdapter.find!(object_properties["cmis:objectTypeId"])
+      type_id = object_properties["cmis:objectTypeId"]
+      
+      result = CmisServer::TypeRegistry.get_type(type_id)
+      
+      # Si le type n'est pas trouvé dans le registry, utiliser les types de base
+      if result.nil? && type_id
+        case type_id
+        when 'cmis:document'
+          result = CmisServer::DocumentType.base
+        when 'cmis:folder'
+          result = CmisServer::FolderType.base
+        when 'cmis:item'
+          result = CmisServer::ItemType.base
+        end
+      end
+      
+      result
     end
 
     def cmis_object_id
@@ -33,38 +58,48 @@ module CmisServer
     end
 
     def atom_entry
-      @atom_entry||=Atom::Entry.parse(raw_body)
+      @atom_entry ||= begin
+        require 'nokogiri'
+        Nokogiri::XML(raw_body)
+      end
     end
 
     def content_element
-      atom_entry.extensions.find{|e| e.namespace==CMIS_REST_ATOM_NAMESPACE&&e.local_name=='content'}
+      atom_entry.at_xpath("//cmisra:content", {
+        'cmisra' => CMIS_REST_ATOM_NAMESPACE
+      })
     end
 
     def object_element
-      atom_entry.extensions.find{|e| e.namespace==CMIS_REST_ATOM_NAMESPACE&&e.local_name=='object'}
+      atom_entry.at_xpath("//cmisra:object", {
+        'cmisra' => CMIS_REST_ATOM_NAMESPACE
+      })
     end
 
     def object_properties
       unless @properties
-        properties_element=object_element.get_elements("#{cmis_namespace_name}:properties").first
-        @properties=properties_element.elements.each_with_object(Hash.new){|p,h| h.merge!(parse_property(p))}
+        properties_element = object_element&.at_xpath(".//cmis:properties", {
+          'cmis' => CMIS_NAMESPACE
+        })
+        
+        if properties_element
+          @properties = {}
+          # Chercher tous les éléments qui commencent par 'property'
+          props = properties_element.xpath(".//cmis:propertyId | .//cmis:propertyString | .//cmis:propertyInteger | .//cmis:propertyBoolean | .//cmis:propertyDateTime | .//cmis:propertyDecimal", {'cmis' => CMIS_NAMESPACE})
+          
+          props.each do |prop|
+            key = prop['propertyDefinitionId']
+            value = prop.at_xpath(".//cmis:value", {'cmis' => CMIS_NAMESPACE})&.text
+            @properties[key] = value if key
+          end
+        else
+          @properties = {}
+        end
       end
       @properties
     end
 
-    def cmis_namespace_name
-      object_element.namespaces.find{|_k,v|v==CMIS_NAMESPACE}[0]
-    end
-
-    def cmis_rest_atom_namespace_name
-      object_element.namespaces.find{|_k,v|v==CMIS_REST_ATOM_NAMESPACE}[0]
-    end
-
-    def parse_property(property_element)
-      {
-          property_element.attributes['propertyDefinitionId'] => property_element.get_elements("#{cmis_namespace_name}:value").first&.text
-      }
-    end
+    # Namespace helpers not needed with Nokogiri xpath
 
 
   end

data/lib/cmis_server/cmis_object.rb

@@ -18,14 +18,44 @@ module CmisServer
         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)
+      # Stocker les propriétés directement sans utiliser de setters dynamiques
+      properties.to_h.each do |property_id, property_value|
+        @properties[property_id] = property_value
       end
     end
 
     def to_renderable_object
       CmisServer::RenderableObject.new(base_object: self)
     end
+    
+    # Méthodes d'accès aux propriétés communes CMIS
+    def cmis_object_id
+      @cmis_object_id || @properties['cmis:objectId']&.value
+    end
+    
+    def cmis_object_id=(value)
+      @cmis_object_id = value
+    end
+    
+    def cmis_name
+      @properties['cmis:name']&.value
+    end
+    
+    def cmis_description
+      @properties['cmis:description']&.value
+    end
+    
+    def cmis_creation_date
+      @properties['cmis:creationDate']&.value || Time.now
+    end
+    
+    def cmis_last_modification_date
+      @properties['cmis:lastModificationDate']&.value || Time.now
+    end
+    
+    def cmis_created_by
+      @properties['cmis:createdBy']&.value || 'Unknown'
+    end
 
     def copy_properties_values_of object
       self.properties.each{|_k,property| property.value=object.send(property.property_definition.getter_method_name)}

data/lib/cmis_server/configuration.rb

@@ -27,11 +27,12 @@ module CmisServer
         {
           type: defined?(FolderType) ? FolderType.base : nil,
           properties:{
-            cmis_object_id:              'cmis:root_folder',
-            cmis_name:                   "Root Folder",
+            cmis_object_id:              'root_folder',
+            cmis_name:                   "Espaces favoris",
+            cmis_description:            "Vos espaces favoris dans Core",
             cmis_last_modification_date: DateTime.now,
             cmis_creation_date:          DateTime.now,
-            cmis_created_by:             'unknown'
+            cmis_created_by:             'Core System'
           }
         }
       }

data/lib/cmis_server/connectors/CORE_CONNECTOR_QUERIES.md

@@ -0,0 +1,180 @@
+# Documentation du Connecteur Core pour CMIS Server
+
+## Vue d'ensemble
+
+Le connecteur Core permet d'exposer les documents et espaces de l'application Core via le protocole CMIS 1.1. Il traduit les requêtes CMIS en recherches Core via les services `Search::DocsSearch` et `Search::SpacesSearch`.
+
+## Architecture
+
+### Mapping des concepts
+
+| Concept CMIS | Concept Core | Description |
+|--------------|--------------|-------------|
+| cmis:document | Doc | Document Core avec contenu et métadonnées |
+| cmis:folder | Tagset/Space | Espace de travail ou dossier dans Core |
+| Repository | Core App | L'instance Core complète |
+| Root Folder | Espaces favoris | Collection virtuelle des espaces favoris de l'utilisateur |
+
+### Authentification
+
+Le connecteur utilise l'authentification par device (uuid/auth_token) de Core :
+- L'uuid est passé comme username dans l'authentification HTTP Basic
+- L'auth_token est passé comme password
+- Le connecteur récupère automatiquement l'utilisateur Core associé
+
+## Capacités de requête
+
+### 1. Recherche de documents
+
+Le connecteur traduit les paramètres CMIS vers les paramètres de `Search::DocsSearch` :
+
+| Paramètre CMIS | Paramètre Core | Description |
+|----------------|----------------|-------------|
+| `cmis:name` | `text` | Recherche textuelle dans le titre du document |
+| `cmis:parentId` | `space_id` | Filtrer par espace parent |
+| `cmis:objectTypeId` | `template_id` | Filtrer par type/template de document |
+| `cmis:creationDate` | `created_date` | Filtrer par date de création |
+| `cmis:lastModificationDate` | `modified_date` | Filtrer par date de modification |
+| - | `favorite` | Filtrer uniquement les favoris |
+| - | `tag_ids` | Filtrer par tags associés |
+| - | `workflow_id` | Filtrer par workflow |
+
+**Exemple de requête CMIS SQL :**
+```sql
+SELECT * FROM cmis:document WHERE cmis:name LIKE '%rapport%' AND cmis:parentId = '67936240e1eb1c1220721357'
+```
+
+Cette requête sera traduite en paramètres Core :
+```ruby
+{
+  'text' => 'rapport',
+  'space_id' => '67936240e1eb1c1220721357'
+}
+```
+
+### 2. Recherche d'espaces/dossiers
+
+Le connecteur traduit les paramètres CMIS vers les paramètres de `Search::SpacesSearch` :
+
+| Paramètre CMIS | Paramètre Core | Description |
+|----------------|----------------|-------------|
+| `cmis:name` | `text` | Recherche textuelle dans le nom de l'espace |
+| `cmis:parentId` | `tagset_id` | Filtrer par espace parent (hiérarchie) |
+| - | `children_ids` | Filtrer par enfants |
+| - | `favorite` | Filtrer uniquement les favoris |
+| - | `category` | Filtrer par catégorie d'espace |
+| - | `type` | Filtrer par type d'espace |
+
+**Exemple de requête CMIS SQL :**
+```sql
+SELECT * FROM cmis:folder WHERE cmis:name = 'Projets 2024'
+```
+
+Cette requête sera traduite en paramètres Core :
+```ruby
+{
+  'text' => 'Projets 2024'
+}
+```
+
+### 3. Navigation dans la hiérarchie
+
+#### Dossier racine
+- L'ID `root_folder` retourne un dossier virtuel représentant la racine
+- Les enfants du root folder sont les espaces favoris de l'utilisateur
+
+#### Navigation par ID
+```
+GET /cmis/atom_pub/core_repository/id?id={space_id}
+```
+
+#### Navigation par chemin
+```
+GET /cmis/atom_pub/core_repository/path?path=/
+```
+
+### 4. Pagination et tri
+
+Les paramètres de pagination CMIS sont directement transmis à Core :
+
+| Paramètre CMIS | Paramètre Core | Description |
+|----------------|----------------|-------------|
+| `maxItems` | `per_page` | Nombre d'éléments par page |
+| `skipCount` | `page` | Numéro de page (calculé) |
+| `orderBy` | `sort` | Critère de tri |
+
+## Exemples de requêtes
+
+### 1. Lister tous les documents
+```sql
+SELECT * FROM cmis:document
+```
+
+### 2. Rechercher des documents par nom
+```sql
+SELECT * FROM cmis:document WHERE cmis:name LIKE '%facture%'
+```
+
+### 3. Documents dans un espace spécifique
+```sql
+SELECT * FROM cmis:document WHERE cmis:parentId = '67936240e1eb1c1220721357'
+```
+
+### 4. Documents créés après une date
+```sql
+SELECT * FROM cmis:document WHERE cmis:creationDate > '2024-01-01T00:00:00Z'
+```
+
+### 5. Espaces favoris
+```sql
+SELECT * FROM cmis:folder WHERE favorite = true
+```
+
+### 6. Combinaison de critères
+```sql
+SELECT * FROM cmis:document 
+WHERE cmis:name LIKE '%contrat%' 
+AND cmis:parentId = '67936240e1eb1c1220721357'
+AND cmis:lastModificationDate > '2024-01-01T00:00:00Z'
+ORDER BY cmis:creationDate DESC
+```
+
+## Limitations connues
+
+1. **Recherche par path** : La recherche par chemin complet n'est pas encore implémentée
+2. **ACL** : Les permissions CMIS ne sont pas mappées vers le système RACI de Core
+3. **Versioning** : Le versioning CMIS n'est pas supporté
+4. **Relationships** : Les relations CMIS ne sont pas implémentées
+5. **Content Stream** : La lecture/écriture de contenu n'est pas encore implémentée
+
+## Configuration
+
+Le connecteur est automatiquement sélectionné quand l'authentification utilise des credentials Core (uuid/auth_token).
+
+Aucune configuration supplémentaire n'est nécessaire, le connecteur découvre automatiquement les classes Core disponibles (`Doc`, `Tagset`, `Search::DocsSearch`, etc.).
+
+## Endpoints disponibles
+
+Avec le connecteur Core, les endpoints CMIS suivants sont opérationnels :
+
+- ✅ Service Document (`/cmis/atom_pub/`)
+- ✅ Repository Info (`/capabilities`, `/extensions`, `/info`)
+- ✅ Types (`/types`, `/types/{typeId}`)
+- ✅ Navigation (`/id?id={objectId}`, `/path?path={path}`)
+- ✅ Query (`/query`, `/query/types`)
+- ✅ Collections (`/folder_collection/{folderId}`)
+- ✅ Entries (`/entry?id={objectId}`)
+
+## Debugging
+
+Pour activer les logs détaillés du connecteur :
+
+```ruby
+Rails.logger.level = :debug
+```
+
+Les logs incluront :
+- Les paramètres CMIS reçus
+- Les paramètres Core traduits
+- Les résultats des recherches
+- Les erreurs d'authentification