zendesk2 1.4.2 → 1.5.3

data/lib/zendesk2/client/requests/get_user_memberships.rb

@@ -1,22 +1,16 @@
-class Zendesk2::Client
-  class Real
-    def get_user_memberships(params={})
-      user_id     = params["user_id"]
-      page_params = Zendesk2.paging_parameters(params)
+class Zendesk2::Client::GetUserMemberships < Zendesk2::Client::Request
+  request_method :get
+  request_path  { |r| "/users/#{r.user_id}/organization_memberships.json" }
 
-      request(
-        :params  => page_params,
-        :method  => :get,
-        :path    => "/users/#{user_id}/organization_memberships.json",
-      )
-    end
-  end # Real
+  page_params!
 
-  class Mock
-    def get_user_memberships(params={})
-      user_id = params["user_id"]
+  def user_id
+    params.fetch("membership").fetch("user_id").to_i
+  end
 
-      resources(:memberships, "/users/#{user_id}/organization_memberships.json", "organization_memberships", filter: lambda{|c| c.select { |a| a["user_id"] == user_id }})
-    end
-  end # Mock
+  def mock
+    collection = self.data[:memberships].values.select { |m| m["user_id"] == user_id }
+
+    resources(collection, root: "organization_memberships")
+  end
 end

data/lib/zendesk2/client/requests/get_users.rb

@@ -1,18 +1,10 @@
-class Zendesk2::Client
-  class Real
-    def get_users(params={})
-      page_params = Zendesk2.paging_parameters(params)
+class Zendesk2::Client::GetUsers < Zendesk2::Client::Request
+  request_method :get
+  request_path { "/users.json" }
 
-      request(
-        :params  => page_params,
-        :method  => :get,
-        :path    => "/users.json",
-      )
-    end
-  end
-  class Mock
-    def get_users(params={})
-      page(params, :users, "/users.json", "users")
-    end
+  page_params!
+
+  def mock(params={})
+    page(:users, params)
   end
 end

data/lib/zendesk2/client/requests/mark_membership_default.rb

@@ -1,36 +1,25 @@
-class Zendesk2::Client
-  class Real
-    def mark_membership_default(params={})
-      id      = params.delete("id")
-      user_id = params.delete("user_id")
+class Zendesk2::Client::MarkMembershipDefault < Zendesk2::Client::Request
+  request_method :put
+  request_path { |r| "/users/#{r.user_id}/organization_memberships/#{r.identity}/make_default.json" }
 
-      path = "/users/#{user_id}/organization_memberships/#{id}/make_default.json"
-
-      request(
-        :method => :put,
-        :path   => path,
-      )
-    end
+  def identity
+    params.fetch("membership").fetch("id")
   end
-  class Mock
-    def mark_membership_default(params={})
-      id      = params.delete("id")
-      user_id = params.delete("user_id")
 
-      path = "/users/#{user_id}/organization_memberships/#{id}/make_default.json"
+  def user_id
+    params.fetch("membership").fetch("user_id").to_i
+  end
 
-      if (membership = self.find!(:memberships, id)) && membership["user_id"] == user_id
-        # only one user can be default
-        other_user_memberships = self.data[:memberships].values.select { |m| m["user_id"] == user_id }
-        other_user_memberships.each { |i| i["default"] = false }
-        membership["default"] = true
+  def mock
+    if (membership = self.find!(:memberships, identity)) && (membership["user_id"] == user_id)
+      # only one user can be default
+      other_user_memberships = self.data[:memberships].values.select { |m| m["user_id"]== user_id }
+      other_user_memberships.each { |i| i["default"] = false }
+      membership["default"] = true
 
-        response(
-          :method => :put,
-          :path   => path
-        )
-      else error!(:not_found)
-      end
+      mock_response(params)
+    else
+      error!(:not_found)
     end
   end
 end

data/lib/zendesk2/client/requests/mark_user_identity_primary.rb

@@ -1,37 +1,24 @@
-class Zendesk2::Client
-  class Real
-    def mark_user_identity_primary(params={})
-      id      = params.delete("id")
-      user_id = params.delete("user_id")
-      path    = "/users/#{user_id}/identities/#{id}/make_primary.json"
+class Zendesk2::Client::MarkUserIdentityPrimary < Zendesk2::Client::Request
+  request_path { |r| "/users/#{r.user_id}/identities/#{r.user_identity_id}/make_primary.json" }
+  request_method :put
 
-      request(
-        :method => :put,
-        :path   => path,
-      )
-    end
+  def user_id
+    params.fetch("user_identity").fetch("user_id")
   end
-  class Mock
-    def mark_user_identity_primary(params={})
-      id      = params.delete("id").to_s
-      user_id = params.delete("user_id").to_s
-      path    = "/users/#{user_id}/identities/#{id}/make_primary.json"
 
