livefyre-mashable 0.2.0

data/lib/livefyre/model_extensions.rb

@@ -0,0 +1,64 @@
+module Livefyre
+  module Model
+    extend ActiveSupport::Concern
+
+    # Public: Ping Livefyre to refresh this user's record
+    def refresh_livefyre
+      if _livefyre_callback
+        _livefyre_callback.call( self, self.send(:_livefyre_id) )
+      else
+        Livefyre::User.refresh( self.send(:_livefyre_id) )
+      end
+    end
+
+    protected
+
+    def update_livefyre_if_fields_changed
+      if updates = _livefyre_options[:update_on]
+        updates.each do |field|
+          if send("#{field}_changed?")
+            refresh_livefyre
+            break
+          end
+        end
+      end
+    end
+
+    def _livefyre_options
+      self.class.instance_variable_get("@livefyre_options")
+    end
+
+    def _livefyre_callback
+      self.class.instance_variable_get("@livefyre_update_block")
+    end
+
+    def _livefyre_id
+      livefyre_id = self.id
+      if _livefyre_options[:id]
+        livefyre_id = self.send(_livefyre_options[:id])
+      end
+      livefyre_id
+    end
+
+    public
+
+    module ClassMethods
+      # Public: Adds callback handlers and additional methods for treating this record as a user record.
+      #
+      # options    - [Hash] of options to initialize behavior with
+      # :update_on - [Array<Symbol>] List of fields which should trigger a Livefyre update when they're updated.
+      # :id        - [Symbol] Name of the method to use for determining this record's livefyre ID. If not given, #id is used.
+      #
+      # Examples
+      #
+      #    livefyre_user :update_on => [:email, :first_name, :last_name, :username, :picture_url], :id => :custom_livefyre_id
+      #
+      # Returns [nil]
+      def livefyre_user(options = {}, &block)
+        @livefyre_options = options
+        @livefyre_update_block = block
+        after_save :update_livefyre_if_fields_changed
+      end
+    end
+  end
+end

data/lib/livefyre/site.rb

