discourse_api 0.44.0 → 0.47.0

data/lib/discourse_api/api/invite.rb

@@ -3,17 +3,82 @@ module DiscourseApi
   module API
     module Invite
       def invite_user(params = {})
-        post("/invites", params)
+        args = API.params(params)
+          .optional(
+            :email,
+            :skip_email,
+            :custom_message,
+            :max_redemptions_allowed,
+            :topic_id,
+            :group_ids,
+            :expires_at
+          ).to_h
+
+        post("/invites", args)
       end
 
+      # TODO: Deprecated. Remove after 20220506
       def invite_user_to_topic(params = {})
-        post("/t/#{params[:topic_id]}/invite", params)
+        deprecated(__method__, 'invite_to_topic')
+        invite_to_topic(params[:topic_id], params)
+      end
+
+      def invite_to_topic(topic_id, params = {})
+        args = API.params(params)
+          .optional(
+            :email,
+            :user,
+            :group_ids,
+            :custom_message
+          ).to_h
+
+        post("/t/#{topic_id}/invite", args)
+      end
+
+      def retrieve_invite(params = {})
+        args = API.params(params).required(:email).to_h
+
+        response = get("invites/retrieve.json", args)
+
+        response.body
       end
 
       # requires this plugin => https://github.com/discourse/discourse-invite-tokens
       def disposable_tokens(params = {})
         post("/invite-token/generate", params)
       end
+
+      def update_invite(invite_id, params = {})
+        args = API.params(params)
+          .optional(
+            :topic_id,
+            :group_ids,
+            :group_names,
+            :email,
+            :send_email,
+            :custom_message,
+            :max_redemptions_allowed,
+            :expires_at
+          ).to_h
+
+        put("invites/#{invite_id}", args)
+      end
+
+      def destroy_all_expired_invites
+        post("invites/destroy-all-expired")
+      end
+
+      def resend_all_invites
+        post("invites/reinvite-all")
+      end
+
+      def resend_invite(email)
+        post("invites/reinvite", { "email": email })
+      end
+
+      def destroy_invite(invite_id)
+        delete("/invites", { id: invite_id })
+      end
     end
   end
 end

data/lib/discourse_api/api/notifications.rb

@@ -2,8 +2,11 @@
 module DiscourseApi
   module API
     module Notifications
-      def notifications
-        response = get('/notifications.json')
+      def notifications(params = {})
+        params = API.params(params)
+          .optional(:username, :recent, :limit, :offset, :filter)
+
+        response = get('/notifications.json', params)
         response[:body]
       end
     end

data/lib/discourse_api/api/private_messages.rb

@@ -3,13 +3,20 @@ module DiscourseApi
   module API
     module PrivateMessages
 
-      # :target_usernames REQUIRED comma separated list of usernames
+      # TODO: Deprecated. Remove after 20220628
+      def create_private_message(args = {})
+        deprecated(__method__, 'create_pm')
+        args[:target_recipients] = args.delete :target_usernames
+        create_pm(args.to_h)
+      end
+
+      # :target_recipients REQUIRED comma separated list of usernames
       # :category OPTIONAL name of category, not ID
       # :created_at OPTIONAL seconds since epoch.
-      def create_private_message(args = {})
+      def create_pm(args = {})
         args[:archetype] = 'private_message'
         args = API.params(args)
-          .required(:title, :raw, :target_usernames, :archetype)
+          .required(:title, :raw, :target_recipients, :archetype)
           .optional(:category, :created_at, :api_username)
         post("/posts", args.to_h)
       end

data/lib/discourse_api/api/search.rb

@@ -12,7 +12,7 @@ module DiscourseApi
         raise ArgumentError.new("#{term} is required but not specified") unless term
         raise ArgumentError.new("#{term} is required but not specified") unless !term.empty?
 
-        response = get('/search/query', options.merge(term: term))
+        response = get('/search', options.merge(q: term))
         response[:body]
       end
     end

data/lib/discourse_api/api/topics.rb

@@ -29,6 +29,11 @@ module DiscourseApi
         response[:body]['topic_list']['topics']
       end
 
