etna 0.1.33 → 0.1.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49dacbad5431a0004c77536e600b8f46ee544effb472a459cd9205cb6d3d0aed
-  data.tar.gz: 669d95414188d35adcff630545dde4d49caa43c064a7db3cfc19bf81fba6eff8
+  metadata.gz: ccfc9ac71071c9d8a8307849c585a388e983a4d5a44ca644f63a0501d7c758b6
+  data.tar.gz: ae4b4fb56594d585c9a5cc8267edac39af8718efb5f33b57e59b75e61ad38d5d
 SHA512:
-  metadata.gz: d1089f55be44686e14264f9b0df51b926a1ad758d40944010ca4fee40e69ced8d6be1cdaf452dc9ea6e05ab0fb099b597b6c4746f2bee400b090be4ec7a9ec56
-  data.tar.gz: d28be042a1210b12472a39502fa3ae8164ff4cd0ee3a2e0b552fb2f520ff5863d15cf88e7d66b9776aa6c7ecd54e1795e3527a16bdb5f7e6f860b944a87a20eb
+  metadata.gz: b146fcb1b3484943d63a6a365127b968738601816a566730e9292e2a73ae7c4e855042c0d7522c3ff896dbc3ab6aa817eb7edc6a5e8af12a4ffd1011da13d2bc
+  data.tar.gz: 1d29823e63c48b159e980ee05349505b8a43271a1593a6084771b22952b4efa919ba2d285e70140e24fde29bbdb6ca5e8c216144e8e15810a622acd6960561f7

data/lib/etna/clients/magma/formatting/models_csv.rb

@@ -138,7 +138,7 @@ module Etna
                 attribute_type: attribute.attribute_type,
                 link_model_name: attribute.link_model_name,
                 reciprocal_link_type: models.find_reciprocal(model: model, attribute: attribute)&.attribute_type,
-                description: attribute.desc,
+                description: attribute.description,
                 display_name: attribute.display_name,
                 match: attribute.match,
                 format_hint: attribute.format_hint,
@@ -175,7 +175,7 @@ module Etna
           # This should line up with the attribute names _on the model itself_.
           ATTRIBUTE_ROW_ENTRIES = [
               :attribute_type,
-              :link_model_name, :desc,
+              :link_model_name, :description,
               :display_name, :format_hint,
               :restricted, :read_only,
               :validation, :attribute_group,
@@ -188,7 +188,6 @@ module Etna
 
           def format_row(row)
             replace_row_column(row, :attribute_type) { |s| AttributeType.new(s) }
-            replace_row_column(row, :desc) { row.delete(:description) }
             replace_row_column(row, :restricted, &COLUMN_AS_BOOLEAN)
             replace_row_column(row, :read_only, &COLUMN_AS_BOOLEAN)
             replace_row_column(row, :options) { |s| {"type" => "Array", "value" => s.split(',').map(&:strip)} }
@@ -250,7 +249,7 @@ module Etna
                 parent_att.name = parent_att.attribute_name = parent_model_name
                 parent_att.attribute_type = Etna::Clients::Magma::AttributeType::PARENT
                 parent_att.link_model_name = parent_model_name
-                parent_att.desc = prettify(parent_model_name)
+                parent_att.description = prettify(parent_model_name)
                 parent_att.display_name = prettify(parent_model_name)
               end
             end
@@ -275,7 +274,7 @@ module Etna
                   attr.attribute_name = attr.name = template.name
                   attr.attribute_type = parent_link_type
                   attr.link_model_name = template.name
-                  attr.desc = prettify(template.name)
+                  attr.description = prettify(template.name)
                   attr.display_name = prettify(template.name)
                 end
               end
@@ -338,7 +337,7 @@ module Etna
                     models.build_model(att.link_model_name).build_template.build_attributes.build_attribute(template.name).tap do |rec_att|
                       rec_att.attribute_name = rec_att.name = template.name
                       rec_att.display_name = prettify(template.name)
-                      rec_att.desc = prettify(template.name)
+                      rec_att.description = prettify(template.name)
                       rec_att.attribute_type = Etna::Clients::Magma::AttributeType::COLLECTION
                       rec_att.link_model_name = template.name
                     end

data/lib/etna/clients/magma/formatting/models_odm_xml.rb

@@ -246,7 +246,7 @@ module Etna
               }
 
               params['redcap:TextValidationType'] = redcap_text_validation_map[attribute_type] if redcap_text_validation_map[attribute_type]
