dm_api 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4d367b16598aeaa0c05f8064b881bfd68337fc33ce5858ab23c2421b412ef936
+  data.tar.gz: 2061c3feb8f6e63f2d8abf3f88723c14a75c5b3c4ba6a66ebeda745644ab97cd
+SHA512:
+  metadata.gz: 126ae454dbf89c1f09651862a87ff97f51838a4bd09cd0732e98c2c0e6e6f929b9dfa92c3e448f1ef567a42c99c129a2a391689c83a28e6a869e12ccd00c9d27
+  data.tar.gz: cd41be68e47ae01563339f25c77fb52adb3588b2ed78a8542cd7c7e5d93c164a266b41a8b88b96f48c8beca10950e519fe8bc2ecedac1a535151db4dac8205bf

data/README.md

@@ -0,0 +1,76 @@
+# dm_api client
+
+## Adding to Gemfile
+
+### Local - development
+
+Add `gem "dm_api", path: "/home/user/clones/dm_api"` to your Gemfile and run `bundle install`
+
+### Git
+
+```bash
+bundle add dm_api --git git@gitlab.vmin.cz:vm/dm_api.git
+```
+
+## Usage
+
+### Configuration
+
+```ruby
+DmApi::Configuration.instance.api_key = File.read(Rails.root.join('config', 'dm_api.key')).chomp
+DmApi::Configuration.instance.proxy = 'http://localhost:8080'
+DmApi::Configuration.instance.ssl_verify = false
+```
+
+### Create (empty) document
+
+```ruby
+container_id = '7b1d9be9-e329-45b2-860b-c54462f14312'
+dm_doc = DmApi::Resource::Document.create(
+  body: {
+    title: 'document_title',
+    container: { data: {
+      id: container_id,
+      type: 'binder'
+    } }
+  }
+)
+```
+
+### Upload file data
+
+
+```ruby
+filename = Rails.root.join('example.pdf').to_s
+file_uuid, upload_response = DmApi::Resource::File.upload(filename)
+
+file_uuid = '54b49b1f-084e-4e2d-948c-7222f450821a'
+
+```
+
+### Attach file to document
+
+```ruby
+    file_data = [ { data: { id: file_uuid, type: 'file' } } ]
+    response = DmApi::Resource::Document.add_file(dm_doc.id, body: file_data)
+```
+
+
+### Display list of info fields
+
+```ruby
+DmApi::Resource::Document.find(dm_doc.id).information.map { |info| info.label }
+```
+
+```ruby
+
+DmApi::Resource::Document.find(dm_doc.id).information.each do |info|
+  case info.label
+  when 'DUZP'
+    date = Date.today
+    DmApi::Resource::Information.update(info.id, body: { value: { data: date.to_time } })
+  when 'DPH'
+    value = { number: 123.45, unit: 'CZK' }
+    DmApi::Resource::Information.update(info.id, body: { value: { data: value } })
+  end
+end

data/dm_api.gemspec

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |s|
+  s.name        = 'dm_api'
+  s.version     = `git describe --tags | sed -e s/^v//`
+  s.summary     = 'DocumentManager API client'
+  s.description = 'DocumentManager API v3 bare bones client'
+  s.authors     = ['Lukáš Bauer', 'Matouš Vokál', 'Josef Liška']
+  s.email       = 'billing@virtualmaster.com'
+  s.homepage    = ''
+  s.license     = 'MIT'
+
+  s.add_dependency('typhoeus', ['>= 1.3.0'])
+
+  s.files        = `git ls-files`.split("\n")
+  s.test_files   = `git ls-files -- spec/*`.split("\n")
+  s.require_path = 'lib'
+end

data/lib/dm_api/api.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module DmApi
+  class Api
+    attr_reader :config
+
+    def initialize
+      @config = Configuration.instance
+    end
+
+    def call(endpoint, method, options = {})
+      request_url = @config.base_url + endpoint
+      if options[:params]
+        request_url +=
+          "?#{options[:params].map { |key, val| "#{key}=#{CGI.escape(val)}" }.join('&')}"
+      end
+      json_body = call_url(request_url, method, options)
+      ApiResponse.new(json_body)
+    end
+
+    def call_url(request_url, method, options = {})
+      request_options = {
+        headers: {
+          'Authorization': "Bearer #{@config.api_key}",
+          'Accept': 'application/json',
+          'Content-Type': 'application/json; charset=utf-8'
+        },
+        method: method,
+        ssl_verifypeer: @config.ssl_verify
+      }
+
+      request_options[:body] = options[:body]&.to_json unless options[:body].nil?
+      request_options[:proxy] = @config.proxy unless @config.proxy.nil?
+
+      response = Typhoeus::Request.new(request_url, request_options).run
+      unless response.success?
+        raise DmApi::Errors::FailedResponse.new('Could not get data from DM API', response)
+      end
+
+      JSON.parse(response.body)
+    end
+  end
+end

