trophonius 2.1.7 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7e8354023ac2793edf55b987cb32151705e4e36d173e4ce543e85f18cb54cea
-  data.tar.gz: b8445ef34040269df2bcb9d6183359fa36107410126d2065707a76b768188125
+  metadata.gz: 4a84b2bfd47dee89330a357ee38cee77f490e3eba810f9743bac995b61b3601f
+  data.tar.gz: 19209c6e6b419c624be3b25e3d6bbda7cf68340e719b7ab5851c6a98f635cafc
 SHA512:
-  metadata.gz: ab653916b39228ed1de20c164d7aa9a1c1fd151ab1b9dac251efd827561e974b832c7ebbb080e2dc18719752ad2a6f2a9684abe32a088499fb4c934ac1797a6b
-  data.tar.gz: fcbb644e94eb52245bc2300f4b13307f2f707a451c2d1826fc94c4d1daaa9f02a800a1d40d5ff1d0a935603ee022d59bfbe6b0a1355145bec6175c00b2b9ff67
+  metadata.gz: 1d1d01693932f60cce0f79011efecbe5610bf594725850c468ed1ecb4363d8c16c87b97eb556d7499de63e830b41a8247fb6e97644e0a899ab4cc42f52024606
+  data.tar.gz: a851707b8c5cd2dd9e6680a66065eebebbcdc3c131280c69d91c7366e863e9e7f4feb84ba72decc23b6f08b45cf2f3aebe7eca2c3979f6c1581998bfa0fd0da2

data/lib/connectors/connection.rb

@@ -30,6 +30,8 @@ module Trophonius
     # Disconnects from the FileMaker server
     #
     def disconnect
+      return unless test_connection
+
       uri = URI::RFC2396_Parser.new
       url =
         URI(
@@ -174,8 +176,10 @@ module Trophonius
       return !last_connection.nil? && last_connection > Time.now - (15 * 60) if Trophonius.config.layout_name == ''
 
       path = "/layouts/#{Trophonius.config.layout_name}/records?_limit=1"
+
+      token_to_check = Trophonius.config.redis_connection ? Trophonius::RedisManager.get_key(key: 'token') : @token
       response =
-        Trophonius::DatabaseRequest.make_request(path, :get, {}, bypass_queue_with: "Bearer #{@token}")
+        Trophonius::DatabaseRequest.make_request(path, :get, {}, bypass_queue_with: "Bearer #{token_to_check}")
       response['messages'][0]['code'] == '0'
     rescue StandardError => e
       puts e

data/lib/connectors/connection_manager.rb

@@ -27,7 +27,8 @@ module Trophonius
     end
 
     def disconnect_all
-      @connections.each { |_connection_id, connection| connection[:connection].disconnect }
+      @connections.reject { |_connection_id, connection| connection[:token].blank? }
+                  .each { |_connection_id, connection| connection[:connection].disconnect }
     end
 
     private

data/lib/record.rb

@@ -22,10 +22,11 @@ module Trophonius
       @modifiable_fields = {}
       @modified_fields = {}
       @model_name = model
-      @model = model_name.instance_of?(String) ? ActiveSupport::Inflector.constantize(ActiveSupport::Inflector.classify(ActiveSupport::Inflector.singularize(model_name))) : model_name
+      @model = model_name.instance_of?(String) ? constantize_model(model_name) : model_name
       @layout_name = @model.layout_name
-      define_field_methods(fm_record)
-      define_portal_methods(fm_record)
+      @portals = []
+      define_field_methods(fm_record) if fm_record.present?
+      define_portal_methods(fm_record) if fm_record.present?
       super()
     end
 
@@ -41,113 +42,14 @@ module Trophonius
 
     def method_missing(method, *args, &block)
       if ActiveSupport::Inflector.pluralize(method).to_s == method.to_s
-        model = ActiveSupport::Inflector.constantize(ActiveSupport::Inflector.classify(ActiveSupport::Inflector.singularize(method)))
-        pk_model = ActiveSupport::Inflector.constantize(ActiveSupport::Inflector.classify(ActiveSupport::Inflector.singularize(model_name)))
-
-        if model.belongs_to_relations[ActiveSupport::Inflector.parameterize(model_name).to_sym]
-          relation = model.belongs_to_relations[ActiveSupport::Inflector.parameterize(model_name).to_sym]
-          layout = model.layout_name
-          model.create_translations if model.translations.keys.empty?
-
-          url = "/layouts/#{layout}/_find"
-          foreign_key_field = if model.translations.key?(relation[:foreign_key])
-                                model.translations[relation[:foreign_key]].to_s
-                              else
-                                relation[:foreign_key].to_s
-                              end
-
-          primary_key_field = if pk_model.translations.key?(relation[:primary_key])
-                                pk_model.translations[relation[:primary_key]].to_s
-                              else
-                                relation[:primary_key].to_s
-                              end
-
-          body = { query: [{ foreign_key_field => self[primary_key_field].to_s }], limit: 100_000 }.to_json
-          response = DatabaseRequest.make_request(url, 'post', body)
-
-          if response['messages'][0]['code'] == '0'
-            r_results = response['response']['data']
-            ret_val = RecordSet.new(layout, model.non_modifiable_fields)
-            r_results.each do |r|
-              hash = model.build_result(r)
-              ret_val << hash
-            end
-            @response = ret_val
-            @response
-          elsif response['messages'][0]['code'] == '101' || response['messages'][0]['code'] == '401'
-            RecordSet.new(layout, model.non_modifiable_fields)
-
-          else
-            if response['messages'][0]['code'] == '102'
-              results = DatabaseRequest.retrieve_first(layout)
-              if results['messages'][0]['code'] == '0'
-                r_results = results['response']['data']
-                ret_val = r_results.empty? ? Error.throw_error('102') : r_results[0]['fieldData']
-                query_keys = [foreign_key_field]
-                Error.throw_error('102', (query_keys - ret_val.keys.map(&:downcase)).flatten.join(', '), layout)
-              else
-                Error.throw_error('102')
-              end
-            end
-            Error.throw_error(response['messages'][0]['code'])
-          end
-        end
-      elsif ActiveSupport::Inflector.constantize(ActiveSupport::Inflector.classify(ActiveSupport::Inflector.singularize(method))).respond_to?('first')
-        fk_model = ActiveSupport::Inflector.constantize(ActiveSupport::Inflector.classify(ActiveSupport::Inflector.singularize(model_name)))
-        pk_model = ActiveSupport::Inflector.constantize(ActiveSupport::Inflector.classify(ActiveSupport::Inflector.singularize(method)))
-
-        if pk_model.has_many_relations[ActiveSupport::Inflector.parameterize(ActiveSupport::Inflector.pluralize(model_name)).to_sym]
-          relation = pk_model.has_many_relations[ActiveSupport::Inflector.parameterize(ActiveSupport::Inflector.pluralize(model_name)).to_sym]
-          layout = pk_model.layout_name
-          pk_model.create_translations if pk_model.translations.keys.empty?
-
-          url = "/layouts/#{layout}/_find"
-
-          foreign_key_field = if fk_model.translations.key?(relation[:foreign_key])
-                                fk_model.translations[relation[:foreign_key]].to_s
-                              else
-                                relation[:foreign_key].to_s
-                              end
-
-          primary_key_field = if pk_model.translations.key?(relation[:primary_key])
-                                pk_model.translations[relation[:primary_key]].to_s
-                              else
-                                relation[:primary_key].to_s
-                              end
-
-          body = { query: [{ primary_key_field => self[foreign_key_field].to_s }], limit: 1 }.to_json
-
-          response = DatabaseRequest.make_request(url, 'post', body)
-          if response['messages'][0]['code'] == '0'
-            r_results = response['response']['data']
-            ret_val = RecordSet.new(layout, pk_model.non_modifiable_fields)
-            r_results.each do |r|
-              hash = pk_model.build_result(r)
-              ret_val << hash
-            end
-            @response = ret_val
-            @response.first
-          elsif response['messages'][0]['code'] == '101' || response['messages'][0]['code'] == '401'
-            RecordSet.new(layout, pk_model.non_modifiable_fields)
-
-          else
-            if response['messages'][0]['code'] == '102'
-              results = DatabaseRequest.retrieve_first(layout)
-              if results['messages'][0]['code'] == '0'
-                r_results = results['response']['data']
-                ret_val = r_results.empty? ? Error.throw_error('102') : r_results[0]['fieldData']
-                query_keys = [primary_key_field]
-                Error.throw_error('102', (query_keys - ret_val.keys.map(&:downcase)).flatten.join(', '), layout)
-              else
-                Error.throw_error('102')
-              end
-            end
-            Error.throw_error(response['messages'][0]['code'])
-          end
-        end
-      else
-        super
+        result = find_has_many_relation(method)
+        return result if result
+      elsif constantize_model(method).respond_to?('first')
+        result = find_belongs_to_relation(method)
+        return result if result
       end
+
+      super
     rescue NameError => e
       if e.message.include?('constant')
         Error.throw_error('102', e.message.split(' ')[-1], layout_name)
@@ -156,6 +58,20 @@ module Trophonius
       end
     end
 
+    def respond_to_missing?(method, include_private = false)
+      if ActiveSupport::Inflector.pluralize(method).to_s == method.to_s
+        target_model = constantize_model(method)
+        return true if target_model.belongs_to_relations[parameterize_name(model_name)]
+      else
+        target_model = constantize_model(method)
+        relation_key = parameterize_name(ActiveSupport::Inflector.pluralize(model_name))
+        return true if target_model.has_many_relations[relation_key]
+      end
+      super
+    rescue NameError
+      super
+    end
+
     ##
     # Runs a FileMaker script from the context of the Model.
     #
@@ -216,6 +132,11 @@ module Trophonius
     # @return [True] if successful
     def update(field_data, portal_data: {})
       url = "layouts/#{layout_name}/records/#{record_id}"
+      differences = calculate_differences_before_update(field_data, portal_data)
+      puts differences
+      puts differences.all? { |diff| diff.length.zero? }
+      return if differences.all? { |diff| diff.length.zero? }
+
       field_data.each_key { |field| modifiable_fields[field] = field_data[field] }
       field_data.transform_keys! { |k| (@model.translations[k.to_s] || k).to_s }
       @model.run_before_update
@@ -289,6 +210,10 @@ module Trophonius
     def define_portal_methods(fm_record)
       fm_record['portalData'].each_key do |key|
         method_name = methodize_field(key)
+        relation_name = portal_relation_name(fm_record.dig('portalData', key, 0))
+        @portals.push(key)
+        @portals.push(relation_name) unless relation_name == key
+
         define_singleton_method(method_name) { self[key] }
         fm_record['portalData'][key].each do |portal_record|
           portal_record.each_key do |inner_key|
@@ -311,5 +236,111 @@ module Trophonius
         Error.throw_error('102')
       end
     end
+
+    def constantize_model(name)
+      ActiveSupport::Inflector.constantize(
+        ActiveSupport::Inflector.classify(
+          ActiveSupport::Inflector.singularize(name.to_s)
+        )
+      )
+    end
+
+    def parameterize_name(name)
+      ActiveSupport::Inflector.parameterize(name.to_s).to_sym
+    end
+
+    def resolve_field(model, field_key)
+      model.create_translations if model.translations.keys.empty?
+      if model.translations.key?(field_key)
+        model.translations[field_key].to_s
+      else
+        field_key.to_s
+      end
+    end
+
+    def build_relation_record_set(model, layout, data)
+      ret_val = RecordSet.new(layout, model.non_modifiable_fields)
+      data.each { |r| ret_val << model.build_result(r) }
+      ret_val
+    end
+
+    def handle_relation_field_error(code, query_field, layout)
+      return unless code == '102'
+
+      results = DatabaseRequest.retrieve_first(layout)
+      if results['messages'][0]['code'] == '0'
+        r_results = results['response']['data']
+        if r_results.empty?
+          Error.throw_error('102')
+        else
+          ret_val = r_results[0]['fieldData']
+          Error.throw_error('102', ([query_field] - ret_val.keys.map(&:downcase)).flatten.join(', '), layout)
+        end
+      else
+        Error.throw_error('102')
+      end
+    end
+
+    def execute_relation_query(target_model, query_field, query_value, limit:)
+      layout = target_model.layout_name
+      url = "/layouts/#{layout}/_find"
+      body = { query: [{ query_field => query_value.to_s }], limit: limit }.to_json
+      response = DatabaseRequest.make_request(url, 'post', body)
+      code = response['messages'][0]['code']
+
+      if code == '0'
+        build_relation_record_set(target_model, layout, response['response']['data'])
+      elsif code == '101' || code == '401'
+        RecordSet.new(layout, target_model.non_modifiable_fields)
+      else
+        handle_relation_field_error(code, query_field, layout)
+        Error.throw_error(code)
+      end
+    end
+
+    def find_has_many_relation(method)
+      target_model = constantize_model(method)
+      current_model = constantize_model(model_name)
+      relation = target_model.belongs_to_relations[parameterize_name(model_name)]
+      return nil unless relation
+
+      foreign_key_field = resolve_field(target_model, relation[:foreign_key])
+      primary_key_field = resolve_field(current_model, relation[:primary_key])
+
+      @response = execute_relation_query(
+        target_model,
+        foreign_key_field,
+        self[primary_key_field],
+        limit: 100_000
+      )
+    end
+
+    def find_belongs_to_relation(method)
+      current_model = constantize_model(model_name)
+      target_model = constantize_model(method)
+      relation = target_model.has_many_relations[parameterize_name(ActiveSupport::Inflector.pluralize(model_name))]
+      return nil unless relation
+
+      foreign_key_field = resolve_field(current_model, relation[:foreign_key])
+      primary_key_field = resolve_field(target_model, relation[:primary_key])
+
+      @response = execute_relation_query(
+        target_model,
+        primary_key_field,
+        self[foreign_key_field],
+        limit: 1
+      )
+      @response.first
+    end
+
+    def calculate_differences_before_update(field_data, portal_data)
+      fields = self.reject { |k,v| @portals.include?(k) || !field_data.keys.include?(k) }
+      portals = self.select { |k,v| @portals.include?(k) && portal_data.keys.include?(k) }
+
+      updated_fields = field_data.present? ? field_data.to_set - fields.to_set  : []
+      updated_portals = portal_data.present? ? portal_data.to_set - portals.to_set : []
+
+      [updated_fields.to_h, updated_portals.to_h]
+    end
   end
 end

data/lib/translator.rb

@@ -11,5 +11,11 @@ module Trophonius
     def methodize_portal_field(field_name)
       ActiveSupport::Inflector.parameterize(ActiveSupport::Inflector.underscore(field_name.gsub(/\w+::/, '').to_s), separator: '_')
     end
+
+    def portal_relation_name(first_related_record)
+      return '' if first_related_record.nil?
+
+      first_related_record.keys.map{ |f| f[/.*(?=::)/] }.tally.max_by(&:last).first
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trophonius
 version: !ruby/object:Gem::Version
-  version: 2.1.7
+  version: 2.2.1
 platform: ruby
 authors:
 - Kempen Automatisering
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-15 00:00:00.000000000 Z
+date: 2026-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -98,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.7
+rubygems_version: 3.5.5
 signing_key:
 specification_version: 4
 summary: Link between Ruby (on Rails) and FileMaker.