-              params['redcap:FieldNote'] = attribute.desc if attribute.desc
+              params['redcap:FieldNote'] = attribute.description if attribute.description
               xml.ItemDef(params) do
                 xml.Question do
                   xml.send('TranslatedText', attribute_name.capitalize)

data/lib/etna/clients/magma/models.rb

@@ -10,7 +10,7 @@ require_relative '../base_client'
 module Etna
   module Clients
     class Magma < Etna::Clients::BaseClient
-      class RetrievalRequest < Struct.new(:model_name, :attribute_names, :record_names, :project_name, :page, :page_size, :order, :filter, keyword_init: true)
+      class RetrievalRequest < Struct.new(:model_name, :attribute_names, :record_names, :project_name, :page, :page_size, :order, :filter, :hide_templates, keyword_init: true)
         include JsonSerializableStruct
 
         def initialize(**params)
@@ -18,7 +18,7 @@ module Etna
         end
       end
 
-      class QueryRequest < Struct.new(:query, :project_name, keyword_init: true)
+      class QueryRequest < Struct.new(:query, :project_name, :order, :page, :page_size, keyword_init: true)
         include JsonSerializableStruct
       end
 
@@ -117,14 +117,6 @@ module Etna
           super({action_name: 'update_attribute'}.update(args))
         end
 
-        def desc=(val)
-          self.description = val
-        end
-
-        def desc
-          self.description
-        end
-
         def as_json
           super(keep_nils: true)
         end
@@ -454,6 +446,16 @@ module Etna
           @raw = raw
         end
 
