gooddata 0.6.20 → 0.6.22

data/lib/gooddata/models/schedule.rb

@@ -1,4 +1,8 @@
 # encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
 
 require_relative '../rest/resource'
 require_relative '../extensions/hash'
@@ -23,7 +27,7 @@ module GoodData
         :timezone => nil,
         :params => {},
         :hiddenParams => {},
-        :reschedule => nil
+        # :reschedule => nil
       }
     }
 
@@ -90,27 +94,30 @@ module GoodData
 
         fail 'Process ID has to be provided' if process_id.blank?
         fail 'Executable has to be provided' if executable.blank?
+        fail 'Trigger schedule has to be provided' if trigger.blank?
+
+        schedule = c.create(GoodData::Schedule, GoodData::Helpers.deep_stringify_keys(GoodData::Helpers.deep_dup(SCHEDULE_TEMPLATE)), client: c, project: p)
 
         default_opts = {
           :type => 'MSETL',
           :timezone => 'UTC',
+          :state => 'ENABLED',
           :params => {
             'PROCESS_ID' => process_id,
             'EXECUTABLE' => executable
           },
-          :reschedule => 0
+          # :reschedule => nil
         }
 
-        schedule = c.create(GoodData::Schedule, GoodData::Helpers.deep_stringify_keys(GoodData::Helpers.deep_dup(SCHEDULE_TEMPLATE)), client: c, project: p)
-
         schedule.name = options[:name]
-        schedule.hidden_params = options[:hidden_params]
         schedule.set_trigger(trigger)
         schedule.params = default_opts[:params].merge(options[:params] || {})
+        schedule.hidden_params = options[:hidden_params] || {}
         schedule.timezone = options[:timezone] || default_opts[:timezone]
+        schedule.state = options[:state] || default_opts[:state]
         schedule.schedule_type = options[:type] || default_opts[:type]
-        schedule.reschedule = options[:reschedule] || default_opts[:reschedule]
-        schedule.save
+        schedule.reschedule = options[:reschedule] if options[:reschedule]
+        schedule
       end
     end
 
@@ -121,13 +128,13 @@ module GoodData
     def initialize(json)
       json = GoodData::Helpers.deep_stringify_keys(json)
       super
-      GoodData::Helpers.decode_params(json['schedule']['params'] || {})
-      GoodData::Helpers.decode_params(json['schedule']['hiddenParams'] || {})
       @json = json
+      self.params = GoodData::Helpers.decode_params(json['schedule']['params'] || {})
+      self.hidden_params = GoodData::Helpers.decode_params(json['schedule']['hiddenParams'] || {})
     end
 
     def after
-      schedules.find { |s| s.obj_id == trigger_id }
+      project.schedules(trigger_id)
     end
 
     def after=(schedule)
@@ -139,7 +146,7 @@ module GoodData
 
     # Deletes schedule
     def delete
-      client.delete uri
+      saved? ? client.delete(uri) : nil
     end
 
     # Is schedule enabled?
@@ -180,7 +187,8 @@ module GoodData
     # @option opts [Boolean] :wait Wait for execution result
     # @return [Object] Raw Response
     def execute(opts = {})
-      opts =  { :wait => true }.merge(opts)
+      return nil unless saved?
+      opts = { :wait => true }.merge(opts)
       data = {
         :execution => {}
       }
@@ -195,7 +203,7 @@ module GoodData
     #
     # @return [String] Executions URL
     def execution_url
-      @json['schedule']['links']['executions']
+      saved? ? @json['schedule']['links']['executions'] : nil
     end
 
     # Returns execution state
@@ -205,6 +213,10 @@ module GoodData
       @json['schedule']['state']
     end
 
+    def state=(a_state)
+      @json['schedule']['state'] = a_state
+    end
+
     # Returns execution timezone
     #
     # @return [String] Execution timezone
@@ -300,19 +312,65 @@ module GoodData
       @dirty = true
     end
 
-    # Returns list of executions
+    # Returns enumerator of executions
     #
     # @return [Array] Raw Executions JSON
     def executions
-      if @json # rubocop:disable Style/GuardClause
-        url = @json['schedule']['links']['executions']
-        res = client.get url
-        res['executions']['items'].map do |e|
-          client.create(Execution, e, :project => project)
+      return nil unless @json
+      url = @json['schedule']['links']['executions']
+      Enumerator.new do |y|
+        loop do
+          res = client.get url
+          res['executions']['paging']['next']
+          res['executions']['items'].each do |execution|
+            y << client.create(Execution, execution, :project => project)
+          end
+          url = res['executions']['paging']['next']
+          break unless url
         end
       end
     end
 
