cmis_server 1.0.3

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

@@ -0,0 +1,58 @@
+module CmisServer
+  module AtomPub
+    class UriTemplatesController < CmisServer::AtomPub::BaseController
+
+      include CmisServer::AtomPub::RepositoryScopable
+
+      before_action :set_filter
+
+
+      def object_by_id
+        service=ObjectService.new(@repository, 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)
+        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
+      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
+        )
+
+        @collection=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
+
+      protected
+
+      def set_filter
+        @filter=params[:filter].to_s.split(',')
+      end
+
+    end
+  end
+end
+

data/app/controllers/concerns/cmis_server/atom_pub/repository_scopable.rb

@@ -0,0 +1,18 @@
+require 'active_support/concern'
+
+module CmisServer
+  module AtomPub
+    module RepositoryScopable
+      extend ActiveSupport::Concern
+
+      included do
+        before_action :set_repository
+      end
+
+      def set_repository
+        @repository=CmisServer::Repository.find(params[:repository_id])
+      end
+
+    end
+  end
+end

data/app/helpers/cmis_server/application_helper.rb

@@ -0,0 +1,31 @@
+module CmisServer
+  module ApplicationHelper
+
+
+    def atom_entry_properties_for(object)
+      {
+          id:      object&.cmis_object_id,
+          title:   object&.cmis_name,
+          summary: object&.cmis_description,
+          edited:  object&.cmis_creation_date,
+          updated: object&.cmis_last_modification_date,
+          author:  object&.cmis_created_by,
+          content: object.try(:content_stream)
+      }
+    end
+
+    def links_for(object)
+      result=""
+      if lookup_context.find_all("cmis_server/atom_pub/entries/_#{object.type.base_id.path_sanitize}_links").any?
+        result+=render(partial: "cmis_server/atom_pub/entries/#{object.type.base_id.path_sanitize}_links", locals: {object: object})
+      end
+
+      if object.type.id != object.type.base_id
+        if lookup_context.find_all("cmis_server/atom_pub/entries/_#{object.type.id.path_sanitize}_links").any?
+          result+=render(partial: "cmis_server/atom_pub/entries/#{object.type.id.path_sanitize}_links", locals: {object: object})
+        end
+      end
+      result
+    end
+  end
+end

data/app/models/cmis_server/application_record.rb

@@ -0,0 +1,5 @@
+module CmisServer
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/services/cmis_server/bulk_update_service.rb

@@ -0,0 +1,69 @@
+module CmisServer
+  class BulkUpdateService
+    attr_reader :context
+    
+    def initialize(context = {})
+      @context = context
+    end
+    
+    def repository
+      context[:repository]
+    end
+    
+    # Met à jour en masse les propriétés de plusieurs objets
+    # @param object_ids [Array<String>] les identifiants des objets à mettre à jour
+    # @param properties [Hash] les propriétés à mettre à jour
+    # @return [Hash] résultat de la mise à jour (succès et échecs)
+    def bulk_update(object_ids, properties)
+      # Vérifier que le repository supporte la mise à jour en masse
+      unless repository.capabilities[:bulk_update]
+        raise CapabilityError.new("Repository does not support bulk update")
+      end
+      
+      result = {
+        succeeded: [],
+        failed: []
+      }
+      
+      # Traiter chaque objet individuellement mais dans une seule opération atomique
+      repository.transaction do
+        object_ids.each do |object_id|
+          begin
+            # Récupérer l'objet
+            object = repository.object(object_id)
+            if object.nil?
+              result[:failed] << { id: object_id, message: "Object not found" }
+              next
+            end
+            
+            # Appliquer les nouvelles propriétés
+            properties.each do |property_id, value|
+              if object.properties.has_key?(property_id)
+                object.properties[property_id].value = value
+              else
+                # Si la propriété n'existe pas, c'est peut-être une propriété d'un type secondaire qui n'est pas encore appliqué
+                result[:failed] << { id: object_id, message: "Property '#{property_id}' not found" }
+                next
+              end
+            end
+            
+            # Valider et enregistrer l'objet
+            if object.valid?
+              repository.update_object(object)
+              result[:succeeded] << object_id
+            else
+              result[:failed] << { id: object_id, message: "Validation failed: #{object.errors.full_messages.join(', ')}" }
+            end
+          rescue StandardError => e
+            # En cas d'erreur, ajouter l'objet à la liste des échecs
+            result[:failed] << { id: object_id, message: e.message }
+          end
+        end
+      end
+      
+      result
+    end
+    
+    class CapabilityError < StandardError; end
+  end
+end

data/app/services/cmis_server/content_stream_service.rb

