sf_cli 0.0.8 → 0.0.10

data/lib/sf_cli/sf/model/query_condition.rb

@@ -6,7 +6,16 @@ module SfCli
       module QueryMethods
         # @private :nodoc: just for developers
         class QueryCondition
-          attr_reader :connection, :object_name, :all_field_names, :fields, :conditions, :limit_num, :row_order
+          attr_reader :connection,
+                      :object_name,
+                      :all_field_names,
+                      :fields,
+                      :conditions,
+                      :limit_num,
+                      :row_order,
+                      :count_select,
+                      :max_select_field,
+                      :min_select_field
 
           def initialize(connection, object_name, field_names)
             @object_name = object_name
@@ -16,71 +25,23 @@ module SfCli
             @conditions = [] 
             @limit_num = nil
             @row_order = nil
+            @count_select = false
+            @max_select_field = nil
+            @min_select_field = nil
           end
 
           def where(*expr)
-            return self if expr&.empty?
-            return self if expr.map{|o| (o == '' || o == {} || o == []) ? nil : o}.compact.size.zero?
-            return self unless [Hash, Symbol, String].any?{|klass| expr.first.instance_of? klass}
+            return self unless valid_expr?(expr)
 
-            if expr.size > 1
-              return self if expr.size < 3
-
-              value = case expr[2].class.name.to_sym
-                      when :String
-                        %|'#{expr[2]}'|
-                      when :Time
-                        expr[2].to_datetime
-                      when :Array
-                        candidates = expr[2].map do |o|
-                            case o.class.name.to_sym
-                            when :String
-                              %|'#{o}'|
-                            when :Time
-                              o.to_datetime
-                            else
-                              o
-                            end
-                          end
-                        %|IN (#{candidates.join(', ')})|
-                      else
-                        expr[2]
-                      end
-              conditions << %|#{expr[0]} #{expr[1]} #{value}|
-
-              return self
-            end
+            conditions.append to_string_expr(expr)
+            self
+          end
 
-            if expr[0].instance_of? String
-              conditions << expr[0]
-              return self
-            end
+          def not(*expr)
+            return self unless valid_expr?(expr)
 
-            new_conditions =
-              expr[0].map do |k,v| 
-                case v.class.name.to_sym
-                when :String
-                  %|#{k} = '#{v}'|
-                when :Time
-                  %|#{k} = #{v.to_datetime}|
-                when :Array
-                  candidates = v.map do |o|
-                      case o.class.name.to_sym
-                      when :String
-                        %|'#{o}'|
-                      when :Time
-                        %|#{o.to_datetime}|
-                      else
-                        o
-                      end
-                    end
-                  %|#{k} IN (#{candidates.join(', ')})|
-                else
-                  "#{k} = #{v}"
-                end
-              end
-            conditions.append new_conditions
-            return self
+            conditions.append %|NOT(#{to_string_expr(expr)})|
+            self
           end
 
           def select(*expr)
@@ -115,21 +76,113 @@ module SfCli
             [base, where, _order, limit].compact.join(' ')
           end
 
+          def to_csv
+            connection.query(to_soql, Object.const_get(object_name.to_sym), :csv)
+          end
+
           def all
             connection.query(to_soql, Object.const_get(object_name.to_sym))
           end
 
           def pluck(field_name)
-            all.map{|record| record.__send__(field_name.to_sym)}
+            connection.query(to_soql, nil).map{|record| record[field_name.to_s]}
           end
 
           def take
             limit(1).all.first
           end
 
+          def count
+            @count_select = true
+            connection.query(to_soql, nil).first['expr0']
+          end
+
+          def max(field_name)
+            @max_select_field = field_name
+            connection.query(to_soql, nil).first['expr0']
+          end
+
+          def min(field_name)
+            @min_select_field = field_name
+            connection.query(to_soql, nil).first['expr0']
+          end
+
+          private
+
           def select_fields
+            return 'COUNT(Id)'                if count_select
+            return "MAX(#{max_select_field})" if max_select_field
+            return "MIN(#{min_select_field})" if min_select_field
+
             (fields.empty? ? all_field_names : fields).join(', ')
           end 
+
+          def to_string_expr(expr)
+            return str_by_ternary_expr(expr) if expr.size > 1
+            return expr[0] if expr[0].instance_of? String
+
+            strs_by_hash_expr(expr)
+          end
+
+          def str_by_ternary_expr(expr)
+            return self if expr.size < 3
+
+            value = case expr[2].class.name.to_sym
+                    when :String
+                      %|'#{expr[2]}'|
+                    when :Time
+                      expr[2].to_datetime
+                    when :Array
+                      candidates = expr[2].map do |o|
+                          case o.class.name.to_sym
+                          when :String
+                            %|'#{o}'|
+                          when :Time
+                            o.to_datetime
+                          else
+                            o
+                          end
+                        end
+                      %|IN (#{candidates.join(', ')})|
+                    else
+                      expr[2]
+                    end
+            %|#{expr[0]} #{expr[1]} #{value}|
+          end
+
+          def valid_expr?(expr)
+            return false if expr&.empty?
+            return false if expr.map{|o| (o == '' || o == {} || o == []) ? nil : o}.compact.size.zero?
+            return false unless [Hash, Symbol, String].any?{|klass| expr.first.instance_of? klass}
+
+            true
+          end
+
+          def strs_by_hash_expr(expr)
+            expr[0].map do |k,v|
+              case v.class.name.to_sym
+              when :String
+                %|#{k} = '#{v}'|
+              when :Time
+                %|#{k} = #{v.to_datetime}|
+              when :Array
+                candidates = v.map do |o|
+                    case o.class.name.to_sym
+                    when :String
+                      %|'#{o}'|
+                    when :Time
+                      %|#{o.to_datetime}|
+                    else
+                      o
+                    end
+                  end
+                %|#{k} IN (#{candidates.join(', ')})|
+              else
+                "#{k} = #{v}"
+              end
+            end
+            .join(' AND ')
+          end
         end
       end
     end

data/lib/sf_cli/sf/model/query_methods.rb

@@ -22,10 +22,6 @@ module SfCli
             return qc
           end
 
-          def find(id)
-            connection.find(name.to_sym, id, Object.const_get(name.to_sym))
-          end
-
           def limit(num)
             qc = QueryCondition.new(connection, self.name, self.field_names)
             qc.limit(num)
@@ -38,11 +34,25 @@ module SfCli
             qc
           end
 
+          def find(id)
+            connection.find(name.to_sym, id, Object.const_get(name.to_sym))
+          end
+
+          def find_by(*find_condition)
+            qc = QueryCondition.new(connection, self.name, self.field_names)
+            qc.where(*find_condition).take
+          end
+
           def all
             qc = QueryCondition.new(connection, self.name, self.field_names)
             qc.all
           end
 
+          def to_csv
+            qc = QueryCondition.new(connection, self.name, self.field_names)
+            qc.to_csv
+          end
+
           def pluck(field_name)
             qc = QueryCondition.new(connection, self.name, self.field_names)
             qc.pluck(field_name)
@@ -52,6 +62,21 @@ module SfCli
             qc = QueryCondition.new(connection, self.name, self.field_names)
             qc.take
           end
+
+          def count
+            qc = QueryCondition.new(connection, self.name, self.field_names)
+            qc.count
+          end
+
+          def max(field_name)
+            qc = QueryCondition.new(connection, self.name, self.field_names)
+            qc.max(field_name)
+          end
+
+          def min(field_name)
+            qc = QueryCondition.new(connection, self.name, self.field_names)
+            qc.min(field_name)
+          end
         end
       end
     end

data/lib/sf_cli/sf/model/sf_command_connection.rb

@@ -37,8 +37,8 @@ module SfCli
         #
         # For query details, see {SfCli::Sf::Data::Query sf data query}
         #
-        def exec_query(soql, format: nil, bulk: false, timeout: nil, model_class: nil)
-          sf_data.query(soql, target_org: target_org, format: format, bulk: bulk, timeout: timeout, model_class: model_class)
+        def exec_query(soql, format: nil, bulk: false, wait: nil, model_class: nil)
+          sf_data.query(soql, target_org: target_org, format: format, bulk: bulk, wait: wait, model_class: model_class)
         end
 
         # @private :nodoc: just for developers
@@ -65,8 +65,8 @@ module SfCli
         end
 
         # @private :nodoc: just for developers
-        def query(soql, klass)
-          sf_data.query soql, target_org: target_org, model_class: klass
+        def query(soql, klass, format = nil)
+          sf_data.query soql, target_org: target_org, format: format, model_class: klass
         end
 
         # @private :nodoc: just for developers

data/lib/sf_cli/sf/org/display.rb

@@ -5,6 +5,7 @@ module SfCli::Sf::Org
     #
     # Returns the org's connection information
     # @param target_org [Symbol,String] an alias of paticular org, or username can be used
+    # @param api_version [Numeric]      override the api version used for api requests made by this command
     #
     # @note this function returns the org information including security sensitive things such as access token, username and so on.
     # @return [ConnectionInfo] the org's connection information
@@ -24,8 +25,8 @@ module SfCli::Sf::Org
     #
     # @see https://developer.salesforce.com/docs/atlas.en-us.sfdx_cli_reference.meta/sfdx_cli_reference/cli_reference_org_commands_unified.htm#cli_reference_org_display_unified command reference
     #
-    def display(target_org: nil)
-      flags    = {:"target-org" => target_org}
+    def display(target_org: nil, api_version: nil)
+      flags    = {:"target-org" => target_org, :"api-version" => api_version}
       json = exec(__method__, flags: flags, redirection: :null_stderr)
 
       ConnectionInfo.new(

data/lib/sf_cli/sf/sobject/describe.rb

@@ -5,6 +5,7 @@ module SfCli::Sf::Sobject
     # Returns a schema object containing the Salesforce object schema
     # @param object_type [Symbol,String] object type(ex: Account)
     # @param target_org  [Symbol,String] an alias of paticular org, or username can be used
+    # @param api_version [Numeric]       override the api version used for api requests made by this command
     #
     # @return [Schema] a schema object that represents the object schema
     #
@@ -12,15 +13,16 @@ module SfCli::Sf::Sobject
     #   schema = sf.sobject.describe :Account
     #   schema.name  # Account
     #   schema.label # Account
-    #   schema.field_names # [:Id, :Name, ....]
-    #   schema.fields[:Name] # => {"aggregatable"=>true, "aiPredictionField"=>false, "autoNumber"=>false,...}
+    #   schema.field_names            # [:Id, :Name, ....]
+    #   schema.fields.name_and_labels # [['Id', 'Account Id'], ['Name', 'Account Name'], ...]
     #
     # @see https://developer.salesforce.com/docs/atlas.en-us.sfdx_cli_reference.meta/sfdx_cli_reference/cli_reference_sobject_commands_unified.htm#cli_reference_sobject_describe_unified command reference
     #
-    def describe(object_type, target_org: nil)
+    def describe(object_type, target_org: nil, api_version: nil)
       flags    = {
-        :"sobject"    => object_type,
-        :"target-org" => target_org,
+        :"sobject"     => object_type,
+        :"target-org"  => target_org,
+        :"api-version" => api_version,
       }
       json = exec(__method__, flags: flags, redirection: :null_stderr)
       Schema.new(json['result'])

data/lib/sf_cli/sf/sobject/list.rb

@@ -3,13 +3,15 @@ module SfCli::Sf::Sobject
     # Returns a list of Salesforce object name
     # @param object_type [Symbol,String] 'all' or 'custom'
     # @param target_org  [Symbol,String] an alias of paticular org, or username can be used
+    # @param api_version [Numeric]       override the api version used for api requests made by this command
     #
     # @see https://developer.salesforce.com/docs/atlas.en-us.sfdx_cli_reference.meta/sfdx_cli_reference/cli_reference_sobject_commands_unified.htm#cli_reference_sobject_list_unified command reference
     #
-    def list(object_type, target_org: nil)
+    def list(object_type, target_org: nil, api_version: nil)
       flags    = {
-        :"sobject"    => (object_type.to_sym == :custom ? :custom : :all),
-        :"target-org" => target_org,
+        :"sobject"     => (object_type.to_sym == :custom ? :custom : :all),
+        :"target-org"  => target_org,
+        :"api-version" => api_version,
       }
       json = exec(__method__, flags: flags, redirection: :null_stderr)
       json['result']