Class: Solis::Model

Inherits:
Object
  • Object
show all
Defined in:
lib/solis/model.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(attributes = {}) ⇒ Model

Returns a new instance of Model.



12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/solis/model.rb', line 12

def initialize(attributes = {})
  @model_name = self.class.name
  @model_plural_name = @model_name.pluralize
  @language = Graphiti.context[:object]&.language || Solis::Options.instance.get[:language] || 'en'

  raise "Please look at /#{@model_name.tableize}/model for structure to supply" if attributes.nil?

  attributes.each do |attribute, value|
    if self.class.metadata[:attributes].keys.include?(attribute.to_s)
      if !self.class.metadata[:attributes][attribute.to_s][:node_kind].nil? && !(value.is_a?(Hash) || value.is_a?(Array) || value.class.ancestors.include?(Solis::Model))
        raise Solis::Error::InvalidAttributeError, "'#{@model_name}.#{attribute}' must be an object"
      end

      if self.class.metadata[:attributes][attribute.to_s][:node_kind].is_a?(RDF::URI) && value.is_a?(Hash)
        inner_class = self.class.metadata[:attributes][attribute.to_s][:datatype].to_s
        inner_model = self.class.graph.shape_as_model(inner_class)

        if value.key?('id') && value['id'].match?(self.class.graph_name)
          inner_class = value['id'].gsub(self.class.graph_name, '').split('/').first.classify.to_s
          if inner_model.descendants.map(&:to_s).include?(inner_class)
            inner_model = self.class.graph.shape_as_model(inner_class)
          end
        end

        value = inner_model.new(value)
      elsif self.class.metadata[:attributes][attribute.to_s][:node_kind].is_a?(RDF::URI) && value.is_a?(Array)
        new_value = []
        value.each do |v|
          if v.is_a?(Hash)
            inner_model = self.class.graph.shape_as_model(self.class.metadata[:attributes][attribute.to_s][:datatype].to_s)
            new_value << inner_model.new(v)
          else
            new_value << v
          end
        end
        value = new_value
      end

      # switched off. currently language query parameters returns the value
      # value = {
      #   "@language" => @language,
      #   "@value" => value
      # } if self.class.metadata[:attributes][attribute.to_s][:datatype_rdf].eql?('http://www.w3.org/1999/02/22-rdf-syntax-ns#langString')

      value = value.first if value.is_a?(Array) && (attribute.eql?('id') || attribute.eql?(:id))

      instance_variable_set("@#{attribute}", value)
    else
      raise Solis::Error::InvalidAttributeError, "'#{attribute}' is not part of the definition of #{@model_name}"
    end
  end

  self.class.make_id_for(self)
rescue StandardError => e
  Solis::LOGGER.error(e.message)
  raise Solis::Error::GeneralError, "Unable to create entity #{@model_name}"
end

Class Method Details

.batch_exists?(sparql, entities) ⇒ Boolean

Check existence of multiple entities in a single SPARQL query Returns a Set of graph_ids that exist

Returns:

  • (Boolean) 


471
472
473
474
475
476
477
478
479
480
 
# File 'lib/solis/model.rb', line 471

def self.batch_exists?(sparql, entities)
  return Set.new if entities.empty?
  return Set.new([entities.first.graph_id]) if entities.size == 1 && entities.first.exists?(sparql)
  return Set.new if entities.size == 1

  values = entities.map { |e| "<#{e.graph_id}>" }.join(' ')
  query = "SELECT DISTINCT ?s WHERE { VALUES ?s { #{values} } . ?s ?p ?o }"
  results = sparql.query(query)
  Set.new(results.map { |r| r[:s].to_s })
end

.batch_save(entities, validate_dependencies: true, batch_size: 100) ⇒ Array<Solis::Model>

Save multiple entities in a single SPARQL INSERT operation. Entities that already exist are updated individually.

Parameters:

  • entities (Array<Solis::Model>) —

    entities to save

  • validate_dependencies (Boolean) (defaults to: true) —

    whether to validate dependencies

  • batch_size (Integer) (defaults to: 100) —

    max entities per INSERT (default 100)

Returns:



419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
 
# File 'lib/solis/model.rb', line 419

def self.batch_save(entities, validate_dependencies: true, batch_size: 100)
  raise "I need a SPARQL endpoint" if sparql_endpoint.nil?
  return [] if entities.empty?

  sparql = SPARQL::Client.new(sparql_endpoint)

  # Batch check existence of all entities
  existing_ids = batch_exists?(sparql, entities)

  to_create = []
  to_update = []

  entities.each do |entity|
    if existing_ids.include?(entity.graph_id)
      to_update << entity
    else
      to_create << entity
    end
  end

  # Batch insert: combine new entity graphs into single INSERT DATA operations
  unless to_create.empty?
    to_create.each_slice(batch_size) do |batch|
      combined_graph = RDF::Graph.new
      combined_graph.name = RDF::URI(graph_name)
      visited = Set.new

      batch.each do |entity|
        entity.before_create_proc&.call(entity)
        entity.send(:serialize_entity, combined_graph, entity, true, visited, [])
      end

      sparql.insert_data(combined_graph, graph: combined_graph.name)

      batch.each { |entity| entity.after_create_proc&.call(entity) }
    end

    # Invalidate cache once for the entity type
    Solis::Query.invalidate_cache_for(name)
  end

  # Updates still processed individually (DELETE/INSERT requires per-entity WHERE)
  to_update.each do |entity|
    data = entity.send(:properties_to_hash, entity)
    entity.update(data, validate_dependencies, true, sparql)
  end

  entities
end

.construct(level = 0) ⇒ Object 



593
594
595
 
# File 'lib/solis/model.rb', line 593

def self.construct(level = 0)
  raise 'to be implemented'
end

.graph ⇒ Object 



539
540
541
 
# File 'lib/solis/model.rb', line 539

def self.graph
  @graph
end

.graph=(graph) ⇒ Object 



543
544
545
 
# File 'lib/solis/model.rb', line 543

def self.graph=(graph)
  @graph = graph
end

.graph_name ⇒ Object 



515
516
517
 
# File 'lib/solis/model.rb', line 515

def self.graph_name
  @graph_name
end

.graph_name=(graph_name) ⇒ Object 



519
520
521
 
# File 'lib/solis/model.rb', line 519

def self.graph_name=(graph_name)
  @graph_name = graph_name
end

.graph_prefix ⇒ Object 



527
528
529
 
# File 'lib/solis/model.rb', line 527

def self.graph_prefix
  @graph_prefix
end

.graph_prefix=(graph_prefix) ⇒ Object 



523
524
525
 
# File 'lib/solis/model.rb', line 523

def self.graph_prefix=(graph_prefix)
  @graph_prefix = graph_prefix
end

.language ⇒ Object 



547
548
549
 
# File 'lib/solis/model.rb', line 547

def self.language
  Graphiti.context[:object]&.language || Solis::Options.instance.get[:language] || @language || 'en'
end

.language=(language) ⇒ Object 



551
552
553
 
# File 'lib/solis/model.rb', line 551

def self.language=(language)
  @language = language
end

.make_id_for(model) ⇒ Object 



482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
 
# File 'lib/solis/model.rb', line 482

def self.make_id_for(model)
  id = model.instance_variable_get("@id")
  if id.nil? || (id.is_a?(String) && id&.empty?)
    id = SecureRandom.uuid
    LOGGER.info("ID(#{id}) generated for #{self.name}") if ConfigFile[:debug]
    model.instance_variable_set("@id", id)
  elsif id.to_s =~ /^https?:\/\//
    id = id.to_s.split('/').last
    LOGGER.info("ID(#{id}) normalised for #{self.name}") if ConfigFile[:debug]
    model.instance_variable_set("@id", id)
  end
  model
rescue StandardError => e
  Solis::LOGGER.error(e.message)
  raise Solis::Error::GeneralError, "Error generating id for #{self.name}"
end

.metadata ⇒ Object 



499
500
501
 
# File 'lib/solis/model.rb', line 499

def self.metadata
  @metadata
end

.metadata=(m) ⇒ Object 



503
504
505
 
# File 'lib/solis/model.rb', line 503

def self.metadata=(m)
  @metadata = m
end

.model(level = 0) ⇒ Object 



555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
 
# File 'lib/solis/model.rb', line 555

def self.model(level = 0)
  m = { type: self.name.tableize, attributes: [] }
  self.metadata[:attributes].each do |attribute, attribute_metadata|
    if attribute_metadata.key?(:class) && !attribute_metadata[:class].nil? && attribute_metadata[:class].value =~ /#{self.graph_name}/ && level == 0
      cm = self.graph.shape_as_model(self.metadata[:attributes][attribute][:datatype].to_s).model(level + 1)
    end

    attribute_data = { name: attribute,
                       data_type: attribute_metadata[:datatype],
                       mandatory: (attribute_metadata[:mincount].to_i > 0),
                       repeatable: (attribute_metadata[:maxcount].to_i > 1 || attribute_metadata[:maxcount].nil?),
                       description: attribute_metadata[:comment]&.value
    }
    attribute_data[:order] = attribute_metadata[:order]&.value.to_i if attribute_metadata.key?(:order) && !attribute_metadata[:order].nil?
    attribute_data[:group] = attribute_metadata[:group]&.value.gsub(graph_name,'').gsub(/Group$/,'') if attribute_metadata.key?(:group) && !attribute_metadata[:group].nil?
    attribute_data[:attributes] = cm[:attributes] if cm && cm[:attributes]

    m[:attributes] << attribute_data
  end

  m
end

.model_after_create(&blk) ⇒ Object 



609
610
611
 
# File 'lib/solis/model.rb', line 609

def self.model_after_create(&blk)
  self.after_create_proc = blk
end

.model_after_delete(&blk) ⇒ Object 



625
626
627
 
# File 'lib/solis/model.rb', line 625

def self.model_after_delete(&blk)
  self.after_delete_proc = blk
end

.model_after_read(&blk) ⇒ Object 



601
602
603
 
# File 'lib/solis/model.rb', line 601

def self.model_after_read(&blk)
  self.after_read_proc = blk
end

.model_after_update(&blk) ⇒ Object 



617
618
619
 
# File 'lib/solis/model.rb', line 617

def self.model_after_update(&blk)
  self.after_update_proc = blk
end

.model_before_create(&blk) ⇒ Object 



605
606
607
 
# File 'lib/solis/model.rb', line 605

def self.model_before_create(&blk)
  self.before_create_proc = blk
end

.model_before_delete(&blk) ⇒ Object 



621
622
623
 
# File 'lib/solis/model.rb', line 621

def self.model_before_delete(&blk)
  self.before_delete_proc = blk
end

.model_before_read(&blk) ⇒ Object 



597
598
599
 
# File 'lib/solis/model.rb', line 597

def self.model_before_read(&blk)
  self.before_read_proc = blk
end

.model_before_update(&blk) ⇒ Object 



613
614
615
 
# File 'lib/solis/model.rb', line 613

def self.model_before_update(&blk)
  self.before_update_proc = blk
end

.model_template(level = 0) ⇒ Object 



578
579
580
581
582
583
584
585
586
587
588
589
590
591
 
# File 'lib/solis/model.rb', line 578

def self.model_template(level = 0)
  m = { type: self.name.tableize, attributes: {} }
  self.metadata[:attributes].each do |attribute, attribute_metadata|

    if attribute_metadata.key?(:class) && !attribute_metadata[:class].nil? && attribute_metadata[:class].value =~ /#{self.graph_name}/ && level == 0
      cm = self.graph.shape_as_model(self.metadata[:attributes][attribute][:datatype].to_s).model_template(level + 1)
      m[:attributes][attribute.to_sym] = cm[:attributes]
    else
      m[:attributes][attribute.to_sym] = ''
    end
  end

  m
end

.shapes ⇒ Object 



511
512
513
 
# File 'lib/solis/model.rb', line 511

def self.shapes
  @shapes
end

.shapes=(s) ⇒ Object 



507
508
509
 
# File 'lib/solis/model.rb', line 507

def self.shapes=(s)
  @shapes = s
end

.sparql_endpoint ⇒ Object 



531
532
533
 
# File 'lib/solis/model.rb', line 531

def self.sparql_endpoint
  @sparql_endpoint
end

.sparql_endpoint=(sparql_endpoint) ⇒ Object 



535
536
537
 
# File 'lib/solis/model.rb', line 535

def self.sparql_endpoint=(sparql_endpoint)
  @sparql_endpoint = sparql_endpoint
end

Instance Method Details

#destroy ⇒ Object

Raises:



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/solis/model.rb', line 118

def destroy
  raise "I need a SPARQL endpoint" if self.class.sparql_endpoint.nil?
  sparql = Solis::Store::Sparql::Client.new(self.class.sparql_endpoint)

  raise Solis::Error::QueryError, "#{self.id} is still referenced, refusing to delete" if is_referenced?(sparql)

  before_delete_proc&.call(self)

  query = %(
with <#{self.class.graph_name}>
delete {?s ?p ?o}
where {
values ?s {<#{self.graph_id}>}
?s ?p ?o }
  )
  result = sparql.query(query)

  if result.count > 0
    if result.first.bound?(result.variable_names.first) && result.first[result.variable_names.first].value =~ /done$/
      after_delete_proc&.call(self)
    else
      after_delete_proc&.call(result)
    end
  end

  # Invalidate cached queries for this entity type
  Solis::Query.invalidate_cache_for(self.class.name)

  result
end

#dump(format = :ttl, resolve_all = true) ⇒ Object 



94
95
96
97
 
# File 'lib/solis/model.rb', line 94

def dump(format = :ttl, resolve_all = true)
  graph = as_graph(self, deep: resolve_all)
  graph.dump(format)
end

#exists?(sparql) ⇒ Boolean

Returns:

  • (Boolean) 


409
410
411
 
# File 'lib/solis/model.rb', line 409

def exists?(sparql)
  sparql.query("ASK WHERE { <#{self.graph_id}> ?p ?o }")
end

#graph_id ⇒ Object 



401
402
403
 
# File 'lib/solis/model.rb', line 401

def graph_id
  "#{self.class.graph_name}#{tableized_class_name(self)}/#{self.id}"
end

#is_referenced?(sparql) ⇒ Boolean

Returns:

  • (Boolean) 


405
406
407
 
# File 'lib/solis/model.rb', line 405

def is_referenced?(sparql)
  sparql.query("ASK WHERE { ?s ?p <#{self.graph_id}>. filter (!contains(str(?s), 'audit') && !contains(str(?p), 'audit'))}")
end

#model_class_name(plural = false) ⇒ Object

Removed the ‘name’ instance method to avoid conflicts with ‘name’ attributes Use model_class_name instead, or access @model_name directly



72
73
74
75
76
77
78
 
# File 'lib/solis/model.rb', line 72

def model_class_name(plural = false)
  if plural
    @model_plural_name
  else
    @model_name
  end
end

#query ⇒ Object 



80
81
82
83
84
85
86
87
 
# File 'lib/solis/model.rb', line 80

def query
  raise "I need a SPARQL endpoint" if self.class.sparql_endpoint.nil?

  # before_read_proc&.call(self)
  result = Solis::Query.new(self)
  # after_read_proc&.call(result)
  result
end

#save(validate_dependencies = true, top_level = true) ⇒ Object 



149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
# File 'lib/solis/model.rb', line 149

def save(validate_dependencies = true, top_level = true)
  raise "I need a SPARQL endpoint" if self.class.sparql_endpoint.nil?
  sparql = SPARQL::Client.new(self.class.sparql_endpoint)

  before_create_proc&.call(self)

  if self.exists?(sparql)
    data = properties_to_hash(self)
    result = update(data, validate_dependencies, top_level, sparql)
  else
    readonly_list = (Solis::Options.instance.get[:embedded_readonly] || []).map(&:to_s)

    # Enumerate the whole in-memory tree: self plus every embedded descendant.
    all_entities = collect_known_entities(self).values
    existing_ids = self.class.batch_exists?(sparql, all_entities)

    # Classify each entity: new (insert), existing embedded (update), or readonly.
    # readonly only protects EMBEDDED entities; the entity being saved (self) is
    # always created even when its class is a code table.
    new_entities = []
    existing_embedded = []
    all_entities.each do |entity|
      entity_exists = existing_ids.include?(entity.graph_id)
      if !entity.equal?(self) && readonly_entity?(entity, readonly_list)
        Solis::LOGGER.warn("#{entity.class.name} (id: #{entity.id}) is readonly but does not exist in database. Skipping.") unless entity_exists
      elsif entity_exists
        existing_embedded << entity
      else
        new_entities << entity
      end
    end

    # Existing embedded entities are updated individually (each needs DELETE/INSERT).
    unless existing_embedded.empty?
      embedded_originals = batch_load_originals(existing_embedded)
      existing_embedded.each do |embedded|
        embedded.update(properties_to_hash(embedded), validate_dependencies, false, nil,
                        prefetched_original: embedded_originals[embedded.id])
      end
    end

    # Serialize self and every new embedded entity into one INSERT DATA operation.
    graph = RDF::Graph.new
    graph.name = RDF::URI(self.class.graph_name)
    visited = Set.new
    new_entities.each { |entity| serialize_entity(graph, entity, false, visited, []) }

    validate_graph(graph) if validate_dependencies

    Solis::LOGGER.info SPARQL::Client::Update::InsertData.new(graph, graph: graph.name).to_s if ConfigFile[:debug]

    result = sparql.insert_data(graph, graph: graph.name)
  end

  # Invalidate cached queries for this entity type
  Solis::Query.invalidate_cache_for(self.class.name)

  after_create_proc&.call(self)
  self
rescue StandardError => e
  Solis::LOGGER.error e.message
  raise e
end

#to_graph(resolve_all = true) ⇒ Object 



99
100
101
 
# File 'lib/solis/model.rb', line 99

def to_graph(resolve_all = true)
  as_graph(self, deep: resolve_all)
end

#to_ttl(resolve_all = true) ⇒ Object 



89
90
91
92
 
# File 'lib/solis/model.rb', line 89

def to_ttl(resolve_all = true)
  graph = as_graph(self, deep: resolve_all)
  graph.dump(:ttl)
end

#update(data, validate_dependencies = true, top_level = true, sparql_client = nil, patch: false, prefetched_original: nil) ⇒ Object

Update an entity.

Parameters:

  • data (Hash) —

    the attributes to update. Must include ‘id’.

  • validate_dependencies (Boolean) (defaults to: true) —

    whether to validate dependencies (default: true)

  • top_level (Boolean) (defaults to: true) —

    whether this is a top-level call (default: true)

  • sparql_client (SPARQL::Client, nil) (defaults to: nil) —

    optional reusable SPARQL client

  • patch (Boolean) (defaults to: false) —

    when true, uses PATCH semantics:

    • Only provided attributes are changed; omitted attributes are untouched

    • Embedded entity arrays are merged (new IDs added, existing IDs updated, missing IDs are kept as-is — not orphaned)

    • No orphan detection or deletion

    When false (default), uses PUT semantics:

    • Embedded entity arrays are fully replaced

    • Entities removed from the array are orphaned and deleted if unreferenced

  • prefetched_original (Solis::Model, nil) (defaults to: nil) —

    optional pre-fetched original entity to avoid re-querying



228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
 
# File 'lib/solis/model.rb', line 228

def update(data, validate_dependencies = true, top_level = true, sparql_client = nil, patch: false, prefetched_original: nil)
  raise Solis::Error::GeneralError, "I need a SPARQL endpoint" if self.class.sparql_endpoint.nil?

  attributes = data.include?('attributes') ? data['attributes'] : data
  raise "id is mandatory when updating" unless attributes.keys.include?('id')

  id = attributes.delete('id')
  sparql = sparql_client || SPARQL::Client.new(self.class.sparql_endpoint)

  # prefetched_original is used only when it is a complete entity; an id-only stub
  # cannot seed updated_klass (omitted mandatory attributes would be lost).
  original_klass = prefetched_original unless prefetched_original && shallow_stub?(prefetched_original)
  original_klass ||= load_original(id)
  raise Solis::Error::NotFoundError if original_klass.nil?
  updated_klass = original_klass.deep_dup

  # Cache readonly entities list once
  readonly_list = (Solis::Options.instance.get[:embedded_readonly] || []).map(&:to_s)

  # Track entities to potentially delete (only used in PUT mode)
  entities_to_check_for_deletion = {}

  # First pass: collect all embedded entities for batched existence check
  embedded_by_key = {}
  attributes.each_pair do |key, value|
    unless original_klass.class.metadata[:attributes][key][:node].nil?
      value = [value] unless value.is_a?(Array)
      embedded_by_key[key] = value.map do |sub_value|
        self.class.graph.shape_as_model(original_klass.class.metadata[:attributes][key][:datatype].to_s).new(sub_value)
      end
    end
  end

  all_embedded = embedded_by_key.values.flatten
  existing_ids = self.class.batch_exists?(sparql, all_embedded)

  # Batch-load full stored originals for embedded entities that already exist, so
  # each recursive embedded update receives a complete original (one query per class).
  existing_embedded = all_embedded.select do |e|
    existing_ids.include?(e.graph_id) && !readonly_entity?(e, readonly_list)
  end
  embedded_originals = batch_load_originals(existing_embedded)

  # Second pass: process embedded entities using batched results
  embedded_by_key.each do |key, embedded_list|
    value = attributes[key]
    value = [value] unless value.is_a?(Array)

    # Get original embedded entities for this attribute
    original_embedded = original_klass.instance_variable_get("@#{key}")
    original_embedded = [original_embedded] unless original_embedded.nil? || original_embedded.is_a?(Array)
    original_embedded ||= []

    # Track original IDs
    original_ids = original_embedded.map { |e| solis_model?(e) ? e.id : nil }.compact

    # Build new array of embedded entities
    new_embedded_values = []
    new_ids = []

    embedded_list.each do |embedded|
      new_ids << embedded.id if embedded.id
      entity_exists = existing_ids.include?(embedded.graph_id)

      if readonly_entity?(embedded, readonly_list)
        if entity_exists
          new_embedded_values << embedded
        else
          Solis::LOGGER.warn("#{embedded.class.name} (id: #{embedded.id}) is readonly but does not exist in database. Skipping.")
        end
      else
        if entity_exists
          embedded_data = properties_to_hash(embedded)
          embedded.update(embedded_data, validate_dependencies, false, nil, prefetched_original: embedded_originals[embedded.id])
          new_embedded_values << embedded
        else
          embedded_value = embedded.save(validate_dependencies, false)
          new_embedded_values << embedded_value
        end
      end
    end

    if patch
      # PATCH mode: merge new embedded entities into the original array.
      # Keep original entities that were not mentioned in the update data.
      unmentioned = original_embedded.select do |e|
        solis_model?(e) && !new_ids.include?(e.id)
      end
      merged_values = unmentioned + new_embedded_values
    else
      # PUT mode: replace the entire array; detect orphans for deletion
      merged_values = new_embedded_values

      orphaned_ids = original_ids - new_ids
      unless orphaned_ids.empty?
        orphaned_entities = original_embedded.select { |e| solis_model?(e) && orphaned_ids.include?(e.id) }
        entities_to_check_for_deletion[key] = orphaned_entities
      end
    end

    maxcount = original_klass.class.metadata[:attributes][key][:maxcount]
    embedded_value = maxcount && maxcount == 1 ? merged_values.first : merged_values
    updated_klass.instance_variable_set("@#{key}", embedded_value)
  end

  # Process non-embedded attributes
  attributes.each_pair do |key, value|
    next unless original_klass.class.metadata[:attributes][key][:node].nil?

    updated_klass.instance_variable_set("@#{key}", value)
  end

  before_update_proc&.call(original_klass, updated_klass)

  properties_original_klass = properties_to_hash(original_klass)
  properties_updated_klass = properties_to_hash(updated_klass)

  if Hashdiff.best_diff(properties_original_klass, properties_updated_klass).empty?
    Solis::LOGGER.info("#{original_klass.class.name} unchanged, skipping")
    data = original_klass
  else
    # The delete graph carries the stored original's triples; the insert graph the
    # updated entity's. Embedded children are emitted as URI references in both —
    # they are persisted by their own recursive update/save above.
    delete_graph = as_graph(original_klass, deep: false)
    insert_graph = as_graph(updated_klass, deep: false)
    where_graph = RDF::Graph.new(graph_name: RDF::URI("#{self.class.graph_name}#{tableized_class_name(self)}/#{id}"), data: RDF::Repository.new)

    if id.is_a?(Array)
      id.each do |i|
        where_graph << [RDF::URI("#{self.class.graph_name}#{tableized_class_name(self)}/#{i}"), :p, :o]
      end
    else
      where_graph << [RDF::URI("#{self.class.graph_name}#{tableized_class_name(self)}/#{id}"), :p, :o]
    end

    validate_graph(insert_graph) if validate_dependencies

    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')

    sparql.query(delete_insert_query)

    # Invalidate cache before verification to avoid stale reads
    Solis::Query.invalidate_cache_for(self.class.name)

    # Verify the update succeeded by re-fetching; fallback to insert if needed
    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 = updated_klass
    end

    # Delete orphaned entities after successful update (PUT mode only)
    delete_orphaned_entities(entities_to_check_for_deletion, sparql) unless patch
  end

  # Invalidate cached queries for this entity type
  Solis::Query.invalidate_cache_for(self.class.name)

  after_update_proc&.call(updated_klass, data)

  data
rescue StandardError => e
  original_graph = as_graph(original_klass, deep: false) if defined?(original_klass) && original_klass
  Solis::LOGGER.error(e.message)
  Solis::LOGGER.error original_graph.dump(:ttl) if defined?(original_graph) && original_graph
  Solis::LOGGER.error delete_insert_query if defined?(delete_insert_query)
  sparql.insert_data(original_graph, graph: original_graph.name) if defined?(original_graph) && original_graph && defined?(sparql) && sparql

  raise e
end

#valid? ⇒ Boolean

Returns:

  • (Boolean) 


103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/solis/model.rb', line 103

def valid?
  begin
    graph = as_graph(self)
  rescue Solis::Error::InvalidAttributeError => e
    Solis::LOGGER.error(e.message)
  end

  shacl = SHACL.get_shapes(self.class.graph.instance_variable_get(:"@graph"))
  report = shacl.execute(graph)

  report.conform?
rescue StandardError => e
  false
end