gooddata 0.6.51 → 0.6.52

data/lib/gooddata/models/metadata/scheduled_mail.rb

@@ -48,7 +48,10 @@ module GoodData
       # Method intended to get all objects of that type in a specified project
       #
       # @param options [Hash] the options hash
-      # @option options [Boolean] :full if passed true the subclass can decide to pull in full objects. This is desirable from the usability POV but unfortunately has negative impact on performance so it is not the default
+      # @option options [Boolean] :full if passed true the subclass can decide
+      # to pull in full objects. This is desirable from the usability POV
+      # but unfortunately has negative impact on performance so it is not the
+      # default
       # @return [Array<GoodData::MdObject> | Array<Hash>] Return the appropriate metadata objects or their representation
       def all(options = { :client => GoodData.connection, :project => GoodData.project })
         query('scheduledMail', ScheduledMail, options)

data/lib/gooddata/models/metadata/variable.rb

@@ -14,7 +14,10 @@ module GoodData
       # Method intended to get all objects of that type in a specified project
       #
       # @param options [Hash] the options hash
-      # @option options [Boolean] :full if passed true the subclass can decide to pull in full objects. This is desirable from the usability POV but unfortunately has negative impact on performance so it is not the default
+      # @option options [Boolean] :full if passed true the subclass can decide
+      # to pull in full objects. This is desirable from the usability
+      # POV but unfortunately has negative impact on performance so it
+      # is not the default
       # @return [Array<GoodData::MdObject> | Array<Hash>] Return the appropriate metadata objects or their representation
       def all(options = { :client => GoodData.connection, :project => GoodData.project })
         query('prompt', Variable, options)
@@ -67,7 +70,9 @@ module GoodData
       values.select { |x| x.level == :user }
     end
 
-    # Method used for replacing values in their state according to mapping. Can be used to replace any values but it is typically used to replace the URIs. Returns a new object of the same type.
+    # Method used for replacing values in their state according to mapping.
+    # Can be used to replace any values but it is typically used to replace
+    # the URIs. Returns a new object of the same type.
     #
     # @param [Array<Array>]Mapping specifying what should be exchanged for what. As mapping should be used output of GoodData::Helpers.prepare_mapping.
     # @return [GoodData::Variable]

data/lib/gooddata/models/model.rb

@@ -267,13 +267,24 @@ module GoodData
         d = GoodData::Helpers.deep_dup(a_schema_blueprint)
         d[:columns] = d[:columns] + b_schema_blueprint[:columns]
         d[:columns].uniq!
-        columns_that_failed_to_merge = d[:columns].group_by { |x| [:reference, :date].include?(x[:type]) ? x[:dataset] : x[:id] }.map { |k, v| [k, v.count, v] }.select { |x| x[1] > 1 }
+        columns_that_failed_to_merge = d[:columns]
+          .group_by { |x| [:reference, :date].include?(x[:type]) ? x[:dataset] : x[:id] }
+          .map { |k, v| [k, v.count, v] }.select { |x| x[1] > 1 }
         unless columns_that_failed_to_merge.empty?
           columns_that_failed_to_merge.each do |error|
-            GoodData.logger.error "Columns #{error[0]} failed to merge. There are #{error[1]} conflicting columns. When merging columns with the same name they have to be identical."
+            message = "Columns #{error[0]} failed to merge. There are " \
+                      "#{error[1]} conflicting columns. When merging columns " \
+                      "with the same name they have to be identical."
+            GoodData.logger.error message
             GoodData.logger.error error[2]
           end
-          fail "Columns #{columns_that_failed_to_merge.first} failed to merge. There are #{columns_that_failed_to_merge[1]} conflicting columns. #{columns_that_failed_to_merge[2]} When merging columns with the same name they have to be identical." unless columns_that_failed_to_merge.empty?
+          unless columns_that_failed_to_merge.empty?
+            fail "Columns #{columns_that_failed_to_merge.first} failed to " \
+                 "merge. There are #{columns_that_failed_to_merge[1]} " \
+                 "conflicting columns. #{columns_that_failed_to_merge[2]} " \
+                 "When merging columns with the same name they have to be " \
+                 "identical."
+          end
         end
         d
       end

