cmis_server 1.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5a06882af4391857d952ae571fe62d9cecd8b189448b7a74da1f9aedc7d936fb
+  data.tar.gz: defe5fdf0356330dccaaa0d7819f9f5f0fccda34315ae9d056980eb5b9b10bb9
+SHA512:
+  metadata.gz: e322038687939ec2b099c76366dd2bc646af018e803f60b35861c2d71ca5ddff14ff275d009de7977be59c2185e12aaed72e6c1bce3b8fa4df1191ad8aa65680
+  data.tar.gz: b2f428f15608eb7aa583f42a00271ccac21f8b0b19ba8c9c82f3202113ab56622b249d0fd9799c7329e6699c32da8ec2c0e59c9e2e3fa23af6eb7054389483af

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Alexandre Narbonne
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= CmisServer
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,51 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'CmisServer'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+GENERATED_PARSER = 'lib/cmis_server/query/parser.racc.rb'
+GENERATED_LEXER = 'lib/cmis_server/query/parser.rex.rb'
+
+file GENERATED_LEXER => 'lib/cmis_server/query/parser.rex' do |t|
+  sh "rex -do #{t.name} #{t.prerequisites.first}"
+end
+
+file GENERATED_PARSER => 'lib/cmis_server/query/parser.racc' do |t|
+  sh "racc -t -g -v -o #{t.name} #{t.prerequisites.first}"
+end
+
+task :parser => [GENERATED_LEXER, GENERATED_PARSER]
+
+# Make sure the parser's up-to-date when we test.
+Rake::Task['test'].prerequisites << :parser

data/app/assets/javascripts/cmis_server/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/app/assets/stylesheets/cmis_server/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/cmis_server/application_controller.rb

@@ -0,0 +1,19 @@
+module CmisServer
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception, unless: -> { request.format.symbol.in?([:atom_xml, :atom_feed, :atom_entry, :atom_service]) }
+
+    skip_before_action :verify_authenticity_token
+    before_action :check_auth
+
+    def context
+      @context ||= Hash.new
+    end
+
+    def check_auth
+      #ToDo Proc to be provided in gem config by the final application
+
+      #auth_proc= Proc.new {|username,password|  (resource=User.find_by(login: username))&&resource.valid_password?(password)&&(context.current_user=resource)}
+      context[:current_user] = authenticate_or_request_with_http_basic &CmisServer.configuration.http_basic_auth_procedure
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module CmisServer
+  module AtomPub
+    class BaseController < CmisServer::ApplicationController
+      rescue_from StandardError, with: :render_standard_error
+      # skip_before_action :verify_authenticity_token # Déjà défini dans ApplicationController
+
+      def raw_post_body
+        @raw_body ||= request.raw_post
+      end
+
+      def request_entry_parser
+        @r_entry_parser ||= CmisServer::EntryParser.new(raw_post_body)
+      end
+
+      def render_standard_error(error)
+        cmis_error = error.is_a?(CmisServer::CmisStandardError) ? error : CmisServer::RuntimeError.new(trigger: error)
+        cmis_error.log(Rails.logger)
+
+        render xml: cmis_error.to_xml, content_type: 'application/xml', status: cmis_error.http_status_code
+      end
+    end
+  end
+end

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

