discourse_api 0.10.1 → 0.11.0

data/lib/discourse_api/api/search.rb

@@ -1,19 +1,19 @@
-module DiscourseApi
-  module API
-    module Search
-      # Returns search results that match the specified term.
-      #
-      # @param term [String] a search term
-      # @param options [Hash] A customizable set of options
-      # @option options [String] :type_filter Returns results of the specified type.
-      # @return [Array] Return results as an array of Hashes.
-      def search(term, options={})
-        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[:body]
-      end
-    end
-  end
-end
+module DiscourseApi
+  module API
+    module Search
+      # Returns search results that match the specified term.
+      #
+      # @param term [String] a search term
+      # @param options [Hash] A customizable set of options
+      # @option options [String] :type_filter Returns results of the specified type.
+      # @return [Array] Return results as an array of Hashes.
+      def search(term, options={})
+        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[:body]
+      end
+    end
+  end
+end

data/lib/discourse_api/api/sso.rb

@@ -1,22 +1,22 @@
-module DiscourseApi
-  module API
-    module SSO
-      def sync_sso(params={})
-        sso = DiscourseApi::SingleSignOn.new
-        sso.sso_secret = params[:sso_secret]
-        sso.name = params[:name]
-        sso.username = params[:username]
-        sso.email = params[:email]
-        sso.external_id = params[:external_id]
-        sso.suppress_welcome_message = params[:suppress_welcome_message] === true
-        sso.avatar_url = params[:avatar_url]
-        sso.avatar_force_update = params[:avatar_force_update] === true
-        params.keys.select{|key| key.to_s.start_with?("custom") }.each do |custom_key|
-          sso.custom_fields[custom_key] = params[custom_key]
-        end
-
-        post("/admin/users/sync_sso", sso.payload)
-      end
-    end
-  end
-end
+module DiscourseApi
+  module API
+    module SSO
+      def sync_sso(params={})
+        sso = DiscourseApi::SingleSignOn.new
+        sso.sso_secret = params[:sso_secret]
+        sso.name = params[:name]
+        sso.username = params[:username]
+        sso.email = params[:email]
+        sso.external_id = params[:external_id]
+        sso.suppress_welcome_message = params[:suppress_welcome_message] === true
+        sso.avatar_url = params[:avatar_url]
+        sso.avatar_force_update = params[:avatar_force_update] === true
+        params.keys.select{|key| key.to_s.start_with?("custom") }.each do |custom_key|
+          sso.custom_fields[custom_key] = params[custom_key]
+        end
+
+        post("/admin/users/sync_sso", sso.payload)
+      end
+    end
+  end
+end

data/lib/discourse_api/api/tags.rb

@@ -1,10 +1,10 @@
-module DiscourseApi
-  module API
-    module Tags
-      def show_tag(tag)
-        response = get("/tags/#{tag}")
-        response[:body]
-      end
-    end
-  end
-end
+module DiscourseApi
+  module API
+    module Tags
+      def show_tag(tag)
+        response = get("/tags/#{tag}")
+        response[:body]
+      end
+    end
+  end
+end

data/lib/discourse_api/api/topics.rb