data/lib/dm_api/api_response.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module DmApi
+  class ApiResponse
+    delegate_missing_to :data
+    delegate :to_json, to: :data
+    attr_reader :data, :links, :metadata, :raw_body
+
+    def initialize(response)
+      @data = parse_response_data(response)
+      @links = response['links']
+      @metadata = response['meta']
+      @raw_body = response
+    end
+
+    def next
+      return if @links['next'].nil?
+
+      next_url = @links['next']
+      json_body = Api.new.call_url(next_url, :get)
+      ApiResponse.new(json_body)
+    end
+
+    def prev
+      return if @links['prev'].nil?
+
+      prev_url = @links['prev']
+      json_body = Api.new.call_url(prev_url, :get)
+      ApiResponse.new(json_body)
+    end
+
+    def first
+      return if @links['first'].nil?
+
+      first_url = @links['first']
+      json_body = Api.new.call_url(first_url, :get)
+      ApiResponse.new(json_body)
+    end
+
+    def last
+      return if @links['last'].nil?
+
+      last_url = @links['last']
+      json_body = Api.new.call_url(last_url, :get)
+      ApiResponse.new(json_body)
+    end
+
+    private
+
+    def parse_response_data(response)
+      response_data = response['data']
+      return if response_data.nil?
+
+      if response_data.is_a?(Array)
+        response_data.map do |response_data_item|
+          parse_response_item(response_data_item)
+        end
+      else
+        parse_response_item(response)
+      end
+    end
+
+    def parse_response_item(response_item = {})
+      Resource.init_from_hash(response_item)
+    end
+  end
+end

data/lib/dm_api/configuration.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DmApi
+  class Configuration
+    include Singleton
+
+    attr_accessor :base_url, :api_key, :proxy, :ssl_verify
+
+    def initialize
+      @base_url = 'https://documentmanager.cz/api/v3'
+      @api_key = nil
+      @proxy = nil
+      @ssl_verify = true
+    end
+
+    def configure
+      yield(self) if block_given?
+    end
+  end
+end

data/lib/dm_api/errors/failed_response.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module DmApi
+  module Errors
+    class FailedResponse < StandardError
+      attr_reader :response
+
+      private
+
+      def initialize(msg = nil, response = {})
+        @response = response
+        super(msg)
+      end
+    end
+  end
+end

data/lib/dm_api/errors/required_parameter_missing.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module DmApi
+  module Errors
+    class RequiredParameterMissing < StandardError
+    end
+  end
+end

