memori-client 0.1.1 → 0.1.6

data/lib/memori_client/configuration.rb

@@ -5,6 +5,11 @@ module MemoriClient
     attr_accessor :backend_api_password
     attr_accessor :backend_api_tenant
     attr_accessor :engine_api_root
+    attr_accessor :engine_private_api_root
+
+    # Used to authorize private API calls to the engine
+    attr_accessor :engine_app_id
+    attr_accessor :engine_api_key
 
     # Initialize every configuration with a default.
     # Users of the gem will override these with their

data/lib/memori_client/engine/hmac_helper.rb

@@ -0,0 +1,186 @@
+require 'digest/md5'
+require 'securerandom'
+require 'time'
+
+class MemoriClient::Engine::HMACHelper
+  IPAD = 0x36
+  OPAD = 0x5c
+
+  def initialize(app_id, key, max_delta_secs = 30)
+    # Check arguments
+    raise ArgumentError, "HMAC: invalid appID" if app_id.nil?
+    raise ArgumentError, "HMAC: invalid key" if key.nil? || key.to_s == "00000000-0000-0000-0000-000000000000"
+
+    # Initialization
+    @app_id = app_id
+    @max_delta_secs = max_delta_secs
+
+    @message_cache = {}
+    @cache_mutex = Mutex.new
+
+    @@next_nonce ||= 0
+    @nonce_mutex = Mutex.new
+
+    # Build inner and outer keys
+    key_bytes = guid_to_bytes(key)
+
+    inner_key_bytes = key_bytes.map { |byte| byte ^ IPAD }
+    @inner_key = inner_key_bytes.map { |byte| byte.to_s(16).rjust(2, '0') }.join
+
+    outer_key_bytes = key_bytes.map { |byte| byte ^ OPAD }
+    @outer_key = outer_key_bytes.map { |byte| byte.to_s(16).rjust(2, '0') }.join
+
+    # Start a thread for cache expiration
+    Thread.new do
+      loop do
+        clean_cache
+        sleep 1
+      end
+    end
+  end
+
+  # Not meant to be invoked directly, but could be used for testing
+  # @return [Hash] the message and the signed HMAC
+  def build_hmac(nonce:, epoch:)
+    message = "#{@app_id}:#{nonce}:#{epoch}"
+
+    # Sign the message
+    signature = sign(message, @inner_key, @outer_key)
+    [message, signature]
+  end
+
+  def next_hmac
+    nonce = @nonce_mutex.synchronize { @@next_nonce += 1 }
+    epoch = Time.now.utc.to_i  # Use UTC time like C#
+    message, signature = build_hmac(nonce: nonce, epoch: epoch)
+
+    "#{message}:#{signature}"
+  end
+
+  def verify_hmac(hmac)
+    # Check arguments
+    raise ArgumentError, "HMAC: invalid message" if hmac.nil? || hmac.empty?
+
+    # String split HMAC message
+    parts = hmac.split(':')
+    raise ArgumentError, "HMAC: invalid message format" if parts.length != 4
+
+    # Check the app ID
+    begin
+      app_id = Integer(parts[0])
+    rescue
+      raise ArgumentError, "HMAC: invalid app ID"
+    end
+
+    raise ArgumentError, "HMAC: unrecognized app ID" if app_id != @app_id
+
+    # Check the nonce
+    begin
+      nonce = Integer(parts[1])
+    rescue
+      raise ArgumentError, "HMAC: invalid nonce"
+    end
+
+    raise ArgumentError, "HMAC: invalid nonce" if nonce < 1
+
+    # Check the timestamp
+    begin
+      timestamp = Integer(parts[2])
+    rescue
+      raise ArgumentError, "HMAC: invalid timestamp"
+    end
+
+    epoch = Time.now.utc.to_i  # Use UTC time like C#
+    time_diff = epoch - timestamp
+    raise ArgumentError, "HMAC: timestamp out of range" if time_diff <= -@max_delta_secs || time_diff >= @max_delta_secs
+
+    # Check the signature
+    message = "#{app_id}:#{nonce}:#{timestamp}"
+    expected_signature = sign(message, @inner_key, @outer_key)
+    actual_signature = parts[3]
+
+    # Use a constant-time comparison to prevent timing attacks
+    signature_valid = secure_compare(expected_signature, actual_signature)
+    raise ArgumentError, "HMAC: wrong signature" unless signature_valid
+
+    # Check if the message has already been seen
+    is_new = false
+
+    @cache_mutex.synchronize do
+      unless @message_cache.key?(message)
+        @message_cache[message] = Time.now.to_i + 30
+        is_new = true
+      end
+    end
+
+    raise ArgumentError, "HMAC: message already seen" unless is_new
+
+    true
+  end
+
+  private
+
+  def sign(message, inner_key, outer_key)
+    # Compute the inner MD5 hash exactly like C#
+    inner_hash_bytes = Digest::MD5.digest(inner_key + message)
+    inner_hash_str = inner_hash_bytes.unpack1('H*')
+
+    # Compute the outer MD5 hash
+    outer_hash_bytes = Digest::MD5.digest(outer_key + inner_hash_str)
+    outer_hash_str = outer_hash_bytes.unpack1('H*')
+
+    return outer_hash_str
+  end
+
+  def guid_to_bytes(guid)
+    # Convert GUID to string if it's already an object
+    guid_str = guid.to_s
+
+    # Remove any curly braces and hyphens, standardize format
+    guid_str = guid_str.gsub(/[{}-]/, '')
+
+    # Ensure we have a valid 32-character GUID
+    raise ArgumentError, "Invalid GUID format" unless guid_str.length == 32
+
+    # Parse the GUID using the same byte ordering as .NET's Guid.ToByteArray()
+    # This matches the specific layout: Int32, Int16, Int16, byte[8]
+
+    # First 4 bytes (8 hex chars) - need to reverse byte order (little-endian)
+    int32_bytes = [guid_str[0, 8]].pack('H*').bytes.reverse
+
+    # Next 2 bytes (4 hex chars) - need to reverse byte order (little-endian)
+    int16_1_bytes = [guid_str[8, 4]].pack('H*').bytes.reverse
+
+    # Next 2 bytes (4 hex chars) - need to reverse byte order (little-endian)
+    int16_2_bytes = [guid_str[12, 4]].pack('H*').bytes.reverse
+
+    # Remaining 8 bytes (16 hex chars) - keep original byte order
+    remaining_bytes = [guid_str[16, 16]].pack('H*').bytes
+
+    # Combine all byte arrays in the correct order
+    return int32_bytes + int16_1_bytes + int16_2_bytes + remaining_bytes
+  end
+
+  def secure_compare(a, b)
+    return false if a.bytesize != b.bytesize
+
+    # Constant-time comparison
+    result = 0
+    a.bytes.zip(b.bytes) { |x, y| result |= x ^ y }
+    result == 0
+  end
+
+  def clean_cache
+    now = Time.now.to_i
+    @cache_mutex.synchronize do
+      # Remove expired entries
+      @message_cache.delete_if { |_, expiry| expiry < now }
+
+      # Enforce size limit
+      if @message_cache.size > 100000
+        sorted = @message_cache.sort_by { |_, expiry| expiry }
+        @message_cache = Hash[sorted.first(100000)]
+      end
+    end
+  end
+end