@@ -1,65 +1,78 @@
-module DiscourseApi
-  module API
-    module Topics
-      # :category OPTIONAL name of category, not ID
-      # :skip_validations OPTIONAL boolean
-      # :auto_track OPTIONAL boolean
-      def create_topic(args={})
-        args = API.params(args)
-                  .required(:title, :raw)
-                  .optional(:skip_validations, :category, :auto_track)
-        post("/posts", args.to_h)
-      end
-
-      def create_topic_action(args)
-        args = API.params(args)
-                   .required(:id, :post_action_type_id)
-        post("/post_actions", args.to_h.merge(flag_topic: true))
-      end
-
-      def latest_topics(params={})
-        response = get('/latest.json', params)
-        response[:body]['topic_list']['topics']
-      end
-
-      def new_topics(params={})
-        response = get("/new.json", params)
-        response[:body]['topic_list']['topics']
-      end
-
-      def rename_topic(topic_id, title)
-        put("/t/#{topic_id}.json", { topic_id: topic_id, title: title })
-      end
-
-      def recategorize_topic(topic_id, category_id)
-        put("/t/#{topic_id}.json", { topic_id: topic_id, category_id: category_id })
-      end
-
-      def topic(id, params={})
-        response = get("/t/#{id}.json", params)
-        response[:body]
-      end
-
-      def topics_by(username, params={})
-        response = get("/topics/created-by/#{username}.json", params)
-        response[:body]['topic_list']['topics']
-      end
-
-      def delete_topic(id)
-        delete("/t/#{id}.json")
-      end
-
-      def topic_posts(topic_id, post_ids=[])
-        url = "/t/#{topic_id}/posts.json"
-        if post_ids.count > 0
-          url << '?'
-          post_ids.each do |id|
-            url << "post_ids[]=#{id}&"
-          end 
-        end
-        response = get(url) 
-        response[:body]
-      end
-    end
-  end
-end
+module DiscourseApi
+  module API
+    module Topics
+      # :category OPTIONAL name of category, not ID
+      # :skip_validations OPTIONAL boolean
+      # :auto_track OPTIONAL boolean
+      # :created_at OPTIONAL seconds since epoch.
+      def create_topic(args={})
+        args = API.params(args)
+                  .required(:title, :raw)
+                  .optional(:skip_validations, :category, :auto_track, :created_at, :api_username)
+        post("/posts", args.to_h)
+      end
+
+      def create_topic_action(args)
+        args = API.params(args)
+                   .required(:id, :post_action_type_id)
+        post("/post_actions", args.to_h.merge(flag_topic: true))
+      end
+
+      # timestamp is seconds past the epoch.
+      def edit_topic_timestamp(topic_id,timestamp)
+        put("/t/#{topic_id}/change-timestamp", { timestamp: timestamp })
+      end
+
+      def latest_topics(params={})
+        response = get('/latest.json', params)
+        response[:body]['topic_list']['topics']
+      end
+
+      def new_topics(params={})
+        response = get("/new.json", params)
+        response[:body]['topic_list']['topics']
+      end
+
+      def rename_topic(topic_id, title)
+        put("/t/#{topic_id}.json", { topic_id: topic_id, title: title })
+      end
+
+      def recategorize_topic(topic_id, category_id)
+        put("/t/#{topic_id}.json", { topic_id: topic_id, category_id: category_id })
+      end
+
+      def change_topic_status(topic_slug, topic_id, params={})
+        params = API.params(params)
+                     .required(:status, :enabled)
+                     .optional(:api_username)
+        put("/t/#{topic_slug}/#{topic_id}/status", params.to_h)
+      end
+
+      def topic(id, params={})
+        response = get("/t/#{id}.json", params)
+        response[:body]
+      end
+
+      def topics_by(username, params={})
+        response = get("/topics/created-by/#{username}.json", params)
+        response[:body]['topic_list']['topics']
+      end
+
+      def delete_topic(id)
+        delete("/t/#{id}.json")
+      end
+
+      def topic_posts(topic_id, post_ids=[])
+        url = "/t/#{topic_id}/posts.json"
+        if post_ids.count > 0
+          url << '?'
+          post_ids.each do |id|
+            url << "post_ids[]=#{id}&"
+          end 
+        end
+        response = get(url) 
+        response[:body]
+      end
+    end
+  end
+end

data/lib/discourse_api/api/users.rb