@@ -0,0 +1,237 @@
+module Livefyre
+  # Public: Exception representing a failure to validate a signature
+  class InvalidSignatureException < Exception; end
+
+  # Public: An object representing a Livefyre site belonging to a Livefyre domain
+  class Site
+    attr_accessor :client, :secret, :options, :id
+
+    # Public: Create a new Site
+    def initialize(id, client = nil, options = {})
+      @id = id
+      @client = client || Livefyre.client
+      @options = options
+      @secret = options["api_secret"]
+    end
+
+    # Public: Search conversations on this domain
+    #
+    # query   - string to query for
+    # options - [Hash] of options
+    # :fields - list of fields to search. Default [:article, :title, :body]
+    # :sort   - Sort order for options. Valid values are [:relevance, :created, :updated, :hotness, :ncomments]. Default is :relevance
+    # :fields - List of fields to return in the result. Valid values are: article_id, site_id, domain_id, title, published, updated, author, url, ncomment, nuser, annotation, nlp, hotness, hottest_value, hottest_time, peak, peak_value, peak_time, comments:5, users:5, comment_state, hit_field, dispurl, relevancy
+    # :max    - Maximum number of fields to return
+    # :since  - [DateTime] Minimum date of results to return
+    # :until  - [DateTime] Maximum date of results to return
+    # :page   - Page of results to fetch. Default 1.
+    #
+    # Returns [Array<Conversation>] An array of matching conversations
+    # Raises [APIException] when response is not valid
+    def search_conversations(query, options = {})
+      options[:sites] = [self]
+      Domain.new(@client).search_conversations(query, options)
+    end
+
+    # Public: Get a list of properties for this site
+    #
+    # reload - Force a reload when set
+    #
+    # Returns [Hash] Site properties
+    # Raises [APIException] when response is not valid
+    def properties(reload = false)
+      return @options unless @options.nil? or @options.empty? or reload
+      response = client.get "/site/#{id}/", {:actor_token => client.system_token}
+      if response.success?
+        @options = JSON.parse response.body
+        @secret = options["api_secret"]
+        @options
+      else
+        raise APIException.new(response.body)
+      end
+    end
+
+    # Public: Fetches a feed of the site's latest activity.
+    #
+    # since_id - [Integer] If provided, will return feed items after the given feed item.
+    #
+    # Returns [Array<Activity>] List of feed activities
+    def feed(since_id = nil)
+      reload if secret.nil?
+      timestamp = Time.now.utc.to_i
+      sig = Base64.encode64 HMAC::SHA1.new(Base64.decode64 secret).update("sig_created=%s" % timestamp).digest
+      url = "/%s/" % ["site", id, "sync", since_id].compact.join("/")
+      response = client.get url, {:sig_created => timestamp, :sig => sig}
+      if response.success?
+        payload = JSON.parse(response.body).map {|item| Activity.new(client, item) }
+      else
+        raise APIException.new(response.body)
+      end
+    end
+
+    # Public: Fetches the latest comments from this site
+    #
+    # since_id - [Integer] If provided, will return feed items after the given comment.
+    #
+    # Returns: [Array<Comment>] List of comment
+    def comments(since = nil)
+      feed(since).select(&:comment?).map(&:comment)
+    end
+
+    # Public: Reload this site's properties from Livefyre
+    #
+    # Returns self
+    def reload
+      properties(true)
+      self
+    end
+
+    # Public: Set the postback URL for actions on this site
+    #         See: https://github.com/Livefyre/livefyre-docs/wiki/Accessing-Site-Comment-Data
+    #
+    # url - [String] URL to use as the postback URL for actions
+    #
+    # Returns [Bool] true on success
+    # Raises: [APIException] when response is not valid
+    def set_postback_url(url)
+      response = client.post "/site/#{id}/", {:actor_token => client.system_token, :postback_url => url}
+      if response.success?
+        properties(true) rescue APIException nil
+        true
+      else
+        raise APIException.new(response.body)
+      end
+    end
+
+    # Public: Retrieve a list of owners associated with this site
+    #
+    # Returns [Array<Livefyre::User>] A list of {Livefyre::User users}
+    # Raises: APIException when response is not valid
+    def owners
+      response = client.get "/site/#{id}/owners/", {:actor_token => client.system_token}
+      if response.success?
+        JSON.parse(response.body).map do |u|
+          client.user u.split("@", 2).first
+        end
+      else
+        raise APIException.new(response.body)
+      end
+    end
+
+    # Public: Adds a user to the list of owners for this site
+    #
+    # Returns [Bool] true on success
+    # Raises [APIException] when response is not valid
+    def add_owner(user)
+      uid = User.get_user_id(user)
+      response = client.post "/site/#{id}/owners/?actor_token=#{CGI.escape client.system_token}", {:jid => client.jid(uid)}
+      if response.success?
+        true
+      else
+        raise APIException.new(response.body)
+      end
+    end
+
+    # Public: Removes a user from the list of owners for this site
+    #
+    # Returns [Bool] true on success
+    # Raises [APIException] when response is not valid
+    def remove_owner(user)
+      user = User.get_user(user, client)
+      response = client.delete "/site/#{id}/owner/#{user.jid}/?actor_token=#{CGI.escape client.system_token}"
+      if response.success?
+        true
+      else
+        raise APIException.new(response.body)
+      end
+    end
+
+    # Public: Retrieve a list of owners associated with this site
+    #
+    # Returns [Array<Livefyre::User>] A list of {Livefyre::User users}
+    # Raises: [APIException] when response is not valid
+    def admins
+      response = client.get "/site/#{id}/admins/", {:actor_token => client.system_token}
+      if response.success?
+        JSON.parse(response.body).map do |u|
+          client.user u.split("@", 2).first
+        end
+      else
+        raise APIException.new(response.body)
+      end
+    end
+
+    # Public: Adds a user to the list of admins for this site
+    #
+    # Returns [Bool] true on success
+    # Raises [APIException] when response is not valid
+    def add_admin(user)
+      user = User.get_user(user, client)
+      response = client.post "/site/#{id}/admins/?actor_token=#{CGI.escape client.system_token}", {:jid => user.jid}
+      if response.success?
+        true
+      else
+        raise APIException.new(response.body)
+      end
+    end
+
+    # Public: Removes a user from the list of admins for this site
+    #
+    # Returns [Bool] true on success
+    # Raises [APIException] when response is not valid
+    def remove_admin(user)
+      user = User.get_user(user, client)
+      response = client.delete "/site/#{id}/admin/#{user.jid}/?actor_token=#{CGI.escape client.system_token}"
+      if response.success?
+        true
+      else
+        raise APIException.new(response.body)
+      end
+    end
+
+    # Public: Create a conversation collection on this site
+    #
+    # Returns [Conversation]
+    def create_conversation(article_id, title, link, tags = nil)
+      Conversation.create(client, article_id, title, link, tags)
+    end
+
+    # Internal: Returns a cleaner string representation of this object
+    #
+    # Returns [String] representation of this class
+    def to_s
+      "#<#{self.class.name}:0x#{object_id.to_s(16).rjust(14, "0")} id='#{id}' secret='#{secret}' options=#{options.inspect}>"
+    end
+
+    # Public: Validate a signature as passed by the Livefyre postback service
+    #
+    # params      - Hash of request parameters
+    # secret      - Site key to validate signature with
+    # time_window - Enforce that the sig_created is within time_window seconds of the current time.
+    #               Slush is given to account for system time drift. Pass nil or false to disable timestamp checking.
+    #
+    # Returns [Bool]
+    # Raises [InvalidSignatureException] on failure
+    def self.validate_signature(params, secret, time_window = 300)
+      params = params.clone
+      params.delete :controller
+      params.delete :action
+      sig = (params.delete(:sig) || "").strip
+      raise InvalidSignatureException.new "Missing sig" if sig.nil?
+      raise InvalidSignatureException.new "Missing site key" if secret.nil?
+
+      hash_str = params.sort.map {|v| v.join("=") }.join("&")
+
+      if time_window
+        created_at = params[:sig_created]
+        raise InvalidSignatureException.new "Missing sig_created" if created_at.nil?
+        raise InvalidSignatureException.new "Invalid timestamp" if (Time.now.utc - Time.at(created_at.to_i).utc).abs > time_window
+      end
+
+      check = Base64.encode64 HMAC::SHA1.new(Base64.decode64 secret).update(hash_str).digest
+      check = check.strip
+      raise InvalidSignatureException.new "Invalid signature" if check != sig
+      return sig == check
+    end
+  end
+end

