livefyre 0.1.2 → 1.0.0

data/lib/livefyre/activity.rb

@@ -1,43 +0,0 @@
-module Livefyre
-  # Public: Proxy object for an item from a Conversation activity feed
-  class Activity
-    attr_accessor :id, :user, :conversation, :body, :state, :created_at
-    def initialize(client, params = {})
-      @client = Livefyre.client
-      @params = params
-      @id = params["activity_id"]
-      @conversation = Conversation.new(@params["lf_conv_id"], @params["article_identifier"])
-      @created_at = Time.at(@params["created"]) - Time.at(0).utc_offset
-    end
-
-    # Public: Cast this activity to a Comment
-    #
-    # Return [Comment]
-    def comment
-      Comment.new(@params["lf_comment_id"], conversation,
-        :body => @params["body_text"],
-        :user => user,
-        :parent_id => @params["lf_parent_comment_id"],
-        :author_ip => @params["author_ip"],
-        :state => @params["state"]
-      )
-    end
-
-    # Public: Fetch the user that created this record
-    #
-    # Returns [User]
-    def user
-      User.new((@params["lf_jid"] || "").split("@", 2).first, @client, @params["author"],
-        :email => @params["author_email"],
-        :url => @params["author_url"]
-      )
-    end
-
-    # Internal: Test if this activity represented a comment
-    #
-    # Returns [Boolean]
-    def comment?
-      @params["activity_type"] == "comment-add"
-    end
-  end
-end

data/lib/livefyre/client.rb

@@ -1,141 +0,0 @@
-module Livefyre
-  # Public: Primary interface to the Livefyre API
-  class Client
-    extend Forwardable
-    # Public: Valid roles for #set_user_role
-    ROLES = %w(admin member none outcast owner)
-
-    # Public: Valid scopes for #set_user_role
-    SCOPES = %w(domain site conv)
-
-    attr_accessor :host, :key, :options, :system_token, :http_client, :site_key, :quill, :stream, :bootstrap, :search
-
-    def_delegators :http_client, :get, :post, :delete, :put
-
-    # Public: Create a new Livefyre client.
-    #
-    # options - [Hash] array of options to pass to the client for initialization
-    # :host         - your Livefyre network_host
-    # :key          - your Livefyre network_key
-    # :system_token - your Livefyre long-lived system user key
-    def initialize(options = {})
-      @options = options.clone
-      @host = options.delete(:network) || options.delete(:host)
-      raise "Invalid host" if @host.nil?
-      @http_client = Faraday.new(:url => "http://#{@host}")
-      @quill = Faraday.new(:url => "http://quill.#{@host}")
-      @stream = Faraday.new(:url => "http://stream.#{@host}")
-      @search = Faraday.new(:url => "http://search.#{@host}")
-      @bootstrap = Faraday.new(:url => "http://bootstrap.#{@host}")
-      @site_key = options[:site_key]
-
-      @key = options.delete(:secret) || options.delete(:key) || options.delete(:network_key)
-      raise "Invalid secret key" if @key.nil?
-
-      @system_token = options.delete(:system_token)
-      raise "Invalid system token" if @system_token.nil?
-    end
-
-    # Public: Sign a data structure with this client's network key.
-    #
-    # Returns [String] A signed JWT token
-    def sign(data)
-      JWT.encode(data, @key)
-    end
-
-    # Public: Validates and decodes a JWT token
-    #
-    # Returns [Hash] A hash of data passed from the token
-    # Raises [JWT::DecodeError] if invalid token contents or signature
-    def validate(data)
-      JWT.decode(data, @key)
-    end
-
-    # Public: Create a {Livefyre::User} with this client's credentials.
-    #
-    # uid          - the user ID to create a Livefyre user for. This should be the ID used to reference this user in Livefyre's system.
-    # display_name - the displayed name for this user. Optional.
-    #
-    # Returns [Livefyre::User]
-    def user(uid, display_name = nil)
-      User.new(uid, self, display_name)
-    end
-
-    # Public: Sets a user's role (affiliation) in a given scope.
-    #
-    # user_id   - The user ID (without the host) to set roles for
-    # role      - The {ROLES role} to set.
-    # scope     - The {SCOPES scope} for which to set this role.
-    # scope_id  - In the case that the given scope requires identification, specifies which scope to operate on.
-    #
-    # Examples
-    #
-    #   set_user_role(1234, "owner", "domain")
-    #   set_user_role(1234, "moderator", "site", site_id)
-    #   set_user_role(1234, "moderator", "conv", conversation_id)
-    #
-    #
-    # Returns [Bool] true on success
-    # Raises APIException if the request failed
-    def set_user_role(user_id, role, scope = 'domain', scope_id = nil)
-      raise "Invalid scope" unless SCOPES.include? scope
-      raise "Invalid role" unless ROLES.include? role
-
-      post_data = {
-        :affiliation => role,
-        :lftoken => system_token,
-      }
-      case scope
-      when "domain"
-        post_data[:domain_wide] = 1
-      when "conv"
-        raise "Invalid scope_id" if scope_id.nil?
-        post_data[:conv_id] = scope_id
-      when "site"
-        raise "Invalid scope_id" if scope_id.nil?
-        post_data[:site_id] = scope_id
-      end
-      result = post "/api/v1.1/private/management/user/#{jid(user_id)}/role/", post_data
-      if result.success?
-        true
-      else
-        raise APIException.new(result.body)
-      end
-    end
-
-    # Public: Transform the given ID into a jid
-    #
-    # id - a string value to compose the JID with
-    #
-    # Returns [String] JID
-    def jid(id)
-      "%s@%s" % [id, host]
-    end
-
-    # Internal: Identifier to use to uniquely identify this client.
-    #
-    # Returns string ID
-    def identifier
-      @identifier ||= "RubyLib-#{Process.pid}-#{local_ip}-#{object_id}"
-    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")} host='#{host}' key='#{key}'>"
-    end
-
-    private
-
-    def local_ip
-      orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true  # turn off reverse DNS resolution temporarily
-      UDPSocket.open do |s|
-        s.connect '64.233.187.99', 1
-        s.addr.last
-      end
-    ensure
-      Socket.do_not_reverse_lookup = orig
-    end
-  end
-end

