peal 0.1.0 → 0.3.0

data/lib/peal/notices/client.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Peal
+  module Notices
+    class Client
+      # @param client [Peal::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Lists the user's notices, newest first, 20 a page unless `limit` (at most 100) says otherwise. Pass the page's
+      # `nextCursor` as `cursor` for the next one. Each notice is data, for the client to write in the reader's
+      # language.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String, nil] :cursor
+      # @option params [String, nil] :limit
+      #
+      # @example
+      #   client.notices.list
+      #
+      # @return [Peal::Types::NoticePage]
+      def list(request_options: {}, **params)
+        params = Peal::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["cursor"] = params[:cursor] if params.key?(:cursor)
+        query_params["limit"] = params[:limit] if params.key?(:limit)
+
+        request = Peal::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "api/me/notices",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Peal::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          (response.body.to_s.empty? ? nil : Peal::Types::NoticePage.load(response.body))
+        else
+          error_class = Peal::Errors::ResponseError.subclass_for_code(code)
+          error_types = {
+            401 => Peal::Types::UnauthenticatedEncoded,
+            403 => Peal::Types::ForbiddenEncoded
+          }
+          error_body = Peal::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body, headers: response.to_hash)
+        end
+      end
+
+      # Counts the user's unread notices.
+      #
+      # @param request_options [Hash]
+      # @param _params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @example
+      #   client.notices.unread
+      #
+      # @return [Peal::Types::UnreadNotices]
+      def unread(request_options: {}, **_params)
+        request = Peal::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "api/me/notices/unread",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Peal::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          (response.body.to_s.empty? ? nil : Peal::Types::UnreadNotices.load(response.body))
+        else
+          error_class = Peal::Errors::ResponseError.subclass_for_code(code)
+          error_types = {
+            401 => Peal::Types::UnauthenticatedEncoded,
+            403 => Peal::Types::ForbiddenEncoded
+          }
+          error_body = Peal::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body, headers: response.to_hash)
+        end
+      end
+
+      # Marks up to 100 of the user's notices read, and answers with how many stay unread. Ids that name none of the
+      # user's notices, and notices already read, are left as they are.
+      #
+      # @param request_options [Hash]
+      # @param params [Peal::Notices::Types::MarkNoticesRead]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @example
+      #   client.notices.mark_read(ids: ["ids"])
+      #
+      # @return [Peal::Types::UnreadNotices]
+      def mark_read(request_options: {}, **params)
+        params = Peal::Internal::Types::Utils.normalize_keys(params)
+        request = Peal::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "api/me/notices/read",
+          body: Peal::Notices::Types::MarkNoticesRead.new(params).to_h,
+          request_options: request_options,
+          max_retries: 0
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Peal::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          (response.body.to_s.empty? ? nil : Peal::Types::UnreadNotices.load(response.body))
+        else
+          error_class = Peal::Errors::ResponseError.subclass_for_code(code)
+          error_types = {
+            401 => Peal::Types::UnauthenticatedEncoded,
+            403 => Peal::Types::ForbiddenEncoded
+          }
+          error_body = Peal::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body, headers: response.to_hash)
+        end
+      end
+
+      # Marks every notice of the user read.
+      #
+      # @param request_options [Hash]
+      # @param _params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @example
+      #   client.notices.mark_all_read
+      #
+      # @return [Peal::Types::UnreadNotices]
+      def mark_all_read(request_options: {}, **_params)
+        request = Peal::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "api/me/notices/read-all",
+          request_options: request_options,
+          max_retries: 0
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Peal::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          (response.body.to_s.empty? ? nil : Peal::Types::UnreadNotices.load(response.body))
+        else
+          error_class = Peal::Errors::ResponseError.subclass_for_code(code)
+          error_types = {
+            401 => Peal::Types::UnauthenticatedEncoded,
+            403 => Peal::Types::ForbiddenEncoded
+          }
+          error_body = Peal::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body, headers: response.to_hash)
+        end
+      end
+    end
+  end
+end