data/lib/livefyre/user.rb

@@ -0,0 +1,162 @@
+module Livefyre
+  # Public: Interface for dealing with Livefyre users by User ID.
+  class User
+    attr_accessor :id, :display_name
+
+    # Public: Create a new Livefyre User proxy.
+    #
+    # id           - [String] ID of the user to proxy
+    # client       - [Livefyre::Client] an instance of Livefyre::Client. If nil, the default client is used.
+    # display_name - [String] The display name for this user (optional)
+    def initialize(id, client = nil, display_name = nil, args = {})
+      @id = id
+      @client = client || Livefyre.client
+      @display_name = display_name
+      @options = args
+    end
+
+    # Public: Retrieve user information and recent comments for this user from Livefyre
+    #
+    # Returns [Hash] of profile data
+    # Raises [JSON::ParserError] if the returned data cannot be parsed
+    # Raises [APIException] if the API does not return a valid response
+    def profile
+      response = @client.get "/profile/#{id}/", {:actor_token => token}
+      if response.success?
+        begin
+          JSON.parse(response.body)["data"]
+        rescue JSON::ParserError => e
+          raise APIException.new("Parse error: #{e.message}")
+        end
+      else
+        raise APIException.new(result.body)
+      end
+    end
+
+    # Public: Setter for the client to associate with this user
+    def client=(client)
+      @client = client
+    end
+
+    # Internal - Fetch an internal Jabber-style ID for this user
+    #
+    # Returns [String] representation of this user
+    def jid
+      "#{id}@#{@client.host}"
+    end
+
+    # Public: Creates a signed JWT token for this user
+    #
+    # max_age - [Integer] Expiry time for this token in seconds (default: 86400)
+    #
+    # Returns [String] token
+    def token(max_age = 86400)
+      data = {
+        :domain => @client.host,
+        :user_id => id,
+        :expires => Time.now.to_i + max_age
+      }.tap do |opts|
+        opts[:display_name] = @display_name unless @display_name.nil?
+      end
+      JWT.encode(data, @client.key)
+    end
+
+    # Public: Update this user's profile on Livefyre
+    #
+    # data - [Hash] A hash of user data as defined by the Livefyre user profile schema
+    #
+    # Returns [Bool] true on success
+    # Raises [APIException] if the request failed
+    def push(data)
+      result = @client.post "/profiles/?actor_token=#{CGI.escape @client.system_token}&id=#{id}", {:data => data.to_json}
+      if result.success?
+        true
+      else
+        raise APIException.new(result.body)
+      end
+    end
+
+    # Public: Invoke Livefyre ping-to-pull to refresh this user's data
+    #
+    # Returns [Bool] true on success
+    # Raises [APIException] if the request failed
+    def refresh
+      result = @client.post "/api/v3_0/user/#{id}/refresh", {:lftoken => @client.system_token}
+      if result.success?
+        true
+      else
+        raise APIException.new(result.body)
+      end
+    end
+
+    # Public: Follow the given conversation
+    #
+    # conversation - [Conversation] to follow
+    # Returns [Boolean] true on success
+    # Raises [APIException] on failure
+    def follow_conversation(conversation)
+      conversation.follow_as self
+    end
+
+    # Public: Unfollow the given conversation
+    #
+    # conversation - [Conversation] to unfollow
+    # Returns [Boolean] true on success
+    # Raises [APIException] on failure
+    def unfollow_conversation(conversation)
+      conversation.unfollow_as self
+    end
+
+    # Public: Coerce a string or [User] into a user ID
+    #
+    # userish - [String/User/Int]A [User] or user ID
+    #
+    # Returns [String] User ID
+    # Raises Exception when value can't be coerced
+    def self.get_user_id(userish)
+      case userish
+      when String
+        userish.split("@", 2).first
+      when Fixnum
+        userish
+      when User
+        userish.id
+      else
+        raise "Invalid user ID"
+      end
+    end
+
+    # Public: Convenience method to refresh a user by ID
+    #
+    # id - A Livefyre user ID to refresh
+    #
+    # Returns [Bool] true on success
+    # Raises [APIException] if the request failed
+    def self.refresh(id)
+      new(id).refresh
+    end
+
+    # Public: Fetch a Livefyre::User from a user record or ID
+    #
+    # userish - [String/User/Int] A User or user ID
+    # client  - [Livefyre::Client] Client to bind to the User record
+    #
+    # Returns [User]
+    def self.get_user(userish, client)
+      case userish
+      when User
+        userish.client = client
+        userish
+      else
+        new get_user_id(userish), client
+      end
+    end
+
+    # Internal: Returns a cleaner string representation of this object
+    #
+    # Returns [String] representation of this class
+    def to_s
+      "#<#{self.class.name}:0x#{object_id.to_s(16).rjust(14, "0")} id='#{id}' display_name='#{display_name}'>"
+    end
+  end
+end