data/lib/gooddata/models/process.rb

@@ -123,6 +123,8 @@ module GoodData
                 client.put("/gdc/projects/#{project.pid}/dataload/processes/#{process_id}", data)
               end
 
+        File.delete(deployed_path) if File.exist?(deployed_path)
+
         process = client.create(Process, res, project: project)
         puts HighLine.color("Deploy DONE #{path}", HighLine::GREEN) if verbose
         process
@@ -207,16 +209,15 @@ module GoodData
 
       def with_zip(opts = {})
         client = opts[:client]
-        Tempfile.open('deploy-graph-archive') do |temp|
-          zip_filename = temp.path
-          File.open(zip_filename, 'w') do |zip|
-            Zip::File.open(zip.path, Zip::File::CREATE) do |zipfile|
-              yield zipfile
-            end
-          end
-          client.upload_to_user_webdav(temp.path, opts)
-          temp.path
+        temp = Tempfile.new(['deploy-graph-archive', '.zip'])
+        zip_filename = temp.path
+
+        temp.close!
+        Zip::File.open(zip_filename, Zip::File::CREATE) do |zipfile|
+          yield zipfile
         end
+        client.upload_to_user_webdav(zip_filename, opts)
+        zip_filename
       end
 
       def zip_and_upload(path, files_to_exclude, opts = {})

data/lib/gooddata/models/project.rb

@@ -140,7 +140,9 @@ module GoodData
 
         project = create_object(opts)
         project.save
-        # until it is enabled or deleted, recur. This should still end if there is a exception thrown out from RESTClient. This sometimes happens from WebApp when request is too long
+        # until it is enabled or deleted, recur. This should still end if there
+        # is a exception thrown out from RESTClient. This sometimes happens from
+        # WebApp when request is too long
         while project.state.to_s != 'enabled'
           if project.deleted?
             # if project is switched to deleted state, fail. This is usually problem of creating a template which is invalid.
@@ -220,7 +222,10 @@ module GoodData
       # Clones project along with etl and schedules.
       #
       # @param client [GoodData::Rest::Client] GoodData client to be used for connection
-      # @param from_project [GoodData::Project | GoodData::Segment | GoodData:Client | String] Object to be cloned from. Can be either segment in which case we take the master, client in which case we take its project, string in which case we treat is as an project object or directly project
+      # @param from_project [GoodData::Project | GoodData::Segment | GoodData:Client | String]
+      # Object to be cloned from. Can be either segment in which case we
+      # take the master, client in which case we take its project, string
+      # in which case we treat is as an project object or directly project
       # @param to_project [GoodData::Project | GoodData::Segment | GoodData:Client | String]
       def transfer_etl(client, from_project, to_project)
         from_project = case from_project
@@ -304,7 +309,10 @@ module GoodData
       # Clones project along with etl and schedules.
       #
       # @param client [GoodData::Rest::Client] GoodData client to be used for connection
-      # @param from_project [GoodData::Project | GoodData::Segment | GoodData:Client | String] Object to be cloned from. Can be either segment in which case we take the master, client in which case we take its project, string in which case we treat is as an project object or directly project
+      # @param from_project [GoodData::Project | GoodData::Segment | GoodData:Client | String]
+      # Object to be cloned from. Can be either segment in which case we take
+      # the master, client in which case we take its project, string in which
+      # case we treat is as an project object or directly project.
       def transfer_schedules(from_project, to_project)
         cache = to_project
                   .processes.sort_by(&:name)
@@ -335,7 +343,7 @@ module GoodData
           v.compact
         end
 