@@ -0,0 +1,75 @@
+module CmisServer
+  class ContentStreamService
+    attr_reader :context
+    
+    def initialize(context = {})
+      @context = context
+    end
+    
+    def repository
+      context[:repository]
+    end
+    
+    # Ajoute du contenu à un stream existant
+    # @param object_id [String] l'identifiant de l'objet
+    # @param content_stream [ContentStream] le contenu à ajouter
+    # @param is_last_chunk [Boolean] indique si c'est le dernier morceau
+    # @return [Boolean] true si l'ajout a réussi
+    def append_content_stream(object_id, content_stream, is_last_chunk = true)
+      # Vérifier que le repository supporte l'ajout de contenu
+      unless repository.capabilities[:append_content_stream]
+        raise CapabilityError.new("Repository does not support appending content stream")
+      end
+      
+      # Récupérer l'objet
+      object = repository.object(object_id)
+      if object.nil?
+        raise ObjectNotFoundError.new("Object '#{object_id}' not found")
+      end
+      
+      # Vérifier que l'objet est un document
+      unless object.is_a?(DocumentObject)
+        raise NotSupportedError.new("Object '#{object_id}' is not a document")
+      end
+      
+      # Si l'objet n'a pas encore de contenu, c'est un ajout initial
+      if object.content_stream.nil?
+        object.content_stream = content_stream
+      else
+        # Combiner le contenu existant avec le nouveau contenu
+        existing_content = object.content_stream.stream.read
+        object.content_stream.stream.rewind  # Important pour réinitialiser le curseur
+        
+        new_content = content_stream.stream.read
+        
+        combined_content = StringIO.new(existing_content + new_content)
+        
+        # Créer un nouveau content stream avec le contenu combiné
+        combined_stream = ContentStream.new(
+          id: object.content_stream.id,
+          media_type: object.content_stream.media_type,  # Conserver le type MIME original
+          stream: combined_content,
+          filename: object.content_stream.filename
+        )
+        
+        object.content_stream = combined_stream
+      end
+      
+      # Mettre à jour les propriétés du document si nécessaire
+      if is_last_chunk
+        object.cmis_content_stream_length = object.content_stream.length if object.respond_to?(:cmis_content_stream_length=)
+        object.cmis_content_stream_mime_type = object.content_stream.media_type if object.respond_to?(:cmis_content_stream_mime_type=)
+        object.cmis_content_stream_file_name = object.content_stream.filename if object.respond_to?(:cmis_content_stream_file_name=)
+      end
+      
+      # Enregistrer l'objet
+      repository.update_object(object)
+      
+      true
+    end
+    
+    class CapabilityError < StandardError; end
+    class ObjectNotFoundError < StandardError; end
+    class NotSupportedError < StandardError; end
+  end
+end

data/app/services/cmis_server/discovery_service.rb

@@ -0,0 +1,31 @@
+module CmisServer
+  class DiscoveryService
+
+    def initialize(repository, context)
+      @repository= repository.is_a?(Repository) ? repository : CmisServer::Repository.find(repository)
+      @context   =context
+    end
+
+
+    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)
+
+      #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)
+
+      objects=target_klass.adapter_class.class_adapter(context: @context).where(query_statement.query_expression.where.to_h, limit: 10, offset: 0)
+
+      {
+          query_results:  objects.map { |o| o.to_renderable_object },
+          has_more_items: false, #ToDO
+          num_items: nil, #ToDO
+      }
+
+
+    end
+
+  end
+end

data/app/services/cmis_server/navigation_service.rb

@@ -0,0 +1,43 @@
+module CmisServer
+  class NavigationService
+
+    def initialize(repository, context)
+      @repository= repository.is_a?(Repository) ? repository : CmisServer::Repository.find(repository)
+      @context   =context
+    end
+
+    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)
+
+      {
+          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,
+      }
+    end
+
+    def get_descendants(folder_id, depth: 2, filter: [], include_relationships: :none, rendition_filter: "cmis:none", include_allowable_actions: false, include_path_segment: false, with_object: false)
+      folder =CmisServer::Folder.find(folder_id)
+      objects=[]
+
+      return {objects: objects}
+    end
+
+    def get_folder_tree
+      raise NotImplemented
+    end
+
+    def get_folder_parent
+      raise NotImplemented
+    end
+
+    def get_object_parents
+      raise NotImplemented
+    end
+
+    def get_checked_out_docs
+      raise NotImplemented
+    end
+
+  end
+end

data/app/services/cmis_server/object_service.rb