+    # Returns hidden_params as Hash
+    #
+    # @return [Hash] Hidden Parameters
+    def hidden_params
+      @json['schedule']['hiddenParams']
+    end
+
+    # Updates params by merging the current params with new ones
+    #
+    # @param params_to_merge [Hash] params
+    # @return [GoodData::Schedule] Returns self
+    def update_params(params_to_merge)
+      params_to_merge.each do |k, v|
+        set_parameter(k, v)
+      end
+      @dirty = true
+      self
+    end
+
+    # Updates hidden params by merging the current params with new ones
+    #
+    # @param params_to_merge [Hash] params
+    # @return [GoodData::Schedule] Returns self
+    def update_hidden_params(params_to_merge)
+      params_to_merge.each do |k, v|
+        set_hidden_parameter(k, v)
+      end
+      @dirty = true
+      self
+    end
+
+    # Assigns hidden parameters
+    #
+    # @param new_hidden_param [String] Hidden parameters to be set
+    def hidden_params=(new_hidden_params = {})
+      @json['schedule']['hiddenParams'] = new_hidden_params
+      @dirty = true
+      self
+    end
+
     # Returns params as Hash
     #
     # @return [Hash] Parameters
@@ -328,23 +386,9 @@ module GoodData
         'PROCESS_ID' => process_id,
         'EXECUTABLE' => executable
       }
-      @json['schedule']['params'] = default_params.merge(new_params || {})
-      @dirty = true
-    end
-
-    # Returns hidden_params as Hash
-    #
-    # @return [Hash] Hidden Parameters
-    def hidden_params
-      @json['schedule']['hiddenParams'] || {}
-    end
-
-    # Assigns hidden parameters
-    #
-    # @param new_hidden_param [String] Hidden parameters to be set
-    def hidden_params=(new_hidden_params = {})
-      @json['schedule']['hiddenParams'] = new_hidden_params || {}
+      @json['schedule']['params'] = default_params.merge(new_params)
       @dirty = true
+      self
     end
 
     # Saves object if dirty
@@ -355,33 +399,52 @@ module GoodData
       fail 'A timezone has to be provided' if timezone.blank?
       fail 'Schedule type has to be provided' if schedule_type.blank?
       if @dirty
-        update_json = {
-          'schedule' => {
-            'name' => @json['schedule']['name'],
-            'type' => @json['schedule']['type'],
-            'state' => @json['schedule']['state'],
-            'timezone' => @json['schedule']['timezone'],
-            'reschedule' => @json['schedule']['reschedule'],
-            'cron' => @json['schedule']['cron'],
-            'triggerScheduleId' => trigger_id,
-            'params' => GoodData::Helpers.encode_params(params, false),
-            'hiddenParams' => GoodData::Helpers.encode_params(hidden_params, true)
-          }.compact
-        }
-        if uri
-          res = client.put(uri, update_json)
-          @json = res
+        if saved?
+          res = client.put(uri, to_update_payload)
+          @json = Schedule.new(res).json
         else
-          res = client.post "/gdc/projects/#{project.pid}/schedules", update_json
+          res = client.post "/gdc/projects/#{project.pid}/schedules", to_update_payload
           fail 'Unable to create new schedule' if res.nil?
           new_obj_json = client.get res['schedule']['links']['self']
-          @json = new_obj_json
+          @json = Schedule.new(new_obj_json).json
         end
         @dirty = false
       end
       self
     end
 
+    # Updates params at key k with val v
+    #
+    # @param k [String] key
+    # @param v [Object] value
+    # @return [GoodData::Schedule] Returns self
+    def set_parameter(k, v)
+      params[k] = v
+      @dirty = true
+      self
+    end
+
+    # Updates hidden params at key k with val v
+    #
+    # @param k [String] key
+    # @param v [Object] value
+    # @return [GoodData::Schedule] Returns self
+    def set_hidden_parameter(k, v)
+      hidden_params[k] = v
+      @dirty = true
+      self
+    end
+
+    def schedule_type
+      json['schedule']['type']
+    end
+
+    def schedule_type=(type)
+      json['schedule']['type'] = type
+      @dirty = true
+      self
+    end
+
     def time_based?
       cron != nil
     end
@@ -396,18 +459,11 @@ module GoodData
         cron: cron,
         trigger_id: trigger_id,
         timezone: timezone,