data/lib/memori_client/engine/resource.rb

@@ -1,39 +1,13 @@
 class MemoriClient::Engine::Resource < MemoriClient::Resource
-  # def self.exec_http_request(method, path, args)
-  #   stop = false
-  #   processed_tokens = []
-  #   path.split('/').each do |token|
-  #     break if stop == true
-  #     if token =~ /^{.*}$/
-  #       param_name = token.match(/^{(.*)}$/).captures.first
-  #       if args[param_name.to_sym].blank?
-  #         stop = true
-  #       else
-  #         processed_tokens << args[param_name.to_sym]
-  #       end
-  #     else
-  #       processed_tokens << token
-  #     end
-  #   end
-  #
-  #   url = processed_tokens.join('/')
-  #   url = [MemoriClient.configuration.engine_api_root, url].join('')
-  #   http = MemoriClient::HttpClient.new
-  #
-  #   case method
-  #   when 'get'
-  #     status, body = http.get(url)
-  #   else
-  #     status, body = http.send(method, url, payload: args[:payload])
-  #   end
-  #
-  #   [status, body]
-  # end
-
   def self.build_url(url)
     [
       MemoriClient.configuration.engine_api_root,
       url
     ].join('')
   end
+
+  def self.hmac_authorization_header
+    helper = MemoriClient::Engine::HMACHelper.new(MemoriClient.configuration.engine_app_id, MemoriClient.configuration.engine_api_key)
+    ["HMAC", helper.next_hmac].join(' ')
+  end
 end

data/lib/memori_client/engine/resources.rb