@@ -0,0 +1,176 @@
+module CmisServer
+  class ObjectService
+
+    class DuplicateFile< StandardError
+      attr_reader :duplicate
+
+      def initialize(msg, duplicate:)
+        @duplicate=duplicate
+        super(msg)
+      end
+    end
+
+    def initialize(repository, context)
+      @repository= repository.is_a?(Repository) ? repository : CmisServer::Repository.find(repository)
+      @context   =context
+    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)
+      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)
+      end
+
+      if content_stream
+        adapter.add_content_stream(content_stream)
+      end
+
+      adapter.save!
+      adapter.object.cmis_object_id
+    end
+
+    def create_document_from_source
+      raise NotImplemented
+    end
+
+    def create_folder(properties, add_aces: [], remove_aces: [])
+      raise NotImplemented
+    end
+
+    def create_relationship
+      raise NotImplemented
+    end
+
+    def create_policy
+      raise NotImplemented
+    end
+
+    def create_item(properties, folder_id: nil, policies: [], add_aces: [], remove_aces: [])
+      item = CmisServer::ItemObject.new(type: ItemType.base, properties: properties)
+      adapter = CmisServer::ItemAdapter.new(item, context: @context)
+
+      if folder_id && folder = CmisServer::FolderAdapter.class_adapter(context: @context).find(folder_id)
+        adapter.add_to_folder(folder)
+      end
+
+      adapter.save!
+      adapter.object.cmis_object_id
+    end
+
+    def get_allowable_actions
+      raise NotImplemented
+    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)
+      raise CmisServer::ObjectNotFound unless record
+      return record.to_renderable_object
+    end
+
+    def get_properties(id, filter: [])
+      raise NotImplemented
+    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
+    end
+
+    def get_content_stream
+      raise NotImplemented
+    end
+
+    def get_renditions
+      raise NotImplemented
+    end
+
+    def update_properties(id, properties, with_object: false)
+      if id==CmisServer::FolderObject.root_folder.cmis_object_id
+        record=CmisServer::Folder.Objectroot_folder
+      else
+        #Todo Mockup
+        record=CmisServer::DocumentAdapter::ClassAdapter.new(context: @context).find(id)||CmisServer::Folder.find(id)||CmisServer::ItemAdapter::ClassAdapter.new(context: @context).find(id)
+      end
+      raise CmisServer::ObjectNotFound unless record
+      
+      # Gérer les types secondaires
+      if properties['cmis:secondaryObjectTypeIds']
+        current_secondary_types = record.properties['cmis:secondaryObjectTypeIds']&.value || []
+        new_secondary_types = properties['cmis:secondaryObjectTypeIds']
+        
+        # Supprimer les types qui ne sont plus présents
+        types_to_remove = current_secondary_types - new_secondary_types
+        
+        # Ajouter les nouveaux types
+        types_to_add = new_secondary_types - current_secondary_types
+        
+        # Mettre à jour les propriétés secondaryObjectTypeIds
+        record.properties['cmis:secondaryObjectTypeIds'].value = new_secondary_types
+        
+        # Supprimer les propriétés des types secondaires qui ont été retirés
+        # et ajouter celles des nouveaux types (implementation future)
+      end
+
+      # Mettre à jour les autres propriétés
+      properties.each do |prop_id, value|
+        next if prop_id == 'cmis:secondaryObjectTypeIds' # Déjà traité au-dessus
+        record.properties[prop_id.to_s].value = value if record.properties[prop_id.to_s]
+      end
+
+      adapter = if record.is_a?(CmisServer::DocumentObject)
+                  CmisServer::DocumentAdapter.new(record, context: @context)
+                elsif record.is_a?(CmisServer::FolderObject)
+                  CmisServer::FolderAdapter.new(record, context: @context)
+                elsif record.is_a?(CmisServer::ItemObject)
+                  CmisServer::ItemAdapter.new(record, context: @context)
+                end
+
+      adapter.save!
+      return adapter.object.to_renderable_object
+    end
+
+    def bulk_update_properties
+      raise NotImplemented
+    end
+
+    def move_object
+      raise NotImplemented
+    end
+
+    def delete_object
+      raise NotImplemented
+    end
+
+    def delete_tree
+      raise NotImplemented
+    end
+
+    def set_content_stream
+      raise NotImplemented
+    end
+
+    def append_content_stream
+      raise NotImplemented
+    end
+
+    def delete_content_stream
+      raise NotImplemented
+    end
+
+    protected
+
+    def filter(properties, filter=[])
+      filter.any? ? properties.slice(*filter) : properties
+    end
+
+  end
+end

data/app/services/cmis_server/repository_service.rb

