gooddata 0.6.16 → 0.6.17

data/lib/gooddata/models/to_wire.rb

@@ -18,7 +18,8 @@ module GoodData
           {
             attribute: {
               identifier: GoodData::Model.identifier_for(dataset, type: :anchor_no_label),
-              title: "Records of #{ GoodData::Model.title(dataset) }"
+              title: "Records of #{ GoodData::Model.title(dataset) }",
+              folder: dataset[:folder] || GoodData::Model.title(dataset)
             }
           }
         end
@@ -43,10 +44,11 @@ module GoodData
       def self.attribute_to_wire(dataset, attribute)
         default_label = DatasetBlueprint.default_label_for_attribute(dataset, attribute)
         label = default_label[:type].to_sym == :label ? default_label : default_label.merge(type: :primary_label)
-        {
+        payload = {
           attribute: {
             identifier: GoodData::Model.identifier_for(dataset, attribute),
             title: GoodData::Model.title(attribute),
+            folder: attribute[:folder] || dataset[:folder] || GoodData::Model.title(dataset),
             labels: ([attribute.merge(type: :primary_label)] + DatasetBlueprint.labels_for_attribute(dataset, attribute)).map do |l|
               {
                 label: {
@@ -60,6 +62,9 @@ module GoodData
             defaultLabel: GoodData::Model.identifier_for(dataset, label, attribute)
           }
         }
+        payload.tap do |p|
+          p[:attribute][:description] = GoodData::Model.description(attribute) if GoodData::Model.description(attribute)
+        end
       end
 
       # Converts dataset to wire format.
@@ -100,13 +105,17 @@ module GoodData
       # @param fact [Hash] Fact blueprint
       # @return [Hash] Manifest for a particular reference
       def self.fact_to_wire(dataset, fact)
-        {
+        payload = {
           fact: {
             identifier: GoodData::Model.identifier_for(dataset, fact),
             title: GoodData::Model.title(fact),
+            folder: fact[:folder] || dataset[:folder] || GoodData::Model.title(dataset),
             dataType: fact[:gd_data_type] || DEFAULT_FACT_DATATYPE
           }
         }
+        payload.tap do |p|
+          p[:fact][:description] = GoodData::Model.description(fact) if GoodData::Model.description(fact)
+        end
       end
 
       # Converts references to wire format.

data/lib/gooddata/models/user_filters/user_filter_builder.rb

@@ -1,5 +1,8 @@
 # encoding: UTF-8
 
+require_relative 'user_filter_builder_create'
+require_relative 'user_filter_builder_execute'
+
 module GoodData
   module UserFilterBuilder
     # Main Entry function. Gets values and processes them to get filters
@@ -119,116 +122,6 @@ module GoodData
       end
     end
 
-    def self.create_label_cache(result, options = {})
-      project = options[:project]
-
-      result.reduce({}) do |a, e|
-        e[:filters].map do |filter|
-          a[filter[:label]] = project.labels(filter[:label]) unless a.key?(filter[:label])
-        end
-        a
-      end
-    end
-
-    def self.create_lookups_cache(small_labels)
-      small_labels.reduce({}) do |a, e|
-        lookup = e.values(:limit => 1_000_000).reduce({}) do |a1, e1|
-          a1[e1[:value]] = e1[:uri]
-          a1
-        end
-        a[e.uri] = lookup
-        a
-      end
-    end
-
-    # Walks over provided labels and picks those that have fewer than certain amount of values
-    # This tries to balance for speed when working with small datasets (like users)
-    # so it precaches the values and still be able to function for larger ones even
-    # though that would mean tons of requests
-    def self.get_small_labels(labels_cache)
-      labels_cache.values.select { |label| label.values_count < 100_000 }
-    end
-
-    # Creates a MAQL expression(s) based on the filter defintion.
-    # Takes the filter definition looks up any necessary values and provides API executable MAQL
-    def self.create_expression(filter, labels_cache, lookups_cache, options = {})
-      errors = []
-      values = filter[:values]
-      label = labels_cache[filter[:label]]
-      element_uris = values.map do |v|
-        begin
-          if lookups_cache.key?(label.uri)
-            if lookups_cache[label.uri].key?(v)
-              lookups_cache[label.uri][v]
-            else
-              fail
-            end
-          else
-            label.find_value_uri(v)
-          end
-        rescue
-          errors << [label.title, v]
-          nil
-        end
-      end
-      expression = if element_uris.compact.empty? && options[:restrict_if_missing_all_values] && options[:type] == :muf
-                     '1 <> 1'
-                   elsif element_uris.compact.empty? && options[:restrict_if_missing_all_values] && options[:type] == :variable
-                     nil
-                   elsif element_uris.compact.empty?
-                     'TRUE'
-                   elsif filter[:over] && filter[:to]
-                     "([#{label.attribute_uri}] IN (#{ element_uris.compact.sort.map { |e| '[' + e + ']' }.join(', ') })) OVER [#{filter[:over]}] TO [#{filter[:to]}]"
-                   else
-                     "[#{label.attribute_uri}] IN (#{ element_uris.compact.sort.map { |e| '[' + e + ']' }.join(', ') })"
-                   end
-      [expression, errors]
-    end
-
-    # Encapuslates the creation of filter
-    def self.create_user_filter(expression, related)
-      {
-        'related' => related,
-        'level' => :user,
-        'expression' => expression,
-        'type' => :filter
-      }
-    end
-
-    # Resolves and creates maql statements from filter definitions.
-    # This method does not perform any modifications on API but
-    # collects all the information that is needed to do so.
-    # Method collects all info from the user and current state in project and compares.
-    # Returns suggestion of what should be deleted and what should be created
-    # If there is some discrepancies in the data (missing values, nonexistent users) it
-    # finishes and collects all the errors at once
-    #
-    # @param filters [Array<Hash>] Filters definition
-    # @return [Array] first is list of MAQL statements
-    def self.maqlify_filters(filters, options = {})
-      project = options[:project]
-      users_cache = options[:users_cache] || create_cache(project.users, :login)
-      labels_cache = create_label_cache(filters, options)
-      small_labels = get_small_labels(labels_cache)
-      lookups_cache = create_lookups_cache(small_labels)
-
-      errors = []
-      results = filters.mapcat do |filter|
-        login = filter[:login]
-        filter[:filters].mapcat do |f|
-          expression, error = create_expression(f, labels_cache, lookups_cache, options)
-          errors << error unless error.empty?
-          profiles_uri = (users_cache[login] && users_cache[login].uri)
-          if profiles_uri && expression
-            [create_user_filter(expression, profiles_uri)]
-          else
-            []
-          end
-        end
-      end
-      [results, errors]
-    end
-
     def self.resolve_user_filter(user = [], project = [])
       user ||= []
       project ||= []
@@ -257,78 +150,6 @@ module GoodData
       [to_create, to_delete]
     end
 
-    # Executes the update for variables. It resolves what is new and needed to update.
-    # @param filters [Array<Hash>] Filter Definitions
-    # @param filters [Variable] Variable instance to be updated
-    # @param options [Hash]
-    # @option options [Boolean] :dry_run If dry run is true. No changes to he proejct are made but list of changes is provided
-    # @return [Array] list of filters that needs to be created and deleted
-    def self.execute_variables(filters, var, options = {})
-      client = options[:client]
-      project = options[:project]
-      dry_run = options[:dry_run]
-      to_create, to_delete = execute(filters, var.user_values, VariableUserFilter, options.merge(type: :variable))
-      return [to_create, to_delete] if dry_run
-
-      # TODO: get values that are about to be deleted and created and update them.
-      # This will make sure there is no downitme in filter existence
-      unless options[:do_not_touch_filters_that_are_not_mentioned]
-        to_delete.each { |_, group| group.each(&:delete) }
-      end
-      data = to_create.values.flatten.map(&:to_hash).map { |var_val| var_val.merge(prompt: var.uri) }
-      data.each_slice(200) do |slice|
-        client.post("/gdc/md/#{project.obj_id}/variables/user", :variables => slice)
-      end
-      [to_create, to_delete]
-    end
-
-    def self.execute_mufs(filters, options = {})
-      client = options[:client]
-      project = options[:project]
-
-      dry_run = options[:dry_run]
-      to_create, to_delete = execute(filters, project.data_permissions, MandatoryUserFilter, options.merge(type: :muf))
-      return [to_create, to_delete] if dry_run
-
-      to_create.peach do |related_uri, group|
-        group.each(&:save)
-
-        res = client.get("/gdc/md/#{project.pid}/userfilters?users=#{related_uri}")
-        items = res['userFilters']['items'].empty? ? [] : res['userFilters']['items'].first['userFilters']
-
-        payload = {
-          'userFilters' => {
-            'items' => [{
-              'user' => related_uri,
-              'userFilters' => items.concat(group.map(&:uri))
-            }]
-          }
-        }
-        client.post("/gdc/md/#{project.pid}/userfilters", payload)
-      end
-      unless options[:do_not_touch_filters_that_are_not_mentioned]
-        to_delete.peach do |related_uri, group|
-          if related_uri
-            res = client.get("/gdc/md/#{project.pid}/userfilters?users=#{related_uri}")
-            items = res['userFilters']['items'].empty? ? [] : res['userFilters']['items'].first['userFilters']
-            payload = {
-              'userFilters' => {
-                'items' => [
-                  {
-                    'user' => related_uri,
-                    'userFilters' => items - group.map(&:uri)
-                  }
-                ]
-              }
-            }
-            client.post("/gdc/md/#{project.pid}/userfilters", payload)
-          end
-          group.each(&:delete)
-        end
-      end
-      [to_create, to_delete]
-    end
-
     private
 
     # Reads values from File/Array. Abstracts away the fact if it is column based,
@@ -354,57 +175,5 @@ module GoodData
       end
       memo
     end
-
-    # Executes the procedure necessary for loading user filters. This method has what
-    # is common for both implementations. Funcion
-    #   * makes sure that filters are in normalized form.
-    #   * verifies that users are in the project (and domain)
-    #   * creates maql expressions of the filters provided
-    #   * resolves the filters against current values in the project
-    # @param user_filters [Array] Filters that user is trying to set up
-    # @param project_filters [Array] List of filters currently in the project
-    # @param klass [Class] Class can be aither UserFilter or VariableFilter
-    # @param options [Hash] Filter definitions
-    # @return [Array<Hash>]
-    def self.execute(user_filters, project_filters, klass, options = {})
-      client = options[:client]
-      project = options[:project]
-
-      ignore_missing_values = options[:ignore_missing_values]
-      users_must_exist = options[:users_must_exist] == false ? false : true
-      filters = normalize_filters(user_filters)
-      domain = options[:domain]
-      users = domain ? project.users + domain.users : project.users
-      users_cache = create_cache(users, :login)
-      verify_existing_users(filters, options.merge(users_must_exist: users_must_exist, users_cache: users_cache))
-      user_filters, errors = maqlify_filters(filters, options.merge(users_cache: users_cache, users_must_exist: users_must_exist))
-      fail "Validation failed #{errors}" if !ignore_missing_values && !errors.empty?
-
-      filters = user_filters.map { |data| client.create(klass, data, project: project) }
-      resolve_user_filters(filters, project_filters)
-    end
-
-    # Gets definition of filters from user. They might either come in the full definition
-    # as hash or a simplified version. The simplified version do not cover all the possible
-    # features but it is much simpler to remember and suitable for quick hacking around
-    # @param filters [Array<Array | Hash>]
-    # @return [Array<Hash>]
-    def self.normalize_filters(filters)
-      filters.map do |filter|
-        if filter.is_a?(Hash)
-          filter
-        else
-          {
-            :login => filter.first,
-            :filters => [
-              {
-                :label => filter[1],
-                :values => filter[2..-1]
-              }
-            ]
-          }
-        end
-      end
-    end
   end
 end

data/lib/gooddata/models/user_filters/user_filter_builder_create.rb

@@ -0,0 +1,115 @@
+# encoding: UTF-8
+
+module GoodData
+  module UserFilterBuilder
+    def self.create_label_cache(result, options = {})
+      project = options[:project]
+
+      result.reduce({}) do |a, e|
+        e[:filters].map do |filter|
+          a[filter[:label]] = project.labels(filter[:label]) unless a.key?(filter[:label])
+        end
+        a
+      end
+    end
+
+    def self.create_lookups_cache(small_labels)
+      small_labels.reduce({}) do |a, e|
+        lookup = e.values(:limit => 1_000_000).reduce({}) do |a1, e1|
+          a1[e1[:value]] = e1[:uri]
+          a1
+        end
+        a[e.uri] = lookup
+        a
+      end
+    end
+
+    # Walks over provided labels and picks those that have fewer than certain amount of values
+    # This tries to balance for speed when working with small datasets (like users)
+    # so it precaches the values and still be able to function for larger ones even
+    # though that would mean tons of requests
+    def self.get_small_labels(labels_cache)
+      labels_cache.values.select { |label| label.values_count < 100_000 }
+    end
+
+    # Creates a MAQL expression(s) based on the filter defintion.
+    # Takes the filter definition looks up any necessary values and provides API executable MAQL
+    def self.create_expression(filter, labels_cache, lookups_cache, options = {})
+      errors = []
+      values = filter[:values]
+      label = labels_cache[filter[:label]]
+      element_uris = values.map do |v|
+        begin
+          if lookups_cache.key?(label.uri)
+            if lookups_cache[label.uri].key?(v)
+              lookups_cache[label.uri][v]
+            else
+              fail
+            end
+          else
+            label.find_value_uri(v)
+          end
+        rescue
+          errors << [label.title, v]
+          nil
+        end
+      end
+      expression = if element_uris.compact.empty? && options[:restrict_if_missing_all_values] && options[:type] == :muf
+                     '1 <> 1'
+                   elsif element_uris.compact.empty? && options[:restrict_if_missing_all_values] && options[:type] == :variable
+                     nil
+                   elsif element_uris.compact.empty?
+                     'TRUE'
+                   elsif filter[:over] && filter[:to]
+                     "([#{label.attribute_uri}] IN (#{ element_uris.compact.sort.map { |e| '[' + e + ']' }.join(', ') })) OVER [#{filter[:over]}] TO [#{filter[:to]}]"
+                   else
+                     "[#{label.attribute_uri}] IN (#{ element_uris.compact.sort.map { |e| '[' + e + ']' }.join(', ') })"
+                   end
+      [expression, errors]
+    end
+
+    # Encapuslates the creation of filter
+    def self.create_user_filter(expression, related)
+      {
+        'related' => related,
+        'level' => :user,
+        'expression' => expression,
+        'type' => :filter
+      }
+    end
+
+    # Resolves and creates maql statements from filter definitions.
+    # This method does not perform any modifications on API but
+    # collects all the information that is needed to do so.
+    # Method collects all info from the user and current state in project and compares.
+    # Returns suggestion of what should be deleted and what should be created
+    # If there is some discrepancies in the data (missing values, nonexistent users) it
+    # finishes and collects all the errors at once
+    #
+    # @param filters [Array<Hash>] Filters definition
+    # @return [Array] first is list of MAQL statements
+    def self.maqlify_filters(filters, options = {})
+      project = options[:project]
+      users_cache = options[:users_cache] || create_cache(project.users, :login)
+      labels_cache = create_label_cache(filters, options)
+      small_labels = get_small_labels(labels_cache)
+      lookups_cache = create_lookups_cache(small_labels)
+
+      errors = []
+      results = filters.mapcat do |filter|
+        login = filter[:login]
+        filter[:filters].mapcat do |f|
+          expression, error = create_expression(f, labels_cache, lookups_cache, options)
+          errors << error unless error.empty?
+          profiles_uri = (users_cache[login] && users_cache[login].uri)
+          if profiles_uri && expression
+            [create_user_filter(expression, profiles_uri)]
+          else
+            []
+          end
+        end
+      end
+      [results, errors]
+    end
+  end
+end

data/lib/gooddata/models/user_filters/user_filter_builder_execute.rb

@@ -0,0 +1,133 @@
+# encoding: UTF-8
+
+module GoodData
+  module UserFilterBuilder
+    # Executes the update for variables. It resolves what is new and needed to update.
+    # @param filters [Array<Hash>] Filter Definitions
+    # @param filters [Variable] Variable instance to be updated
+    # @param options [Hash]
+    # @option options [Boolean] :dry_run If dry run is true. No changes to he proejct are made but list of changes is provided
+    # @return [Array] list of filters that needs to be created and deleted
+    def self.execute_variables(filters, var, options = {})
+      client = options[:client]
+      project = options[:project]
+      dry_run = options[:dry_run]
+      to_create, to_delete = execute(filters, var.user_values, VariableUserFilter, options.merge(type: :variable))
+      return [to_create, to_delete] if dry_run
+
+      # TODO: get values that are about to be deleted and created and update them.
+      # This will make sure there is no downitme in filter existence
+      unless options[:do_not_touch_filters_that_are_not_mentioned]
+        to_delete.each { |_, group| group.each(&:delete) }
+      end
+      data = to_create.values.flatten.map(&:to_hash).map { |var_val| var_val.merge(prompt: var.uri) }
+      data.each_slice(200) do |slice|
+        client.post("/gdc/md/#{project.obj_id}/variables/user", :variables => slice)
+      end
+      [to_create, to_delete]
+    end
+
+    def self.execute_mufs(filters, options = {})
+      client = options[:client]
+      project = options[:project]
+
+      dry_run = options[:dry_run]
+      to_create, to_delete = execute(filters, project.data_permissions, MandatoryUserFilter, options.merge(type: :muf))
+      return [to_create, to_delete] if dry_run
+
+      to_create.peach do |related_uri, group|
+        group.each(&:save)
+
+        res = client.get("/gdc/md/#{project.pid}/userfilters?users=#{related_uri}")
+        items = res['userFilters']['items'].empty? ? [] : res['userFilters']['items'].first['userFilters']
+
+        payload = {
+          'userFilters' => {
+            'items' => [{
+              'user' => related_uri,
+              'userFilters' => items.concat(group.map(&:uri))
+            }]
+          }
+        }
+        client.post("/gdc/md/#{project.pid}/userfilters", payload)
+      end
+      unless options[:do_not_touch_filters_that_are_not_mentioned]
+        to_delete.peach do |related_uri, group|
+          if related_uri
+            res = client.get("/gdc/md/#{project.pid}/userfilters?users=#{related_uri}")
+            items = res['userFilters']['items'].empty? ? [] : res['userFilters']['items'].first['userFilters']
+            payload = {
+              'userFilters' => {
+                'items' => [
+                  {
+                    'user' => related_uri,
+                    'userFilters' => items - group.map(&:uri)
+                  }
+                ]
+              }
+            }
+            client.post("/gdc/md/#{project.pid}/userfilters", payload)
+          end
+          group.each(&:delete)
+        end
+      end
+      [to_create, to_delete]
+    end
+
+    private
+
+    # Executes the procedure necessary for loading user filters. This method has what
+    # is common for both implementations. Funcion
+    #   * makes sure that filters are in normalized form.
+    #   * verifies that users are in the project (and domain)
+    #   * creates maql expressions of the filters provided
+    #   * resolves the filters against current values in the project
+    # @param user_filters [Array] Filters that user is trying to set up
+    # @param project_filters [Array] List of filters currently in the project
+    # @param klass [Class] Class can be aither UserFilter or VariableFilter
+    # @param options [Hash] Filter definitions
+    # @return [Array<Hash>]
+    def self.execute(user_filters, project_filters, klass, options = {})
+      client = options[:client]
+      project = options[:project]
+
+      ignore_missing_values = options[:ignore_missing_values]
+      users_must_exist = options[:users_must_exist] == false ? false : true
+      filters = normalize_filters(user_filters)
+      domain = options[:domain]
+      users = domain ? project.users + domain.users : project.users
+      users_cache = create_cache(users, :login)
+      verify_existing_users(filters, options.merge(users_must_exist: users_must_exist, users_cache: users_cache))
+      user_filters, errors = maqlify_filters(filters, options.merge(users_cache: users_cache, users_must_exist: users_must_exist))
+      fail "Validation failed #{errors}" if !ignore_missing_values && !errors.empty?
+
+      filters = user_filters.map { |data| client.create(klass, data, project: project) }
+      resolve_user_filters(filters, project_filters)
+    end
+
+    private
+
+    # Gets definition of filters from user. They might either come in the full definition
+    # as hash or a simplified version. The simplified version do not cover all the possible
+    # features but it is much simpler to remember and suitable for quick hacking around
+    # @param filters [Array<Array | Hash>]
+    # @return [Array<Hash>]
+    def self.normalize_filters(filters)
+      filters.map do |filter|
+        if filter.is_a?(Hash)
+          filter
+        else
+          {
+            :login => filter.first,
+            :filters => [
+              {
+                :label => filter[1],
+                :values => filter[2..-1]
+              }
+            ]
+          }
+        end
+      end
+    end
+  end
+end