@@ -1,22 +1,21 @@
 require 'memori_client/engine/v2/chat_log.rb'
-require 'memori_client/engine/v2/completion_log.rb'
 require 'memori_client/engine/v2/context_var.rb'
 require 'memori_client/engine/v2/correlation_pair.rb'
 require 'memori_client/engine/v2/custom_dictionary.rb'
 require 'memori_client/engine/v2/dialog.rb'
 require 'memori_client/engine/v2/event_log.rb'
 require 'memori_client/engine/v2/expert_reference.rb'
+require 'memori_client/engine/v2/function.rb'
 require 'memori_client/engine/v2/intent.rb'
 require 'memori_client/engine/v2/localization_key.rb'
 require 'memori_client/engine/v2/medium.rb'
-require 'memori_client/engine/v2/memori.rb'
 require 'memori_client/engine/v2/memory.rb'
 require 'memori_client/engine/v2/nlp.rb'
 require 'memori_client/engine/v2/person.rb'
-require 'memori_client/engine/v2/prompted_question.rb'
 require 'memori_client/engine/v2/search.rb'
 require 'memori_client/engine/v2/session.rb'
 require 'memori_client/engine/v2/stat.rb'
+require 'memori_client/engine/v2/topic.rb'
 require 'memori_client/engine/v2/unanswered_question.rb'
 require 'memori_client/engine/v2/user.rb'
 require 'memori_client/engine/v2/web_hook.rb'

data/lib/memori_client/engine/v2/chat_log.rb

@@ -1,49 +1,87 @@
-# Generated on 2024-01-18 17:37:07 +0000    
+# Generated on 2025-01-27 20:29:52 +0000    
 class MemoriClient::Engine::V2::ChatLog < MemoriClient::Engine::Resource
-    # GET /memori/v2/ChatLogs/{strSessionID}/{strDateFrom}/{strDateTo}
+    # `GET /memori/v2/ChatLogs/{strSessionID}/{strDateFrom}/{strDateTo}`
+    #
     # Gets the Chat Log objects for the Memori of the current session record in a specific date interval.
-    # Params list:
+    #
+    #
     # @param [string] strSessionID The session ID. required
+    #
     # @param [string] strDateFrom The optional begin of the date interval, in UTC time, in the format yyyyMMddHHmmssfff. optional
+    #
     # @param [string] strDateTo The optional end of the date interval, in UTC time, in the format yyyyMMddHHmmssfff. optional
-    # list_memori_chat_logs(strSessionID:, strDateFrom: nil, strDateTo: nil)
+    #
+    # `list_memori_chat_logs(strSessionID:, strDateFrom: nil, strDateTo: nil)`
     def self.list_memori_chat_logs(strSessionID:, strDateFrom: nil, strDateTo: nil)
       args = build_arguments(binding)
 
       exec_http_request('get', '/memori/v2/ChatLogs/{strSessionID}/{strDateFrom}/{strDateTo}', **args)
     end
 
-    # DELETE /memori/v2/ChatLogs/{strSessionID}/{strDateFrom}/{strDateTo}
+    # `DELETE /memori/v2/ChatLogs/{strSessionID}/{strDateFrom}/{strDateTo}`
+    #
     # Removes all Chat Log objects in a specific date interval.
-    # Params list:
+    #
+    #
     # @param [string] strSessionID The session ID. required
+    #
     # @param [string] strDateFrom The optional begin of the date interval, in UTC time, in the format yyyyMMddHHmmssfff. optional
+    #
     # @param [string] strDateTo The optional end of the date interval, in UTC time, in the format yyyyMMddHHmmssfff. optional
-    # remove_chat_logs(strSessionID:, strDateFrom: nil, strDateTo: nil)
+    #
+    # `remove_chat_logs(strSessionID:, strDateFrom: nil, strDateTo: nil)`
     def self.remove_chat_logs(strSessionID:, strDateFrom: nil, strDateTo: nil)
       args = build_arguments(binding)
 
       exec_http_request('delete', '/memori/v2/ChatLogs/{strSessionID}/{strDateFrom}/{strDateTo}', **args)
     end
 
-    # GET /memori/v2/SessionChatLogs/{strSessionID}/{strChatLogSessionID}
+    # `GET /memori/v2/SessionChatLogs/{strSessionID}/{strChatLogSessionID}`
+    #
     # Gets the Chat Log objects for the Memori of the current session recorded during a specific other session.
-    # Params list:
+    #
+    #
     # @param [string] strSessionID The session ID. required