data/lib/livefyre/comment.rb

@@ -1,190 +0,0 @@
-module Livefyre
-  # Public: Proxy object for a [Comment] on a [Livefyre::Conversation]
-  class Comment
-    private
-    SOURCES       = %w(Livefyre Twitter Twitter Facebook Livefyre Livefyre Facebook Twitter Livefyre)
-    VISIBILITIES  = %w(None Everyone Owner Group)
-    CONTENT_TYPES = %w(Message Opinion)
-    PERMISSIONS   = %w(Global Network Site Collection CollectionRule)
-    REASONS       = %w(disagree spam offensive off-topic)
-
-    public
-
-    attr_accessor :id, :body, :user, :parent_id, :ip, :conversation, :created_at
-    def initialize(id, conversation, options = {})
-      @id           = id
-      @body         = options[:body]
-      @user         = options[:user]
-      @parent_id    = options[:parent_id]
-      @ip           = options[:author_ip]
-      @conversation = conversation
-      @created_at   = options[:created_at]
-      @client       = options[:client] || Livefyre.client
-      @options      = options
-    end
-
-    # Public: Flag a comment
-    #
-    # reason - one of [disagree, spam, offensive, off-topic]
-    # notes  - String containing the reason for the flag
-    # email  - email address of the flagger
-    # user   - [User] If set, will include the user token for validation of the flag
-    def flag(reason, notes, email, user = nil)
-      raise "invalid reason" unless REASONS.include? reason
-      payload = {
-        :message_id => @id,
-        :collection_id => @conversation.id,
-        :flag => reason,
-        :notes => notes,
-        :email => email
-      }
-      payload[:lftoken] = user.token if user
-      response = client.quill.post "/api/v3.0/message/25818122/flag/#{reason}/", payload.to_json
-      if response.success?
-        true
-      else
-        raise APIException.new(response.body)
-      end
-    end
-
-    # Public: Delete this comment
-    #
-    # Returns [Boolean] true on success
-    # Raises [APIException] on failure
-    def delete!
-      response = client.quill.post "/api/v3.0/message/#{id}/delete", {:lftoken => @client.system_token}
-      if response.success?
-        true
-      else
-        raise APIException.new(response.body)
-      end
-    end
-
-    # Public: Update this comment's content
-    #
-    # Returns [Boolean] true on success
-    # Raises [APIException] on failure
-    def update(body)
-      response = client.quill.post "/api/v3.0/message/#{id}/edit", {:lftoken => @client.system_token, :body => body}
-      if response.success?
-        true
-      else
-        raise APIException.new(response.body)
-      end
-    end
-
-    # Public: Get the comment source as a string.
-    #         Currently only populated when created via ::create
-    #
-    # Returns [Enum<SOURCES>]
-    def source
-      source_id ? SOURCES[source_id] : nil
-    end
-
-    # Public: Get the comment source as an integer.
-    #         Currently only populated when created via ::create
-    #
-    # Returns [Integer]
-    def source_id
-      @options[:source]
-    end
-
-    # Public: Get the comment visibility as a string.
-    #         Currently only populated when created via ::create
-    #
-    # Returns [Enum<VISIBILITIES>]
-    def visibility
-      visibility_id ? VISIBILITIES[visibility_id] : nil
-    end
-
-    # Public: Get the comment visibility as an integer.
-    #         Currently only populated when created via ::create
-    #
-    # Returns [Integer]
-    def visibility_id
-      @options[:visibility]
-    end
-
-    # Public: Get the comment content type as a string.
-    #         Currently only populated when created via ::create
-    #
-    # Returns [Enum<CONTENT_TYPES>]
-    def content_type
-      content_type_id ? CONTENT_TYPES[content_type_id] : nil
-    end
-
-    # Public: Get the comment visibility as an integer.
-    #         Currently only populated when created via ::create
-    #
-    # Returns [Integer]
-    def content_type_id
-      @options[:type]
-    end
-
-    # Public: Likes a comment as the passed user
-    #
-    # Returns [Boolean] true on success
-    # Raises [APIException] on failure
-    def like!(user)
-      response = @client.quill.post "/api/v3.0/message/#{id}/like/", {:collection_id => conversation.id, :lftoken => user.token}
-      if response.success?
-        true
-      else
-        raise APIException.new(response.body)
-      end
-    end
-
-    # Public: Unlikes a comment as the passed user
-    #
-    # Returns [Boolean] true on success
-    # Raises [APIException] on failure
-    def unlike!(user)
-      response = @client.quill.post "/api/v3.0/message/#{id}/unlike/", {:collection_id => conversation.id, :lftoken => user.token}
-      if response.success?
-        true
-      else
-        raise APIException.new(response.body)
-      end
-    end
-
-    # Public: create a new comment on a conversation
-    #
-    # client       - [Client] representing the site to use when creating the conversation
-    # user         - [User] to create the comment as
-    # conversation - [Conversation] to create
-    # body         - [String] Comment body
-    #
-    # Returns [Comment]
-    # Raises [APIException] when the API call fails
-    def self.create(client, user, conversation, body, reply_to = nil)
-      response = client.quill.post "/api/v3.0/collection/#{conversation.id}/post/", {:lftoken => user.token, :body => body, :_bi => client.identifier, :parent_id => reply_to}
-      if response.success?
-        puts JSON.parse(response.body).inspect
-        data = JSON.parse(response.body)["data"]
-
-        data["messages"].map do |entry|
-          c = entry["content"]
-          Comment.new(c["id"], conversation, {
-            :body         => c["bodyHtml"],
-            :parent_id    => c["parentId"],
-            :user         => User.new(c["authorId"], data["authors"].first.last["displayName"], data["authors"].first.last),
-            :created_at   => Time.at(c["createdAt"]),
-            :source       => entry["source"],
-            :visibility   => entry["vis"],
-            :client       => client,
-            :type         => entry["type"]
-          })
-        end.first
-      else
-        raise APIException.new(response.body)
-      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}' options=#{@options.inspect}>"
-    end
-  end
-end