data/lib/peal/notices/types/list_notices_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Peal
+  module Notices
+    module Types
+      class ListNoticesRequest < Internal::Types::Model
+        field :cursor, -> { String }, optional: true, nullable: false
+
+        field :limit, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/peal/notices/types/mark_notices_read.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Peal
+  module Notices
+    module Types
+      class MarkNoticesRead < Internal::Types::Model
+        field :ids, -> { Internal::Types::Array[String] }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/peal/notification_preferences/client.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Peal
+  module NotificationPreferences
+    class Client
+      # @param client [Peal::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Answers with which notices the user receives by email, and whether they hear about every post. Until they change
+      # it: failed and unconfirmed posts, and channels to reconnect, but not published posts, are emailed; and they hear
+      # only about the posts they wrote.
+      #
+      # @param request_options [Hash]
+      # @param _params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @example
+      #   client.notification_preferences.get
+      #
+      # @return [Peal::Types::NotificationPreferences]
+      def get(request_options: {}, **_params)
+        request = Peal::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "api/me/notification-preferences",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Peal::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          (response.body.to_s.empty? ? nil : Peal::Types::NotificationPreferences.load(response.body))
+        else
+          error_class = Peal::Errors::ResponseError.subclass_for_code(code)
+          error_types = {
+            401 => Peal::Types::UnauthenticatedEncoded,
+            403 => Peal::Types::ForbiddenEncoded
+          }
+          error_body = Peal::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body, headers: response.to_hash)
+        end
+      end
+
+      # Changes the preferences given, keeps the others, and answers with them all. Staff impersonating the user may not
+      # change them.
+      #
+      # @param request_options [Hash]
+      # @param params [Peal::NotificationPreferences::Types::NotificationPreferencesChange]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @example
+      #   client.notification_preferences.update
+      #
+      # @return [Peal::Types::NotificationPreferences]
+      def update(request_options: {}, **params)
+        params = Peal::Internal::Types::Utils.normalize_keys(params)
+        request = Peal::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "PATCH",
+          path: "api/me/notification-preferences",
+          body: Peal::NotificationPreferences::Types::NotificationPreferencesChange.new(params).to_h,
+          request_options: request_options,
+          max_retries: 0
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Peal::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          (response.body.to_s.empty? ? nil : Peal::Types::NotificationPreferences.load(response.body))
+        else
+          error_class = Peal::Errors::ResponseError.subclass_for_code(code)
+          error_types = {
+            401 => Peal::Types::UnauthenticatedEncoded,
+            403 => Peal::Types::ForbiddenEncoded
+          }
+          error_body = Peal::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body, headers: response.to_hash)
+        end
+      end
+    end
+  end
+end

data/lib/peal/notification_preferences/types/notification_preferences_change.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Peal
+  module NotificationPreferences
+    module Types
+      class NotificationPreferencesChange < Internal::Types::Model
+        field :email, -> { Peal::NotificationPreferences::Types::NotificationPreferencesChangeEmail }, optional: true, nullable: false
+
+        field :every_post, -> { Internal::Types::Boolean }, optional: true, nullable: false, api_name: "everyPost"
+      end
+    end
+  end
+end

data/lib/peal/notification_preferences/types/notification_preferences_change_email.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "../../../peal"
+
+module Peal
+  module NotificationPreferences
+    module Types
+      class NotificationPreferencesChangeEmail < Internal::Types::Model
+        field :channel_reconnect, -> { Internal::Types::Boolean }, optional: true, nullable: false, api_name: "channelReconnect"
+
+        field :post_failed, -> { Internal::Types::Boolean }, optional: true, nullable: false, api_name: "postFailed"
+
+        field :post_published, -> { Internal::Types::Boolean }, optional: true, nullable: false, api_name: "postPublished"
+
+        field :post_unconfirmed, -> { Internal::Types::Boolean }, optional: true, nullable: false, api_name: "postUnconfirmed"
+      end
+    end
+  end
+end