onoffice_sdk 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e90e22cbea56ed44b807826226353a8d45bb71269e94579c2e201c68b8513ad0
+  data.tar.gz: 8b88aa66df26aa055510af7af24a56495434b18b2d78caef599901985d0275af
+SHA512:
+  metadata.gz: 9b6bb076780f3c46930df2ba8c26bbee7d95aa88768d9f04418e8521c5b7558784fafd3943ee08e2cd41c69db56c560469135dbf0f39679b8a5e5292a97b7a35
+  data.tar.gz: 944d8601530766b1d2457cbf06aee806f48133e3e704c3190e6ae8f735a8498953d312d076ae4c7877aea515bf549b5e1b6fa2a5e6dc2ec021ae143bda6e3e4b

data/README.md

@@ -0,0 +1,200 @@
+# onoffice_sdk (Ruby)
+
+Ruby client for the onOffice API.
+
+- HTTP over TLS
+- Token + HMAC (v2) signing per action
+- Batched requests
+- Pluggable cache hooks
+
+## Install
+
+Build and install locally:
+
+```
+gem build onoffice_sdk.gemspec
+gem install onoffice_sdk-*.gem
+```
+
+Add to your Gemfile:
+
+```
+# For local development using this repo
+gem 'onoffice_sdk', path: '.'
+
+# Or use the released gem
+# gem 'onoffice_sdk', '~> 0.x'
+```
+
+## Quickstart
+
+```ruby
+require 'onoffice_sdk'
+
+sdk = OnOfficeSDK::SDK.new
+sdk.set_api_version('stable')
+
+parameters_read_estate = {
+  'data' => ['Id', 'kaufpreis', 'lage'],
+  'listlimit' => 10,
+  'sortby' => { 'kaufpreis' => 'ASC', 'warmmiete' => 'ASC' },
+  'filter' => {
+    'kaufpreis' => [{ 'op' => '>', 'val' => 300_000 }],
+    'status' => [{ 'op' => '=', 'val' => 1 }]
+  }
+}
+
+handle = sdk.call_generic(OnOfficeSDK::SDK::ACTION_ID_READ, 'estate', parameters_read_estate)
+
+sdk.send_requests('PUT_TOKEN_HERE', 'PUT_SECRET_HERE')
+
+p sdk.get_response_array(handle)
+```
+
+## API
+
+- `set_api_version(version)` – sets API version (default: `stable`).
+- `set_api_server(url)` – sets base server (default: `https://api.onoffice.de/api/`).
+- `set_http_options(hash)` – Net::HTTP options, e.g., `{ open_timeout: 5, read_timeout: 30 }`.
+- `call_generic(action_id, resource_type, parameters)` – queue an action.
+- `call(action_id, resource_id, identifier, resource_type, parameters)` – queue an action with explicit identifiers.
+- `send_requests(token, secret)` – send all queued actions in a single HTTP request.
+- `get_response_array(handle)` – fetch and remove the response for a prior handle.
+- `add_cache(cache)` / `set_caches([...])` – register cache backends.
+- `remove_cache_instances` – clear all registered caches.
+- `errors` – returns a hash of errors for failed actions.
+
+### Cache interface
+
+Implementors should respond to:
+
+```ruby
+class MyCache
+  include OnOfficeSDK::Cache::Interface
+
+  def initialize(options = {}); end
+  def get_http_response_by_parameter_array(parameters); end # -> String (JSON) or nil
+  def write(parameters, value); end                          # value is a JSON string
+  def cleanup; end
+  def clear_all; end
+end
+```
+
+When a response is cacheable, the SDK writes a JSON string of the response payload to caches. Reads should return that JSON string for a hit.
+
+## Notes
+
+- HMAC v2 implemented as Base64.strict_encode64(HMAC-SHA256(secret, timestamp + token + resourcetype + actionid)).
+- Batch request body shape: `{ token, request: { actions: [...] } }`.
+- Response handling uses `status.errorcode`, `data`, and `cacheable`.
+
+## License
+
+MIT (see repository LICENSE).
+
+## Rails Integration
+
+The gem includes a Railtie for auto-configuration, an optional Rails.cache adapter, and a generator.
+
+1) Gemfile
+
+```
+# For local development using this repo
+gem 'onoffice_sdk', path: '.'
+
+# Or use the released gem
+# gem 'onoffice_sdk', '~> 0.x'
+```
+
+2) Credentials or ENV
+
+Set `ONOFFICE_TOKEN` and `ONOFFICE_SECRET` (or use Rails credentials):
+
+```
+# .env or deployment env
+ONOFFICE_TOKEN=your_token
+ONOFFICE_SECRET=your_secret
+ONOFFICE_API_VERSION=stable
+ONOFFICE_API_BASE=https://api.onoffice.de/api/
+```
+
+3) Initializer (auto-config via Railtie or generator)
+
+```ruby
+OnOfficeSDK.configure do |c|
+  # c.api_server = ENV.fetch('ONOFFICE_API_BASE', 'https://api.onoffice.de/api/')
+  # c.api_version = ENV.fetch('ONOFFICE_API_VERSION', 'stable')
+  # c.open_timeout = 5
+  # c.read_timeout = 30
+  # c.token = Rails.application.credentials.dig(:onoffice, :token)
+  # c.secret = Rails.application.credentials.dig(:onoffice, :secret)
+  # c.use_rails_cache = true
+  # c.rails_cache_ttl = 600
+end
+```
+
+4) Use the generator (optional)
+
+```
+bin/rails g onoffice_sdk:install
+```
+
+This creates `config/initializers/onoffice_sdk.rb` and `app/services/onoffice_client.rb`.
+
+5) Example service (app/services/onoffice_client.rb)
+
+```ruby
+class OnofficeClient
+  def initialize(sdk: OnOfficeSDK.client)
+    @sdk = sdk
+  end
+
+  def read_estates(limit: 10)
+    params = { 'data' => ['Id', 'kaufpreis'], 'listlimit' => limit }
+    handle = @sdk.call_generic(OnOfficeSDK::SDK::ACTION_ID_READ, 'estate', params)
+    @sdk.send_requests(token, secret)
+    @sdk.get_response_array(handle)
+  end
+
+  private
+
+  def token
+    ENV.fetch('ONOFFICE_TOKEN')
+  end
+
+  def secret
+    ENV.fetch('ONOFFICE_SECRET')
+  end
+end
+```
+
+5) Use in a controller
+
+```ruby
+class EstatesController < ApplicationController
+  def index
+    @result = OnofficeClient.new.read_estates(limit: 10)
+  end
+end
+```
+
+6) Optional: Rails.cache adapter
+
+```ruby
+require 'digest/md5'
+
+Built-in: `OnOfficeSDK::Cache::RailsCache`.
+
+```ruby
+# In the initializer
+# OnOfficeSDK.configure do |c|
+#   c.use_rails_cache = true
+#   c.rails_cache_ttl = 10.minutes
+# end
+```
+
+Notes for Rails
+- The client is stateless; create once and reuse per-process or inject per-request.
+- `send_requests(token, secret)` batches all queued actions; queue multiple calls, then send once.
+- Cache interface expects JSON strings; example above writes/reads raw strings to `Rails.cache`.
+- ActiveSupport::Notifications: emits `onoffice_sdk.request` around each HTTP call.

data/lib/generators/onoffice_sdk/install/install_generator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+module OnofficeSdk
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('templates', __dir__)
+
+      desc 'Creates an initializer for OnOfficeSDK and an optional service class'
+
+      class_option :service, type: :boolean, default: true, desc: 'Generate a simple service class using the SDK'
+
+      def create_initializer
+        template 'initializer.rb', 'config/initializers/onoffice_sdk.rb'
+      end
+
+      def create_service
+        return unless options[:service]
+
+        template 'service.rb', 'app/services/onoffice_client.rb'
+      end
+    end
+  end
+end

data/lib/generators/onoffice_sdk/install/templates/initializer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+OnOfficeSDK.configure do |c|
+  # Configure via ENV, Rails credentials, or set here
+  # c.api_server = ENV.fetch('ONOFFICE_API_BASE', 'https://api.onoffice.de/api/')
+  # c.api_version = ENV.fetch('ONOFFICE_API_VERSION', 'stable')
+  # c.open_timeout = 5
+  # c.read_timeout = 30
+  # c.token = Rails.application.credentials.dig(:onoffice, :token)
+  # c.secret = Rails.application.credentials.dig(:onoffice, :secret)
+  # c.use_rails_cache = true
+  # c.rails_cache_ttl = 600
+end

data/lib/generators/onoffice_sdk/install/templates/service.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class OnofficeClient
+  def initialize(sdk: OnOfficeSDK.client)
+    @sdk = sdk
+  end
+
+  def read_estates(limit: 10)
+    params = { 'data' => %w[Id kaufpreis], 'listlimit' => limit }
+    handle = @sdk.call_generic(OnOfficeSDK::SDK::ACTION_ID_READ, 'estate', params)
+    @sdk.send_requests(token, secret)
+    @sdk.get_response_array(handle)
+  end
+
+  private
+
+  def token
+    OnOfficeSDK.configuration.token || ENV.fetch('ONOFFICE_TOKEN', nil)
+  end
+
+  def secret
+    OnOfficeSDK.configuration.secret || ENV.fetch('ONOFFICE_SECRET', nil)
+  end
+end

data/lib/onoffice_sdk/cache/interface.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module OnOfficeSDK
+  module Cache
+    # Informal interface for cache backends.
+    # Implementers should provide the following methods:
+    # - initialize(options = {})
+    # - get_http_response_by_parameter_array(parameters) -> String or nil
+    # - write(parameters, value) -> true/false
+    # - cleanup
+    # - clear_all
+    module Interface
+      def get_http_response_by_parameter_array(_parameters); end
+      def write(_parameters, _value); end
+      def cleanup; end
+      def clear_all; end
+    end
+  end
+end

data/lib/onoffice_sdk/cache/rails_cache.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'digest/md5'
+
+module OnOfficeSDK
+  module Cache
+    class RailsCache
+      include OnOfficeSDK::Cache::Interface
+
+      def initialize(options = {})
+        @namespace = options[:namespace] || 'onoffice'
+        @ttl = options[:ttl] || 300
+      end
+
+      def get_http_response_by_parameter_array(parameters)
+        return nil unless defined?(Rails)
+
+        Rails.cache.read(key(parameters))
+      end
+
+      def write(parameters, value)
+        return false unless defined?(Rails)
+
+        Rails.cache.write(key(parameters), value, expires_in: @ttl)
+      end
+
+      def cleanup; end
+
+      def clear_all
+        return unless defined?(Rails)
+
+        # Best-effort namespaced clear
+        Rails.cache.delete_matched("#{@namespace}:*") if Rails.cache.respond_to?(:delete_matched)
+      end
+
+      private
+
+      def key(parameters)
+        digest = Digest::MD5.hexdigest(Marshal.dump(parameters))
+        "#{@namespace}:#{digest}"
+      end
+    end
+  end
+end

data/lib/onoffice_sdk/configuration.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module OnOfficeSDK
+  class Configuration
+    attr_accessor :api_server, :api_version, :open_timeout, :read_timeout,
+                  :token, :secret, :use_rails_cache, :rails_cache_ttl
+
+    def initialize
+      @api_server = 'https://api.onoffice.de/api/'
+      @api_version = 'stable'
+      @open_timeout = 5
+      @read_timeout = 30
+      @token = nil
+      @secret = nil
+      @use_rails_cache = false
+      @rails_cache_ttl = 300 # seconds
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+      refresh_default_client!
+    end
+
+    def client
+      @client ||= build_client_from_config
+    end
+
+    def refresh_default_client!
+      @client = build_client_from_config
+    end
+
+    private
+
+    def build_client_from_config
+      sdk = OnOfficeSDK::SDK.new
+      cfg = configuration
+      sdk.set_api_server(cfg.api_server)
+      sdk.set_api_version(cfg.api_version)
+      sdk.set_http_options(open_timeout: cfg.open_timeout, read_timeout: cfg.read_timeout)
+      if cfg.use_rails_cache && defined?(Rails)
+        begin
+          require_relative 'cache/rails_cache'
+          sdk.add_cache(OnOfficeSDK::Cache::RailsCache.new(ttl: cfg.rails_cache_ttl))
+        rescue LoadError
+          # ignore if Rails cache adapter not available
+        end
+      end
+      sdk
+    end
+  end
+end

data/lib/onoffice_sdk/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module OnOfficeSDK
+  class SDKError < StandardError; end
+
+  class ApiCallFaultyResponseError < SDKError; end
+  class ApiCallNoActionParametersError < SDKError; end
+
+  class HttpFetchNoResultError < SDKError
+    attr_accessor :errno
+  end
+end

data/lib/onoffice_sdk/internal/api_action.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module OnOfficeSDK
+  module Internal
+    class ApiAction
+      def initialize(action_id, resource_type, parameters, resource_id = '', identifier = '', timestamp = nil)
+        sorted_params = parameters.is_a?(Hash) ? parameters.sort.to_h : parameters
+        @action_parameters = {
+          'actionid' => action_id,
+          'identifier' => identifier,
+          'parameters' => sorted_params,
+          'resourceid' => resource_id,
+          'resourcetype' => resource_type,
+          'timestamp' => timestamp
+        }
+      end
+
+      attr_reader :action_parameters
+
+      def identifier
+        # Deterministic identifier for caching
+        require 'digest/md5'
+        Digest::MD5.hexdigest(Marshal.dump(@action_parameters))
+      end
+    end
+  end
+end

data/lib/onoffice_sdk/internal/api_call.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module OnOfficeSDK
+  module Internal
+    class ApiCall
+      def initialize
+        @request_queue = {}
+        @responses = {}
+        @errors = {}
+        @api_version = 'stable'
+        @caches = []
+        @server = nil
+        @http_options = {}
+      end
+
+      def call_by_raw_data(action_id, resource_id, identifier, resource_type, parameters = {})
+        p_api_action = ApiAction.new(action_id, resource_type, parameters, resource_id, identifier)
+        p_request = Request.new(p_api_action)
+        request_id = p_request.request_id
+        @request_queue[request_id] = p_request
+        request_id
+      end
+
+      def send_requests(token, secret, http_fetch = nil)
+        collect_or_gather_requests(token, secret, http_fetch)
+      end
+
+      def set_http_options(opts)
+        @http_options = opts || {}
+      end
+
+      def get_response(handle)
+        if @responses.key?(handle)
+          p_response = @responses[handle]
+          raise ApiCallFaultyResponseError, "Handle: #{handle}" unless p_response.valid?
+
+          @responses.delete(handle)
+          return p_response.response_data
+        end
+        nil
+      end
+
+      def set_api_version(v)
+        @api_version = v
+      end
+
+      def set_server(server)
+        @server = server
+      end
+
+      attr_reader :errors
+
+      def add_cache(cache)
+        @caches << cache
+      end
+
+      def remove_cache_instances
+        @caches = []
+      end
+
+      private
+
+      def collect_or_gather_requests(token, secret, http_fetch)
+        action_parameters = []
+        action_parameters_order = []
+
+        @request_queue.each_value do |p_request|
+          used_parameters = p_request.api_action.action_parameters
+          cached_response = get_from_cache(used_parameters)
+          if cached_response.nil?
+            parameters_this_action = p_request.create_request(token, secret)
+            action_parameters << parameters_this_action
+            action_parameters_order << p_request
+          else
+            @responses[p_request.request_id] = Response.new(p_request, cached_response)
+          end
+        end
+
+        send_http_requests(token, action_parameters, action_parameters_order, http_fetch)
+        @request_queue = {}
+      end
+
+      def send_http_requests(token, action_parameters, action_parameters_order, http_fetch)
+        return if action_parameters.empty?
+
+        response_http = get_from_http(token, action_parameters, http_fetch)
+        result = JSON.parse(response_http)
+        raise HttpFetchNoResultError unless result.dig('response', 'results')
+
+        ids_for_cache = []
+
+        result['response']['results'].each_with_index do |result_http, request_number|
+          p_request = action_parameters_order[request_number]
+          request_id = p_request.request_id
+          if result_http.dig('status', 'errorcode').to_i.zero?
+            @responses[request_id] = Response.new(p_request, result_http)
+            ids_for_cache << request_id
+          else
+            @errors[request_id] = result_http
+          end
+        end
+
+        write_cache_for_responses(ids_for_cache)
+      end
+
+      def get_from_http(token, action_parameters, http_fetch)
+        request = {
+          'token' => token,
+          'request' => { 'actions' => action_parameters }
+        }
+        if http_fetch.nil?
+          http_fetch = HttpFetch.new(api_url, JSON.generate(request))
+          http_fetch.http_options = @http_options
+        end
+        if defined?(ActiveSupport::Notifications)
+          ActiveSupport::Notifications.instrument('onoffice_sdk.request',
+                                                  url: api_url,
+                                                  actions_count: action_parameters.size) do
+            http_fetch.send
+          end
+        else
+          http_fetch.send
+        end
+      end
+
+      def write_cache_for_responses(response_ids)
+        return if @caches.empty?
+
+        response_objects = @responses.slice(*response_ids).values
+        response_objects.each do |p_response|
+          next unless p_response.cacheable?
+
+          response_data = p_response.response_data
+          request_parameters = p_response.request.api_action.action_parameters
+          write_cache(JSON.generate(response_data), request_parameters)
+        end
+      end
+
+      def write_cache(result, action_parameters)
+        @caches.each { |cache| cache.write(action_parameters, result) }
+      end
+
+      def get_from_cache(parameters)
+        @caches.each do |cache|
+          result_cache = cache.get_http_response_by_parameter_array(parameters)
+          next if result_cache.nil?
+
+          begin
+            return JSON.parse(result_cache)
+          rescue JSON::ParserError
+            # ignore invalid cache content
+          end
+        end
+        nil
+      end
+
+      def api_url
+        raise SDKError, 'Server not set' unless @server
+
+        base = @server.end_with?('/') ? @server : "#{@server}/"
+        "#{base}#{URI.encode_www_form_component(@api_version)}/api.php"
+      end
+    end
+  end
+end

data/lib/onoffice_sdk/internal/http_fetch.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+
+module OnOfficeSDK
+  module Internal
+    class HttpFetch
+      def initialize(url, post_data)
+        @url = url
+        @post_data = post_data
+        @http_options = {}
+      end
+
+      def http_options=(opts)
+        @http_options = opts || {}
+      end
+
+      def send
+        uri = URI.parse(@url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == 'https')
+        # Timeouts / options
+        http.open_timeout = @http_options[:open_timeout] if @http_options[:open_timeout]
+        http.read_timeout = @http_options[:read_timeout] if @http_options[:read_timeout]
+
+        req = Net::HTTP::Post.new(uri.request_uri)
+        req['Content-Type'] = 'application/json'
+        req['Accept-Encoding'] = 'gzip,deflate,br'
+        req.body = @post_data
+
+        res = http.request(req)
+        body = res&.body
+        unless res.is_a?(Net::HTTPSuccess) && body
+          err = HttpFetchNoResultError.new(res&.code.to_s)
+          err.errno = nil
+          raise err
+        end
+        body
+      end
+    end
+  end
+end

data/lib/onoffice_sdk/internal/request.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'base64'
+require 'openssl'
+
+module OnOfficeSDK
+  module Internal
+    class Request
+      @request_id_static = 0
+      class << self
+        attr_accessor :request_id_static
+      end
+
+      def initialize(api_action)
+        @api_action = api_action
+        @request_id = (self.class.request_id_static ||= 0)
+        self.class.request_id_static += 1
+      end
+
+      def create_request(token, secret)
+        action_parameters = @api_action.action_parameters.dup
+        action_parameters['timestamp'] ||= Time.now.to_i
+        action_parameters['hmac_version'] = 2
+
+        action_id = action_parameters['actionid']
+        type = action_parameters['resourcetype']
+        hmac = create_hmac2(token, secret, action_parameters['timestamp'], type, action_id)
+        action_parameters['hmac'] = hmac
+
+        action_parameters
+      end
+
+      def create_hmac2(token, secret, timestamp, type, action_id)
+        fields = {
+          'timestamp' => timestamp,
+          'token' => token,
+          'resourcetype' => type,
+          'actionid' => action_id
+        }
+        raw = fields.values.join
+        digest = OpenSSL::HMAC.digest('sha256', secret.to_s, raw)
+        Base64.strict_encode64(digest)
+      end
+
+      attr_reader :request_id, :api_action
+    end
+  end
+end

data/lib/onoffice_sdk/internal/response.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module OnOfficeSDK
+  module Internal
+    class Response
+      def initialize(request, response_data)
+        @request = request
+        @response_data = response_data
+      end
+
+      def valid?
+        @response_data.is_a?(Hash) &&
+          @response_data.key?('actionid') &&
+          @response_data.key?('resourcetype') &&
+          @response_data.key?('data')
+      end
+
+      def cacheable?
+        valid? && @response_data['cacheable']
+      end
+
+      attr_reader :request, :response_data
+    end
+  end
+end

data/lib/onoffice_sdk/railtie.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+
+module OnOfficeSDK
+  class Railtie < ::Rails::Railtie
+    config.onoffice_sdk = ActiveSupport::OrderedOptions.new
+
+    initializer 'onoffice_sdk.configure' do |app|
+      cfg = app.config.onoffice_sdk
+
+      OnOfficeSDK.configure do |c|
+        c.api_server = cfg.api_server || ENV['ONOFFICE_API_BASE'] || c.api_server
+        c.api_version = cfg.api_version || ENV['ONOFFICE_API_VERSION'] || c.api_version
+        c.open_timeout = cfg.open_timeout || c.open_timeout
+        c.read_timeout = cfg.read_timeout || c.read_timeout
+
+        c.token = cfg.token || begin
+          Rails.application.credentials.dig(:onoffice,
+                                            :token)
+        rescue StandardError
+          nil
+        end || ENV.fetch('ONOFFICE_TOKEN', nil)
+        c.secret = cfg.secret || begin
+          Rails.application.credentials.dig(:onoffice,
+                                            :secret)
+        rescue StandardError
+          nil
+        end || ENV.fetch('ONOFFICE_SECRET', nil)
+
+        c.use_rails_cache = cfg.fetch(:use_rails_cache, c.use_rails_cache)
+        c.rails_cache_ttl = cfg.rails_cache_ttl || c.rails_cache_ttl
+      end
+    end
+  end
+end

data/lib/onoffice_sdk/sdk.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module OnOfficeSDK
+  # Main SDK client for the onOffice API.
+  class SDK
+    ACTION_ID_READ   = 'urn:onoffice-de-ns:smart:2.5:smartml:action:read'
+    ACTION_ID_CREATE = 'urn:onoffice-de-ns:smart:2.5:smartml:action:create'
+    ACTION_ID_MODIFY = 'urn:onoffice-de-ns:smart:2.5:smartml:action:modify'
+    ACTION_ID_GET    = 'urn:onoffice-de-ns:smart:2.5:smartml:action:get'
+    ACTION_ID_DO     = 'urn:onoffice-de-ns:smart:2.5:smartml:action:do'
+    ACTION_ID_DELETE = 'urn:onoffice-de-ns:smart:2.5:smartml:action:delete'
+
+    RELATION_TYPE_BUYER   = 'urn:onoffice-de-ns:smart:2.5:relationTypes:estate:address:buyer'
+    RELATION_TYPE_TENANT  = 'urn:onoffice-de-ns:smart:2.5:relationTypes:estate:address:renter'
+    RELATION_TYPE_OWNER   = 'urn:onoffice-de-ns:smart:2.5:relationTypes:estate:address:owner'
+    MODULE_ADDRESS        = 'address'
+    MODULE_ESTATE         = 'estate'
+    MODULE_SEARCHCRITERIA = 'searchcriteria'
+    RELATION_TYPE_CONTACT_BROKER  = 'urn:onoffice-de-ns:smart:2.5:relationTypes:estate:address:contactPerson'
+    RELATION_TYPE_CONTACT_PERSON  = 'urn:onoffice-de-ns:smart:2.5:relationTypes:estate:address:contactPersonAll'
+    RELATION_TYPE_COMPLEX_ESTATE_UNITS = 'urn:onoffice-de-ns:smart:2.5:relationTypes:complex:estate:units'
+    RELATION_TYPE_ESTATE_ADDRESS_OWNER = 'urn:onoffice-de-ns:smart:2.5:relationTypes:estate:address:owner'
+
+    def initialize(api_call: nil)
+      @api_call = api_call || Internal::ApiCall.new
+      @api_call.set_server('https://api.onoffice.de/api/')
+    end
+
+    def set_api_version(api_version)
+      @api_call.set_api_version(api_version)
+    end
+
+    def set_api_server(server)
+      @api_call.set_server(server)
+    end
+
+    def set_http_options(options)
+      @api_call.set_http_options(options)
+    end
+
+    def call_generic(action_id, resource_type, parameters)
+      @api_call.call_by_raw_data(action_id, '', '', resource_type, parameters)
+    end
+
+    def call(action_id, resource_id, identifier, resource_type, parameters)
+      @api_call.call_by_raw_data(action_id, resource_id, identifier, resource_type, parameters)
+    end
+
+    def send_requests(token, secret)
+      @api_call.send_requests(token, secret)
+    end
+
+    def get_response_array(number)
+      @api_call.get_response(number)
+    end
+
+    def add_cache(cache)
+      @api_call.add_cache(cache)
+    end
+
+    def set_caches(cache_instances)
+      Array(cache_instances).each { |c| @api_call.add_cache(c) }
+    end
+
+    def remove_cache_instances
+      @api_call.remove_cache_instances
+    end
+
+    def errors
+      @api_call.errors
+    end
+  end
+end

data/lib/onoffice_sdk/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module OnOfficeSDK
+  VERSION = '0.1.0'
+end

data/lib/onoffice_sdk.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'uri'
+
+require_relative 'onoffice_sdk/version'
+require_relative 'onoffice_sdk/configuration'
+require_relative 'onoffice_sdk/sdk'
+require_relative 'onoffice_sdk/internal/api_call'
+require_relative 'onoffice_sdk/internal/api_action'
+require_relative 'onoffice_sdk/internal/request'
+require_relative 'onoffice_sdk/internal/response'
+require_relative 'onoffice_sdk/internal/http_fetch'
+require_relative 'onoffice_sdk/cache/interface'
+require_relative 'onoffice_sdk/errors'
+
+# Auto-load Railtie if in Rails
+begin
+  require_relative 'onoffice_sdk/railtie' if defined?(Rails::Railtie)
+rescue LoadError
+  # ignore when Rails is not present
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: onoffice_sdk
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- onOffice GmbH
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.48'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.48'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.20'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.20'
+description: Lightweight Ruby client to communicate with the onOffice API, supporting
+  batched requests, HMAC signing, and pluggable caching.
+email:
+- support@onoffice.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/generators/onoffice_sdk/install/install_generator.rb
+- lib/generators/onoffice_sdk/install/templates/initializer.rb
+- lib/generators/onoffice_sdk/install/templates/service.rb
+- lib/onoffice_sdk.rb
+- lib/onoffice_sdk/cache/interface.rb
+- lib/onoffice_sdk/cache/rails_cache.rb
+- lib/onoffice_sdk/configuration.rb
+- lib/onoffice_sdk/errors.rb
+- lib/onoffice_sdk/internal/api_action.rb
+- lib/onoffice_sdk/internal/api_call.rb
+- lib/onoffice_sdk/internal/http_fetch.rb
+- lib/onoffice_sdk/internal/request.rb
+- lib/onoffice_sdk/internal/response.rb
+- lib/onoffice_sdk/railtie.rb
+- lib/onoffice_sdk/sdk.rb
+- lib/onoffice_sdk/version.rb
+homepage: https://apidoc.onoffice.de/
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: Ruby client for the onOffice API
+test_files: []