@@ -1,85 +1,85 @@
-module DiscourseApi
-  module API
-    module Users
-      def activate(id)
-        put "/admin/users/#{id}/activate", api_key: api_key, api_username: api_username
-      end
-
-      def user(username, params={})
-        response = get("/users/#{username}.json", params)
-        response[:body]['user']
-      end
-
-      def user_sso(username)
-        response = get("/admin/users/#{username.downcase}")
-        response[:body]['single_sign_on_record']
-      end
-
-      def update_avatar(args)
-        args = API.params(args)
-                  .required(:username)
-                  .optional(:file, :url)
-                  .default(type: 'avatar', synchronous: true)
-                  .to_h
-        upload_response = post("/uploads", args)
-        put("/users/#{args[:username]}/preferences/avatar/pick", { upload_id: upload_response['id'] })
-      end
-
-      def update_email(username, email)
-        put("/users/#{username}/preferences/email", { email: email, api_key: api_key })
-      end
-
-      def update_user(username, params={})
-        put("/users/#{username}", params)
-      end
-
-      def update_username(username, new_username)
-        put("/users/#{username}/preferences/username", { new_username: new_username, api_key: api_key })
-      end
-
-      def update_trust_level(args)
-        args = API.params(args)
-                  .required(:user_id, :level)
-                  .to_h
-        response = put("/admin/users/#{args[:user_id]}/trust_level", args)
-        response[:body]
-      end
-
-      def create_user(args)
-        args = API.params(args)
-                  .required(:name, :email, :password, :username)
-                  .optional(:active)
-                  .to_h
-        post("/users", args)
-      end
-
-      def log_out(id)
-        post("/admin/users/#{id}/log_out")
-      end
-
-      def invite_admin(args={})
-        post("/admin/users/invite_admin", args)
-      end
-
-      def list_users(type)
-        response = get("admin/users/list/#{type}.json")
-        response[:body]
-      end
-
-      def grant_admin(user_id)
-        response = put("admin/users/#{user_id}/grant_admin")
-        response[:body]
-      end
-
-      def revoke_admin(user_id)
-        response = put("admin/users/#{user_id}/revoke_admin")
-        response[:body]
-      end
-
-      def by_external_id(external_id)
-        response = get("/users/by-external/#{external_id}")
-        response[:body]['user']
-      end
-    end
-  end
-end
+module DiscourseApi
+  module API
+    module Users
+      def activate(id)
+        put "/admin/users/#{id}/activate", api_key: api_key, api_username: api_username
+      end
+
+      def user(username, params={})
+        response = get("/users/#{username}.json", params)
+        response[:body]['user']
+      end
+
+      def user_sso(username)
+        response = get("/admin/users/#{username.downcase}")
+        response[:body]['single_sign_on_record']
+      end
+
+      def update_avatar(args)
+        args = API.params(args)
+                  .required(:username)
+                  .optional(:file, :url)
+                  .default(type: 'avatar', synchronous: true)
+                  .to_h
+        upload_response = post("/uploads", args)
+        put("/users/#{args[:username]}/preferences/avatar/pick", { upload_id: upload_response['id'] })
+      end
+
+      def update_email(username, email)
+        put("/users/#{username}/preferences/email", { email: email, api_key: api_key })
+      end
+
+      def update_user(username, params={})
+        put("/users/#{username}", params)
+      end
+
+      def update_username(username, new_username)
+        put("/users/#{username}/preferences/username", { new_username: new_username, api_key: api_key })
+      end
+
+      def update_trust_level(args)
+        args = API.params(args)
+                  .required(:user_id, :level)
+                  .to_h
+        response = put("/admin/users/#{args[:user_id]}/trust_level", args)
+        response[:body]
+      end
+
+      def create_user(args)
+        args = API.params(args)
+                  .required(:name, :email, :password, :username)
+                  .optional(:active, :staged)
+                  .to_h
+        post("/users", args)
+      end
+
+      def log_out(id)
+        post("/admin/users/#{id}/log_out")
+      end
+
+      def invite_admin(args={})
+        post("/admin/users/invite_admin", args)
+      end
+
+      def list_users(type)
+        response = get("admin/users/list/#{type}.json")
+        response[:body]
+      end
+
+      def grant_admin(user_id)
+        response = put("admin/users/#{user_id}/grant_admin")
+        response[:body]
+      end
+
+      def revoke_admin(user_id)
+        response = put("admin/users/#{user_id}/revoke_admin")
+        response[:body]
+      end
+
+      def by_external_id(external_id)
+        response = get("/users/by-external/#{external_id}")
+        response[:body]['user']
+      end
+    end
+  end
+end