+      def top_topics(params = {})
+        response = get("/top.json", params)
+        response[:body]['topic_list']['topics']
+      end
+
       def new_topics(params = {})
         response = get("/new.json", params)
         response[:body]['topic_list']['topics']
@@ -69,15 +74,45 @@ module DiscourseApi
         delete("/t/#{id}.json")
       end
 
-      def topic_posts(topic_id, post_ids = [])
+      def topic_posts(topic_id, post_ids = [], params = {})
+        params = API.params(params)
+          .optional(:asc,
+            :filter,
+            :include_raw,
+            :include_suggested,
+            :post_number,
+            :username_filters,
+          )
+
         url = ["/t/#{topic_id}/posts.json"]
         if post_ids.count > 0
           url.push('?')
           url.push(post_ids.map { |id| "post_ids[]=#{id}" }.join('&'))
         end
-        response = get(url.join)
+        response = get(url.join, params)
         response[:body]
       end
+
+      def change_owner(topic_id, params = {})
+        params = API.params(params)
+          .required(:username, :post_ids)
+
+        post("/t/#{topic_id}/change-owner.json", params)
+      end
+
+      def topic_set_user_notification_level(topic_id, params)
+        params = API.params(params)
+          .required(:notification_level)
+        post("/t/#{topic_id}/notifications", params)
+      end
+
+      def bookmark_topic(topic_id)
+        put("/t/#{topic_id}/bookmark.json")
+      end
+
+      def remove_topic_bookmark(topic_id)
+        put("/t/#{topic_id}/remove_bookmarks.json")
+      end
     end
   end
 end

data/lib/discourse_api/api/users.rb

@@ -52,7 +52,7 @@ module DiscourseApi
       def create_user(args)
         args = API.params(args)
           .required(:name, :email, :password, :username)
-          .optional(:active, :staged, :user_fields)
+          .optional(:active, :approved, :staged, :user_fields)
           .to_h
         post("/users", args)
       end

data/lib/discourse_api/client.rb

@@ -29,7 +29,9 @@ module DiscourseApi
   class Client
     attr_accessor :api_key
     attr_accessor :basic_auth
-    attr_reader :host, :api_username
+    attr_reader :host, :api_username, :timeout
+
+    DEFAULT_TIMEOUT = 30
 
     include DiscourseApi::API::Categories
     include DiscourseApi::API::Search
@@ -60,6 +62,11 @@ module DiscourseApi
       @use_relative = check_subdirectory(host)
     end
 
+    def timeout=(timeout)
+      @timeout = timeout
+      @connection.options.timeout = timeout if @connection
+    end
+
     def api_username=(api_username)
       @api_username = api_username
       @connection.headers['Api-Username'] = api_username unless @connection.nil?
@@ -68,6 +75,9 @@ module DiscourseApi
     def connection_options
       @connection_options ||= {
         url: @host,
+        request: {
+          timeout: @timeout || DEFAULT_TIMEOUT
+        },
         headers: {
           accept: 'application/json',
           user_agent: user_agent,
@@ -158,6 +168,8 @@ module DiscourseApi
       response.env
     rescue Faraday::ClientError, JSON::ParserError
       raise DiscourseApi::Error
+    rescue Faraday::ConnectionFailed
+      raise DiscourseApi::Timeout
     end
 
     def handle_error(response)

data/lib/discourse_api/error.rb

@@ -33,4 +33,7 @@ module DiscourseApi
 
   class TooManyRequests < DiscourseError
   end
+
+  class Timeout < DiscourseError
+  end
 end

data/lib/discourse_api/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module DiscourseApi
-  VERSION = "0.44.0"
+  VERSION = "0.47.0"
 end

data/spec/discourse_api/api/api_key_spec.rb

@@ -10,77 +10,101 @@ describe DiscourseApi::API::ApiKey do
     )
   }
 
-  describe "#api" do
+  describe "#list_api_keys" do
     before do