-      user_identity = self.find!(:identities, id)
+  def user_identity_id
+    params.fetch("user_identity").fetch("id")
+  end
+
+  def mock
+    user_identity = self.find!(:identities, user_identity_id)
+
+    # only one user can be primary
+    other_user_identities = service.data[:identities].values.select { |i| i["user_id"] == user_id }
+    other_user_identities.map { |i| i["primary"] = false }
 
-      if user_identity && user_identity["user_id"] == user_id
-        # only one user can be primary
-        other_user_identities = self.data[:identities].values.select{|i| i["user_id"] == user_id}
-        other_user_identities.map{|i| i["primary"] = false}
-        user_identity["primary"] = true
+    user_identity.merge!("primary" => true)
 
-        response(
-          :method => :put,
-          :path   => path
-        )
-      else
-        error!(:not_found)
-      end
-    end
+    mock_response(nil)
   end
 end

data/lib/zendesk2/client/requests/search.rb

@@ -1,23 +1,34 @@
-class Zendesk2::Client
-  class Real
-    def search(query, params={})
-      request(
-        :method => :get,
-        :params => {query: query}.merge(params),
-        :path   => "/search.json",
-      )
-    end
-  end # Real
+class Zendesk2::Client::Search < Zendesk2::Client::Request
+  request_method :get
+  request_body { |r| { query: r.query } }
+  request_path { |_| "/search.json" }
 
-  class Mock
-    def search(query, params={})
-      terms = Hash[query.split(" ").map { |t| t.split(":") }]
-      type = terms.delete("type")
-      collection = type.nil? ? self.data.values : self.data[pluralize(type).to_sym]
+  attr_reader :query
 
-      results = collection.values.select { |v| terms.all?{ |term, condition| v[term.to_s].to_s == condition.to_s } }
+  def _mock(query, params={})
+    @query = query
+    setup(params)
+    mock
+  end
 
-      page(params, nil, "/search.json", "results", resources: results, query: {query: query})
-    end
-  end # Mock
+  def _real(query, params={})
+    @query = query
+    setup(params)
+    real
+  end
+
+  def mock
+    terms = Hash[query.split(" ").map { |t| t.split(":") }]
+    type  = terms.delete("type")
+
+    collection = if type.nil?
+                   service.data.values
+                 else
+                   service.data[pluralize(type).to_sym]
+                 end
+
+    results = collection.values.select { |v| terms.all?{ |term, condition| v[term].to_s == condition.to_s } }
+
+    page(results, params: {"query" => query}, root: "results")
+  end
 end

data/lib/zendesk2/client/requests/search_help_center_articles.rb

@@ -1,23 +1,27 @@
-class Zendesk2::Client
-  class Real
-    def search_help_center_articles(query, params={})
-      request(
-        :method => :get,
-        :params => {query: query}.merge(params),
-        :path   => "/help_center/articles/search.json",
-      )
-    end
-  end # Real
+class Zendesk2::Client::SearchHelpCenterArticles < Zendesk2::Client::Request
+  request_path { |_| "/help_center/articles/search.json" }
 
-  class Mock
-    def search_help_center_articles(query, params={})
-      terms = Hash[query.split(" ").map { |t| t.split(":") }]
+  attr_reader :query
 
-      collection = self.data[:help_center_articles].values
+  def _mock(query, params={})
+    @query = query
+    setup(params)
+    mock
+  end
 
-      results = collection.select { |v| terms.all?{ |term, condition| v[term.to_s].to_s == condition.to_s } }
+  def _real(query, params={})
+    @query = query
+    setup(params)
+    real
+  end
 
-      page(params, :help_center_articles, "/search.json", "results", resources: results, query: {query: query})
-    end
-  end # Mock
+  def mock
+    terms = Hash[query.split(" ").map { |t| t.split(":") }]
+
+    collection = self.data[:help_center_articles].values
+
+    results = collection.select { |v| terms.all?{ |term, condition| v[term.to_s].to_s == condition.to_s } }
+
+    page(results, params: {"query" => query}, root: "results")
+  end
 end

data/lib/zendesk2/client/requests/search_organization.rb

@@ -1,36 +1,48 @@
-class Zendesk2::Client
-  class Real
-    alias search_organization search
-  end # Real
+class Zendesk2::Client::SearchOrganization < Zendesk2::Client::Request
+  request_method :get
+  request_path { "/search.json" }
+  request_body { |r| { "query" => r.query } }
 
-  class Mock
-    def search_organization(query, params={})
-      terms = Hash[query.split(" ").map { |t| t.split(":") }]
-      terms.delete("type") # context already provided
+  attr_reader :query
 
-      collection = self.data[:organizations].values
+  def _mock(query, params={})
+    @query = query
+    setup(params)
+    mock
+  end
 
-      # organization name is fuzzy matched
-      if organization_name = terms.delete("name")
-        terms.merge!("name" => "*#{organization_name}*")
-      end
+  def _real(query, params={})
+    @query = query
+    setup(params)
+    real
+  end
 
