redd 0.8.8 → 0.9.0.pre.1

data/lib/redd/models/live_thread.rb

@@ -1,22 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'basic_model'
-require_relative 'lazy_model'
+require_relative 'model'
 
 module Redd
   module Models
     # Represents a live thread.
-    class LiveThread < LazyModel
-      # An update in a live thread.
-      class LiveUpdate < BasicModel; end
-
-      # Get a LiveThread from its id.
-      # @param id [String] the id
-      # @return [LiveThread]
-      def self.from_id(client, id)
-        new(client, id: id)
-      end
-
+    class LiveThread < Model
       # Get the updates from the thread.
       # @param params [Hash] a list of params to send with the request
       # @option params [String] :after return results after the given fullname
@@ -25,7 +14,7 @@ module Redd
       # @option params [1..100] :limit the maximum number of things to return
       # @return [Listing]
       def updates(**params)
-        @client.model(:get, "/live/#{get_attribute(:id)}", params)
+        client.model(:get, "/live/#{read_attribute(:id)}", params)
       end
 
       # Configure the settings of this live thread
@@ -35,26 +24,38 @@ module Redd
       # @option params [String] :resources the new resources
       # @option params [String] :title the thread title
       def configure(**params)
-        @client.post("/api/live/#{get_attribute(:id)}/edit", params)
+        client.post("/api/live/#{read_attribute(:id)}/edit", params)
       end
 
       # Add an update to this live event.
       # @param body [String] the update text
       def update(body)
-        @client.post("/api/live/#{get_attribute(:id)}/update", body: body)
+        client.post("/api/live/#{read_attribute(:id)}/update", body: body)
+      end
+
+      # Strike out a live thread update.
+      # @param live_update [LiveUpdate] the update to strike out
+      def strike_update(live_update)
+        client.post("/api/live/#{read_attribute(:id)}/strike_update", id: live_update.name)
+      end
+
+      # Delete a live thread update.
+      # @param live_update [LiveUpdate] the update to strike out
+      def delete_update(live_update)
+        client.post("/api/live/#{read_attribute(:id)}/delete_update", id: live_update.name)
       end
 
       # @return [Array<User>] the contributors to this thread
       def contributors
-        @client.get("/live/#{get_attribute(:id)}/contributors").body[0][:data].map do |user|
-          User.new(@client, user)
+        client.get("/live/#{read_attribute(:id)}/contributors").body[0][:data].map do |user|
+          User.new(client, user)
         end
       end
 
       # @return [Array<User>] users invited to contribute to this thread
       def invited_contributors
-        @client.get("/live/#{get_attribute(:id)}/contributors").body[1][:data].map do |user|
-          User.new(@client, user)
+        client.get("/live/#{read_attribute(:id)}/contributors").body[1][:data].map do |user|
+          User.new(client, user)
         end
       end
 
@@ -67,13 +68,65 @@ module Redd
       #
       # @return [Listing<Submission>]
       def discussions(**params)
-        @client.model(:get, "/live/#{get_attribute(:id)}/discussions", params)
+        client.model(:get, "/live/#{read_attribute(:id)}/discussions", params)
       end
 
+      # @!attribute [r] id
+      #   @return [String] the thread id
+      property :id, :required
+
+      # @!attribute [r] name
+      #   @return [String] the thread fullname
+      property :name, default: ->() { "LiveUpdateEvent_#{read_attribute(:id)}" }
+
+      # @!attribute [r] description
+      #   @return [String] the live thread description
+      property :description
+
+      # @!attribute [r] description_html
+      #   @return [String] the html-rendered thread description
+      property :description_html
+
+      # @!attribute [r] title
+      #   @return [String] the live thread title
+      property :title
+
+      # @!attribute [r] created_at
+      #   @return [String] the live thread creation time
+      property :created_at, from: :created_utc, with: ->(t) { Time.at(t) }
+
+      # @!attribute [r] websocket_url
+      #   @return [String] the websocket url for listening to updates
+      property :websocket_url
+
+      # @!attribute [r] state
+      #   @return [String] the thread state (e.g. "live")
+      property :state
+
+      # @!attribute [r] nsfw?
+      #   @return [Boolean] whether the thread is nsfw
+      property :nsfw?, from: :nsfw
+
+      # @!attribute [r] viewer_count
+      #   @return [Integer] the thread viewer count
+      property :viewer_count
+
+      # @!attribute [r] viewer_count_fuzzed?
+      #   @return [Boolean] whether the viewer count is fuzzed
+      property :viewer_count_fuzzed?, from: :viewer_count_fuzzed
+
+      # @!attribute [r] resources
+      #   @return [String] the thread's resources section
+      property :resources
+
+      # @!attribute [r] resources_html
+      #   @return [String] the html-rendered thread resources
+      property :resources_html
+
       private
 