-        diff = GoodData::Helpers.diff(remote_stuff, local_stuff, key: :name, fields: [:name, :cron, :after, :params, :hidden_params, :reschedule])
+        diff = GoodData::Helpers.diff(remote_stuff, local_stuff, key: :name, fields: [:name, :cron, :after, :params, :hidden_params, :reschedule, :state])
         stack = diff[:added].map do |x|
           [:added, x]
         end
@@ -369,7 +377,7 @@ module GoodData
             if process_spec.type != :dataload
               executable = schedule_spec[:executable] || (process_spec.type == :ruby ? 'main.rb' : 'main.grf')
             end
-            params = schedule_parameters(to_project.pid, schedule_spec)
+            params = schedule_parameters(schedule_spec)
             created_schedule = remote_process.create_schedule(schedule_spec[:cron] || schedule_cache[schedule_spec[:after]], executable, params)
             schedule_cache[created_schedule.name] = created_schedule
 
@@ -403,6 +411,7 @@ module GoodData
 
             schedule.reschedule = schedule_spec[:reschedule]
             schedule.name = schedule_spec[:name]
+            schedule.state = schedule_spec[:state]
             schedule.save
             schedule_cache[schedule.name] = schedule
 
@@ -449,12 +458,13 @@ module GoodData
 
       private
 
-      def schedule_parameters(id, schedule_spec)
+      def schedule_parameters(schedule_spec)
         {
-          params: schedule_spec[:params].merge('PROJECT_ID' => id),
+          params: schedule_spec[:params],
           hidden_params: schedule_spec[:hidden_params],
           name: schedule_spec[:name],
-          reschedule: schedule_spec[:reschedule]
+          reschedule: schedule_spec[:reschedule],
+          state: schedule_spec[:state]
         }
       end
     end
@@ -535,6 +545,15 @@ module GoodData
       GoodData::Attribute[id, project: self, client: client]
     end
 
+    def computed_attributes(id = :all)
+      attrs = attributes(id)
+      if attrs.is_a?(GoodData::Attribute)
+        attrs.computed_attribute? ? attrs : nil
+      else
+        attrs.select(&:computed_attribute?)
+      end
+    end
+
     def attribute_by_identifier(identifier)
       GoodData::Attribute.find_first_by_identifier(identifier, project: self, client: client)
     end
@@ -555,10 +574,10 @@ module GoodData
     #
     # @return [GoodData::ProjectRole] Project role if found
     def blueprint(options = {})
-      result = client.get("/gdc/projects/#{pid}/model/view", params: { includeDeprecated: true, includeGrain: true })
+      result = client.get("/gdc/projects/#{pid}/model/view", params: { includeDeprecated: true, includeGrain: true, includeCA: true })
       polling_url = result['asyncTask']['link']['poll']
       model = client.poll_on_code(polling_url, options)
-      bp = GoodData::Model::FromWire.from_wire(model)
+      bp = GoodData::Model::FromWire.from_wire(model, { include_ca: true }.merge(options))
       bp.title = title
       bp
     end
@@ -1119,10 +1138,18 @@ module GoodData
     def objects_export(objs, options = {})
       fail 'Nothing to migrate. You have to pass list of objects, ids or uris that you would like to migrate' if objs.nil?
       objs = Array(objs)
-      fail 'Nothing to migrate. The list you provided is empty' if objs.empty?
+      if objs.empty?
+        GoodData.logger.warn 'Nothing to migrate.'
+        return
+      end
 
       objs = objs.pmap { |obj| [obj, objects(obj)] }