-      compiled_terms = terms.inject({}) do |r,(term, raw_condition)|
-        condition = if raw_condition.include?("*")
-                      Regexp.compile(raw_condition.gsub("*", ".*"), Regexp::IGNORECASE)
-                    else
-                      raw_condition
-                    end
-        r.merge(term => condition)
-      end
+  def mock
+    terms = Hash[query.split(" ").map { |t| t.split(":") }]
+    terms.delete("type") # context already provided
 
-      results = collection.select do |v|
-        compiled_terms.all? do |term, condition|
-          condition.is_a?(Regexp) ? condition.match(v[term.to_s]) : v[term.to_s].to_s == condition.to_s
-        end
-      end
+    collection = self.data[:organizations].values
+
+    # organization name is fuzzy matched
+    if organization_name = terms.delete("name")
+      terms.merge!("name" => "*#{organization_name}*")
+    end
 
-      page(params, :organizations, "/search.json", "results", resources: results, query: {query: query})
+    compiled_terms = terms.inject({}) do |r,(term, raw_condition)|
+      condition = if raw_condition.include?("*")
+                    Regexp.compile(raw_condition.gsub("*", ".*"), Regexp::IGNORECASE)
+                  else
+                    raw_condition
+                  end
+      r.merge(term => condition)
     end
-  end # Mock
+
+    results = collection.select do |v|
+      compiled_terms.all? do |term, condition|
+        condition.is_a?(Regexp) ? condition.match(v[term.to_s]) : v[term.to_s].to_s == condition.to_s
+      end
+    end
+
+    page(results, params: {"query" => query}, root: "results")
+  end
 end

data/lib/zendesk2/client/requests/search_user.rb

@@ -1,52 +1,64 @@
-class Zendesk2::Client
-  class Real
-    alias search_user search
-  end # Real
-
-  class Mock
-    def search_user(query, params={})
-      terms = Hash[query.split(" ").map { |t| t.split(":") }]
-      terms.delete("type") # context already provided
-
-      collection = self.data[:users].values
-
-      # create a copy of each user mapped to a specific user identity
-      collection = collection.map do |user|
-        self.data[:identities].values.select{|i| i["type"] == "email" && i["user_id"] == user["id"]}.map do |identity|
-          user.merge("email" => identity["value"])
-        end
-      end.flatten
-
-      # allow searching by organization name
-      collection = collection.map do |user|
-        if organization = self.data[:organizations][user["organization_id"].to_s]
-          user.merge("organization" => organization["name"])
-        else
-          user
-        end
-      end
+class Zendesk2::Client::SearchUser < Zendesk2::Client::Request
+  request_method :get
+  request_path { "/search.json" }
+  request_body { |r| { "query" => r.query } }
 
-      # organization name is fuzzy matched
-      if organization_name = terms.delete("organization")
-        terms.merge!("organization" => "*#{organization_name}*")
-      end
+  attr_reader :query
+
+  def _mock(query, params={})
+    @query = query
+    setup(params)
+    mock
+  end
+
+  def _real(query, params={})
+    @query = query
+    setup(params)
+    real
+  end
 
-      compiled_terms = terms.inject({}) do |r,(term, raw_condition)|
-        condition = if raw_condition.include?("*")
-                      Regexp.compile(raw_condition.gsub("*", ".*"), Regexp::IGNORECASE)
-                    else
-                      raw_condition
-                    end
-        r.merge(term => condition)
+  def mock
+    terms = Hash[query.split(" ").map { |t| t.split(":") }]
+    terms.delete("type") # context already provided
+
+    collection = self.data[:users].values
+
+    # create a copy of each user mapped to a specific user identity
+    collection = collection.map do |user|
+      self.data[:identities].values.select{|i| i["type"] == "email" && i["user_id"] == user["id"]}.map do |identity|
+        user.merge("email" => identity["value"])
       end
+    end.flatten
 
-      results = collection.select do |v|
-        compiled_terms.all? do |term, condition|
-          condition.is_a?(Regexp) ? condition.match(v[term.to_s]) : v[term.to_s].to_s == condition.to_s
-        end
+    # allow searching by organization name
+    collection = collection.map do |user|
+      if organization = self.data[:organizations][user["organization_id"].to_i]
+        user.merge("organization" => organization["name"])
+      else
+        user
       end
+    end
 
-      page(params, :users, "/search.json", "results", resources: results, query: {query: query})
+    # organization name is fuzzy matched
+    if organization_name = terms.delete("organization")
+      terms.merge!("organization" => "*#{organization_name}*")
     end
-  end # Mock
+
+    compiled_terms = terms.inject({}) do |r,(term, raw_condition)|
+      condition = if raw_condition.include?("*")
+                    Regexp.compile(raw_condition.gsub("*", ".*"), Regexp::IGNORECASE)
+                  else
+                    raw_condition
+                  end
+      r.merge(term => condition)
+    end
+
+    results = collection.select do |v|
+      compiled_terms.all? do |term, condition|
+        condition.is_a?(Regexp) ? condition.match(v[term.to_s]) : v[term.to_s].to_s == condition.to_s
+      end
+    end
+
+    page(results, params: {"query" => query}, root: "results")
+  end
 end