data/lib/dm_api/resource/base.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module DmApi
+  module Resource
+    class Base
+      UNLOADED_ATTR = Object.new
+
+      class << self
+        def belongs_to_relations
+          @belongs_to_relations ||= {}
+        end
+
+        def has_many_relations
+          @has_many_relations ||= {}
+        end
+
+        def attributes
+          @attributes ||= {}
+        end
+
+        def api_method(name, method, endpoint)
+          endpoint_params = endpoint.scan(/:\w+/).map { |param| param[1..] }
+          method_args = endpoint_params.join(', ')
+          method_args += ', ' if method_args.present?
+          method_args += 'opts = HashWithIndifferentAccess.new'
+          formatted_endpoint = endpoint.gsub(/:(\w+)/, '#{\1}')
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def self.#{name}(#{method_args})
+              #{endpoint_params.map { |param| "raise DmApi::Errors::RequiredParameterMissing, 'parameter #{param} is required' if #{param}.nil?" }.join("\n")}
+
+              endpoint = "#{formatted_endpoint}"
+              opts[:body] = { data: opts[:body] } if opts[:body].present?
+              Api.new.call(endpoint, :#{method}, opts)
+            end
+          RUBY
+        end
+
+        def attribute(name, options = {})
+          full_options = default_attr_options.merge(options)
+          attributes[name] = full_options
+          if full_options[:lazy_loaded]
+            define_lazy_loaded_attr(name)
+          else
+            attr_reader name
+          end
+
+          attr_writer(name) unless full_options[:read_only]
+        end
+
+        def define_lazy_loaded_attr(attr)
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def #{attr}
+              return @#{attr} unless @#{attr} == UNLOADED_ATTR && @lazy_loaded
+              return if @links.nil? || @links['self'].nil?
+
+              request_url = @links['self']['href']
+              obj_hash = Api.new.call_url(request_url, :get)
+              data = obj_hash['data']
+              new_data = data.except('type')
+              new_data['links'] = obj_hash['links']
+              load_from_hash(new_data, lazy_loaded: false)
+              @#{attr}
+            end
+          RUBY
+        end
+
+        def has_many(attribute, options = {})
+          full_options = default_relation_options.merge(options)
+          if full_options[:lazy_loaded]
+            define_lazy_loaded_attr(attribute)
+          else
+            attr_reader attribute
+          end
+
+          has_many_relations[attribute] = options
+        end
+
+        def belongs_to(attribute, options = {})
+          full_options = default_relation_options.merge(options)
+          if full_options[:lazy_loaded]
+            define_lazy_loaded_attr(attribute)
+          else
+            attr_reader attribute
+          end
+
+          belongs_to_relations[attribute] = full_options
+        end
+
+        def default_relation_options
+          {
+            json_column: nil,
+            lazy_loaded: true
+          }
+        end
+
+        def default_attr_options
+          {
+            json_column: nil,
+            lazy_loaded: true,
+            read_only: false,
+            type: :default
+          }
+        end
+      end
+
+      def to_json(*_args)
+        self.class.attributes.map do |attr_name, _opts|
+          attr_val = instance_variable_get("@#{attr_name}")
+          [attr_name, attr_val.to_json] if attr_val.present?
+        end.compact.to_h.merge(self.class.belongs_to_relations.map do |rel_name, _opts|
+          [rel_name, instance_variable_get("@#{rel_name}").to_json]
+        end.to_h.merge(self.class.has_many_relations.map do |rel_name, _opts|
+          [rel_name, instance_variable_get("@#{rel_name}").to_json]
+        end.to_h)).to_json
+      end
+
+      private
+
+      def initialize(data = {})
+        load_from_hash(data)
+      end
+
+      def load_from_hash(data, lazy_loaded: true)
+        @lazy_loaded = lazy_loaded
+        @links = data['links']
+        load_attributes(data)
+        load_relations(data)
+      end
+
+      def load_attributes(data)
+        self.class.attributes.each do |attr_name, options|
+          assign_attribute(data, attr_name, options)
+        end
+      end
+
+      def assign_attribute(data, attr_name, options)
+        json_name = (options[:json_column] || attr_name).to_s
+
+        unless data.key?(json_name)
+          instance_variable_set("@#{attr_name}", UNLOADED_ATTR)
+          return
+        end
+
+        json_value = data[json_name]
+
+        variable_value = case options[:type]
+                         when :string
+                           json_value&.to_s
+                         when :integer
+                           json_value&.to_i
+                         when :float
+                           json_value&.to_f
+                         when :object
+                           parse_inline_object(json_value)
+                         else
+                           json_value
+                         end
+        instance_variable_set("@#{attr_name}", variable_value)
+      end
+
+      def parse_inline_object(obj_hash)
+        return obj_hash unless obj_hash.keys.include?('data')
+
+        data = obj_hash['data']
+        return if data.nil?
+
+        if data.respond_to?(:each_pair)
+          data.transform_keys!(&:underscore)
+          klass = Base
+          data.each_key do |key|
+            klass.attribute key, lazy_loaded: false
+          end
+          klass.new(data)
+        elsif data.respond_to?(:each)
+          data.map do |data_item|
+            parse_inline_object({ 'data' => data_item })
+          end
+        else
+          data
+        end
+      end
+
+      def load_relations(data)
+        self.class.belongs_to_relations.each do |relation, options|
+          json_name = (options[:json_column] || relation).to_s
+          instance_variable_set(
+            "@#{relation}", data[json_name].nil? ? nil : Resource.init_from_hash(data[json_name])
+          )
+        end
+        self.class.has_many_relations.each do |relation, options|
+          json_name = (options[:json_column] || relation).to_s
+          instance_variable_set(
+            "@#{relation}", data[json_name].nil? ? nil : ResourceSet.new(data[json_name])
+          )
+        end
+      end
+    end
+  end
+end

data/lib/dm_api/resource/binder.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DmApi
+  module Resource
+    class Binder < Base
+      api_method :all, :get, '/binders'
+      api_method :find, :get, '/binders/:id'
+      api_method :list_documents, :get, '/binders/:id/documents'
+
+      attribute :id, lazy_loaded: false
+      attribute :count
+      attribute :color
+      attribute :label
+      attribute :secondary_label, json_column: 'secondaryLabel'
+      belongs_to :shelf
+    end
+  end
+end

data/lib/dm_api/resource/cabinet.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module DmApi
+  module Resource
+    class Cabinet < Base
+      api_method :find, :get, '/cabinets/:id'
+
+      attribute :id, lazy_loaded: false
+      attribute :label
+    end
+  end
+end

data/lib/dm_api/resource/document.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DmApi
+  module Resource
+    class Document < Base
+      api_method :all, :get, '/documents'
+      api_method :create, :post, '/documents'
+      api_method :find, :get, '/documents/:id'
+      api_method :update, :patch, '/documents/:id'
+      api_method :add_file, :post, '/documents/:id/files'
+
+      attribute :id, lazy_loaded: false
+      attribute :title
+      attribute :note
+      attribute :created_at, json_column: 'createdAt'
+      has_many :information
+      belongs_to :container
+    end
+  end
+end

data/lib/dm_api/resource/file.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module DmApi
+  module Resource
+    class File < Base
+      api_method :all, :get, '/files'
+      api_method :find, :get, '/files/:id'
+      api_method :request_uuid, :post, '/files'
+      api_method :request_upload, :post, '/files/:id/content'
+
+      attribute :id, lazy_loaded: false
+      attribute :created_at, json_column: 'createdAt'
+      attribute :filename
+      attribute :size, type: :integer
+      attribute :media_type, json_column: 'mediaType'
+      attribute :checksums
+      attribute :status
+
+      class << self
+        def upload(file_name, uuid: nil)
+          if uuid.blank?
+            resp = request_uuid
+            uuid = resp.id
+          end
+          resp = request_upload(uuid)
+          aws_meta = resp.metadata['location']
+          req = Typhoeus::Request.new(aws_meta['url'],
+                                      {
+                                        method: aws_meta['method'],
+                                        headers: aws_headers(aws_meta['headers']),
+                                        body: aws_body(aws_meta['formFields'], file_name)
+                                      })
+          response = req.run
+
+          retries = 5
+          retries.times do
+            sleep 1
+            doc = DmApi::Resource::File.find(uuid)
+            puts doc.status
+
+            break if %w[analyzed checked].include?(doc.status)
+          rescue DmApi::Errors::FailedResponse => e
+            raise e unless e.response.code.to_s == '404'
+          end
+
+          [uuid, response]
+        end
+
+        def aws_headers(headers)
+          aws_headers = {}
+          headers.each do |key, value|
+            aws_headers[key] = value if value.present?
+          end
+          aws_headers['User-Agent'] = 'curl/7.68.0'
+          aws_headers
+        end
+
+        def aws_body(body, file_name)
+          aws_body = {}
+          body.each do |key, value|
+            value = ::File.open(file_name, 'r') if key == 'file'
+            next if value.blank?
+
+            aws_body[key] = value
+          end
+          aws_body[:file] = ::File.open(file_name, 'r') if aws_body['file'].nil?
+          aws_body
+        end
+      end
+    end
+  end
+end

data/lib/dm_api/resource/information.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module DmApi
+  module Resource
+    class Information < Base
+      api_method :all, :get, '/documents/:document_id/information'
+      api_method :find, :get, '/information/:id'
+      api_method :update, :patch, '/information/:id'
+
+      attribute :id, lazy_loaded: false
+      attribute :label
+      attribute :value, type: :object
+      attribute :tags
+    end
+  end
+end

data/lib/dm_api/resource/information_definition.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DmApi
+  module Resource
+    class InformationDefinition < Base
+      attribute :id, lazy_loaded: false
+      attribute :label, lazy_loaded: false
+      attribute :tags, lazy_loaded: false
+    end
+  end
+end

data/lib/dm_api/resource/shelf.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module DmApi
+  module Resource
+    class Shelf < Base
+      api_method :find, :get, '/shelves/:id'
+
+      attribute :id, lazy_loaded: false
+      attribute :label
+      has_many :information_definitions, json_column: 'informationDefinitions'
+      belongs_to :cabinet
+    end
+  end
+end

data/lib/dm_api/resource/tray.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module DmApi
+  module Resource
+    class Tray < Base
+      api_method :all, :get, '/trays'
+      api_method :find, :get, '/trays/:id'
+
+      attribute :id, lazy_loaded: false
+      attribute :label
+      attribute :color
+      attribute :count
+      attribute :secondary_label, json_column: 'secondaryLabel'
+      belongs_to :shelf
+    end
+  end
+end

data/lib/dm_api/resource.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module DmApi
+  module Resource
+    RESOURCE_CLASS_MAP = {
+      'document' => 'DmApi::Resource::Document',
+      'binder' => 'DmApi::Resource::Binder',
+      'information' => 'DmApi::Resource::Information',
+      'shelf' => 'DmApi::Resource::Shelf',
+      'informationDefinition' => 'DmApi::Resource::InformationDefinition',
+      'cabinet' => 'DmApi::Resource::Cabinet',
+      'file' => 'DmApi::Resource::File',
+      'tray' => 'DmApi::Resource::Tray'
+    }.freeze
+
+    class << self
+      def init_from_hash(obj_hash = {})
+        data = obj_hash['data']
+
+        if data.is_a? Array
+          ResourceSet.new(obj_hash)
+        else
+          data['links'] = obj_hash['links']
+          return obj_hash if data['type'].nil?
+
+          type = RESOURCE_CLASS_MAP[data['type']]
+          return obj_hash if type.nil?
+
+          init_resource(type, data)
+        end
+      end
+
+      def init_resource(type, data)
+        new_data = data.except('type')
+        type.constantize.new(new_data)
+      end
+    end
+  end
+end

data/lib/dm_api/resource_set.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module DmApi
+  class ResourceSet
+    delegate_missing_to :resources
+    delegate :to_json, to: :resources
+
+    attr_reader :links
+
+    private
+
+    def initialize(data)
+      load_from_hash(data)
+    end
+
+    def load_from_hash(data)
+      if data.is_a? Array
+        @resources = data&.map do |resource|
+          Resource.init_from_hash({ 'data' => resource })
+        end
+        @links = nil
+      else
+        @resources = data['data']&.map do |resource|
+          Resource.init_from_hash(resource)
+        end
+        @links = data['links']
+      end
+    end
+
+    def resources
+      return @resources unless @resources.nil?
+
+      return if @links.nil? || @links['self'].nil?
+
+      request_url = @links['self']['href']
+      obj_hash = Api.new.call_url(request_url, :get)
+      load_from_hash(obj_hash)
+      @resources
+    end
+  end
+end

data/lib/dm_api.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'dm_api/configuration'
+require_relative 'dm_api/resource/base'
+require_relative 'dm_api/resource/binder'
+require_relative 'dm_api/resource/file'
+require_relative 'dm_api/resource/shelf'
+require_relative 'dm_api/resource/tray'
+require_relative 'dm_api/resource/document'
+require_relative 'dm_api/resource/cabinet'
+require_relative 'dm_api/resource/information_definition'
+require_relative 'dm_api/resource/information'
+require_relative 'dm_api/errors/required_parameter_missing'
+require_relative 'dm_api/errors/failed_response'
+require_relative 'dm_api/resource'
+require_relative 'dm_api/resource_set'
+require_relative 'dm_api/api'
+require_relative 'dm_api/api_response'
+
+module DmApi
+  class << self
+    def configure
+      if block_given?
+        yield(Configuration.instance)
+      else
+        Configuration.instance
+      end
+    end
+
+    def use_relative_model_naming?
+      true
+    end
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: dm_api
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Lukáš Bauer
+- Matouš Vokál
+- Josef Liška
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2025-08-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+description: DocumentManager API v3 bare bones client
+email: billing@virtualmaster.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- dm_api.gemspec
+- lib/dm_api.rb
+- lib/dm_api/api.rb
+- lib/dm_api/api_response.rb
+- lib/dm_api/configuration.rb
+- lib/dm_api/errors/failed_response.rb
+- lib/dm_api/errors/required_parameter_missing.rb
+- lib/dm_api/resource.rb
+- lib/dm_api/resource/base.rb
+- lib/dm_api/resource/binder.rb
+- lib/dm_api/resource/cabinet.rb
+- lib/dm_api/resource/document.rb
+- lib/dm_api/resource/file.rb
+- lib/dm_api/resource/information.rb
+- lib/dm_api/resource/information_definition.rb
+- lib/dm_api/resource/shelf.rb
+- lib/dm_api/resource/tray.rb
+- lib/dm_api/resource_set.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key: 
+specification_version: 4
+summary: DocumentManager API client
+test_files: []