solis 0.72.0 → 0.74.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa7c729b1acbe8c1881ebf3cc00ac228830bf04d269447f55b2f029c7eef703c
-  data.tar.gz: 81ceb99f9f6284b8c4163bfe4d263f6703edbe1733eb42fcc6c31530be2c8d91
+  metadata.gz: 166805286e332f8a5a9f572fa6ab7841f2f234223384b298139fa25d8339cf91
+  data.tar.gz: e43b4f5b33c911c8759e96012165cd9203b6941113e511442d169b0acd61bfe3
 SHA512:
-  metadata.gz: 6a5fe949952a2931c1189644690446ddc0b63ca719eb2f4b15f5cab83779d81b50872c3b57d4b677278cc4c6ca1e54ff8f14ff4b8c09ce842e8e5a3226835177
-  data.tar.gz: 03af55e0505d6e987522e8d799450be43a83b9968c60f7741b7c5bb2d75f0874d7d127b955f31ad028a35b2993b2ecdefb91653edf5e9941c4e7dfc796658696
+  metadata.gz: 7a091ee239234b0a71cfde2cbebb19905af07af63bf2e58dedb6c0178a7f2c4ac9d3f875df509cecf689857c4dcfac2cc76fa0f4b8dc4ef2d7b1df566af4edc8
+  data.tar.gz: 96dc87a0b2b208f6f56adcae71b391a7cbd18b22ac2ba4ea6d936d87d39bd98d88a2c74bed54d12c6a73fa00896ec23dbd60bf4b52474cc5d7f11f4048188961

data/lib/solis/graph.rb

@@ -351,7 +351,7 @@ module Solis
 
       @sparql_client = SPARQL::Client.new(@sparql_endpoint)
       result = @sparql_client.query("with <#{graph_name}> delete {?s ?p ?o} where{?s ?p ?o}")
-      LOGGER.info(result.first.to_a.first.last.value)
+      LOGGER.info(result)
       true
     end
 

data/lib/solis/model.rb

@@ -1,5 +1,6 @@
 require 'securerandom'
 require 'iso8601'
+require 'hashdiff'
 require_relative 'query'
 
 module Solis
@@ -71,9 +72,9 @@ module Solis
     def query
       raise "I need a SPARQL endpoint" if self.class.sparql_endpoint.nil?
 
-      #before_read_proc&.call(self)
+      # before_read_proc&.call(self)
       result = Solis::Query.new(self)
-      #after_read_proc&.call(result)
+      # after_read_proc&.call(result)
       result
     end
 
@@ -111,7 +112,7 @@ module Solis
       sparql = SPARQL::Client.new(self.class.sparql_endpoint)
 
       raise Solis::Error::QueryError, "#{self.id} is still referenced, refusing to delete" if is_referenced?(sparql)
-      #sparql.query('delete{}')
+      # sparql.query('delete{}')
       before_delete_proc&.call(self)
       #      graph = as_graph(self, false)
       #      Solis::LOGGER.info graph.dump(:ttl) if ConfigFile[:debug]