data/lib/livefyre/controller_extensions.rb

@@ -1,82 +0,0 @@
-module Livefyre
-  # Public: Controller extensions for Rails. Adds methods to be called from your controller to integrate with Livefyre.
-  module Controller
-    extend ActiveSupport::Concern
-
-    # Public: Creates the Livefyre session cookies. Should be called when the user logs in.
-    def livefyre_login(id, display_name)
-      cookie = (Livefyre.config[:cookie_options] || {}).clone || {:path => "/", :expires => Time.now + 1.year}
-      expiry = cookie.delete(:expires) || (Time.now + 1.year)
-
-      token = {
-        :domain  => Livefyre.client.host,
-        :user_id => id,
-        :expires => expiry.to_i,
-        :display_name => display_name
-      }
-
-      name = cookie.delete(:name) || "livefyre_utoken"
-      cookies[name] = cookie.merge(:value => JWT.encode(token, Livefyre.client.key), :expires => expiry)
-    end
-
-    # Public: Destroys the Livefyre session cookies. Should be called when the user logs out
-    def livefyre_logout
-      name = (Livefyre.config[:cookie_options] || {})[:name] || "livefyre_utoken"
-      cookies.delete(name)
-    end
-
-    # Public: Attempt to generate valid Livefire profile dump from the passed user record by guessing at field names.
-    #
-    # user   - The user record to generate data from. Assumes it's ActiveModel-ish.
-    # values - [Hash] of values to force values for, rather than guessing at.
-    #
-    # Returns [Hash] suitable for conversion to JSON
-    def livefire_profile(user, values = {})
-      {
-        :id            => user.id,
-        :display_name  => user.try(:display_name) || user.try(:name) || user.try(:username),
-        :email         => user.try(:email),
-        :profile       => url_for(user),
-        :settings_url  => url_for(:edit, user),
-        :bio           => user.try(:bio) || user.try(:about),
-        :name          => {
-          :first_name  => user.try(:first_name),
-          :last_name   => user.try(:last_name),
-        }
-      }.merge defaults
-    end
-
-    # Public: Check the validity of the JWT that Livefyre sends with pull requests.
-    #
-    # Raises [JWT::DecodeError] if the token is invalid or missing.
-    def validate_livefyre_request!
-      JWT::DecodeError if params[:lftoken].nil?
-      token = JWT.decode params[:lftoken], Livefyre.client.key
-      raise JWT::DecodeError unless token["domain"] == Livefyre.client.host
-      return true
-    end
-
-    # Public: Used in your postback handler to parse the Livefyre postback body into an Activity stream for processing
-    #
-    # Returns [Array<Activity>] List of activities included in this postback.
-    def parse_livefyre_postback
-      JSON.parse(request.body).map {|item| Activity.new(client, item) }
-    end
-
-    module ClassMethods
-      # Public: filter helper to validate postback signatures for Livefyre requests.
-      #
-      # options - valid before_filter options, plus :key
-      #
-      # Example:
-      #
-      #     validate_postback_signature :only => [:postback], :key => "your_site_key"
-      def validate_postback_signature(options = {})
-        key = options.delete :key
-        before_filter Proc.new {|c|
-          Livefyre::Site.validate_signature(c.params, key)
-        }, options
-      end
-    end
-  end
-end

