gooddata 0.6.0 → 0.6.2

data/lib/gooddata/commands/api.rb

@@ -34,19 +34,27 @@ module GoodData
         # Get resource
         # @param path Resource path
         def get(path)
-          raise(GoodData::CommandFailed, 'Specify the path you want to GET.') if path.nil?
+          fail(GoodData::CommandFailed, 'Specify the path you want to GET.') if path.nil?
           result = GoodData.get path
-          result rescue puts result
+          begin
+            result
+          rescue
+            puts result
+          end
         end
 
         # Delete resource
         # @param path Resource path
         def delete(path)
-          raise(GoodData::CommandFailed, 'Specify the path you want to DELETE.') if path.nil?
+          fail(GoodData::CommandFailed, 'Specify the path you want to DELETE.') if path.nil?
           result = GoodData.delete path
-          result rescue puts result
+          begin
+            result
+          rescue
+            puts result
+          end
         end
       end
     end
   end
-end
+end

data/lib/gooddata/commands/auth.rb

@@ -6,57 +6,64 @@ require 'multi_json'
 require_relative '../cli/terminal'
 require_relative '../helpers'
 
-module GoodData::Command
-  class Auth
-    class << self
+module GoodData
+  module Command
+    class Auth
+      class << self
+        # Get path of .gooddata config
+        def credentials_file
+          "#{GoodData::Helpers.home_directory}/.gooddata"
+        end
 
-      # Get path of .gooddata config
-      def credentials_file
-        "#{GoodData::Helpers.home_directory}/.gooddata"
-      end
+        # Ask for credentials
+        def ask_for_credentials
+          puts 'Enter your GoodData credentials.'
+          user = GoodData::CLI.terminal.ask('Email')
+          password = GoodData::CLI.terminal.ask('Password') { |q| q.echo = 'x' }
+          auth_token = GoodData::CLI.terminal.ask('Authorization Token')
 
-      # Ask for credentials
-      def ask_for_credentials
-        puts 'Enter your GoodData credentials.'
-        user = GoodData::CLI.terminal.ask('Email')
-        password = GoodData::CLI.terminal.ask('Password') { |q| q.echo = 'x' }
-        auth_token = GoodData::CLI.terminal.ask('Authorization Token')
+          { :username => user, :password => password, :auth_token => auth_token }
+        end
 
-        {:username => user, :password => password, :auth_token => auth_token}
-      end
+        # Read credentials
+        def read_credentials(credentials_file_path = credentials_file)
+          if File.exist?(credentials_file_path)
+            config = File.read(credentials_file_path)
+            MultiJson.load(config, :symbolize_keys => true)
+          else
+            {}
+          end
+        end
 
-      # Read credentials
-      def read_credentials
-        if File.exists?(credentials_file) then
-          config = File.read(credentials_file)
-          JSON.parser.new(config, :symbolize_names => true).parse
-        else
-          {}
+        # Writes credentials
+        def write_credentials(credentials, credentials_file_path = credentials_file)
+          File.open(credentials_file_path, 'w', 0600) do |f|
+            f.puts MultiJson.encode(credentials, :pretty => true)
+          end
+          credentials
         end
-      end
 
-      # Ask for credentials and store them
-      def store
-        credentials = ask_for_credentials
+        # Ask for credentials and store them
+        def store(credentials_file_path = credentials_file)
+          credentials = ask_for_credentials
 
-        ovewrite = if File.exist?(credentials_file)
-                     GoodData::CLI.terminal.ask("Overwrite existing stored credentials (y/n)")
-                   else
-                     'y'
-                   end
+          ovewrite = if File.exist?(credentials_file_path)
+                       GoodData::CLI.terminal.ask('Overwrite existing stored credentials (y/n)')
+                     else
+                       'y'
+                     end
 
-        if ovewrite == 'y'
-          File.open(credentials_file, 'w', 0600) do |f|
-            f.puts JSON.pretty_generate(credentials)
+          if ovewrite == 'y'
+            write_credentials(credentials, credentials_file_path)
+          else
+            puts 'Aborting...'
           end
-        else
-          puts 'Aborting...'
         end
-      end
 
-      # Delete stored credentials
-      def unstore
-        FileUtils.rm_f(credentials_file)
+        # Delete stored credentials
+        def unstore(credentials_file_path = credentials_file)
+          FileUtils.rm_f(credentials_file_path)
+        end
       end
     end
   end

data/lib/gooddata/commands/base.rb

@@ -1,6 +1,8 @@
 # encoding: UTF-8
 
-module GoodData::Command
-  class Base
+module GoodData
+  module Command
+    class Base
+    end
   end
 end