+        def is_edited?(other)
+          # Don't just override == in case need to do a full comparison.
+          editable_attribute_names = Attribute::EDITABLE_ATTRIBUTE_ATTRIBUTES.map(&:to_s)
+          
+          self_editable = raw.slice(*editable_attribute_names)
+          other_editable = other.raw.slice(*editable_attribute_names)
+
+          self_editable != other_editable
+        end
+
         # Sets certain attribute fields which are implicit, even when not set, to match server behavior.
         def set_field_defaults!
           @raw.replace({
@@ -511,24 +513,12 @@ module Etna
           raw['unique'] = val
         end
 
-        def desc
-          raw['desc']
-        end
-
-        def desc=(val)
-          @raw['desc'] = val
-        end
-
-        # description and description= are needed
-        #   to make UpdateAttribute actions
-        #   work in the model_synchronization_workflow for
-        #   desc.
         def description
-          raw['desc']
+          raw['description']
         end
 
         def description=(val)
-          @raw['desc'] = val
+          @raw['description'] = val
         end
 
         def display_name
@@ -595,11 +585,8 @@ module Etna
           raw['options']
         end
 
-        # NOTE!  The Attribute class returns description as desc, where as actions take it in as description.
-        # There are shortcut methods that try to handle this on the action class side of things.  Ideally we would
-        # make this more consistent in the near future.
         COPYABLE_ATTRIBUTE_ATTRIBUTES = [
-            :attribute_name, :attribute_type, :desc, :display_name, :format_hint,
+            :attribute_name, :attribute_type, :display_name, :format_hint,
             :hidden, :link_model_name, :read_only, :attribute_group, :unique, :validation,
             :restricted, :description
         ]

data/lib/etna/clients/magma/workflows/model_synchronization_workflow.rb

@@ -190,10 +190,7 @@ module Etna
             source_attribute = Attribute.new(source_attribute.raw)
             source_attribute.set_field_defaults!
 
-            source_editable = source_attribute.raw.slice(*Attribute::EDITABLE_ATTRIBUTE_ATTRIBUTES.map(&:to_s))
-            target_editable = target_attribute.raw.slice(*Attribute::EDITABLE_ATTRIBUTE_ATTRIBUTES.map(&:to_s))
-
-            if source_editable == target_editable
+            if !source_attribute.is_edited?(target_attribute)
               return
             end
 

data/lib/etna/clients/magma/workflows/walk_model_tree_workflow.rb

@@ -12,14 +12,37 @@ module Etna
           @template_for = {}
         end
 
+        def all_attributes(template:)
+          template.attributes.attribute_keys
+        end
+
+        def safe_group_attributes(template:, attributes_mask:)
+          result = []
+
+          template.attributes.attribute_keys.each do |attribute_name|
+            next if template.attributes.attribute(attribute_name).attribute_type == Etna::Clients::Magma::AttributeType::TABLE
+            result << attribute_name if attribute_included?(attributes_mask, attribute_name)
+          end
+
+          result
+        end
+
         def masked_attributes(template:, model_attributes_mask:, model_name:)
           attributes_mask = model_attributes_mask[model_name]
-          return ["all", "all"] if attributes_mask.nil?
-          [(attributes_mask + [template.identifier, 'parent']).uniq, attributes_mask]
+
+          if attributes_mask.nil?
+            return [
+              safe_group_attributes(template: template, attributes_mask: attributes_mask),
+              all_attributes(template: template)
+            ]
+          end
+
+          [(safe_group_attributes(template: template, attributes_mask: attributes_mask) + [template.identifier, 'parent']).uniq,
+            attributes_mask]
         end
 
         def attribute_included?(mask, attribute_name)
-          return true if mask == "all"
+          return true if mask.nil?
           mask.include?(attribute_name)
         end
 
@@ -48,7 +71,11 @@ module Etna
             seen.add([path[:from], model_name])
 
             template = template_for(model_name)
-            query_attributes, walk_attributes = masked_attributes(template: template, model_attributes_mask: model_attributes_mask, model_name: model_name)
+            query_attributes, walk_attributes = masked_attributes(
+              template: template,
+              model_attributes_mask: model_attributes_mask,
+              model_name: model_name
+            )
 
             request = RetrievalRequest.new(
                 project_name: magma_crud.project_name,
@@ -62,6 +89,7 @@ module Etna
             related_models = {}
 
             magma_crud.page_records(model_name, request) do |response|
+              logger&.info("Fetched page of #{model_name}")
               tables = []
               collections = []
               links = []
@@ -70,13 +98,15 @@ module Etna
               model = response.models.model(model_name)
 
               template.attributes.attribute_keys.each do |attr_name|
+                attr = template.attributes.attribute(attr_name)
+                if attr.attribute_type == AttributeType::TABLE && attribute_included?(walk_attributes, attr_name)
+                  tables << attr_name
+                end
+
                 next unless attribute_included?(query_attributes, attr_name)
                 attributes << attr_name
 
-                attr = template.attributes.attribute(attr_name)
-                if attr.attribute_type == AttributeType::TABLE
-                  tables << attr_name
-                elsif attr.attribute_type == AttributeType::COLLECTION
+                if attr.attribute_type == AttributeType::COLLECTION
                   related_models[attr.link_model_name] ||= Set.new
                   collections << attr_name
                 elsif attr.attribute_type == AttributeType::LINK
@@ -91,14 +121,32 @@ module Etna
                 end
               end
 
+              table_data = {}
+              # Request tables in an inner chunk.
+              tables.each do |table_attr|
+                request = RetrievalRequest.new(
+                  project_name: magma_crud.project_name,
+                  model_name: model_name,
+                  record_names: model.documents.document_keys,
+                  attribute_names: [table_attr],
+                )
+
+                logger&.info("Fetching inner table #{table_attr}...")
+
+                table_response = magma_crud.magma_client.retrieve(request)
+                d = table_response.models.model(model_name).documents
+                table_d = table_response.models.model(table_attr).documents
+                table_data[table_attr] = d.document_keys.map do |id|
+                  [id, d.document(id)[table_attr].map { |tid| table_d.document(tid) }]
+                end.to_h
+              end
+
               model.documents.document_keys.each do |key|
                 record = model.documents.document(key).slice(*attributes)
 
                 # Inline tables inside the record
                 tables.each do |table_attr|
-                  record[table_attr] = record[table_attr].map do |id|
-                    response.models.model(template.attributes.attribute(table_attr).link_model_name).documents.document(id)
-                  end unless record[table_attr].nil?
+                  record[table_attr] = table_data[table_attr][key] unless table_data[table_attr].nil?
                 end
 
                 collections.each do |collection_attr|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: etna
 version: !ruby/object:Gem::Version
-  version: 0.1.33
+  version: 0.1.34
 platform: ruby
 authors:
 - Saurabh Asthana
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-08 00:00:00.000000000 Z
+date: 2021-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -201,7 +201,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6.2
+rubygems_version: 2.7.6.3
 signing_key: 
 specification_version: 4
 summary: Base classes for Mount Etna applications