data/lib/livefyre/conversation.rb

@@ -1,133 +0,0 @@
-module Livefyre
-  # Public: Proxy object for a Livefyre [Conversation] (also called a Collection)
-  class Conversation
-    attr_accessor :id, :article_id
-    def initialize(id, article_id)
-      @id = id
-      @article_id = article_id
-      @client = Livefyre.client
-    end
-
-    # Public: Fetch a list of comments from a conversation
-    #         TODO: Not currently working.
-    def comments
-      response = @client.bootstrap.get "/bs3/#{@client.options[:domain]}/#{@client.options[:network]}/#{@client.options[:site_id]}/#{Base64.encode64 @article_id}/init"
-      if response.success?
-        JSON.parse response.body
-      else
-        raise APIException.new(response.body)
-      end
-    end
-
-    # Public: Update this collection with new metadata
-    #
-    # Returns [Bool] true on success
-    # Raises [APIException] on failure
-    def update(title, link, tags = nil)
-      meta = self.class.collectionMeta(@client, @article_id, title, link, tags)
-      response = @client.quill.post "/api/v3.0/site/#{@client.options[:site_id]}/collection/update/", {:collectionMeta => meta, :articleId => @article_id}.to_json
-      if response.success?
-        true
-      else
-        raise APIException.new(response.body)
-      end
-    end
-
-    # Public: Create a comment on this conversation
-    #
-    # user - [User] to create the comment as
-    # body - [String] body of the content
-    #
-    # Returns [Comment]
-    def create_comment(user, body)
-      Comment.create(@client, user, self, body)
-    end
-
-    # Public: Follow this conversation as the passed user
-    #
-    # user - [User] to follow the conversation as
-    #
-    # Returns [Boolean] true on success
-    # Raises [APIException] on failure
-    def follow_as(user)
-      response = @client.quill.post "/api/v3.0/collection/10584292/follow/", :lftoken => user.token, :collectionId => @id
-      if response.success?
-        true
-      else
-        raise APIException.new(response.body)
-      end
-    end
-
-    # Public: Unfollow this conversation as the passed user
-    #
-    # user - [User] to unfollow the conversation as
-    #
-    # Returns [Boolean] true on success
-    # Raises [APIException] on failure
-    def unfollow_as(user)
-      response = @client.quill.post "/api/v3.0/collection/10584292/unfollow/", :lftoken => user.token, :collectionId => @id
-      if response.success?
-        true
-      else
-        raise APIException.new(response.body)
-      end
-    end
-
-    # Public: Create a new collection
-    #
-    # client     - [Client] identifying the site to create the collection on
-    # article_id - [String] ID to use to identify this article
-    # title      - [String] Article title
-    # link       - [String] Article link
-    # tags       - [String, Array] Article tags
-    #
-    # Returns [Conversation]
-    def self.create(client, article_id, title, link, tags = nil)
-      meta = collectionMeta(client, article_id, title, link, tags)
-      response = client.quill.post "/api/v3.0/site/#{client.options[:site_id]}/collection/create", {:collectionMeta => meta, :articleId => article_id}.to_json
-      if response.success?
-        body = JSON.parse(response.body)
-        Conversation.new(body["data"]["collectionId"], article_id)
-      else
-        error = JSON.parse(response.body)
-        raise APIException.new(error["msg"])
-      end
-    end
-
-    # Internal: Generate a signed collectionMeta
-    #
-    # client     - [Client] identifying the site to create the collection on
-    # title      - [String] Article title
-    # link       - [String] Article link
-    # tags       - [String, Array] Article tags
-    #
-    # Returns [String] signed token
-    def self.collectionMeta(client, article_id, title, link, tags)
-      tag_str = case tags
-      when Array
-        tags.join ","
-      when String
-        tags
-      when nil
-        nil
-      else
-        raise "Invalid value given for tags: must be Array, String, or nil"
-      end
-
-      begin
-        URI.parse(link)
-      rescue URI::InvalidURIError => e
-        raise "Invalid value for link: #{e.message}"
-      end
-
-      metadata = {
-        :title => title,
-        :url   => link,
-        :articleId => article_id,
-        :tags  => tag_str || "",
-      }
-
-      JWT.encode(metadata, client.site_key)
-    end
-  end
-end