@@ -0,0 +1,302 @@
+module CmisServer
+  module AtomPub
+    class BulkController < BaseController
+      include CmisServer::AtomPub::RepositoryScopable
+      
+      before_action :check_repository_capabilities
+      
+      # POST /bulk - bulkUpdateProperties
+      def update_properties
+        bulk_data = parse_bulk_data_from_request
+        validate_bulk_data(bulk_data)
+        
+        # Utiliser le service dédié pour la mise à jour en masse
+        bulk_service = CmisServer::BulkUpdateService.new(context: context)
+        results = bulk_service.bulk_update(bulk_data[:object_ids], bulk_data[:properties])
+        
+        respond_to do |format|
+          format.atom_feed { render "cmis_server/atom_pub/bulk_update_feed", locals: { results: results } }
+          format.json { render json: format_bulk_results_for_json(results) }
+        end
+      rescue CmisServer::BulkUpdateService::CapabilityError => e
+        render_error(CmisServer::NotSupported.new(e.message))
+      rescue => e
+        render_error(e)
+      end
+      
+      # POST /bulk/delete - bulkDeleteProperties (nouvelle fonctionnalité CMIS 1.1)
+      def delete_properties
+        bulk_data = parse_bulk_delete_from_request
+        validate_bulk_delete_data(bulk_data)
+        
+        results = delete_properties_from_objects(bulk_data)
+        
+        respond_to do |format|
+          format.atom_feed { render "cmis_server/atom_pub/bulk_delete_feed", locals: { results: results } }
+          format.json { render json: format_bulk_results_for_json(results) }
+        end
+      rescue => e
+        render_error(e)
+      end
+      
+      # POST /bulk/move - bulkMoveObjects (extension utile)
+      def move_objects
+        bulk_data = parse_bulk_move_from_request
+        validate_bulk_move_data(bulk_data)
+        
+        results = move_objects_bulk(bulk_data)
+        
+        respond_to do |format|
+          format.atom_feed { render "cmis_server/atom_pub/bulk_move_feed", locals: { results: results } }
+          format.json { render json: format_bulk_results_for_json(results) }
+        end
+      rescue => e
+        render_error(e)
+      end
+      
+      private
+      
+      def check_repository_capabilities
+        repository = repository_from_request
+        
+        case action_name
+        when 'update_properties'
+          unless repository.capabilities[:bulk_update]
+            raise CmisServer::NotSupported.new("Repository does not support bulk update operations")
+          end
+        when 'delete_properties'
+          unless repository.capabilities[:bulk_delete_properties] 
+            raise CmisServer::NotSupported.new("Repository does not support bulk delete properties operations")
+          end
+        when 'move_objects'
+          unless repository.capabilities[:bulk_move]
+            raise CmisServer::NotSupported.new("Repository does not support bulk move operations")
+          end
+        end
+      end
+      
+      def parse_bulk_data_from_request
+        if supports_browser_binding?
+          parse_browser_binding_bulk_request
+        elsif request.content_type =~ /application\/atom\+xml/
+          parse_atom_pub_bulk_request
+        else
+          raise CmisServer::InvalidOperation.new("Unsupported content type: #{request.content_type}")
+        end
+      end
+      
+      def parse_atom_pub_bulk_request
+        doc = Nokogiri::XML(request.body.read)
+        doc.remove_namespaces! # Simplifier le parsing
+        
+        object_ids = doc.xpath("//objectId").map(&:text)
+        properties = parse_properties_from_xml(doc)
+        
+        { object_ids: object_ids, properties: properties }
+      end
+      
+      def parse_browser_binding_bulk_request
+        json_data = JSON.parse(request.body.read)
+        
+        object_ids = json_data["objectIds"] || []
+        properties = json_data["properties"] || {}
+        
+        { object_ids: object_ids, properties: properties }
+      end
+      
+      def parse_properties_from_xml(doc)
+        properties = {}
+        
+        doc.xpath("//properties/*").each do |prop_node|
+          prop_id = prop_node.attributes["propertyDefinitionId"]&.value
+          next unless prop_id
+          
+          prop_type = prop_node.name.split(":").last
+          value_nodes = prop_node.xpath(".//value")
+          
+          if value_nodes.empty?
+            properties[prop_id] = nil
+          elsif value_nodes.length == 1
+            properties[prop_id] = convert_property_value(value_nodes.first.text, prop_type)
+          else
+            properties[prop_id] = value_nodes.map { |n| convert_property_value(n.text, prop_type) }
+          end
+        end
+        
+        properties
+      end
+      
+      def validate_bulk_data(bulk_data)
+        if bulk_data[:object_ids].nil? || bulk_data[:object_ids].empty?
+          raise CmisServer::InvalidOperation.new("No object IDs specified for bulk update")
+        end
+        
+        if bulk_data[:properties].nil? || bulk_data[:properties].empty?
+          raise CmisServer::InvalidOperation.new("No properties specified for bulk update")
+        end
+        
+        # Valider que tous les object_ids sont des chaînes non vides
+        bulk_data[:object_ids].each do |id|
+          if id.nil? || id.to_s.strip.empty?
+            raise CmisServer::InvalidOperation.new("Invalid object ID: #{id}")
+          end
+        end
+      end
+      
+      def parse_bulk_delete_from_request
+        if supports_browser_binding?
+          json_data = JSON.parse(request.body.read)
+          {
+            object_ids: json_data["objectIds"] || [],
+            property_ids: json_data["propertyIds"] || []
+          }
+        else
+          doc = Nokogiri::XML(request.body.read)
+          doc.remove_namespaces!
+          
+          object_ids = doc.xpath("//objectId").map(&:text)
+          property_ids = doc.xpath("//propertyId").map(&:text)
+          
+          { object_ids: object_ids, property_ids: property_ids }
+        end
+      end
+      
+      def validate_bulk_delete_data(bulk_data)
+        if bulk_data[:object_ids].empty?
+          raise CmisServer::InvalidOperation.new("No object IDs specified for bulk delete")
+        end
+        
+        if bulk_data[:property_ids].empty?
+          raise CmisServer::InvalidOperation.new("No property IDs specified for bulk delete")
+        end
+      end
+      
+      def parse_bulk_move_from_request
+        if supports_browser_binding?
+          json_data = JSON.parse(request.body.read)
+          {
+            object_ids: json_data["objectIds"] || [],
+            target_folder_id: json_data["targetFolderId"],
+            source_folder_id: json_data["sourceFolderId"]
+          }
+        else
+          doc = Nokogiri::XML(request.body.read)
+          doc.remove_namespaces!
+          
+          object_ids = doc.xpath("//objectId").map(&:text)
+          target_folder_id = doc.at_xpath("//targetFolderId")&.text
+          source_folder_id = doc.at_xpath("//sourceFolderId")&.text
+          
+          { object_ids: object_ids, target_folder_id: target_folder_id, source_folder_id: source_folder_id }
+        end
+      end
+      
+      def validate_bulk_move_data(bulk_data)
+        if bulk_data[:object_ids].empty?
+          raise CmisServer::InvalidOperation.new("No object IDs specified for bulk move")
+        end
+        
+        if bulk_data[:target_folder_id].nil? || bulk_data[:target_folder_id].strip.empty?
+          raise CmisServer::InvalidOperation.new("Target folder ID is required for bulk move")
+        end
+      end
+      
+      def delete_properties_from_objects(bulk_data)
+        results = []
+        
+        bulk_data[:object_ids].each do |object_id|
+          begin
+            object = find_object(object_id)
+            
+            bulk_data[:property_ids].each do |property_id|
+              object.properties.delete(property_id)
+            end
+            
+            object.save
+            results << { id: object_id, status: "success" }
+          rescue => e
+            results << { id: object_id, status: "error", message: e.message }
+          end
+        end
+        
+        results
+      end
+      
+      def move_objects_bulk(bulk_data)
+        results = []
+        
+        bulk_data[:object_ids].each do |object_id|
+          begin
+            object = find_object(object_id)
+            target_folder = find_object(bulk_data[:target_folder_id])
+            
+            object.move_to(target_folder)
+            results << { id: object_id, status: "success" }
+          rescue => e
+            results << { id: object_id, status: "error", message: e.message }
+          end
+        end
+        
+        results
+      end
+      
+      def format_bulk_results_for_json(results)
+        {
+          results: results,
+          totalCount: results.length,
+          successCount: results.count { |r| r[:status] == "success" },
+          errorCount: results.count { |r| r[:status] == "error" }
+        }
+      end
+      
+      def supports_browser_binding?
+        request.content_type.include?('application/json') || 
+        params[:cmisbrowserbinding] == 'true'
+      end
+      
+      
+      def update_objects(bulk_data)
+        # Cette méthode est maintenant remplacée par l'utilisation du BulkUpdateService
+        # Conservée pour compatibilité si nécessaire
+        bulk_service = CmisServer::BulkUpdateService.new(context: context)
+        results = bulk_service.bulk_update(bulk_data[:object_ids], bulk_data[:properties])
+        
+        # Formatter pour correspondre à l'ancien format attendu
+        formatted_results = []
+        results[:succeeded].each { |id| formatted_results << { id: id, status: "success" } }
+        results[:failed].each { |failure| formatted_results << { id: failure[:id], status: "error", message: failure[:message] } }
+        
+        formatted_results
+      end
+      
+      def find_object(object_id)
+        # Cette méthode doit être implémentée selon votre système de stockage
+        # Elle devrait retourner l'objet CMIS correspondant à l'ID ou lever une exception
+        object = repository_from_request.get_object(object_id)
+        raise CmisServer::ObjectNotFound.new unless object
+        object
+      end
+      
+      def update_object_properties(object, properties)
+        # Cette méthode doit être implémentée selon votre système de stockage
+        # Elle devrait mettre à jour les propriétés de l'objet
+        object.update_properties(properties)
+      end
+      
+      def convert_property_value(value, type)
+        case type
+        when "propertyInteger"
+          value.to_i
+        when "propertyDecimal", "propertyDouble"
+          value.to_f
+        when "propertyBoolean"
+          value.downcase == "true"
+        when "propertyDateTime"
+          DateTime.parse(value)
+        else
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,178 @@
+module CmisServer
+  module AtomPub
+    class ContentController < CmisServer::AtomPub::BaseController
+
+      include CmisServer::AtomPub::RepositoryScopable
+      before_action :check_appendable_capability, only: [:append]
+
+      def show
+        content_id=params[:id]
+        doc_id    =content_id[3..-1]
+        document  =CmisServer::DocumentAdapter::ClassAdapter.new(context: context).find(doc_id)
+        if document&&(cs=document.content_stream)
+          send_data(cs.content,
+                    filename: cs.filename,
+                    type:     cs.media_type
+          )
+        else
+          head :not_found
+        end
+      end
+      
+      # POST /content/{id}/append
+      # Implémentation de appendContentStream pour CMIS 1.1
+      def append
+        content_id = params[:id]
+        doc_id = content_id[3..-1]
+        document = CmisServer::DocumentAdapter::ClassAdapter.new(context: context).find(doc_id)
+        
+        raise CmisServer::ObjectNotFound.new unless document
+        
+        # Vérifier que l'objet est un document
+        raise CmisServer::InvalidOperation.new("Object is not a document") unless document.is_a?(CmisServer::DocumentObject)
+        
+        # Vérifier que le document a déjà un content stream
+        raise CmisServer::InvalidOperation.new("Document has no content stream") unless document.content_stream
+        
+        # Utiliser le service dédié pour l'opération
+        content_service = CmisServer::ContentStreamService.new(context: context)
+        new_content = parse_content_from_request
+        
+        updated_document = content_service.append_content_stream(document, new_content)
+        
+        respond_to do |format|
+          format.atom_entry { render "cmis_server/atom_pub/document_entry", locals: { document: updated_document } }
+          format.json { render json: updated_document.to_json }
+        end
+      rescue => e
+        render_error(e)
+      end
+      
+      # PUT /content/{id} - setContentStream
+      def set_content_stream
+        content_id = params[:id]
+        doc_id = content_id[3..-1]
+        document = CmisServer::DocumentAdapter::ClassAdapter.new(context: context).find(doc_id)
+        
+        raise CmisServer::ObjectNotFound.new unless document
+        
+        overwrite_flag = params[:overwriteFlag] != 'false'
+        new_content = parse_content_from_request
+        
+        content_service = CmisServer::ContentStreamService.new(context: context)
+        updated_document = content_service.set_content_stream(document, new_content, overwrite_flag)
+        
+        respond_to do |format|
+          format.atom_entry { render "cmis_server/atom_pub/document_entry", locals: { document: updated_document } }
+          format.json { render json: updated_document.to_json }
+        end
+      rescue => e
+        render_error(e)
+      end
+      
+      # DELETE /content/{id} - deleteContentStream  
+      def delete_content_stream
+        content_id = params[:id]
+        doc_id = content_id[3..-1]
+        document = CmisServer::DocumentAdapter::ClassAdapter.new(context: context).find(doc_id)
+        
+        raise CmisServer::ObjectNotFound.new unless document
+        
+        content_service = CmisServer::ContentStreamService.new(context: context)
+        updated_document = content_service.delete_content_stream(document)
+        
+        respond_to do |format|
+          format.atom_entry { render "cmis_server/atom_pub/document_entry", locals: { document: updated_document } }
+          format.json { render json: updated_document.to_json }
+        end
+      rescue => e
+        render_error(e)
+      end
+      
+      private
+      
+      def check_appendable_capability
+        repository = repository_from_request
+        
+        unless repository.capabilities[:append_content_stream]
+          raise CmisServer::NotSupported.new(
+            "Repository does not support appending to content streams"
+          )
+        end
+      end
+      
+      def parse_content_from_request
+        # Détection améliorée du type de contenu pour CMIS 1.1
+        if request.content_type =~ /multipart\/form-data/
+          # Contenu provenant d'un formulaire multipart
+          file = params[:file]
+          
+          validate_content_stream(file)
+          
+          CmisServer::ContentStream.new(
+            id: SecureRandom.uuid,
+            base64: Base64.strict_encode64(file.read),
+            media_type: file.content_type,
+            filename: file.original_filename,
+            length: file.size
+          )
+        else
+          # Contenu brut avec validation
+          body_content = request.body.read
+          validate_raw_content(body_content)
+          
+          CmisServer::ContentStream.new(
+            id: SecureRandom.uuid,
+            base64: Base64.strict_encode64(body_content),
+            media_type: request.content_type || 'application/octet-stream',
+            filename: params[:filename] || detect_filename_from_headers || "unnamed",
+            length: body_content.length
+          )
+        end
+      end
+      
+      def validate_content_stream(file)
+        # Validation des limites de taille et types MIME
+        max_size = repository_from_request.capabilities[:max_content_size_kb] || 100_000 # 100MB par défaut
+        
+        if file.size > max_size * 1024
+          raise CmisServer::StreamNotSupported.new("Content size exceeds maximum allowed size")
+        end
+        
+        allowed_mime_types = repository_from_request.capabilities[:allowed_mime_types]
+        if allowed_mime_types && !allowed_mime_types.include?(file.content_type)
+          raise CmisServer::StreamNotSupported.new("MIME type '#{file.content_type}' not allowed")
+        end
+      end
+      
+      def validate_raw_content(content)
+        max_size = repository_from_request.capabilities[:max_content_size_kb] || 100_000
+        
+        if content.length > max_size * 1024
+          raise CmisServer::StreamNotSupported.new("Content size exceeds maximum allowed size")
+        end
+      end
+      
+      def detect_filename_from_headers
+        # Essayer d'extraire le nom de fichier des headers HTTP
+        content_disposition = request.headers['Content-Disposition']
+        return nil unless content_disposition
+        
+        match = content_disposition.match(/filename=["']?([^"'\s;]+)["']?/)
+        match[1] if match
+      end
+      
+      def merge_content_streams(existing, new_content)
+        # Créer un nouveau ContentStream avec le contenu fusionné
+        merged_content = CmisServer::ContentStream.new(
+          id: existing.id,
+          base64: Base64.strict_encode64(existing.content + new_content.content),
+          media_type: existing.media_type,
+          filename: existing.filename
+        )
+        
+        merged_content
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module CmisServer
+  module AtomPub
+    class EntriesController < CmisServer::AtomPub::BaseController
+
+      include CmisServer::AtomPub::RepositoryScopable
+
+      def show
+        @object=object_service.get_object(id, with_object: true, filter: filter)
+        render 'cmis_server/atom_pub/entries/object_entry', formats: :atom_entry
+      end
+
+      def update
+        @object=object_service.update_properties(id, request_entry_parser.object_properties, with_object: true)
+        render 'cmis_server/atom_pub/entries/object_entry', formats: :atom_entry, status: 200
+      end
+
+      def destroy
+
+      end
+
+      protected
+
+      def filter
+        params[:filter].to_s.split(',')
+      end
+
+      def id
+        params.require(:id)
+      end
+
+      def object_service
+        ObjectService.new(@repository, context)
+      end
+
+      def set_format
+        request.format = :atom_entry
+      end
+
+    end
+  end
+end