-      def default_loader
-        @client.get("/live/#{@attributes.fetch(:id)}/about").body[:data]
+      def lazer_reload
+        client.get("/live/#{read_attribute(:id)}/about").body[:data]
       end
     end
   end

data/lib/redd/models/live_update.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'model'
+
+module Redd
+  module Models
+    # A live thread update.
+    class LiveUpdate < Model
+      # @!attribute [r] id
+      #   @return [String] the update id
+      property :id, :required
+
+      # @!attribute [r] name
+      #   @return [String] the update fullname
+      property :name, default: ->() { "LiveUpdate_#{read_attribute(:id)}" }
+
+      # @!attribute [r] body
+      #   @return [String] the update body
+      property :body
+
+      # @!attribute [r] body_html
+      #   @return [String] the html-rendered update body
+      property :body_html
+
+      # @!attribute [r] embeds
+      #   @return [Array]
+      property :embeds
+
+      # @!attribute [r] mobile_embeds
+      #   @return [Array]
+      property :mobile_embeds
+
+      # @!attribute [r] author
+      #   @return [User] the poster of the update
+      property :author, with: ->(n) { User.new(client, name: n) }
+
+      # @!attribute [r] created_at
+      #   @return [Time] the post time
+      property :created_at, from: :created_utc, with: ->(t) { Time.at(t) }
+
+      # @!attribute [r] stricken?
+      #   @return [Boolean] whether the update is stricken
+      property :stricken?, from: :stricken
+    end
+  end
+end

data/lib/redd/models/messageable.rb

@@ -13,7 +13,7 @@ module Redd
       def send_message(to:, subject:, text:, from: nil)
         params = { to: to, subject: subject, text: text }
         params[:from_sr] = from.display_name if from
-        @client.post('/api/compose', params)
+        client.post('/api/compose', params)
       end
     end
   end

data/lib/redd/models/mod_action.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative 'model'
+
+module Redd
+  module Models
+    # Represents a moderator action, part of a moderation log.
+    # @see Subreddit#mod_log
+    class ModAction < Model
+      # @!attribute [r] description
+      #   @return [String] the action description
+      property :description
+
+      # @!attribute [r] target_title
+      #   @return [String] the title of the item that was targeted
+      property :target_title
+
+      # @!attribute [r] target_body
+      #   @return [String] the body of the item that was targeted
+      property :target_body
+
+      # @!attribute [r] target_permalink
+      #   @return [String] the **relative** permalink to the item
+      property :target_permalink
+
+      # @!attribute [r] target_author
+      #   @return [User] the target user
+      property :target_author, with: ->(n) { User.new(client, name: n) }
+
+      # @!attribute [r] mod_id36
+      #   @return [String] the id of the moderator that performed this action
+      property :mod_id36
+
+      # @!attribute [r] created_at
+      #   @return [Time] the time when the action was done
+      property :created_at, from: :created_utc, with: ->(t) { Time.at(t) }
+
+      # @!attribute [r] subreddit
+      #   @return [Subreddit] the subreddit the action was performed on
+      property :subreddit, with: ->(n) { Subreddit.new(client, display_name: n) }
+
+      # @!attribute [r] subreddit_name_prefixed
+      #   @return [String] the subreddit name, prefixed with a "r/"
+      property :subreddit_name_prefixed
+
+      # @!attribute [r] subreddit_id36
+      #   @return [String] the subreddit's id
+      property :subreddit_id36, from: :sr_id36
+
+      # @!attribute [r] details
+      #   @return [String] the action details
+      property :details
+
+      # @!attribute [r] action
+      #   @return [String] the action type
+      property :action
+    end
+  end
+end

data/lib/redd/models/model.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'lazy_lazer'
+
+module Redd
+  module Models
+    # A base model class.
+    class Model
+      include LazyLazer
+
+      # @return [Client] the model's client
+      attr_reader :client
+
+      # Create a new Model.
+      # @param client [Client] the model's client
+      # @param attributes [Hash] the model's attributes
+      def initialize(client, attributes = {})
+        super(attributes)
+        @client = client
+      end
+    end
+  end
+end