-      fail ObjectsExportError, "Exporting objects failed with messages. Object #{objs.select { |_, obj| obj.nil? }.map { |o, _| o }.join(', ')} could not be found." if objs.any? { |_, obj| obj.nil? }
+      if objs.any? { |_, obj| obj.nil? }
+        object = objs.select { |_, obj| obj.nil? }.map { |o, _| o }.join(', ')
+        error_message = "Exporting objects failed with messages. " \
+                        "Object #{object} could not be found."
+        fail ObjectsExportError, error_message
+      end
       export_payload = {
         :partialMDExport => {
           :uris => objs.map { |_, obj| obj.uri },
@@ -1158,7 +1185,8 @@ module GoodData
         :partialMDImport => {
           :token => token,
           :overwriteNewer => '1',
-          :updateLDMObjects => '0'
+          :updateLDMObjects => '0',
+          :importAttributeProperties => '1'
         }
       }
 
@@ -1183,11 +1211,15 @@ module GoodData
     # @option options [GoodData::Project | String | Array<String> | Array<GoodData::Project>] :project Project(s) to migrate to
     # @option options [Number] :batch_size Number of projects that are migrated at the same time. Default is 10
     #
-    # @return [Boolean | Array<Hash>] Return either true or throws exception if you passed only one project. If you provided an array returns list of hashes signifying sucees or failure. Take note that in case of list of projects it does not throw exception
+    # @return [Boolean | Array<Hash>] Return either true or throws exception
+    # if you passed only one project. If you provided an array returns list
+    # of hashes signifying sucees or failure. Take note that in case of list
+    # of projects it does not throw exception.
     def partial_md_export(objects, options = {})
       projects = options[:project]
       batch_size = options[:batch_size] || 10
       token = objects_export(objects)
+      return if token.nil?
 
       if projects.is_a?(Array)
         projects.each_slice(batch_size).flat_map do |batch|
@@ -1269,7 +1301,9 @@ module GoodData
       self
     end
 
-    # Method used for walking through objects in project and trying to replace all occurences of some object for another object. This is typically used as a means for exchanging Date dimensions.
+    # Method used for walking through objects in project and trying to
+    # replace all occurences of some object for another object. This is
+    # typically used as a means for exchanging Date dimensions.
     #
     # @param mapping [Array<Array>] Mapping specifying what should be exchanged for what. As mapping should be used output of GoodData::Helpers.prepare_mapping.
     def replace_from_mapping(mapping, opts = {})
@@ -1328,12 +1362,50 @@ module GoodData
         end
       end
 
+      GoodData.logger.info 'Replacing dashboard saved views'
+      contexts = mapping.map { |a, _| a }.pmapcat { |a| a.usedby('executionContext') }.map { |a| GoodData::MdObject[a['link'], client: client, project: self] }
+      puts "Found #{contexts.count} dashboard saved views"
+      contexts.peach do |item|
+        new_item = GoodData::MdObject.replace_quoted(item, mapping)
+        if new_item.json != item.json
+          if dry_run
+            GoodData.logger.info "Would save #{new_item.uri}. Running in dry run mode"
+          else
+            GoodData.logger.info "Saving #{new_item.uri}"
+            new_item.save
+          end
+        else
+          GoodData.logger.info "Ignore #{item.uri}"
+        end
+      end
+
       GoodData.logger.info 'Replacing variable values'
       variables.each do |var|
         var.values.peach do |val|
           val.replace(mapping).save unless dry_run
         end
       end
+
+      {
+        visualizations: MdObject.query('visualization', MdObject, client: client, project: self),
+        visualization_widgets: MdObject.query('visualizationWidget', MdObject, client: client, project: self),
+        kpis: MdObject.query('kpi', MdObject, client: client, project: self)
+      }.each do |key, collection|
+        GoodData.logger.info "Replacing #{key}"
+        collection.each do |item|
+          new_item = MdObject.replace_quoted(item, mapping)
+          if new_item.json != item.json
+            if dry_run
+              GoodData.logger.info "Would save #{new_item.uri}. Running in dry run mode"
+            else
+              GoodData.logger.info "Saving #{new_item.uri}"
+              new_item.save
+            end
+          else
+            GoodData.logger.info "Ignore #{item.uri}"
+          end
+        end
+      end
       nil
     end
 
@@ -1516,7 +1588,7 @@ module GoodData
     def import_users(new_users, options = {})
       role_list = roles
       users_list = users
-      new_users = new_users.map { |x| (x.is_a?(Hash) && x[:user] && x[:user].to_hash.merge(role: x[:role])) || x.to_hash }
+      new_users = new_users.map { |x| ((x.is_a?(Hash) && x[:user] && x[:user].to_hash.merge(role: x[:role])) || x.to_hash).tap { |u| u[:login].downcase! } }
 
       GoodData.logger.warn("Importing users to project (#{pid})")
 
@@ -1587,22 +1659,24 @@ module GoodData
       @log_formatter.log_updated_users(updated_users_result, diff[:changed], role_list)
       results.concat(updated_users_result)
 
-      # Remove old users
-      to_disable = diff[:removed].reject { |user| user[:status] == 'DISABLED' || user[:status] == :disabled }
-      GoodData.logger.warn("Disabling #{to_disable.count} users from project (#{pid})")
-      disabled_users_result = disable_users(to_disable, roles: role_list, project_users: whitelisted_users)
-      @log_formatter.log_disabled_users(disabled_users_result)
-      results.concat(disabled_users_result)
-
-      # Remove old users completely
-      if options[:remove_users_from_project]
-        to_remove = (to_disable + users(disabled: true).to_a).map(&:to_hash).uniq do |user|
-          user[:uri]
+      unless options[:do_not_touch_users_that_are_not_mentioned]
+        # Remove old users
+        to_disable = diff[:removed].reject { |user| user[:status] == 'DISABLED' || user[:status] == :disabled }
+        GoodData.logger.warn("Disabling #{to_disable.count} users from project (#{pid})")
+        disabled_users_result = disable_users(to_disable, roles: role_list, project_users: whitelisted_users)
+        @log_formatter.log_disabled_users(disabled_users_result)
+        results.concat(disabled_users_result)
+
+        # Remove old users completely
+        if options[:remove_users_from_project]
+          to_remove = (to_disable + users(disabled: true).to_a).map(&:to_hash).uniq do |user|
+            user[:uri]
+          end
+          GoodData.logger.warn("Removing #{to_remove.count} users from project (#{pid})")
+          removed_users_result = remove_users(to_remove)
+          @log_formatter.log_removed_users(removed_users_result)
+          results.concat(removed_users_result)
         end
-        GoodData.logger.warn("Removing #{to_remove.count} users from project (#{pid})")
-        removed_users_result = remove_users(to_remove)
-        @log_formatter.log_removed_users(removed_users_result)
-        results.concat(removed_users_result)
       end
 
       # reassign to groups
@@ -1667,7 +1741,11 @@ module GoodData
           create_group(name: g, description: g)
         end
       else
-        fail "All groups have to be specified before you try to import users. Groups that are currently in project are #{groups.join(',')} and you asked for #{missing_groups.join(',')}" unless missing_groups.empty?
+        unless missing_groups.empty?
+          fail 'All groups have to be specified before you try to import ' \
+            'users. Groups that are currently in project are ' \
+            "#{groups.join(',')} and you asked for #{missing_groups.join(',')}"
+        end
       end
     end
 
@@ -1716,7 +1794,11 @@ module GoodData
         client.post("#{uri}/users", 'users' => payload)
       end
       # this ugly line turns the hash of errors into list of errors with types so we can process them easily
-      typed_results = results.flat_map { |x| x['projectUsersUpdateResult'].flat_map { |k, v| v.map { |v2| v2.is_a?(String) ? { type: k.to_sym, user: v2 } : GoodData::Helpers.symbolize_keys(v2).merge(type: k.to_sym) } } }
+      typed_results = results.flat_map do |x|
+        x['projectUsersUpdateResult'].flat_map do |k, v|
+          v.map { |v2| v2.is_a?(String) ? { type: k.to_sym, user: v2 } : GoodData::Helpers.symbolize_keys(v2).merge(type: k.to_sym) }
+        end
+      end
       # we have to concat errors from role resolution and API result
       typed_results + (users_by_type[:failed] || [])
     end
@@ -1823,6 +1905,22 @@ module GoodData
       GoodData::StyleSetting.reset(client: client, project: self)
     end
 
+    # get maql diff from another project or blueprint to current project
+    #
+    # @param options [Hash] options
+    # @option options [GoodData::Project] :project source project
+    # @option options [GoodData::Model::ProjectBlueprint] :blueprint blueprint of source project
+    # @option options [Array] :params additional parameters for diff api
+    # @return [Hash] project model diff
+    def maql_diff(options = {})
+      fail "No :project or :blueprint specified" unless options[:blueprint] || options[:project]
+      bp = options[:blueprint] || options[:project].blueprint
+      uri = "/gdc/projects/#{pid}/model/diff"
+      params = Hash[(options[:params] || []).map { |i| [i, true] }]
+      result = client.post(uri, bp.to_wire, params: params)
+      client.poll_on_code(result['asyncTask']['link']['poll'])
+    end
+
     private
 
     def send_mail_to_new_users(users, email_options)
@@ -1859,14 +1957,14 @@ module GoodData
       server_side_encryption = options['email_server_side_encryption'] || false
       args['s3_server_side_encryption'] = :aes256 if server_side_encryption
 
-      s3 = AWS::S3.new(args)
-      bucket = s3.buckets[bucket]
+      s3 = Aws::S3::Resource.new(args)
+      bucket = s3.bucket(bucket)
       process_email_template(bucket, path)
     end
 
     def process_email_template(bucket, path)
       type = path.split('/').last.include?('.html') ? 'html' : 'txt'
-      body = bucket.objects[path].read
+      body = bucket.object(path).read
       body.prepend("MIME-Version: 1.0\nContent-type: text/html\n") if type == 'html'
       body
     end

data/lib/gooddata/models/project_creator.rb

@@ -14,7 +14,7 @@ module GoodData
     class ProjectCreator
       class << self
         def migrate(opts = {})
-          opts = { client: GoodData.connection }.merge(opts)
+          opts = { client: GoodData.connection, execute_ca_scripts: true }.merge(opts)
           client = opts[:client]
           fail ArgumentError, 'No :client specified' if client.nil?
 
@@ -25,15 +25,13 @@ module GoodData
 
           project = opts[:project] || client.create_project(opts.merge(:title => opts[:title] || spec[:title], :client => client, :environment => opts[:environment]))
 
-          begin
-            migrate_datasets(spec, opts.merge(project: project, client: client))
-            load(p, spec)
-            migrate_metrics(p, spec[:metrics] || [])
-            migrate_reports(p, spec[:reports] || [])
-            migrate_dashboards(p, spec[:dashboards] || [])
-            execute_tests(p, spec[:assert_tests] || [])
-            project
-          end
+          maqls = migrate_datasets(spec, opts.merge(project: project, client: client))
+          load(p, spec)
+          migrate_metrics(p, spec[:metrics] || [])
+          migrate_reports(p, spec[:reports] || [])
+          migrate_dashboards(p, spec[:dashboards] || [])
+          execute_tests(p, spec[:assert_tests] || [])
+          opts[:execute_ca_scripts] ? project : maqls.find { |maql| maql.key?('maqlDdlChunks') }
         end
 
         def migrate_datasets(spec, opts = {})
@@ -41,17 +39,18 @@ module GoodData
           dry_run = opts[:dry_run]
           replacements = opts['maql_replacements'] || opts[:maql_replacements] || {}
 
-          client, project = GoodData.get_client_and_project(opts)
+          _, project = GoodData.get_client_and_project(opts)
 
           bp = ProjectBlueprint.new(spec)
+          response = project.maql_diff(blueprint: bp, params: [:includeGrain])
 
-          uri = "/gdc/projects/#{project.pid}/model/diff?includeGrain=true"
-          result = client.post(uri, bp.to_wire)
-          response = client.poll_on_code(result['asyncTask']['link']['poll'])
-
+          GoodData.logger.debug("projectModelDiff") { response.pretty_inspect }
           chunks = response['projectModelDiff']['updateScripts']
           return [] if chunks.empty?
 
+          ca_maql = response['projectModelDiff']['computedAttributesScript'] if response['projectModelDiff']['computedAttributesScript']
+          ca_chunks = ca_maql && ca_maql['maqlDdlChunks']
+
           maqls = pick_correct_chunks(chunks, opts)
           replaced_maqls = apply_replacements_on_maql(maqls, replacements)
 
@@ -59,19 +58,32 @@ module GoodData
             errors = []
             replaced_maqls.each do |replaced_maql_chunks|
               begin
-                replaced_maql_chunks['updateScript']['maqlDdlChunks'].each { |chunk| project.execute_maql(chunk) }
+                replaced_maql_chunks['updateScript']['maqlDdlChunks'].each do |chunk|
+                  GoodData.logger.debug(chunk)
+                  project.execute_maql(chunk)
+                end
               rescue => e
                 puts "Error occured when executing MAQL, project: \"#{project.title}\" reason: \"#{e.message}\", chunks: #{replaced_maql_chunks.inspect}"
                 errors << e
                 next
               end
             end
+
+            if ca_chunks && opts[:execute_ca_scripts]
+              begin
+                ca_chunks.each { |chunk| project.execute_maql(chunk) }
+              rescue => e
+                puts "Error occured when executing MAQL, project: \"#{project.title}\" reason: \"#{e.message}\", chunks: #{ca_chunks.inspect}"
+                errors << e
+              end
+            end
+
             if (!errors.empty?) && (errors.length == replaced_maqls.length)
-              messages = errors.map { |e| GoodData::Helpers.interpolate_error_messages(e.data['wTaskStatus']['messages']) }
+              messages = errors.map { |err| GoodData::Helpers.interpolate_error_messages(err.data['wTaskStatus']['messages']) }
               fail "Unable to migrate LDM, reason(s): \n #{messages.join("\n")}"
             end
           end
-          replaced_maqls
+          replaced_maqls + (ca_maql ? [ca_maql] : [])
         end
 
         def migrate_reports(project, spec)
@@ -111,7 +123,9 @@ module GoodData
         end
 
         def pick_correct_chunks(chunks, opts = {})
+          GoodData.logger.debug("update_preference") { opts[:update_preference].pretty_inspect }
           preference = GoodData::Helpers.symbolize_keys(opts[:update_preference] || {})
+          preference = Hash[preference.map { |k, v| [k, GoodData::Helpers.to_boolean(v)] }]
 
           # first is cascadeDrops, second is preserveData
           rules = [
@@ -126,10 +140,19 @@ module GoodData
           end
 
           stuff = stuff.map do |chunk|
-            { cascade_drops: chunk['updateScript']['cascadeDrops'], preserve_data: chunk['updateScript']['preserveData'], maql: chunk['updateScript']['maqlDdlChunks'], orig: chunk }
+            { cascade_drops: chunk['updateScript']['cascadeDrops'],
+              preserve_data: chunk['updateScript']['preserveData'],
+              maql: chunk['updateScript']['maqlDdlChunks'],
+              orig: chunk }
           end
 
-          results_from_api = GoodData::Helpers.join(rules, stuff, [:cascade_drops, :preserve_data], [:cascade_drops, :preserve_data], inner: true).sort_by { |l| l[:priority] } || []
+          results_from_api = GoodData::Helpers.join(
+            rules,
+            stuff,
+            [:cascade_drops, :preserve_data],
+            [:cascade_drops, :preserve_data],
+            inner: true
+          ).sort_by { |l| l[:priority] } || []
 
           if preference.empty?
             [results_from_api.first[:orig]]