+    #
     # @param [string] strChatLogSessionID The session ID for which Chat Log objects are being searched. required
-    # list_session_chat_logs(strSessionID:, strChatLogSessionID:)
+    #
+    # `list_session_chat_logs(strSessionID:, strChatLogSessionID:)`
     def self.list_session_chat_logs(strSessionID:, strChatLogSessionID:)
       args = build_arguments(binding)
 
       exec_http_request('get', '/memori/v2/SessionChatLogs/{strSessionID}/{strChatLogSessionID}', **args)
     end
 
-    # DELETE /memori/v2/ChatLog/{strSessionID}/{strChatLogID}
+    # `GET /memori/v2/UserChatLogs/{strSessionID}/{strUserID}/{strDateFrom}/{strDateTo}`
+    #
+    # Gets the Chat Log objects for the Memori of the current session created by a specific User.
+    #
+    #
+    # @param [string] strSessionID The session ID. required
+    #
+    # @param [string] strUserID The user ID for which Chat Log objects are being searched. required
+    #
+    # @param [string] strDateFrom The optional begin of the date interval, in UTC time, in the format yyyyMMddHHmmssfff. optional
+    #
+    # @param [string] strDateTo The optional end of the date interval, in UTC time, in the format yyyyMMddHHmmssfff. optional
+    #
+    # `list_user_chat_logs(strSessionID:, strUserID:, strDateFrom: nil, strDateTo: nil)`
+    def self.list_user_chat_logs(strSessionID:, strUserID:, strDateFrom: nil, strDateTo: nil)
+      args = build_arguments(binding)
+
+      exec_http_request('get', '/memori/v2/UserChatLogs/{strSessionID}/{strUserID}/{strDateFrom}/{strDateTo}', **args)
+    end
+
+    # `DELETE /memori/v2/ChatLog/{strSessionID}/{strChatLogID}`
+    #
     # Removes an existing Chat Log object.
-    # Params list:
+    #
+    #
     # @param [string] strSessionID The session ID. required
+    #
     # @param [string] strChatLogID The Chat Log object ID. required
-    # remove_chat_log(strSessionID:, strChatLogID:)
+    #
+    # `remove_chat_log(strSessionID:, strChatLogID:)`
     def self.remove_chat_log(strSessionID:, strChatLogID:)
       args = build_arguments(binding)
 

data/lib/memori_client/engine/v2/context_var.rb

@@ -1,33 +1,43 @@
-# Generated on 2024-01-18 17:37:07 +0000    
+# Generated on 2025-01-27 20:29:52 +0000    
 class MemoriClient::Engine::V2::ContextVar < MemoriClient::Engine::Resource
-    # GET /memori/v2/ContextVarNames/{strSessionID}
+    # `GET /memori/v2/ContextVarNames/{strSessionID}`
+    #
     # Gets a list of currently known context variable names.
-    # Params list:
+    #
+    #
     # @param [string] strSessionID The session ID. required
-    # get_context_var_names(strSessionID:)
+    #
+    # `get_context_var_names(strSessionID:)`
     def self.get_context_var_names(strSessionID:)
       args = build_arguments(binding)
 
       exec_http_request('get', '/memori/v2/ContextVarNames/{strSessionID}', **args)
     end
 
-    # GET /memori/v2/ContextVarValues/{strSessionID}/{contextVarName}
+    # `GET /memori/v2/ContextVarValues/{strSessionID}/{contextVarName}`
+    #
     # Gets a list of currently known values for a named context variable.
-    # Params list:
+    #
+    #
     # @param [string] strSessionID The session ID. required
+    #
     # @param [string] contextVarName The name of the context variable. required
-    # get_context_var_values(strSessionID:, contextVarName:)
+    #
+    # `get_context_var_values(strSessionID:, contextVarName:)`
     def self.get_context_var_values(strSessionID:, contextVarName:)
       args = build_arguments(binding)
 
       exec_http_request('get', '/memori/v2/ContextVarValues/{strSessionID}/{contextVarName}', **args)
     end
 
-    # GET /memori/v2/ContextVars/{strSessionID}
+    # `GET /memori/v2/ContextVars/{strSessionID}`
+    #
     # Gets a dictionary of all the known values of known context variables.
-    # Params list:
+    #
+    #
     # @param [string] strSessionID The session ID. required
-    # get_context_vars(strSessionID:)
+    #
+    # `get_context_vars(strSessionID:)`
     def self.get_context_vars(strSessionID:)
       args = build_arguments(binding)
 