data/lib/gooddata/commands/commands.rb

@@ -4,4 +4,4 @@ require 'pathname'
 base = Pathname(__FILE__).dirname.expand_path
 Dir.glob(base + '*.rb').each do |file|
   require file
-end
+end

data/lib/gooddata/commands/datasets.rb

@@ -65,9 +65,18 @@ module GoodData
         # TODO: Review following connect replacement/reimplementation
         # connect
         with_project do |project_id|
-          cfg_file = args.shift rescue nil
-          raise(CommandFailed, "Usage: #{$0} <dataset config>") unless cfg_file
-          config = JSON.load open(cfg_file) rescue raise(CommandFailed, "Error reading dataset config file '#{cfg_file}'")
+          begin
+            cfg_file = args.shift
+          rescue
+            raise(CommandFailed, 'Invalid arguments')
+          end
+
+          fail(CommandFailed, "Usage: #{$PROGRAM_NAME} <dataset config>") unless cfg_file
+          config = begin
+            JSON.load open(cfg_file)
+          rescue
+            raise(CommandFailed, "Error reading dataset config file '#{cfg_file}'")
+          end
           objects = Project[project_id].add_dataset config['title'], config['columns']
           puts "Dataset #{config['title']} added to the project, #{objects['uris'].length} metadata objects affected"
         end
@@ -88,8 +97,12 @@ module GoodData
         # connect
         with_project do |project_id|
           file, cfg_file = args
-          raise(CommandFailed, "Usage: #{$0} datasets:load <file> <dataset config>") unless cfg_file
-          config = JSON.load open(cfg_file) rescue raise(CommandFailed, "Error reading dataset config file '#{cfg_file}'")
+          fail(CommandFailed, "Usage: #{$PROGRAM_NAME} datasets:load <file> <dataset config>") unless cfg_file
+          begin
+            config = JSON.load open(cfg_file)
+          rescue
+            raise(CommandFailed, "Error reading dataset config file '#{cfg_file}'")
+          end
           schema = Model::Schema.new config
           Project[project_id].upload file, schema
         end
@@ -100,7 +113,7 @@ module GoodData
       def with_project
         unless @project_id
           @project_id = extract_option('--project')
-          raise CommandFailed.new('Project not specified, use the --project switch') unless @project_id
+          fail(CommandFailed, 'Project not specified, use the --project switch') unless @project_id
         end
         yield @project_id
       end
@@ -124,7 +137,7 @@ module GoodData
       def create_dataset
         file = extract_option('--file-csv')
         return Extract::CsvFile.new(file) if file
-        raise CommandFailed.new('Unknown data set. Please specify a data set using --file-csv option (more supported data sources to come!)')
+        fail(CommandFailed, 'Unknown data set. Please specify a data set using --file-csv option (more supported data sources to come!)')
       end
     end
   end

data/lib/gooddata/commands/domain.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+require_relative '../exceptions/command_failed'
+require_relative '../models/domain'
+
+module GoodData
+  module Command
+    # Low level access to GoodData API
+    class Domain
+      attr_reader :name
+
+      class << self
+        def add_user(domain, login, password)
+          GoodData::Domain.add_user(domain, login, password)
+        end
+
+        def list_users(domain)
+          GoodData::Domain.users(domain)
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/commands/process.rb

@@ -1,16 +1,20 @@
 # encoding: UTF-8
 
+require 'pathname'
+
+require_relative '../core/core'
+
 module GoodData
   module Command
     class Process
       class << self
-        def list(options={})
+        def list(options = {})
           GoodData.with_project(options[:project_id]) do
-            processes = GoodData::Process[:all]
+            GoodData::Process[:all]
           end
         end
 
-        def get(options={})
+        def get(options = {})
           id = options[:process_id]
           fail 'Unspecified process id' if id.nil?
 
@@ -19,137 +23,39 @@ module GoodData
           end
         end
 
-        def deploy(dir, options={})
-          verbose = options[:verbose] || false
+        def delete(process_id, options = {})
           GoodData.with_project(options[:project_id]) do
-            params = options[:params].nil? ? [] : [options[:params]]
-            deploy_graph(dir, options.merge({:files_to_exclude => params}))
+            process = GoodData::Process[process_id]
+            process.delete
           end
         end
 
-        def with_deploy(dir, options={}, &block)
-          verbose = options[:verbose] || false
-          GoodData.with_project(options[:project_id]) do |project|
+        # TODO: check files_to_exclude param. Does it do anything? It should check that in case of using CLI, it makes sure the files are not deployed
+        def deploy(dir, options = {})
+          GoodData.with_project(options[:project_id]) do
             params = options[:params].nil? ? [] : [options[:params]]