@@ -0,0 +1,40 @@
+module CmisServer
+  class RepositoryService
+
+    def initialize(repository=nil)
+      @repository=CmisServer::Repository.find(repository)
+    end
+
+    def get_repositories
+      raise NotImplemented
+    end
+
+    def get_repository_info
+      @repository.infos
+    end
+
+    def get_type_children
+      raise NotImplemented
+    end
+
+    def get_type_descendants
+      raise NotImplemented
+    end
+
+    def get_type_definition(type_id)
+      type=CmisServer::TypeAdapter.find!(type_id)
+    end
+
+    def create_type(type)
+      raise NotImplemented
+    end
+
+    def update_type(type)
+      raise NotImplemented
+    end
+
+    def delete_type(type)
+      raise NotImplemented
+    end
+  end
+end

data/app/services/cmis_server/secondary_type_service.rb

@@ -0,0 +1,120 @@
+module CmisServer
+  class SecondaryTypeService
+    attr_reader :context
+    
+    def initialize(context = {})
+      @context = context
+    end
+    
+    def repository
+      context[:repository]
+    end
+    
+    # Ajoute un type secondaire à un objet
+    # @param object_id [String] l'identifiant de l'objet
+    # @param type_id [String] l'identifiant du type secondaire
+    # @return [Boolean] true si l'ajout a réussi
+    def add_secondary_type(object_id, type_id)
+      # Récupérer l'objet
+      object = repository.object(object_id)
+      if object.nil?
+        raise ObjectNotFoundError.new("Object '#{object_id}' not found")
+      end
+      
+      # Récupérer le type secondaire
+      secondary_type = repository.type(type_id)
+      if secondary_type.nil?
+        raise TypeNotFoundError.new("Type '#{type_id}' not found")
+      end
+      
+      # Vérifier que c'est bien un type secondaire
+      unless secondary_type.base_id == 'cmis:secondary'
+        raise NotSupportedError.new("Type '#{type_id}' is not a secondary type")
+      end
+      
+      # Vérifier que l'objet n'a pas déjà ce type secondaire
+      if object.secondary_type_ids.include?(type_id)
+        return true  # Déjà ajouté, considéré comme un succès
+      end
+      
+      # Ajouter le type secondaire à l'objet
+      object.secondary_type_ids << type_id
+      
+      # Ajouter les propriétés du type secondaire à l'objet
+      add_secondary_type_properties(object, secondary_type)
+      
+      # Enregistrer l'objet
+      repository.update_object(object)
+      
+      true
+    end
+    
+    # Supprime un type secondaire d'un objet
+    # @param object_id [String] l'identifiant de l'objet
+    # @param type_id [String] l'identifiant du type secondaire
+    # @return [Boolean] true si la suppression a réussi
+    def remove_secondary_type(object_id, type_id)
+      # Récupérer l'objet
+      object = repository.object(object_id)
+      if object.nil?
+        raise ObjectNotFoundError.new("Object '#{object_id}' not found")
+      end
+      
+      # Vérifier que l'objet a ce type secondaire
+      unless object.secondary_type_ids.include?(type_id)
+        return true  # Déjà supprimé, considéré comme un succès
+      end
+      
+      # Récupérer le type secondaire
+      secondary_type = repository.type(type_id)
+      if secondary_type.nil?
+        raise TypeNotFoundError.new("Type '#{type_id}' not found")
+      end
+      
+      # Supprimer le type secondaire de l'objet
+      object.secondary_type_ids.delete(type_id)
+      
+      # Supprimer les propriétés du type secondaire de l'objet
+      remove_secondary_type_properties(object, secondary_type)
+      
+      # Enregistrer l'objet
+      repository.update_object(object)
+      
+      true
+    end
+    
+    private
+    
+    # Ajoute les propriétés d'un type secondaire à un objet
+    # @param object [Object] l'objet auquel ajouter les propriétés
+    # @param secondary_type [Type] le type secondaire
+    def add_secondary_type_properties(object, secondary_type)
+      # Parcourir toutes les propriétés du type secondaire
+      secondary_type.property_definitions.each do |property_id, property_def|
+        # Créer une nouvelle propriété pour l'objet
+        property = Property.new(
+          definition: property_def,
+          value: property_def.default_value
+        )
+        
+        # Ajouter la propriété à l'objet
+        object.properties[property_id] = property
+      end
+    end
+    
+    # Supprime les propriétés d'un type secondaire d'un objet
+    # @param object [Object] l'objet duquel supprimer les propriétés
+    # @param secondary_type [Type] le type secondaire
+    def remove_secondary_type_properties(object, secondary_type)
+      # Parcourir toutes les propriétés du type secondaire
+      secondary_type.property_definitions.each do |property_id, _|
+        # Supprimer la propriété de l'objet
+        object.properties.delete(property_id)
+      end
+    end
+    
+    class ObjectNotFoundError < StandardError; end
+    class TypeNotFoundError < StandardError; end
+    class NotSupportedError < StandardError; end
+  end
+end