cmis_server 1.0.3

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

@@ -0,0 +1,70 @@
+module CmisServer
+  module AtomPub
+    class FolderCollectionController < CmisServer::AtomPub::BaseController
+
+      include CmisServer::AtomPub::RepositoryScopable
+      #before_action :set_filter
+
+
+      def get_children
+        service =NavigationService.new(@repository, context)
+        response=service.get_children(params[:id], max_items: max_items_param, order_by: params[:orderBy])
+
+        @collection=RenderableCollection.new(base_object: CmisServer::FolderAdapter.class_adapter(context: @context).find(params[:id]),
+                                             items:       response[:objects])
+        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)
+            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
+              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
+              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
+              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
+          @object=e.duplicate.to_renderable_object
+          render 'cmis_server/atom_pub/entries/object_entry', formats: :atom_entry, status: :conflict
+        end
+      end
+
+      def get_descendants
+        service=NavigationService.new(@repository, context)
+        service.get_descendants(params[:id])
+      end
+
+      protected
+
+      def max_items_param
+        params[:max_items]&.to_i||CmisServer.configuration.default_page_size
+      end
+
+      def set_filter
+        @filter=params[:filter].to_s.split(',')
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+module CmisServer
+  module AtomPub
+    class QueryController < BaseController
+      include CmisServer::AtomPub::RepositoryScopable
+      
+      before_action :check_query_capabilities
+      
+      # POST /query
+      def query
+        query_data = parse_query_request
+        
+        begin
+          discovery_service = CmisServer::DiscoveryService.new(context: context)
+          results = discovery_service.query(
+            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],
+            rendition_filter: query_data[:rendition_filter],
+            max_items: query_data[:max_items],
+            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)
+        end
+      end
+      
+      # GET /query/types
+      def queryable_types
+        repository = repository_from_request
+        queryable_types = repository.types.select { |_, type| type.queryable }
+        
+        respond_to do |format|
+          format.atom_feed { render "cmis_server/atom_pub/queryable_types_feed", locals: { types: queryable_types } }
+          format.json { render json: format_queryable_types_for_json(queryable_types) }
+        end
+      end
+      
+      # POST /query/validate
+      def validate_query
+        query_data = parse_query_request
+        
+        begin
+          discovery_service = CmisServer::DiscoveryService.new(context: context)
+          validation_result = discovery_service.validate_query(query_data[:statement])
+          
+          respond_to do |format|
+            format.json { render json: { valid: validation_result[:valid], errors: validation_result[:errors] } }
+          end
+        rescue => e
+          render_error(e)
+        end
+      end
+      
+      private
+      
+      def check_query_capabilities
+        repository = repository_from_request
+        
+        case action_name
+        when 'query'
+          unless repository.capabilities[:query]
+            raise CmisServer::NotSupported.new("Repository does not support query operations")
+          end
+        when 'queryable_types'
+          # Toujours disponible si le query de base est supporté
+        when 'validate_query'
+          unless repository.capabilities[:extended_query]
+            raise CmisServer::NotSupported.new("Repository does not support query validation")
+          end
+        end
+      end
+      
+      def parse_query_request
+        if supports_browser_binding?
+          parse_browser_binding_query_request
+        else
+          parse_atom_pub_query_request
+        end
+      end
+      
+      def parse_browser_binding_query_request
+        json_data = JSON.parse(request.body.read)
+        
+        {
+          statement: json_data["statement"],
+          search_all_versions: json_data["searchAllVersions"] || false,
+          include_allowable_actions: json_data["includeAllowableActions"] || false,
+          include_relationships: json_data["includeRelationships"] || "none",
+          rendition_filter: json_data["renditionFilter"] || "",
+          max_items: (json_data["maxItems"] || 100).to_i,
+          skip_count: (json_data["skipCount"] || 0).to_i
+        }
+      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
+        }
+      end
+      
+      def format_query_results_for_json(results)
+        {
+          results: results[:objects].map { |obj| obj.to_json },
+          hasMoreItems: results[:has_more_items],
+          numItems: results[:num_items]
+        }
+      end
+      
+      def format_queryable_types_for_json(types)
+        {
+          types: types.map do |id, type|
+            {
+              id: id,
+              queryName: type.query_name,
+              displayName: type.display_name,
+              description: type.description
+            }
+          end
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+module CmisServer
+  module AtomPub
+    class RepositoryController < BaseController
+      include CmisServer::AtomPub::RepositoryScopable
+      
+      # GET /repositories/{id}/capabilities
+      def capabilities
+        repository = repository_from_request
+        capabilities = repository.capabilities
+        
+        # Enrichir les capabilities avec les fonctionnalités CMIS 1.1
+        enhanced_capabilities = enhance_capabilities_for_cmis_1_1(capabilities)
+        
+        respond_to do |format|
+          format.atom_entry { render "cmis_server/atom_pub/repository_capabilities", locals: { capabilities: enhanced_capabilities } }
+          format.json { render json: { capabilities: enhanced_capabilities } }
+        end
+      end
+      
+      # GET /repositories/{id}/extensions
+      def extensions
+        repository = repository_from_request
+        extensions = repository.extensions || {}
+        
+        respond_to do |format|
+          format.atom_entry { render "cmis_server/atom_pub/repository_extensions", locals: { extensions: extensions } }
+          format.json { render json: { extensions: extensions } }
+        end
+      end
+      
+      # GET /repositories/{id}/info
+      def info
+        repository = repository_from_request
+        
+        info = {
+          id: repository.id,
+          name: repository.name,
+          description: repository.description,
+          vendor_name: repository.vendor_name,
+          product_name: repository.product_name,
+          product_version: repository.product_version,
+          cmis_version_supported: repository.cmis_version_supported,
+          root_folder_id: repository.root_folder_id,
+          latest_change_log_token: repository.latest_change_log_token,
+          capabilities: repository.capabilities,
+          acl_capabilities: repository.acl_capabilities,
+          repository_specific_information: repository.repository_specific_information
+        }
+        
+        respond_to do |format|
+          format.atom_entry { render "cmis_server/atom_pub/repository_info", locals: { repository_info: info } }
+          format.json { render json: { repositoryInfo: info } }
+        end
+      end
+      
+      private
+      
+      def enhance_capabilities_for_cmis_1_1(capabilities)
+        capabilities.merge({
+          # Nouvelles capabilities CMIS 1.1
+          type_management: capabilities[:create_type] || false,
+          bulk_update: capabilities[:bulk_update] || false,
+          bulk_delete_properties: capabilities[:bulk_delete_properties] || false,
+          append_content_stream: capabilities[:append_content_stream] || false,
+          secondary_types: capabilities[:secondary_types] || false,
+          
+          # Extensions utiles
+          bulk_move: capabilities[:bulk_move] || false,
+          extended_query: capabilities[:extended_query] || false,
+          extended_acl: capabilities[:extended_acl] || false
+        })
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+module CmisServer
+  module AtomPub
+    class SecondaryTypesController < BaseController
+      include CmisServer::AtomPub::RepositoryScopable
+      
+      before_action :find_object
+      before_action :check_secondary_types_capability
+      
+      # GET /objects/{id}/types - Lister les types secondaires d'un objet
+      def index
+        secondary_types = @object.secondary_types || []
+        
+        respond_to do |format|
+          format.atom_feed { render "cmis_server/atom_pub/secondary_types_feed", locals: { object: @object, secondary_types: secondary_types } }
+          format.json { render json: format_secondary_types_for_json(secondary_types) }
+        end
+      end
+      
+      # POST /objects/{id}/types
+      def add_secondary_type
+        type_data = parse_secondary_type_request
+        
+        # Support pour l'ajout de plusieurs types secondaires en une fois
+        type_ids = type_data.is_a?(Array) ? type_data : [type_data[:type_id]]
+        
+        results = []
+        
+        type_ids.each do |type_id|
+          begin
+            # Trouver le type secondaire
+            secondary_type = CmisServer::TypeRegistry.get_type(type_id)
+            
+            unless secondary_type
+              results << { type_id: type_id, status: "error", message: "Type '#{type_id}' not found" }
+              next
+            end
+            
+            # Vérifier que c'est bien un type secondaire
+            unless secondary_type.base_id == 'cmis:secondary'
+              results << { type_id: type_id, status: "error", message: "Type '#{type_id}' is not a secondary type" }
+              next
+            end
+            
+            # Vérifier les conflits de propriétés
+            if has_property_conflicts?(@object, secondary_type)
+              results << { type_id: type_id, status: "error", message: "Property conflicts detected with type '#{type_id}'" }
+              next
+            end
+            
+            # Ajouter le type secondaire à l'objet
+            @object.add_secondary_type(secondary_type)
+            results << { type_id: type_id, status: "success" }
+            
+          rescue => e
+            results << { type_id: type_id, status: "error", message: e.message }
+          end
+        end
+        
+        @object.save if results.any? { |r| r[:status] == "success" }
+        
+        respond_to do |format|
+          format.atom_entry { render "cmis_server/atom_pub/entries/object_entry", locals: { object: @object.to_renderable_object } }
+          format.json { render json: { object: @object.to_json, results: results } }
+        end
+      rescue => e
+        render_error(e)
+      end
+      
+      # DELETE /objects/{id}/types/{typeId}
+      def remove_secondary_type
+        type_id = params[:typeId]
+        
+        begin
+          @object.remove_secondary_type(type_id)
+          @object.save
+          
+          respond_to do |format|
+            format.atom_entry { render "cmis_server/atom_pub/entries/object_entry", locals: { object: @object.to_renderable_object } }
+            format.json { render json: @object.to_json }
+          end
+        rescue => e
+          render_error(e)
+        end
+      end
+      
+      private
+      
+      def find_object
+        object_id = params[:id]
+        @object = repository_from_request.get_object(object_id)
+        
+        raise CmisServer::ObjectNotFound.new unless @object
+      end
+      
+      def check_secondary_types_capability
+        repository = repository_from_request
+        
+        unless repository.capabilities[:secondary_types]
+          raise CmisServer::NotSupported.new(
+            "Repository does not support secondary types operations"
+          )
+        end
+      end
+      
+      def parse_secondary_type_request
+        if supports_browser_binding?
+          json_data = JSON.parse(request.body.read)
+          if json_data["typeIds"]
+            json_data["typeIds"]
+          else
+            { type_id: json_data["typeId"] }
+          end
+        else
+          doc = Nokogiri::XML(request.body.read)
+          doc.remove_namespaces!
+          
+          type_ids = doc.xpath("//typeId").map(&:text)
+          if type_ids.length > 1
+            type_ids
+          else
+            { type_id: params[:typeId] || type_ids.first }
+          end
+        end
+      end
+      
+      def has_property_conflicts?(object, secondary_type)
+        # Vérifier s'il y a des conflits de propriétés entre les types existants et le nouveau type secondaire
+        existing_properties = object.properties.keys
+        new_properties = secondary_type.property_definitions.keys
+        
+        conflicts = existing_properties & new_properties
+        !conflicts.empty?
+      end
+      
+      def format_secondary_types_for_json(secondary_types)
+        {
+          secondaryTypes: secondary_types.map do |type|
+            {
+              id: type.id,
+              localName: type.local_name,
+              displayName: type.display_name,
+              description: type.description
+            }
+          end
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module CmisServer
+  module AtomPub
+    class ServiceDocumentsController < CmisServer::AtomPub::BaseController
+      require 'atom/service'
+
+
+      def service_document
+        @repository=Repository.find('my_repo')
+        render 'cmis_server/atom_pub/service_documents/service_document', formats: :atom_service
+      end
+
+
+      private
+
+      def repo_info_elem(repo_id)
+        REXML::Element.new("cmisra:repositoryInfo").tap do |e|
+          e.add_attribute('xmlns:ns3', "http://docs.oasis-open.org/ns/cmis/messaging/200908/")
+          CmisServer::RepositoryService.new(repo_id).get_repository_info.each do |k, v|
+            e.add_element('cmis:'+k.to_s).text=v
+          end
+        end
+      end
+
+      def uri_template_elem(template, type, media_type)
+        REXML::Element.new("cmisra:uritemplate").tap do |e|
+          e.add_element('cmisra:template').text =template
+          e.add_element('cmisra:type').text     =type
+          e.add_element('cmisra:mediatype').text=media_type
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,229 @@
+module CmisServer
+  module AtomPub
+    class TypesController < BaseController
+      include CmisServer::AtomPub::RepositoryScopable
+      
+      before_action :check_repository_capabilities, only: [:create, :update, :destroy]
+      before_action :find_type, only: [:show, :update, :destroy]
+      
+      # GET /types/{typeId}
+      def show
+        respond_to do |format|
+          format.atom_entry { render "cmis_server/atom_pub/type_entry", locals: { type: @type } }
+          format.json { render json: format_type_for_json(@type) }
+        end
+      end
+      
+      # GET /types
+      def index
+        @types = CmisServer::TypeRegistry.types.values
+        
+        # Filtrage par includePropertyDefinitions
+        if params[:includePropertyDefinitions] == "false"
+          # Ne pas inclure les définitions de propriétés
+          @include_property_definitions = false
+        else
+          @include_property_definitions = true
+        end
+        
+        respond_to do |format|
+          format.atom_feed { render "cmis_server/atom_pub/types_feed" }
+          format.json { render json: { types: @types }.to_json }
+        end
+      end
+      
+      # POST /types
+      def create
+        type_definition = parse_type_definition_from_request
+        
+        begin
+          @type = CmisServer::TypeRegistry.create_type(type_definition)
+          
+          respond_to do |format|
+            format.atom_entry { render "cmis_server/atom_pub/type_entry", status: :created }
+            format.json { render json: @type.to_json, status: :created }
+          end
+        rescue CmisServer::InvalidTypeDefinition, CmisServer::InvalidOperation => e
+          render_error(e)
+        end
+      end
+      
+      # PUT /types/{typeId}
+      def update
+        type_definition = parse_type_definition_from_request
+        
+        begin
+          @type = CmisServer::TypeRegistry.update_type(type_definition)
+          
+          respond_to do |format|
+            format.atom_entry { render "cmis_server/atom_pub/type_entry" }
+            format.json { render json: @type.to_json }
+          end
+        rescue CmisServer::InvalidTypeDefinition, CmisServer::InvalidOperation => e
+          render_error(e)
+        end
+      end
+      
+      # DELETE /types/{typeId}
+      def destroy
+        begin
+          CmisServer::TypeRegistry.delete_type(params[:id])
+          
+          head :no_content
+        rescue CmisServer::InvalidTypeDefinition, CmisServer::InvalidOperation => e
+          render_error(e)
+        end
+      end
+      
+      private
+      
+      def find_type
+        @type = CmisServer::TypeRegistry.get_type(params[:id])
+        raise CmisServer::ObjectNotFound.new("Type '#{params[:id]}' not found") unless @type
+      end
+      
+      def format_type_for_json(type)
+        {
+          id: type.id,
+          localName: type.local_name,
+          displayName: type.display_name,
+          description: type.description,
+          baseId: type.base_id,
+          parentId: type.parent_id,
+          creatable: type.creatable,
+          fileable: type.fileable,
+          queryable: type.queryable,
+          controllablePolicy: type.controllable_policy,
+          controllableACL: type.controllable_acl,
+          fulltextIndexed: type.fulltext_indexed,
+          includedInSupertypeQuery: type.included_in_supertype_query,
+          propertyDefinitions: format_property_definitions_for_json(type.property_definitions)
+        }
+      end
+      
+      def format_property_definitions_for_json(property_definitions)
+        result = {}
+        property_definitions.each do |id, prop_def|
+          result[id] = {
+            id: prop_def.id,
+            localName: prop_def.local_name,
+            queryName: prop_def.query_name,
+            displayName: prop_def.display_name,
+            description: prop_def.description,
+            propertyType: prop_def.property_type,
+            cardinality: prop_def.cardinality,
+            updatability: prop_def.updatability,
+            required: prop_def.required,
+            queryable: prop_def.queryable,
+            orderable: prop_def.orderable
+          }
+        end
+        result
+      end
+      
+      def check_repository_capabilities
+        repository = repository_from_request
+        
+        unless repository.capabilities[:create_type]
+          raise CmisServer::NotSupported.new(
+            "Repository does not support type management operations"
+          )
+        end
+      end
+      
+      def parse_type_definition_from_request
+        if request.content_type =~ /application\/atom\+xml/
+          # Parsing XML AtomPub
+          doc = Nokogiri::XML(request.body.read)
+          
+          # Extraire les données du type depuis l'XML
+          # Cette implémentation dépend de la structure XML utilisée
+          {
+            id: doc.at_xpath("//cmis:typeId").text,
+            parent_id: doc.at_xpath("//cmis:parentId").text,
+            local_name: doc.at_xpath("//cmis:localName").text,
+            display_name: doc.at_xpath("//cmis:displayName").text,
+            query_name: doc.at_xpath("//cmis:queryName").text,
+            description: doc.at_xpath("//cmis:description").text,
+            base_id: doc.at_xpath("//cmis:baseId").text,
+            creatable: doc.at_xpath("//cmis:creatable").text == "true",
+            fileable: doc.at_xpath("//cmis:fileable").text == "true",
+            queryable: doc.at_xpath("//cmis:queryable").text == "true",
+            controllable_policy: doc.at_xpath("//cmis:controllablePolicy").text == "true",
+            controllable_acl: doc.at_xpath("//cmis:controllableACL").text == "true",
+            fulltext_indexed: doc.at_xpath("//cmis:fulltextIndexed").text == "true",
+            included_in_supertype_query: doc.at_xpath("//cmis:includedInSupertypeQuery").text == "true",
+            property_definitions: parse_property_definitions_from_xml(doc)
+          }
+        else
+          # Parsing JSON (CMIS Browser Binding)
+          json_data = JSON.parse(request.body.read)
+          
+          {
+            id: json_data["id"],
+            parent_id: json_data["parentId"],
+            local_name: json_data["localName"],
+            display_name: json_data["displayName"],
+            query_name: json_data["queryName"],
+            description: json_data["description"],
+            base_id: json_data["baseId"],
+            creatable: json_data["creatable"],
+            fileable: json_data["fileable"],
+            queryable: json_data["queryable"],
+            controllable_policy: json_data["controllablePolicy"],
+            controllable_acl: json_data["controllableACL"],
+            fulltext_indexed: json_data["fulltextIndexed"],
+            included_in_supertype_query: json_data["includedInSupertypeQuery"],
+            property_definitions: parse_property_definitions_from_json(json_data)
+          }
+        end
+      end
+      
+      def parse_property_definitions_from_xml(doc)
+        property_defs = []
+        
+        doc.xpath("//cmis:propertyDefinition").each do |prop_def_node|
+          property_defs << {
+            id: prop_def_node.at_xpath("cmis:id").text,
+            local_name: prop_def_node.at_xpath("cmis:localName").text,
+            query_name: prop_def_node.at_xpath("cmis:queryName").text,
+            display_name: prop_def_node.at_xpath("cmis:displayName").text,
+            description: prop_def_node.at_xpath("cmis:description").text,
+            property_type: prop_def_node.at_xpath("cmis:propertyType").text,
+            cardinality: prop_def_node.at_xpath("cmis:cardinality").text,
+            updatability: prop_def_node.at_xpath("cmis:updatability").text,
+            required: prop_def_node.at_xpath("cmis:required").text == "true",
+            queryable: prop_def_node.at_xpath("cmis:queryable").text == "true",
+            orderable: prop_def_node.at_xpath("cmis:orderable").text == "true"
+          }
+        end
+        
+        property_defs
+      end
+      
+      def parse_property_definitions_from_json(json_data)
+        property_defs = []
+        
+        if json_data["propertyDefinitions"]
+          json_data["propertyDefinitions"].each do |id, prop_def|
+            property_defs << {
+              id: id,
+              local_name: prop_def["localName"],
+              query_name: prop_def["queryName"],
+              display_name: prop_def["displayName"],
+              description: prop_def["description"],
+              property_type: prop_def["propertyType"],
+              cardinality: prop_def["cardinality"],
+              updatability: prop_def["updatability"],
+              required: prop_def["required"],
+              queryable: prop_def["queryable"],
+              orderable: prop_def["orderable"]
+            }
+          end
+        end
+        
+        property_defs
+      end
+    end
+  end
+end