data/lib/redd/models/moderatable.rb

@@ -6,25 +6,25 @@ module Redd
     module Moderatable
       # Approve a submission.
       def approve
-        @client.post('/api/approve', id: get_attribute(:name))
+        client.post('/api/approve', id: read_attribute(:name))
       end
 
       # Remove a submission.
       # @param spam [Boolean] whether or not this item is removed due to it being spam
       def remove(spam: false)
-        @client.post('/api/remove', id: get_attribute(:name), spam: spam)
+        client.post('/api/remove', id: read_attribute(:name), spam: spam)
       end
 
       # Distinguish a link or comment with a sigil to show that it has been created by a moderator.
       # @param how [:yes, :no, :admin, :special, :sticky] how to distinguish the thing
       # @note :sticky is for comments. see {Submission#make_sticky} for posts.
       def distinguish(how = :yes)
-        params = { id: get_attribute(:name), how: how }
+        params = { id: read_attribute(:name), how: how }
         if how == :sticky
           params[:how] = :yes
           params[:sticky] = true
         end
-        @client.post('/api/distinguish', params)
+        client.post('/api/distinguish', params)
       end
 
       # Remove the sigil that shows a thing was created by a moderator.
@@ -34,12 +34,12 @@ module Redd
 
       # Stop getting any moderator-related reports on the thing.
       def ignore_reports
-        @client.post('/api/ignore_reports', id: get_attribute(:name))
+        client.post('/api/ignore_reports', id: read_attribute(:name))
       end
 
       # Start getting moderator-related reports on the thing again.
       def unignore_reports
-        @client.post('/api/unignore_reports', id: get_attribute(:name))
+        client.post('/api/unignore_reports', id: read_attribute(:name))
       end
     end
   end

data/lib/redd/models/modmail.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'model'
+require_relative 'subreddit'
+
+module Redd
+  module Models
+    # A container for the new modmail.
+    class Modmail < Model
+      # @return [Hash<Symbol, Integer>] the number of unread messages in each category
+      def unread_count
+        client.get('/api/mod/conversations/unread/count').body
+      end
+
+      # @return [Array<Subreddit>] moderated subreddits that are enrolled in the new modmail
+      def enrolled
+        client.get('/api/mod/conversations/subreddits').body[:subreddits].map do |_, s|
+          Subreddit.new(client, s.merge(last_updated: s.delete(:lastUpdated)))
+        end
+      end
+
+      # Get the conversations
+      # @param subreddits [Subreddit, Array<Subreddit>] the subreddits to limit to
+      # @param params [Hash] additional request parameters
+      # @option params [String] :after base36 modmail conversation id
+      # @option params [Integer] :limit an integer (default: 25)
+      # @option params [:recent, :mod, :user, :unread] :sort the sort order
+      # @option params [:new, :inprogress, :mod, :notifications, :archived, :highlighted, :all]
+      #   :state the state to limit the conversations by
+      # @return [Array<ModmailConversation>] the conversations
+      def conversations(subreddits: nil, **params)
+        params[:entity] = Array(subreddits).map(&:display_name).join(',') if subreddits
+        client.get('/api/mod/conversations', **params)
+              .body[:conversations]
+              .values
+              .map { |conv| ModmailConversation.new(client, conv) }
+      end
+
+      # Create a new conversation.
+      # @param from [Subreddit] the subreddit to send the conversation from
+      # @param to [User] the person to send the message to
+      # @param subject [String] the message subject
+      # @param body [String] the message body
+      # @return [ModmailConversation] the created conversation
+      def create(from:, to:, subject:, body:, hidden: false)
+        ModmailConversation.new(client, client.post(
+          '/api/mod/conversations',
+          srName: from.display_name, to: to.name,
+          subject: subject, body: body, isAuthorHidden: hidden
+        ).body[:conversation])
+      end
+
+      # Get a conversation from its base36 id.
+      # @param id [String] the conversation's id
+      # @return [ModmailConversation]
+      def get(id)
+        ModmailConversation.new(client, id: id)
+      end
+    end
+  end
+end