-        uri: uri
-      }.compact
-    end
-
-    def schedule_type
-      json['schedule']['type']
-    end
-
-    def schedule_type=(type)
-      json['schedule']['type'] = type
-      @dirty = true
-      self
+        uri: uri,
+        reschedule: reschedule,
+        executable: executable,
+        process_id: process_id
+      }
     end
 
     def trigger_id
@@ -450,5 +506,24 @@ module GoodData
     def ==(other)
       other.respond_to?(:uri) && other.uri == uri && other.respond_to?(:to_hash) && other.to_hash == to_hash
     end
+
+    def to_update_payload
+      res = {
+        'schedule' => {
+          'name' => name,
+          'type' => type,
+          'state' => state,
+          'timezone' => timezone,
+          'cron' => cron,
+          'triggerScheduleId' => trigger_id,
+          'params' => GoodData::Helpers.encode_public_params(params),
+          'hiddenParams' => GoodData::Helpers.encode_hidden_params(hidden_params)
+        }
+      }
+
+      res['schedule']['reschedule'] = reschedule if reschedule
+
+      res
+    end
   end
 end

data/lib/gooddata/models/tab_builder.rb

@@ -1,4 +1,8 @@
 # encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
 
 module GoodData
   module Model

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

@@ -1,4 +1,8 @@
 # encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
 
 require_relative 'user_filter'
 

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

@@ -1,4 +1,8 @@
 # encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
 
 module GoodData
   class UserFilter < GoodData::MdObject

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

@@ -1,4 +1,8 @@
 # encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
 
 module GoodData
   module UserFilterBuilder
@@ -224,7 +228,11 @@ module GoodData
                    else
                      "[#{label.attribute_uri}] IN (#{element_uris.compact.sort.map { |e| '[' + e + ']' }.join(', ')})"
                    end
-      [expression, errors]
+      if options[:ignore_missing_values]
+        [expression, []]
+      else
+        [expression, errors]
+      end
     end
 
     # Encapuslates the creation of filter
@@ -248,28 +256,48 @@ module GoodData
     # @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)
+      fail_early = options[:fail_early] == false ? false : true
+      users_cache = options[:users_cache]
       labels_cache = create_label_cache(filters, options)
       small_labels = get_small_labels(labels_cache)
       lookups_cache = create_lookups_cache(small_labels)
       attrs_cache = create_attrs_cache(filters, options)
-
-      results = filters.flat_map do |filter|
-        login = filter[:login]
-        filter[:filters].pmapcat do |f|
-          expression, errors = create_expression(f, labels_cache, lookups_cache, attrs_cache, options)
-          profiles_uri = (users_cache[login] && users_cache[login].uri)
-          if profiles_uri && expression
-            [create_user_filter(expression, profiles_uri)] + errors
-          else
-            [] + errors
-          end
+      create_filter_proc = proc do |login, f|
+        expression, errors = create_expression(f, labels_cache, lookups_cache, attrs_cache, options)
+        profiles_uri = if options[:type] == :muf
+                         '/gdc/account/profile/' + login
+                       elsif options[:type] == :variable
+                         (users_cache[login] && users_cache[login].uri)
+                       else
+                         fail 'Unsuported type in maqlify_filters.'
+                       end
+
+        if profiles_uri && expression
+          [create_user_filter(expression, profiles_uri)] + errors
+        else
+          [] + errors
         end
       end
-      results.group_by { |i| i[:type] }
-        .values_at(:filter, :error)
-        .map { |i| i || [] }
+
+      # if fail early process until first error
+      results = if fail_early
+                  x = filters.inject([true, []]) do |(enough, a), e|
+                    login = e[:login]
+                    if enough
+                      y = e[:filters].pmapcat { |f| create_filter_proc.call(login, f) }
+                      [!y.any? { |r| r[:type] == :error }, a.concat(y)]
+                    else
+                      [false, a]
+                    end
+                  end
+                  x.last
+                else
+                  filters.flat_map do |filter|
+                    login = filter[:login]
+                    filter[:filters].pmapcat { |f| create_filter_proc.call(login, f) }
+                  end
+                end
+      results.group_by { |i| i[:type] }.values_at(:filter, :error).map { |i| i || [] }
     end
 
     def self.resolve_user_filter(user = [], project = [])
@@ -325,19 +353,26 @@ module GoodData
       [to_create, to_delete]
     end
 
-    def self.execute_mufs(filters, options = {})
+    def self.execute_mufs(user_filters, options = {})
       client = options[:client]
       project = options[:project]
-
+      ignore_missing_values = options[:ignore_missing_values]
+      users_must_exist = options[:users_must_exist] == false ? false : true
       dry_run = options[:dry_run]