-            if block
-              begin
-                res = deploy_graph(dir, options.merge({:files_to_exclude => params}))
-                block.call(res)
-              ensure
-                self_link = res && res['process']['links']['self']
-                GoodData.delete(self_link)
-              end
-            else
-              deploy_graph(dir, options.merge({:files_to_exclude => params}))
-            end
+            GoodData::Process.deploy(dir, options.merge(:files_to_exclude => params))
           end
         end
 
-        def execute_process(link, dir, options={})
-          dir = Pathname(dir)
-          type = :ruby
-          if type == :ruby
-            result = GoodData.post(link, {
-              :execution => {
-                :graph => ('./main.rb').to_s,
-                :params => options[:expanded_params]
-              }
-            })
-            begin
-              GoodData.poll(result, 'executionTask')
-            rescue RestClient::RequestFailed => e
-
-            ensure
-              result = GoodData.get(result['executionTask']['links']['detail'])
-              if result['executionDetail']['status'] == 'ERROR'
-                fail "Runing process failed. You can look at a log here #{result["executionDetail"]["logFileName"]}"
-              end
-            end
-            result
-          else
-            result = GoodData.post(link, {
-              :execution => {
-                :graph => dir + 'graphs/main.grf',
-                :params => {}
-              }
-            })
-            begin
-              GoodData.poll(result, 'executionTask')
-            rescue RestClient::RequestFailed => e
-
-            ensure
-              result = GoodData.get(result['executionTask']['links']['detail'])
-              if result['executionDetail']['status'] == 'ERROR'
-                fail "Runing process failed. You can look at a log here #{result["executionDetail"]["logFileName"]}"
-              end
-            end
-            result
+        def execute_process(process_id, executable, options = {})
+          GoodData.with_project(options[:project_id]) do
+            process = GoodData::Process[process_id]
+            process.execute_process(executable, options)
           end
         end
 
-        def run(dir, options={})
-          email = options[:email]
+        def run(dir, executable, options = {})
           verbose = options[:v]
           dir = Pathname(dir)
           name = options[:name] || "Temporary deploy[#{dir}][#{options[:project_name]}]"
 
-          with_deploy(dir, options.merge(:name => name)) do |deploy_response|
-            puts HighLine::color('Executing', HighLine::BOLD) if verbose
-            result = execute_process(deploy_response['process']['links']['executions'], dir, options)
-          end
-        end
-
-        private
-
-        def deploy_graph(dir, options={})
-          dir = Pathname(dir) || fail('Directory is not specified')
-          fail "\"#{dir}\" is not a directory" unless dir.directory?
-          files_to_exclude = options[:files_to_exclude].map { |p| Pathname(p) }
-
-          project_id = options[:project_id] || fail('Project Id has to be specified')
-
-          type = options[:type] || 'GRAPH'
-          deploy_name = options[:name]
-          verbose = options[:verbose] || false
-
-          puts HighLine::color("Deploying #{dir}", HighLine::BOLD) if verbose
-          res = nil
-
-          Tempfile.open('deploy-graph-archive') do |temp|
-            Zip::OutputStream.open(temp.path) do |zio|
-              FileUtils::cd(dir) do
-
-                files_to_pack = Dir.glob('./**/*').reject { |f| files_to_exclude.include?(Pathname(dir) + f) }
-                files_to_pack.each do |item|
-                  puts "including #{item}" if verbose
-                  unless File.directory?(item)
-                    zio.put_next_entry(item)
-                    zio.print IO.read(item)
-                  end
-                end
-              end
-            end
-
-            GoodData.upload_to_user_webdav(temp.path)
-            process_id = options[:process]
-
-            data = {
-              :process => {
-                :name => deploy_name,
-                :path => "/uploads/#{File.basename(temp.path)}",
-                :type => type
-              }
-            }
-            res = if process_id.nil?
-                    GoodData.post("/gdc/projects/#{GoodData.project.pid}/dataload/processes", data)
-                  else
-                    GoodData.put("/gdc/projects/#{GoodData.project.pid}/dataload/processes/#{process_id}", data)
-                  end
+          GoodData::Process.with_deploy(dir, options.merge(:name => name)) do |process|
+            puts HighLine.color('Executing', HighLine::BOLD) if verbose
+            process.execute(executable, options)
           end
-          puts HighLine::color("Deploy DONE #{dir}", HighLine::GREEN) if verbose
-          res
         end
       end
     end
   end
-end
+end

data/lib/gooddata/commands/project.rb