data/lib/memori_client/engine/v2/correlation_pair.rb

@@ -1,44 +1,65 @@
-# Generated on 2024-01-18 17:37:07 +0000    
+# Generated on 2025-01-27 20:29:52 +0000    
 class MemoriClient::Engine::V2::CorrelationPair < MemoriClient::Engine::Resource
-    # GET /memori/v2/CorrelationPairs/{strSessionID}
+    # `GET /memori/v2/CorrelationPairs/{strSessionID}`
+    #
     # Lists all Correlation Pair objects.
-    # Params list:
+    #
+    #
     # @param [string] strSessionID The session ID. required
-    # list_correlation_pairs(strSessionID:)
+    #
+    # `list_correlation_pairs(strSessionID:)`
     def self.list_correlation_pairs(strSessionID:)
       args = build_arguments(binding)
 
       exec_http_request('get', '/memori/v2/CorrelationPairs/{strSessionID}', **args)
     end
 
-    # GET /memori/v2/CorrelationPairs/{strSessionID}/{from}/{howMany}
+    # `GET /memori/v2/CorrelationPairs/{strSessionID}/{from}/{howMany}`
+    #
     # Lists Correlation Pair objects with pagination.
-    # Params list:
+    #
+    #
     # @param [string] strSessionID The session ID. required
+    #
     # @param [integer] from The 0-based index of the first Correlation Pair object to list. required
+    #
     # @param [integer] howMany The number of the Correlation Pair objects to list. required
-    # list_correlation_pairs_paginated(strSessionID:, from:, howMany:)
+    #
+    # `list_correlation_pairs_paginated(strSessionID:, from:, howMany:)`
     def self.list_correlation_pairs_paginated(strSessionID:, from:, howMany:)
       args = build_arguments(binding)
 
       exec_http_request('get', '/memori/v2/CorrelationPairs/{strSessionID}/{from}/{howMany}', **args)
     end
 
-    # POST /memori/v2/CorrelationPair/{strSessionID}
+    # `POST /memori/v2/CorrelationPair/{strSessionID}`
+    #
     # Adds a new Correlation Pair object.
-    # Params list:
+    #
+    #
     # @param [string] strSessionID The session ID. required
-    # @param [object] payload request payload. optional
-    # @param [string] payload.pairID . optional
-    # @param [string] payload.text1 . optional
-    # @param [string] payload.text2 . optional
-    # @param [boolean] payload.correlated . optional
-    # @param [integer] payload.occurrences . optional
-    # @param [string] payload.creationTimestamp . optional
-    # @param [string] payload.creationSessionID . optional
-    # @param [string] payload.lastChangeTimestamp . optional
-    # @param [string] payload.lastChangeSessionID . optional
-    # add_correlation_pair(strSessionID:, payload: {})
+    #
+    # @param [Hash] payload request payload. optional
+    #
+    # @param [String] payload.pairID . optional
+    #
+    # @param [String] payload.text1 . optional
+    #
+    # @param [String] payload.text2 . optional
+    #
+    # @param [Boolean] payload.correlated . optional
+    #
+    # @param [Integer] payload.occurrences . optional
+    #
+    # @param [String] payload.creationTimestamp . optional
+    #
+    # @param [String] payload.creationSessionID . optional
+    #
+    # @param [String] payload.lastChangeTimestamp . optional
+    #
+    # @param [String] payload.lastChangeSessionID . optional
+    #
+    # `add_correlation_pair(strSessionID:, payload: {})`
     def self.add_correlation_pair(strSessionID:, payload: {})
       args = build_arguments(binding)
       payload_keys = [
@@ -58,12 +79,16 @@ class MemoriClient::Engine::V2::CorrelationPair < MemoriClient::Engine::Resource
       exec_http_request('post', '/memori/v2/CorrelationPair/{strSessionID}', **args)
     end
 
-    # DELETE /memori/v2/CorrelationPair/{strSessionID}/{strPairID}
+    # `DELETE /memori/v2/CorrelationPair/{strSessionID}/{strPairID}`
+    #
     # Removes an existing Correlation Pair object.
-    # Params list:
+    #
+    #
     # @param [string] strSessionID The session ID. required
+    #
     # @param [string] strPairID The Correlation Pair object ID. required
-    # remove_correlation_pair(strSessionID:, strPairID:)
+    #
+    # `remove_correlation_pair(strSessionID:, strPairID:)`
     def self.remove_correlation_pair(strSessionID:, strPairID:)
       args = build_arguments(binding)