data/lib/discourse_api/client.rb

@@ -1,133 +1,133 @@
-require 'faraday'
-require 'faraday_middleware'
-require 'json'
-require 'discourse_api/version'
-require 'discourse_api/api/categories'
-require 'discourse_api/api/search'
-require 'discourse_api/api/sso'
-require 'discourse_api/api/tags'
-require 'discourse_api/api/topics'
-require 'discourse_api/api/posts'
-require 'discourse_api/api/users'
-require 'discourse_api/api/groups'
-require 'discourse_api/api/invite'
-require 'discourse_api/api/private_messages'
-require 'discourse_api/api/notifications'
-require 'discourse_api/api/badges'
-require 'discourse_api/api/email'
-require 'discourse_api/api/api_key'
-require 'discourse_api/api/backups'
-require 'discourse_api/api/dashboard'
-
-module DiscourseApi
-  class Client
-    attr_accessor :api_key, :api_username
-    attr_reader :host
-
-    include DiscourseApi::API::Categories
-    include DiscourseApi::API::Search
-    include DiscourseApi::API::SSO
-    include DiscourseApi::API::Tags
-    include DiscourseApi::API::Topics
-    include DiscourseApi::API::Posts
-    include DiscourseApi::API::Users
-    include DiscourseApi::API::Groups
-    include DiscourseApi::API::Invite
-    include DiscourseApi::API::PrivateMessages
-    include DiscourseApi::API::Notifications
-    include DiscourseApi::API::Badges
-    include DiscourseApi::API::Email
-    include DiscourseApi::API::ApiKey
-    include DiscourseApi::API::Backups
-    include DiscourseApi::API::Dashboard
-
-    def initialize(host, api_key = nil, api_username = nil)
-      raise ArgumentError, 'host needs to be defined' if host.nil? || host.empty?
-      @host         = host
-      @api_key      = api_key
-      @api_username = api_username
-    end
-
-    def connection_options
-      @connection_options ||= {
-        url: @host,
-        headers: {
-          accept: 'application/json',
-          user_agent: user_agent,
-        }
-      }
-    end
-
-    def ssl(options)
-      connection_options[:ssl] = options
-    end
-
-    def delete(path, params={})
-      request(:delete, path, params)
-    end
-
-    def get(path, params={})
-      request(:get, path, params)
-    end
-
-    def post(path, params={})
-      response = request(:post, path, params)
-      case response.status
-      when 200
-        response.body
-      else
-        raise DiscourseApi::Error, response.body
-      end
-    end
-
-    def put(path, params={})
-      request(:put, path, params)
-    end
-
-    def patch(path, params={})
-      request(:patch, path, params)
-    end
-
-    def user_agent
-      @user_agent ||= "DiscourseAPI Ruby Gem #{DiscourseApi::VERSION}"
-    end
-
-    private
-
-    def connection
-      @connection ||= Faraday.new connection_options do |conn|
-        # Follow redirects
-        conn.use FaradayMiddleware::FollowRedirects, limit: 5
-        # Convert request params to "www-form-encoded"
-        conn.request :url_encoded
-        # Parse responses as JSON
-        conn.use FaradayMiddleware::ParseJson, content_type: 'application/json'
-        # Use Faraday's default HTTP adapter
-        conn.adapter Faraday.default_adapter
-        #pass api_key and api_username on every request
-        unless api_username.nil?
-          conn.params['api_key'] = api_key
-          conn.params['api_username'] = api_username
-        end
-      end
-    end
-
-    def request(method, path, params={})
-      unless Hash === params
-        params = params.to_h if params.respond_to? :to_h
-      end
-      response = connection.send(method.to_sym, path, params)
-      handle_error(response)
-      response.env
-    rescue Faraday::Error::ClientError, JSON::ParserError
-      raise DiscourseApi::Error
-    end
-
-    def handle_error(response)
-      case response.status
-      when 403
-        raise DiscourseApi::UnauthenticatedError.new(response.env[:body])
-      end
-    end
-  end
-end
+require 'faraday'
+require 'faraday_middleware'
+require 'json'
+require 'discourse_api/version'
+require 'discourse_api/api/categories'
+require 'discourse_api/api/search'
+require 'discourse_api/api/sso'
+require 'discourse_api/api/tags'
+require 'discourse_api/api/topics'
+require 'discourse_api/api/posts'
+require 'discourse_api/api/users'
+require 'discourse_api/api/groups'
+require 'discourse_api/api/invite'
+require 'discourse_api/api/private_messages'
+require 'discourse_api/api/notifications'
+require 'discourse_api/api/badges'
+require 'discourse_api/api/email'
+require 'discourse_api/api/api_key'
+require 'discourse_api/api/backups'
+require 'discourse_api/api/dashboard'
+
+module DiscourseApi
+  class Client
+    attr_accessor :api_key, :api_username
+    attr_reader :host
+
+    include DiscourseApi::API::Categories
+    include DiscourseApi::API::Search
+    include DiscourseApi::API::SSO
+    include DiscourseApi::API::Tags
+    include DiscourseApi::API::Topics
+    include DiscourseApi::API::Posts
+    include DiscourseApi::API::Users
+    include DiscourseApi::API::Groups
+    include DiscourseApi::API::Invite
+    include DiscourseApi::API::PrivateMessages
+    include DiscourseApi::API::Notifications
+    include DiscourseApi::API::Badges
+    include DiscourseApi::API::Email
+    include DiscourseApi::API::ApiKey
+    include DiscourseApi::API::Backups
+    include DiscourseApi::API::Dashboard
+
+    def initialize(host, api_key = nil, api_username = nil)
+      raise ArgumentError, 'host needs to be defined' if host.nil? || host.empty?
+      @host         = host
+      @api_key      = api_key
+      @api_username = api_username
+    end
+
+    def connection_options
+      @connection_options ||= {
+        url: @host,
+        headers: {
+          accept: 'application/json',
+          user_agent: user_agent,
+        }
+      }
+    end
+
+    def ssl(options)
+      connection_options[:ssl] = options
+    end
+
+    def delete(path, params={})
+      request(:delete, path, params)
+    end
+
+    def get(path, params={})
+      request(:get, path, params)
+    end
+
+    def post(path, params={})
+      response = request(:post, path, params)
+      case response.status
+      when 200
+        response.body
+      else
+        raise DiscourseApi::Error, response.body
+      end
+    end
+
+    def put(path, params={})
+      request(:put, path, params)
+    end
+
+    def patch(path, params={})
+      request(:patch, path, params)
+    end
+
+    def user_agent
+      @user_agent ||= "DiscourseAPI Ruby Gem #{DiscourseApi::VERSION}"
+    end
+
+    private
+
+    def connection
+      @connection ||= Faraday.new connection_options do |conn|
+        # Follow redirects
+        conn.use FaradayMiddleware::FollowRedirects, limit: 5
+        # Convert request params to "www-form-encoded"
+        conn.request :url_encoded
+        # Parse responses as JSON
+        conn.use FaradayMiddleware::ParseJson, content_type: 'application/json'
+        # Use Faraday's default HTTP adapter
+        conn.adapter Faraday.default_adapter
+        #pass api_key and api_username on every request
+        unless api_username.nil?
+          conn.params['api_key'] = api_key
+          conn.params['api_username'] = api_username
+        end
+      end
+    end
+
+    def request(method, path, params={})
+      unless Hash === params
+        params = params.to_h if params.respond_to? :to_h
+      end
+      response = connection.send(method.to_sym, path, params)
+      handle_error(response)
+      response.env
+    rescue Faraday::Error::ClientError, JSON::ParserError
+      raise DiscourseApi::Error
+    end
+
+    def handle_error(response)
+      case response.status
+      when 403
+        raise DiscourseApi::UnauthenticatedError.new(response.env[:body])
+      end
+    end
+  end
+end