-      to_create, to_delete = execute(filters, project.data_permissions, MandatoryUserFilter, options.merge(type: :muf))
+
+      filters = normalize_filters(user_filters)
+      user_filters, errors = maqlify_filters(filters, options.merge(users_must_exist: users_must_exist, type: :muf))
+
+      fail GoodData::FilterMaqlizationError, errors if !ignore_missing_values && !errors.empty?
+      filters = user_filters.map { |data| client.create(MandatoryUserFilter, data, project: project) }
+      to_create, to_delete = resolve_user_filters(filters, project.data_permissions)
+
       GoodData.logger.warn("Data permissions computed: #{to_create.count} to create and #{to_delete.count} to delete")
-      return [to_create, to_delete] if dry_run
+      return { created: to_create, deleted: to_delete } if dry_run
 
-      to_create.each_slice(100).flat_map do |batch|
-        batch.peach do |related_uri, group|
+      create_results = to_create.each_slice(100).flat_map do |batch|
+        batch.pmapcat 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']
 
@@ -349,32 +384,40 @@ module GoodData
               }]
             }
           }
-          client.post("/gdc/md/#{project.pid}/userfilters", payload)
-        end
-      end
-      unless options[:do_not_touch_filters_that_are_not_mentioned]
-        to_delete.each_slice(100).flat_map do |batch|
-          batch.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.peach(&:delete)
-          end
+          res = client.post("/gdc/md/#{project.pid}/userfilters", payload)
+
+          # turn the errors from hashes into array of hashes
+          res['userFiltersUpdateResult'].flat_map { |k, v| v.map { |r| { status: k.to_sym, user: r, type: :create } } }.map { |result| result[:status] == :failed ? result.merge(GoodData::Helpers.symbolize_keys(result[:user])) : result }
         end
       end
-      [to_create, to_delete]
+      delete_results = unless options[:do_not_touch_filters_that_are_not_mentioned]
+                         to_delete.each_slice(100).flat_map do |batch|
+                           batch.flat_map do |related_uri, group|
+                             results = []
+                             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)
+                                     }
+                                   ]
+                                 }
+                               }
+                               res = client.post("/gdc/md/#{project.pid}/userfilters", payload)
+                               results.concat(res['userFiltersUpdateResult']
+                                 .flat_map { |k, v| v.map { |r| { status: k.to_sym, user: r, type: :delete } } }
+                                 .map { |result| result[:status] == :failed ? result.merge(GoodData::Helpers.symbolize_keys(result[:user])) : result })
+                             end
+                             group.peach(&:delete)
+                             results
+                           end
+                         end
+                       end
+      { created: to_create, deleted: to_delete, results: create_results + (delete_results || []) }
     end
 
     private
@@ -421,25 +464,24 @@ module GoodData
       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 = project.users
+      # domain = options[:domain]
       # users = domain ? project.users : project.users
+      users = project.users
       users_cache = create_cache(users, :login)
       missing_users = get_missing_users(filters, options.merge(users_cache: users_cache))
       user_filters, errors = if missing_users.empty?
                                verify_existing_users(filters, project: project, users_must_exist: users_must_exist, users_cache: users_cache)
                                maqlify_filters(filters, options.merge(users_cache: users_cache, users_must_exist: users_must_exist))
                              elsif missing_users.count < 100
-                               verify_existing_users(filters, project: project, users_must_exist: users_must_exist, users_cache: users_cache,  domain: domain)
-                               maqlify_filters(filters, options.merge(users_cache: users_cache, users_must_exist: users_must_exist, domain: domain))
+                               verify_existing_users(filters, project: project, users_must_exist: users_must_exist, users_cache: users_cache)
+                               maqlify_filters(filters, options.merge(users_cache: users_cache, users_must_exist: users_must_exist))
                              else
-                               users += domain.users
                                users_cache = create_cache(users, :login)
-                               verify_existing_users(filters, project: project, users_must_exist: users_must_exist, users_cache: users_cache,  domain: domain)
-                               maqlify_filters(filters, options.merge(users_cache: users_cache, users_must_exist: users_must_exist, domain: domain))
+                               verify_existing_users(filters, project: project, users_must_exist: users_must_exist, users_cache: users_cache)
+                               maqlify_filters(filters, options.merge(users_cache: users_cache, users_must_exist: users_must_exist))
                              end
 
-      fail "Validation failed #{errors}" if !ignore_missing_values && !errors.empty?
+      fail GoodData::FilterMaqlizationError, 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