data/lib/redd/models/modmail_conversation.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'time'
+require_relative 'model'
+
+module Redd
+  module Models
+    # Represents a conversation in the new modmail.
+    class ModmailConversation < Model
+      # Add a reply to the ongoing conversation.
+      # @param body [String] the message body (probably markdown)
+      # @param hidden [Boolean] whether the message is hidden
+      # @param internal [Boolean] whether the message is internal
+      def reply(body, hidden: false, internal: false)
+        # TODO: merge response into the conversation
+        client.post(
+          "/api/mod/conversations/#{read_attribute(:id)}",
+          body: body, isAuthorHidden: hidden, isInternal: internal
+        ).body
+      end
+
+      # Mark this conversation as read.
+      def mark_as_read
+        client.post('/api/mod/conversations/read', conversationIds: [read_attribute(:id)])
+      end
+
+      # Mark this conversation as unread.
+      def mark_as_unread
+        client.post('/api/mod/conversations/unread', conversationIds: [read_attribute(:id)])
+      end
+
+      # Mark this conversation as archived.
+      def archive
+        perform_action(:post, 'archive')
+      end
+
+      # Removed this conversation from archived.
+      def unarchive
+        perform_action(:post, 'unarchive')
+      end
+
+      # Highlight this conversation.
+      def highlight
+        perform_action(:post, 'highlight')
+      end
+
+      # Remove the highlight on this conversation.
+      def unhighlight
+        perform_action(:delete, 'highlight')
+      end
+
+      # Mute this conversation.
+      def mute
+        perform_action(:post, 'mute')
+      end
+
+      # Unmute this conversation.
+      def unmute
+        perform_action(:post, 'unmute')
+      end
+
+      # @!attribute [r] id
+      #   @return [String] the conversation id
+      property :id, :required
+
+      # @!attribute [r] messages
+      #   @return [Array<ModmailMessage>] the modmail messages
+      property :messages, with: ->(hsh) { hsh.values.map { |m| ModmailMessage.new(client, m) } }
+
+      # @!attribute [r] user
+      #   @return [Object] FIXME: details about the user the conversation deals with
+      property :user
+
+      # @!attribute [r] auto?
+      #   @return [Boolean]
+      property :auto?, from: :isAuto
+
+      # @!attribute [r] message_ids
+      #   @return [Array<String>] the conversation's message ids
+      property :message_ids, from: :objIds
+
+      # @!attribute [r] replyable?
+      #   @return [Boolean] whether you can reply to this conversation
+      property :replyable?, from: :isRepliable
+
+      # @!attribute [r] last_user_update
+      #   @return [Time] the time of last user update
+      property :last_user_update, from: :lastUserUpdate, with: ->(t) { Time.parse(t) }
+
+      # @!attribute [r] internal?
+      #   @return [Boolean]
+      property :internal?, from: :isInternal
+
+      # @!attribute [r] last_mod_update
+      #   @return [Time] the time of last mod update
+      property :last_mod_update, from: :lastModUpdate, with: ->(t) { Time.parse(t) }
+
+      # @!attribute [r] last_updated
+      #   @return [Time] the time of last update
+      property :last_updated, from: :lastUpdated, with: ->(t) { Time.parse(t) }
+
+      # @!attribute [r] authors
+      #   @return [Array<Hash>] FIXME: apply conversions
+      property :authors
+
+      # @!attribute [r] owner
+      #   @return [Hash] FIXME: do shit
+      property :owner
+
+      # @!attribute [r] highlighted?
+      #   @return [Boolean] whether the conversation is highlighted
+      property :highlighted?, from: :isHighlighted
+
+      # @!attribute [r] subject
+      #   @return [String] the conversation subject
+      property :subject
+
+      # @!attribute [r] participant
+      #   @return [Hash] FIXME: do shit
+      property :participant
+
+      # @!attribute [r] state
+      #   @return [Integer]
+      property :state
+
+      # @!attribute [r] last_unread
+      #   @return [Object]
+      property :last_unread, from: :lastUnread
+
+      # @!attribute [r] message_count
+      #   @return [Integer] the message count
+      property :message_count, from: :numMessages
+
+      private
+
+      def lazer_reload
+        fully_loaded!
+        response = client.get("/api/mod/conversations/#{read_attribute(:id)}").body
+        response[:conversation].merge(
+          messages: response[:messages],
+          user: response[:user],
+          modActions: response[:modActions]
+        )
+      end
+
+      # Perform an action on a conversation.
+      # @param method [:post, :delete] the method to use
+      # @param action [String] the name of the action
+      def perform_action(method, action)
+        client.send(method, "/api/mod/conversations/#{read_attribute(:id)}/#{action}")
+      end
+    end
+  end
+end