-      url = "#{host}/admin/api.json"
-      stub_get(url).to_return(body: fixture("api.json"),
+      url = "#{host}/admin/api/keys"
+      stub_get(url).to_return(body: fixture("list_api_keys.json"),
                               headers: { content_type: "application/json" })
     end
 
     it "requests the correct resource" do
-      subject.api
-      url = "#{host}/admin/api.json"
+      subject.list_api_keys
+      url = "#{host}/admin/api/keys"
       expect(a_get(url)).to have_been_made
     end
 
     it "returns the requested api keys" do
-      api = subject.api
-      expect(api).to be_an Array
-      expect(api.first).to be_a Hash
-      expect(api.first).to have_key('key')
+      keys = subject.list_api_keys
+      expect(keys["keys"]).to be_an Array
+      expect(keys["keys"].first).to be_a Hash
+      expect(keys["keys"].first).to have_key('key')
     end
   end
 
-  describe "#generate_master_key" do
+  describe "#create_api_key" do
     before do
-      url = "#{host}/admin/api/key"
-      stub_post(url).to_return(body: fixture("generate_master_key.json"),
+      url = "#{host}/admin/api/keys"
+      stub_post(url).to_return(body: fixture("api_key.json"),
                                headers: { content_type: "application/json" })
     end
 
-    it "returns the generated master key" do
-      master_key = subject.generate_master_key
-      expect(master_key).to be_a Hash
-      expect(master_key['api_key']).to have_key('key')
-      expect(master_key['api_key']['user']).to eq(nil)
+    it "requests the correct resource" do
+      subject.create_api_key(key: { username: 'robin' })
+      url = "#{host}/admin/api/keys"
+      expect(a_post(url)).to have_been_made
+    end
+
+    it "returns the generated api key" do
+      api_key = subject.create_api_key(key: { username: 'robin' })
+      expect(api_key).to be_a Hash
+      expect(api_key['key']).to have_key('key')
     end
   end
 
   describe "#revoke_api_key" do
     before do
-      url = "#{host}/admin/api/key?id=10"
-      stub_delete(url).to_return(body: "",
-                                 headers: { content_type: "application/json" })
+      url = "#{host}/admin/api/keys/10/revoke"
+      stub_post(url).to_return(body: fixture("api_key.json"),
+                               headers: { content_type: "application/json" })
     end
 
     it "requests the correct resource" do
       subject.revoke_api_key(10)
-      url = "#{host}/admin/api/key?id=10"
-      expect(a_delete(url)).to have_been_made
+      url = "#{host}/admin/api/keys/10/revoke"
+      expect(a_post(url)).to have_been_made
     end
 
-    it "returns 200" do
-      response = subject.revoke_api_key(10)
-      expect(response['status']).to eq(200)
+    it "returns the api key" do
+      api_key = subject.revoke_api_key(10)
+      expect(api_key['key']).to have_key('key')
     end
   end
 
-  describe "#regenerate_api_key" do
+  describe "#undo_revoke_api_key" do
     before do
-      url = "#{host}/admin/api/key"
-      stub_put(url).to_return(body: fixture("regenerate_api_key.json"),
-                              headers: { content_type: "application/json" })
+      url = "#{host}/admin/api/keys/10/undo-revoke"
+      stub_post(url).to_return(body: fixture("api_key.json"),
+                               headers: { content_type: "application/json" })
     end
 
     it "requests the correct resource" do
-      subject.regenerate_api_key(10)
-      url = "#{host}/admin/api/key"
-      expect(a_put(url)).to have_been_made
+      subject.undo_revoke_api_key(10)
+      url = "#{host}/admin/api/keys/10/undo-revoke"
+      expect(a_post(url)).to have_been_made
     end
 
-    it "returns the regenerated api key" do
-      key = subject.regenerate_api_key(10)
-      expect(key['api_key']).to have_key('key')
+    it "returns the api key" do
+      api_key = subject.undo_revoke_api_key(10)
+      expect(api_key['key']).to have_key('key')
+    end
+  end
+
+  describe "#delete_api_key" do
+    before do
+      url = "#{host}/admin/api/keys/10"
+      stub_delete(url).to_return(body: '{"success": "OK"}',
+                                 headers: { content_type: "application/json" })
+    end
+
+    it "requests the correct resource" do
+      subject.delete_api_key(10)
+      url = "#{host}/admin/api/keys/10"
+      expect(a_delete(url)).to have_been_made
+    end
+
+    it "returns 200" do
+      response = subject.delete_api_key(10)
+      expect(response['status']).to eq(200)
     end
   end
 end

data/spec/discourse_api/api/categories_spec.rb

@@ -28,6 +28,25 @@ describe DiscourseApi::API::Categories do
     end
   end
 
+  describe "#categories_full" do
+    before do
+      stub_get("#{host}/categories.json")
+        .to_return(body: fixture("categories.json"), headers: { content_type: "application/json" })
+    end
+
+    it "requests the correct resource" do
+      subject.categories
+      expect(a_get("#{host}/categories.json")).to have_been_made
+    end
+
+    it "returns the entire categories response" do
+      categories = subject.categories_full
+      expect(categories).to be_a Hash
+      expect(categories).to have_key 'category_list'
+      expect(categories).to have_key 'featured_users'
+    end
+  end
+
   describe '#category_latest_topics' do
     before do
       stub_get("#{host}/c/category-slug/l/latest.json")
@@ -40,6 +59,20 @@ describe DiscourseApi::API::Categories do
     end
   end
 
+  describe '#category_latest_topics_full' do
+    before do
+      stub_get("#{host}/c/category-slug/l/latest.json")
+        .to_return(body: fixture("category_latest_topics.json"), headers: { content_type: "application/json" })
+    end
+
+    it "returns the entire latest topics in a category response" do
+      latest_topics = subject.category_latest_topics_full(category_slug: 'category-slug')
+      expect(latest_topics).to be_a Hash
+      expect(latest_topics).to have_key 'topic_list'
+      expect(latest_topics).to have_key 'users'
+    end
+  end
+
   describe '#category_top_topics' do
     before do
       stub_get("#{host}/c/category-slug/l/top.json")
@@ -55,6 +88,23 @@ describe DiscourseApi::API::Categories do
     end
   end
 
+  describe '#category_top_topics_full' do
+    before do
+      stub_get("#{host}/c/category-slug/l/top.json")
+        .to_return(
+        body: fixture("category_topics.json"),
+        headers: { content_type: "application/json" }
+      )
+    end
+
+    it "returns the entire top topics in a category response" do
+      topics = subject.category_top_topics_full('category-slug')
+      expect(topics).to be_a Hash
+      expect(topics).to have_key 'topic_list'
+      expect(topics).to have_key 'users'
+    end
+  end
+
   describe '#category_new_topics' do
     before do
       stub_get("#{host}/c/category-slug/l/new.json")
@@ -70,6 +120,23 @@ describe DiscourseApi::API::Categories do
     end
   end
 
+  describe '#category_new_topics_full' do
+    before do
+      stub_get("#{host}/c/category-slug/l/new.json")
+        .to_return(
+        body: fixture("category_topics.json"),
+        headers: { content_type: "application/json" }
+      )
+    end
+
+    it "returns the new topics in a category" do
+      topics = subject.category_new_topics_full('category-slug')
+      expect(topics).to be_a Hash
+      expect(topics).to have_key 'topic_list'
+      expect(topics).to have_key 'users'
+    end
+  end
+
   describe '#category_new_category' do
     before do
       stub_post("#{host}/categories")
@@ -85,4 +152,27 @@ describe DiscourseApi::API::Categories do
     end
   end
 
+  describe "#category_set_user_notification" do
+    before do
+      stub_post("#{host}/category/1/notifications").to_return(body: fixture("notification_success.json"), headers: { content_type: "application/json" })
+    end
+
+    it "makes the post request" do
+      response = subject.category_set_user_notification(id: 1, notification_level: 3)
+      expect(a_post("#{host}/category/1/notifications")).to have_been_made
+      expect(response['success']).to eq('OK')
+    end
+  end
+
+  describe "#category_set_user_notification_level" do
+    before do
+      stub_post("#{host}/category/1/notifications").to_return(body: fixture("notification_success.json"), headers: { content_type: "application/json" })
+    end
+
+    it "makes the post request" do
+      response = subject.category_set_user_notification_level(1, notification_level: 3)
+      expect(a_post("#{host}/category/1/notifications").with(body: "notification_level=3")).to have_been_made
+      expect(response['success']).to eq('OK')
+    end
+  end
 end