@@ -136,8 +137,8 @@ values ?s {<#{self.graph_id}>}
 
       before_create_proc&.call(self)
 
-      if exists?(sparql)
-        data = Model.properties_to_hash(self)
+      if self.exists?(sparql)
+        data = properties_to_hash(self)
 
         result = update(data)
       else
@@ -173,47 +174,169 @@ values ?s {<#{self.graph_id}>}
       raise Solis::Error::NotFoundError if original_klass.nil?
       updated_klass = original_klass.deep_dup
 
-      attributes.each_pair do |key, value|
+      attributes.each_pair do |key, value| # check each key. if it is an entity process it
+        unless original_klass.class.metadata[:attributes][key][:node].nil? #it is an entity
+          value = [value] unless value.is_a?(Array)
+          value.each do |sub_value|
+            embedded = self.class.graph.shape_as_model(original_klass.class.metadata[:attributes][key][:datatype].to_s).new(sub_value)
+            if embedded.exists?(sparql)
+              embedded_data = properties_to_hash(embedded)
+              embedded.update(embedded_data)
+            else
+              embedded.save
+            end
+          end
+        end
+
         updated_klass.instance_variable_set("@#{key}", value)
       end
 
+
+      # attributes.each_pair do |key, value|
+      #   if value.is_a?(Hash)
+      #     embedded = self.class.graph.shape_as_model(original_klass.class.metadata[:attributes][key][:datatype].to_s).new(value)
+      #     if embedded.exists?(sparql)
+      #       embedded_data = properties_to_hash(embedded)
+      #       embedded.update(embedded_data)
+      #     else
+      #       embedded.save
+      #     end
+      #   elsif value.is_a?(Array)
+      #     value.each do |sub_value|
+      #       if sub_value.is_a?(Hash)
+      #         if embedded.exists?(sparql)
+      #           embedded_data = properties_to_hash(embedded)
+      #           embedded.update(embedded_data)
+      #         else
+      #           embedded.save
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      #   updated_klass.instance_variable_set("@#{key}", value)
+      # end
+
+      # attributes.each_pair do |key, value|
+      #   updated_klass.instance_variable_set("@#{key}", value)
+      # end
+      # properties_original_klass=Model.properties_to_hash(original_klass)
+      # properties_updated_klass = Model.properties_to_hash(updated_klass)
+      # changes = Hashdiff.diff(properties_original_klass, properties_updated_klass)
+      # pp changes
+      #
+      # #a=self.class.graph.shape_as_model('Identificatienummer').new
+      # changes.each do |change|
+      #   change_type = change[0]
+      #   original_change_entity = change[1]
+      #   change_entity = original_change_entity.split('.').last
+      #   change[1] = change_object
+      #   data = change[2]
+      #
+      #   case change_type
+      #   when '+' # new
+      #     new_entity_hash = {} #self.class.graph.shape_as_model(change_object.classify).new
+      #     Hashdiff.patch!(new_entity_hash, [change])
+      #
+      #     new_entity = self.class.graph.shape_as_model(change_entity.classify).new(new_entity_hash[change_entity])
+      #     new_entity.save
+      #   when '-' # delete
+      #   when '~' # change
+      #   else
+      #     raise RuntimeError, "Unknown change type(#{change_type}) for #{change[1]}"
+      #   end
+      #
+      # end
+
+      # attributes.each_pair do |key, value|
+      #   updated_klass.instance_variable_set("@#{key}", value)
+      #   unless original_klass.class.metadata[:attributes][key][:node_kind].nil?
+      #     inner_model = self.class.graph.shape_as_model(original_klass.class.metadata[:attributes][key][:datatype].to_s)
+      #     if value.is_a?(Hash)
+      #       value.each_pair do |inner_key, inner_value|
+      #         next unless inner_model.metadata[:attributes][inner_key][:node_kind].is_a?(RDF::URI)
+      #         inner_inner_model = self.class.graph.shape_as_model(inner_model.metadata[:attributes][inner_key][:datatype].to_s)
+      #         # if inner_inner_model.class.ancestors.include?(Codetabel) && inner_value.key?('id')
+      #         #   inner_data = inner_inner_model.query.filter({ language: nil, filters: { id: [inner_value['id']] } }).find_all.map { |m| m }&.first
+      #         # else
+      #         inner_value = inner_value.first if inner_value.is_a?(Array)
+      #           inner_data = inner_inner_model.new(inner_value)
+      #           inner_data.save
+      #         # end
+      #       end
+      #     elsif value.is_a?(Array)
+      #       data = value.map do |m|
+      #         if m.is_a?(Hash)
+      #           m.each do |inner_key, inner_value|
+      #             #next if inner_model.metadata[:attributes][inner_key][:class].nil?
+      #             next unless inner_model.metadata[:attributes][inner_key][:node_kind].is_a?(RDF::URI)
+      #             inner_inner_model = self.class.graph.shape_as_model(inner_model.class.metadata[:attributes][inner_key][:datatype].to_s)
+      #             # if inner_inner_model.class.ancestors.include?(Codetabel) && inner_value.key?('id')
+      #             #   inner_data = inner_inner_model.query.filter({ language: nil, filters: { id: [inner_value['id']] } }).find_all.map { |m| m }&.first
+      #             # else
+      #               inner_value = inner_value.first if inner_value.is_a?(Array)
+      #               inner_data = inner_inner_model.new(inner_value)
+      #               inner_data.save
+      #             # end
+      #
+      #             inner_data
+      #           end
+      #         else
+      #           m
+      #         end
+      #       end
+      #     elsif value.is_a?(Object)
+      #       value.save
+      #     end
+      #   end
+      # end
+
       before_update_proc&.call(original_klass, updated_klass)
 
-      delete_graph = as_graph(original_klass, false)
+      properties_orignal_klass = properties_to_hash(original_klass)
+      properties_updated_klass = properties_to_hash(updated_klass)
+
+      if Hashdiff.best_diff(properties_orignal_klass, properties_updated_klass).empty?
+        Solis::LOGGER.info("#{original_klass.class.name} unchanged, skipping")
+        data = self.query.filter({ filters: { id: [id] } }).find_all.map { |m| m }&.first
+      else
 
-      where_graph = RDF::Graph.new(graph_name: RDF::URI("#{self.class.graph_name}#{self.name.tableize}/#{id}"), data: RDF::Repository.new)
+        delete_graph = as_graph(original_klass, false)
 
-      if id.is_a?(Array)
-        id.each do |i|
-          where_graph << [RDF::URI("#{self.class.graph_name}#{self.name.tableize}/#{i}"), :p, :o]
+        where_graph = RDF::Graph.new(graph_name: RDF::URI("#{self.class.graph_name}#{self.name.tableize}/#{id}"), data: RDF::Repository.new)
+
+        if id.is_a?(Array)
+          id.each do |i|
+            where_graph << [RDF::URI("#{self.class.graph_name}#{self.name.tableize}/#{i}"), :p, :o]
+          end
+        else
+          where_graph << [RDF::URI("#{self.class.graph_name}#{self.name.tableize}/#{id}"), :p, :o]
         end
-      else
-        where_graph << [RDF::URI("#{self.class.graph_name}#{self.name.tableize}/#{id}"), :p, :o]
-      end
 
-      insert_graph = as_graph(updated_klass, true)
+        insert_graph = as_graph(updated_klass, true)
 
-      puts delete_graph.dump(:ttl) #if ConfigFile[:debug]
-      puts insert_graph.dump(:ttl) #if ConfigFile[:debug]
-      puts where_graph.dump(:ttl) #if ConfigFile[:debug]
+        # puts delete_graph.dump(:ttl) #if ConfigFile[:debug]
+        # puts insert_graph.dump(:ttl) #if ConfigFile[:debug]
+        # puts where_graph.dump(:ttl) #if ConfigFile[:debug]
 
-      #if ConfigFile[:debug]
-      delete_insert_query = SPARQL::Client::Update::DeleteInsert.new(delete_graph, insert_graph, where_graph, graph: insert_graph.name).to_s
-      delete_insert_query.gsub!('_:p', '?p')
-      puts delete_insert_query
-      data = sparql.query(delete_insert_query)
-      #pp data
-      #end
+        # if ConfigFile[:debug]
+        delete_insert_query = SPARQL::Client::Update::DeleteInsert.new(delete_graph, insert_graph, where_graph, graph: insert_graph.name).to_s
+        delete_insert_query.gsub!('_:p', '?p')
+        # puts delete_insert_query
+        data = sparql.query(delete_insert_query)
+        # pp data
+        # end
 
-      #      sparql.delete_insert(delete_graph, insert_graph, where_graph, graph: insert_graph.name)
+        #      sparql.delete_insert(delete_graph, insert_graph, where_graph, graph: insert_graph.name)
 
-      data = self.query.filter({ filters: { id: [id] } }).find_all.map { |m| m }&.first
-      if data.nil?
-        sparql.insert_data(insert_graph, graph: insert_graph.name)
         data = self.query.filter({ filters: { id: [id] } }).find_all.map { |m| m }&.first
+        if data.nil?
+          sparql.insert_data(insert_graph, graph: insert_graph.name)
+          data = self.query.filter({ filters: { id: [id] } }).find_all.map { |m| m }&.first
+        end
       end
-
       after_update_proc&.call(updated_klass, data)
+
       data
     rescue StandardError => e
       original_graph = as_graph(original_klass, false)
@@ -386,7 +509,7 @@ values ?s {<#{self.graph_id}>}
 
       graph << [id, RDF::RDFV.type, klass_metadata[:target_class]]
 
-      #load existing object and overwrite
+      # load existing object and overwrite
       original_klass = klass.query.filter({ filters: { id: [uuid] } }).find_all { |f| f.id == uuid }.first || nil
 
       if original_klass.nil?
@@ -411,11 +534,9 @@ values ?s {<#{self.graph_id}>}
     def make_graph(graph, hierarchy, id, klass, klass_metadata, resolve_all)
       klass_metadata[:attributes].each do |attribute, metadata|
         data = klass.instance_variable_get("@#{attribute}")
-
-        raise Solis::Error::InvalidAttributeError,
-              "#{hierarchy.join('.')}.#{attribute} min=#{metadata[:mincount]} and max=#{metadata[:maxcount]}" if data.nil? &&
-          metadata[:mincount] > 0 &&
-          graph.query(RDF::Query.new({ attribute.to_sym => { RDF.type => metadata[:node] } })).size == 0
+        if data.nil? && metadata[:mincount] > 0 && graph.query(RDF::Query.new({ attribute.to_sym => { RDF.type => metadata[:node] } })).size == 0
+          raise Solis::Error::InvalidAttributeError, "#{hierarchy.join('.')}.#{attribute} min=#{metadata[:mincount]} and max=#{metadata[:maxcount]}"
+        end
 
         # skip if nil or an object that is empty
         next if data.nil? || ([Hash, Array, String].include?(data.class) && data&.empty?)
@@ -427,7 +548,7 @@ values ?s {<#{self.graph_id}>}
           data = data.to_json
         end
 
-        #make it an object
+        # make it an object
         unless metadata[:node_kind].nil?
           model = self.class.graph.shape_as_model(metadata[:datatype].to_s)
           if data.is_a?(Hash)
@@ -449,7 +570,7 @@ values ?s {<#{self.graph_id}>}
               internal_resolve = false
               d = build_ttl_objekt2(graph, d, hierarchy, internal_resolve)
             else
-              #d = "#{klass.class.graph_name}#{attribute.tableize}/#{d.id}"
+              # d = "#{klass.class.graph_name}#{attribute.tableize}/#{d.id}"
               d = "#{klass.class.graph_name}#{d.name.tableize}/#{d.id}"
             end
           elsif defined?(d.name) && self.class.graph.shape?(d.name)
@@ -554,7 +675,7 @@ values ?s {<#{self.graph_id}>}
           end
 
           if model && d.is_a?(Hash)
-            #TODO: figure out in what use case we need the parent_model
+            # TODO: figure out in what use case we need the parent_model
             # model_instance = if parent_model
             #                     parent_model.new(d)
             #                  else
@@ -606,7 +727,7 @@ values ?s {<#{self.graph_id}>}
       id
     end
 
-    def self.properties_to_hash(model)
+    def properties_to_hash(model)
       n = {}
       model.class.metadata[:attributes].each_key do |m|
         if model.instance_variable_get("@#{m}").is_a?(Array)

data/lib/solis/query.rb

@@ -191,11 +191,11 @@ order by ?s
       from_cache = Graphiti.context[:object]&.from_cache || '0'
       if @query_cache.key?(query_key) && from_cache.eql?('1')
         result = @query_cache[query_key]
-        Solis::LOGGER.info("CACHE: from #{query_key}")# if ConfigFile[:debug]
+        Solis::LOGGER.info("CACHE: from #{query_key}") if ConfigFile[:debug]
       else
         result = graph_to_object(sparql_client.query(query))
         @query_cache[query_key] = result unless result.nil? || result.empty?
-        Solis::LOGGER.info("CACHE: to #{query_key}")# if ConfigFile[:debug]
+        Solis::LOGGER.info("CACHE: to #{query_key}") if ConfigFile[:debug]
       end
 
       result

data/lib/solis/version.rb

@@ -1,3 +1,3 @@
 module Solis
-  VERSION = "0.72.0"
+  VERSION = "0.74.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solis
 version: !ruby/object:Gem::Version
-  version: 0.72.0
+  version: 0.74.0
 platform: ruby
 authors:
 - Mehmet Celik
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-28 00:00:00.000000000 Z
+date: 2024-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport