gooddata 0.6.0.pre6 → 0.6.0.pre7

data/bin/gooddata

@@ -3,6 +3,12 @@ require 'gli'
 require 'gooddata'
 require 'highline/import'
 require 'gooddata/commands/projects'
+require 'gooddata/commands/auth'
+require 'gooddata/commands/scaffold'
+require 'gooddata/commands/process'
+require 'gooddata/commands/api'
+require 'gooddata/commands/profile'
+require 'pp'
 
 include GLI::App
 
@@ -61,66 +67,77 @@ command :process do |c|
   c.default_value nil
   c.flag :dir
 
-  c.action do |global_options,options,args|
-    require 'gooddata/commands/process'
-    options = options.merge(global_options)
-
-    case args.first
-    when "list"
-      pp GoodData::Command::Process.list(options)
-    when "get"
-      pp GoodData::Command::Process.get(options)
-    when "deploy"
-      GoodData::Command::Process.deploy_graph(options[:dir], options)
+  c.desc 'Specify type of deployment'
+  c.default_value nil
+  c.flag :type
+
+  c.desc 'Specify name of deployed process'
+  c.default_value nil
+  c.flag :name
+
+  c.command :list do |list|
+    list.action do |global_options,options,args|
+      pp GoodData::Command::Process.list(options.merge(global_options))
+    end
+  end
+
+  c.command :get do |get|
+    get.action do |global_options,options,args|
+      pp GoodData::Command::Process.get(options.merge(global_options))
+    end
+  end
+
+  c.command :deploy do |deploy|
+    deploy.action do |global_options,options,args|
+      pp GoodData::Command::Process.deploy(options[:dir], options.merge(global_options))
     end
   end
+
 end
 
 desc 'Some basic API stuff directly from CLI'
 arg_name 'info|test|get|delete'
 command :api do |c|
 
-  c.action do |global_options,options,args|
-    require 'gooddata/commands/api'
-    options = options.merge(global_options)
-
-    case args.first
-    when "list", "index", "info"
+  c.command :info do |info|
+    info.action do |global_options,options,args|
       pp GoodData::Command::Api.info
-    when "get"
-      pp GoodData::Command::Api.get(args[1])
-    when "deploy"
-      GoodData::Command::Api.deploy_graph(options[:dir], options)
     end
   end
+
+  c.command :get do |get|
+    get.action do |global_options,options,args|
+      pp GoodData::Command::Api.get(args[0])
+    end
+  end
+
 end
 
 
 desc 'Describe add here'
 arg_name 'show'
 command :profile do |c|
-  c.action do |global_options, options, args|
-    require 'gooddata/commands/profile'
-    
-    case args.first
-    when "show"
+  
+  c.command :show do |show|
+    show.action do |global_options,options,args|
       pp GoodData::Command::Profile.show()
-    else
-      raise "command provided not right"
     end
   end
+  
 end
 
 desc 'Scaffold things'
 arg_name 'show'
 command :scaffold do |c|
   c.action do |global_options, options, args|
-    require 'gooddata/commands/scaffold'
-    case args.first
-    when "brick"
-      pp GoodData::Command::Scaffold.brick(args[1])
-    else
-      raise "command provided not right"
+
+    c.command :brick do |brick|
+      brick.arg_name 'name'
+      
+      name = args[1]
+      fail "Name of the brick has to be provided" if name.nil? || name.empty?
+      
+      GoodData::Command::Scaffold.brick(name)
     end
   end
 end
@@ -136,6 +153,26 @@ command :project do |c|
     end
   end
 
+  c.command :jack_in do |jack|
+    jack.action do |global_options,options,args|
+
+      goodfile = JSON.parse(File.read(GoodData::Helpers.find_goodfile(Pathname('.'))), :symbolize_names => true)
+      model_key = goodfile[:model]
+      blueprint = GoodData::Model::ProjectBlueprint.new(eval(File.read(model_key)).to_hash) if File.exist?(model_key) && !File.directory?(model_key)
+
+      project_id = global_options[:project_id] || goodfile[:project_id]
+      fail "You have to provide 'project_id'" if project_id.nil?
+
+      GoodData.with_project(project_id) do |project|
+        puts "Use 'exit' to quit the interactive session. Use 'q' to jump out of displaying a large output."
+        binding.pry(:quiet => true,
+          :prompt => [proc { |target_self, nest_level, pry|
+             "project_live_sesion: "
+           }])
+      end
+    end
+  end
+
   c.command :create do |create|
     create.action do |global_options,options,args|
       title = ask "Project name"
@@ -189,9 +226,12 @@ command :project do |c|
 
   c.command :build do |show|
     show.action do |global_options,options,args|
-      spec_path = args.first || fail("You need to specify the path of the build spec")
+      goodfile = JSON.parse(File.read(GoodData::Helpers.find_goodfile(Pathname('.'))), :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)
+
       opts = options.merge(global_options)
-      spec_path = Pathname.new(spec_path)
+      spec_path = Pathname(spec_path)
 
       content = File.read(spec_path)
       spec = if (spec_path.extname == ".rb")
@@ -206,6 +246,17 @@ command :project do |c|
 
 end
 
+desc 'Work with your credentials'
+command :auth do |c|
+
+  c.command :store do |store|
+    store.action do |global_options,options,args|
+      GoodData::Command::Auth.store
+    end
+  end
+
+end
+
 desc 'Run bricks locally'
 # arg_name 'show'
 command :run_ruby do |c|
@@ -214,10 +265,6 @@ command :run_ruby do |c|
   c.default_value nil
   c.flag [:d, :dir]
 
-  c.desc 'Project id for which you would like to run the script'
-  c.default_value nil
-  c.flag [:p, :project, :project_id, :project_pid]
-
   c.desc 'Log file. If empty STDOUT will be used instead'
   c.default_value nil
   c.flag [:l, :logger]
@@ -235,13 +282,13 @@ command :run_ruby do |c|
   
 
   c.action do |global_options, options, args|
-    options[:params] = if (options[:params])
+    options[:expanded_params] = if (options[:params])
       JSON.parse(File.read(options[:params]), :symbolize_names => true)
     else
       {}
     end
     
-    opts = options.merge(global_options).merge({:project_id => options[:project], "project_id" => options[:project], :type => "RUBY"})
+    opts = options.merge(global_options).merge({:type => "RUBY"})
     if options[:remote]
       fail "You have to specify name of the deploy when deploying remotely" if options[:name].nil? || options[:name].empty?
       require 'gooddata/commands/process'
@@ -255,29 +302,28 @@ command :run_ruby do |c|
   end
 end
 
-desc 'Manage your projects'
-arg_name 'project_command'
-command :project do |c|
-
-  c.command :list do |list|
-    list.action do |global_options,options,args|
-      list = GoodData::Command::Projects.list()
-      puts list.map {|p| [p.uri, p.title].join(",")}
-    end
-  end
-
-end
-
 pre do |global,command,options,args|
   require 'logger'
   GoodData.logger = Logger.new(STDOUT) if global[:l]
   username = global[:username]
   password = global[:password]
+  token = global[:token]
 
+  creds = GoodData::Command::Auth.read_credentials
+
+  username = creds[:username] if username.nil?
+  password = creds[:password] if password.nil?
+  token    = creds[:auth_token] if token.nil?
+  
+  global[:token] = token if global[:token].nil?
+  global[:username] = username if global[:username].nil?
+  global[:password] = password if global[:password].nil?
+    
   GoodData.connect(global.merge(options).merge({
     :login => username,
     :password => password,
-    :server => global[:server]
+    :server => global[:server],
+    :token => token
   }))
                     
   # Pre logic here

data/gooddata.gemspec

@@ -41,6 +41,9 @@ Gem::Specification.new do |s|
   s.add_dependency "pry"
   s.add_dependency "erubis"
   s.add_dependency "activesupport"
+  s.add_dependency "restforce"
+  s.add_dependency "salesforce_bulk"
+  s.add_dependency "twitter"
   
 end
 

data/lib/gooddata/bricks/base_downloader.rb

@@ -0,0 +1,62 @@
+module GoodData::Bricks
+  class BaseDownloader
+
+    def initialize(params)
+      @params = params
+    end
+
+    def pre_process(meta)
+      meta
+    end
+
+    def download
+      puts "would download data"
+      []
+    end
+
+    def backup(meta)
+      puts "would send a backup list of files to backup"
+      files = meta.reduce([]) do |memo, item|
+        memo << item[:filename]
+      end
+
+      bucket_name = @params[:s3_backup_bucket_name]
+
+      s3 = AWS::S3.new(
+        :access_key_id => @params[:aws_access_key_id],
+        :secret_access_key => @params[:aws_secret_access_key])
+
+      bucket = s3.buckets[bucket_name]
+      bucket = s3.buckets.create(bucket_name) unless bucket.exists?
+
+      files.each do |file|
+        obj = bucket.objects[file]
+        obj.write(Pathname.new(file))
+      end
+      meta
+    end
+
+    def post_process(meta)
+      puts "Maybe some postprocessing"
+      meta
+    end
+
+    def run
+      downloaded_data = download
+      downloaded_data = pre_process(downloaded_data)
+      backup(downloaded_data)
+      downloaded_data = post_process(downloaded_data)
+    
+      downloaded_data.reduce([]) do |memo, item|
+        item.has_key?(:state) ? memo.concat(item[:state]) : memo
+      end.each do |item|
+        key = item[:key]
+        val = item[:value]
+
+        puts "Saving metadata #{}"
+        GoodData::ProjectMetadata[key] = val
+      end
+    end
+
+  end
+end

data/lib/gooddata/bricks/brick.rb

@@ -1,42 +1,41 @@
 require 'gooddata/bricks/utils'
+require 'gooddata/bricks/base_downloader'
 require 'gooddata/bricks/middleware/middleware'
 require 'gooddata/bricks/middleware/bench_middleware'
 require 'gooddata/bricks/middleware/gooddata_middleware'
 require 'gooddata/bricks/middleware/logger_middleware'
 require 'gooddata/bricks/middleware/stdout_middleware'
 require 'gooddata/bricks/middleware/restforce_middleware'
+require 'gooddata/bricks/middleware/bulk_salesforce_middleware.rb'
 require 'gooddata/bricks/middleware/twitter_middleware'
 
-module GoodData
-  module Bricks
-
-    class Pipeline
-      def self.prepare(pipeline)
-        pipeline.reverse.reduce(nil) {|memo, app| memo.nil? ? app.new : app.new(memo)}
-      end
+module GoodData::Bricks
+  class Pipeline
+    def self.prepare(pipeline)
+      pipeline.reverse.reduce(nil) {|memo, app| memo.nil? ? app.new : app.new(memo)}
     end
-    
-    class Brick
-
-      def log(message)
-        logger = @params[:gdc_logger]
-        logger.info(message) unless logger.nil?
-      end
+  end
+  
+  class Brick
 
-      def name
-        self.class
-      end
+    def log(message)
+      logger = @params[:gdc_logger]
+      logger.info(message) unless logger.nil?
+    end
 
-      def version
-        fail "Method version should be reimplemented"
-      end
+    def name
+      self.class
+    end
 
-      def call(params={})
-        @params = params
-        ""
-      end
+    def version
+      fail "Method version should be reimplemented"
+    end
 
+    def call(params={})
+      @params = params
+      ""
     end
-    
+
   end
+  
 end

data/lib/gooddata/bricks/middleware/bulk_salesforce_middleware.rb

@@ -0,0 +1,38 @@
+require 'gooddata'
+require 'salesforce_bulk'
+
+module GoodData::Bricks
+  class BulkSalesforceMiddleware < GoodData::Bricks::Middleware
+
+    def call(params)
+
+      username      = params[:salesforce_username]
+      password      = params[:salesforce_password]
+      token         = params[:salesforce_token]
+      client_id     = params[:salesforce_client_id]
+      client_secret = params[:salesforce_client_secret]
+      host          = params[:salesforce_host]
+
+      credentials = {}
+
+      credentials = if (username && password && token)
+        {
+          :username       => username,
+          :password       => password,
+          :security_token => token
+        }
+      end
+
+      client = if credentials
+        credentials.merge!({
+          :client_id      => client_id,
+          :client_secret  => client_secret,
+        })
+        credentials[:host] = host unless host.nil?
+        SalesforceBulk::Api.new(credentials[:username], credentials[:password] + credentials[:security_token])
+      end
+      @app.call(params.merge(:salesforce_bulk_client => client))
+    end
+
+  end
+end

data/lib/gooddata/bricks/middleware/gooddata_middleware.rb

@@ -11,12 +11,14 @@ module GoodData::Bricks
       project_id = params[:GDC_PROJECT_ID]
 
       fail "SST (SuperSecureToken) not present in params" if params[token_name].nil?
-      logger.info "Connecting to GD with SST"
       server = if !params[protocol_name].empty? && !params[server_name].empty?
         params[protocol_name] + "://" + params[server_name]
       end
 
-      GoodData.connect_with_sst(params[token_name], {:server => server})
+      fail "GoodData username is missing. Expected param :GDC_USERANME" if params[:GDC_USERNAME].nil?
+      fail "GoodData password is missing. Expected param :GDC_PASSWORD" if params[:GDC_PASSWORD].nil?
+
+      GoodData.connect(params[:GDC_USERNAME], params[:GDC_PASSWORD], {:server => server})
       GoodData.logger = logger
       GoodData.with_project(project_id) do |p|
         @app.call(params)