@@ -0,0 +1,147 @@
+# encoding: UTF-8
+
+require 'pathname'
+
+module GoodData
+  module Command
+    class Project
+      class << self
+        # Create new project based on options supplied
+        def create(options = {})
+          title = options[:title]
+          summary = options[:summary]
+          template = options[:template]
+          token = options[:token]
+
+          GoodData::Project.create(:title => title, :summary => summary, :template => template, :auth_token => token)
+        end
+
+        # Show existing project
+        def show(id)
+          GoodData::Project[id]
+        end
+
+        def invite(project_id, email, role, msg = GoodData::Project::DEFAULT_INVITE_MESSAGE)
+          msg = GoodData::Project::DEFAULT_INVITE_MESSAGE if msg.nil? || msg.empty?
+
+          project = GoodData::Project[project_id]
+          fail "Invalid project id '#{project_id}' specified" if project.nil?
+
+          project.invite(email, role, msg)
+        end
+
+        # Clone existing project
+        def clone(project_id, options)
+          with_data = options[:data] || true
+          with_users = options[:users] || false
+          export = {
+            :exportProject => {
+              :exportUsers => with_users ? 1 : 0,
+              :exportData => with_data ? 1 : 0
+            }
+          }
+
+          result = GoodData.post("/gdc/md/#{project_id}/maintenance/export", export)
+          export_token = result['exportArtifact']['token']
+          status_url = result['exportArtifact']['status']['uri']
+
+          state = GoodData.get(status_url)['taskState']['status']
+          while state == 'RUNNING'
+            sleep 5
+            result = GoodData.get(status_url)
+            state = result['taskState']['status']
+          end
+
+          old_project = GoodData::Project[project_id]
+          project_uri = create(options.merge(:title => "Clone of #{old_project.title}"))
+          new_project = GoodData::Project[project_uri]
+
+          import = {
+            :importProject => {
+              :token => export_token
+            }
+          }
+          result = GoodData.post("/gdc/md/#{new_project.obj_id}/maintenance/import", import)
+          status_url = result['uri']
+          state = GoodData.get(status_url)['taskState']['status']
+          while state == 'RUNNING'
+            sleep 5
+            result = GoodData.get(status_url)
+            state = result['taskState']['status']
+          end
+          true
+        end
+
+        # Delete existing project
+        def delete(project_id)
+          p = GoodData::Project[project_id]
+          p.delete
+        end
+
+        # Get Spec and ID (of project)
+        def get_spec_and_project_id(base_path)
+          goodfile_path = GoodData::Helpers.find_goodfile(Pathname(base_path))
+          fail 'Goodfile could not be located in any parent directory. Please make sure you are inside a gooddata project folder.' if goodfile_path.nil?
+          goodfile = JSON.parse(File.read(goodfile_path), :symbolize_names => true)
+          spec_path = goodfile[:model] || fail('You need to specify the path of the build spec')
+          fail "Model path provided in Goodfile \"#{spec_path}\" does not exist" unless File.exist?(spec_path) && !File.directory?(spec_path)
+
+          spec_path = Pathname(spec_path)
+
+          content = File.read(spec_path)
+          spec = if spec_path.extname == '.rb'
+                   eval(content)
+                 elsif spec_path.extname == '.json'
+                   JSON.parse(spec_path, :symbolize_names => true)
+                 end
+          [spec, goodfile[:project_id]]
+        end
+
+        def list_users(pid)
+          users = []
+          finished = false
+          offset = 0
+          # Limit set to 1000 to be safe
+          limit = 1000
+          until finished
+            result = GoodData.get('/gdc/projects/#{pid}/users?offset=#{offset}&limit=#{limit}')
+            result['users'].map do |u|
+              as = u['user']
+              users.push(
+                  :login => as['content']['email'],
+                  :uri => as['links']['self'],
+                  :first_name => as['content']['firstname'],
+                  :last_name => as['content']['lastname'],
+                  :role => as['content']['userRoles'].first,
+                  :status => as['content']['status']
+            )
+            end
+            if result['users'].count == limit
+              offset += limit
+            else
+              finished = true
+            end
+          end
+          users
+        end
+
+        # Update project
+        def update(options = {})
+          project = options[:project]
+          GoodData::Model::ProjectCreator.migrate(:spec => options[:spec], :project => project)
+        end
+
+        # Build project
+        def build(options = {})
+          GoodData::Model::ProjectCreator.migrate(:spec => options[:spec], :token => options[:token])
+        end
+
+        def validate(project_id)
+          GoodData.with_project(project_id) do |p|
+            p.validate
+          end
+        end
+      end
+    end
+  end
+end