livefyre 1.3.2 → 2.0.0

data/lib/livefyre/core/collection.rb

@@ -0,0 +1,93 @@
+require 'base64'
+require 'digest'
+require 'json'
+require 'jwt'
+require 'rest-client'
+
+require 'livefyre/api/domain'
+require 'livefyre/exceptions/api_exception'
+require 'livefyre/model/collection_data'
+require 'livefyre/utils/livefyre_util'
+require 'livefyre/validator/collection_validator'
+
+module Livefyre
+  class Collection
+    attr_accessor :site, :data
+
+    def initialize(site, data)
+      @site = site
+      @data = data
+    end
+
+    def self.init(site, type, title, article_id, url)
+      data = CollectionData.new(type, title, article_id, url)
+      Collection.new(site, CollectionValidator::validate(data))
+    end
+    
+    def create_or_update
+      response = invoke_collection_api('create')
+      if response.code == 200
+        @data.id = JSON.parse(response)['data']['collectionId']
+        return self
+      elsif response.code == 409
+        response = invoke_collection_api('update')
+        if response.code == 200
+          return self
+        end
+      end
+      raise ApiException.new(self, response.code)
+    end
+
+    def build_collection_meta_token
+      attr = @data.as_hash
+      attr[:iss] = is_network_issued ? @site.network.urn : @site.urn
+      JWT.encode(attr, is_network_issued ? @site.network.data.key : @site.data.key)
+    end
+
+    def build_checksum
+      attr_json = '{' + @data.as_hash.sort.map{|k,v| "#{k.inspect}:#{v.inspect}"}.join(',') + '}'
+      Digest::MD5.new.update(attr_json).hexdigest
+    end
+
+    def get_collection_content
+      response = RestClient.get(
+          "#{Domain::bootstrap(self)}/bs3/#{@site.network.data.name}/#{@site.data.id}/#{Base64.encode64(@data.article_id.to_s).chomp}/init",
+          :accepts => :json
+        ){|response, request, result| response }
+      raise ApiException.new(self, response.code) if response.code >= 400
+      JSON.parse(response)
+    end
+
+    def urn
+      "#{@site.urn}:collection=#{@data.id}"
+    end
+
+    def is_network_issued
+      network_urn = @site.network.urn
+
+      if @data.topics
+        @data.topics.each do |topic|
+          topic_id = topic.id
+          if topic_id.start_with?(network_urn) && !topic_id.sub(network_urn, '').start_with?(':site=')
+            return true
+          end
+        end
+      end
+
+      false
+    end
+    
+    private
+
+    def invoke_collection_api(method)
+      uri = "#{Domain::quill(self)}/api/v3.0/site/#{@site.data.id}/collection/#{method}/?sync=1"
+      data = {
+        :articleId => @data.article_id,
+        :collectionMeta => build_collection_meta_token,
+        :checksum => build_checksum
+      }
+      headers = { :accepts => :json, :content_type => :json }
+      RestClient.post(uri, data.to_json, headers){|response, request, result| response }
+    end
+  end
+end

data/lib/livefyre/core/network.rb

@@ -1,78 +1,83 @@
-require 'addressable/uri'
 require 'jwt'
 require 'rest-client'
 
-require 'livefyre/core/site'
 require 'livefyre/api/domain'
+require 'livefyre/core/site'
+require 'livefyre/exceptions/api_exception'
+require 'livefyre/model/network_data'
+require 'livefyre/validator/network_validator'
 
 module Livefyre
-	class Network
-		DEFAULT_USER = 'system'
-		DEFAULT_EXPIRES = 86400
+  class Network
+    DEFAULT_USER = 'system'
+    DEFAULT_EXPIRES = 86400
 
-		def initialize(name, key)
-			@name = name
-			@key = key
+    attr_accessor :data, :ssl
+
+    def initialize(data)
+      @data = data
       @ssl = true
-      @network_name = name.split('.')[0]
     end
 
-    attr_reader :name
-    attr_reader :key
-    attr_accessor :ssl
-    attr_reader :network_name
-
-		def set_user_sync_url(url_template)
-			raise ArgumentError, 'url_template should contain {id}' if !url_template.include?('{id}')
-			
-			response = RestClient.post(
-					"#{Domain::quill(self)}/",
-					{ actor_token: build_livefyre_token, pull_profile_url: url_template }
-				)
-			response.code == 204
-		end
-
-		def sync_user(user_id)
-			response = RestClient.post(
-					"#{Domain::quill(self)}/api/v3_0/user/#{user_id}/refresh",
-					{ lftoken: build_livefyre_token }
-				)
-			response.code == 200
-		end
-
-		def build_livefyre_token
-			build_user_auth_token(DEFAULT_USER, DEFAULT_USER, DEFAULT_EXPIRES)
-		end
-
-		def build_user_auth_token(user_id, display_name, expires)
-			raise ArgumentError, 'user_id must be alphanumeric' if !(user_id =~ /\A\p{Alnum}+\z/)
-
-			JWT.encode({
-					domain: @name,
-      user_id: user_id,
-          display_name: display_name,
-          expires: Time.new.to_i + expires},
-          @key)
+    def self.init(name, key)
+      data = NetworkData.new(name, key)
+      Network.new(NetworkValidator::validate(data))
     end
 
-    def validate_livefyre_token(lf_token)
-      token_attributes = JWT.decode(lf_token, @key)
+    def set_user_sync_url(url_template)
+      raise ArgumentError, 'url_template should contain {id}' if !url_template.include?('{id}')
+
+      response = RestClient.post(
+          "#{Domain::quill(self)}/",
+          { :actor_token => build_livefyre_token, :pull_profile_url => url_template }
+      ){|response, request, result| response }
+      raise ApiException.new(self, response.code) if response.code >= 400
+    end
+
+    def sync_user(user_id)
+      response = RestClient.post(
+          "#{Domain::quill(self)}/api/v3_0/user/#{user_id}/refresh",
+          { :lftoken => build_livefyre_token }
+      ){|response, request, result| response }
+      raise ApiException.new(self, response.code) if response.code >= 400
+      self
+    end
 
-      token_attributes['domain'] == @name \
-				&& token_attributes['user_id'] == DEFAULT_USER \
-        && token_attributes['expires'] >= Time.new.to_i
+    def build_livefyre_token
+      build_user_auth_token(DEFAULT_USER, DEFAULT_USER, DEFAULT_EXPIRES)
+    end
+
+    def build_user_auth_token(user_id, display_name, expires)
+      raise ArgumentError, 'user_id must be alphanumeric' if !(user_id =~ /^[a-zZA-Z0-9_\.-]+$/)
+      raise ArgumentError, 'expires must be a number' if !expires.is_a? Numeric
+
+      JWT.encode({
+          :domain => @data.name,
+          :user_id => user_id,
+          :display_name => display_name,
+          :expires => Time.new.to_i + expires},
+        @data.key)
+    end
+
+    def validate_livefyre_token(lf_token)
+      token_attributes = JWT.decode(lf_token, @data.key)
+      token_attributes['domain'] == @data.name && token_attributes['user_id'] == DEFAULT_USER && token_attributes['expires'] >= Time.new.to_i
     end
 
     def get_site(site_id, site_key)
-      Site.new(self, site_id, site_key)
+      Site::init(self, site_id, site_key)
+    end
+
+    def urn
+      "urn:livefyre:#{@data.name}"
     end
 
-    def get_urn
-      "urn:livefyre:#{@name}"
+    def get_urn_for_user(user)
+      "#{urn}:user=#{user}"
     end
 
-    def get_user_urn(user)
-      "#{get_urn}:user=#{user}"
+    def network_name
+      @data.name.split('.')[0]
     end
-	end
+  end
 end

data/lib/livefyre/core/site.rb

@@ -1,104 +1,56 @@
-require 'base64'
-require 'digest'
-require 'json'
-require 'jwt'
-require 'rest-client'
-require 'addressable/uri'
-
-require 'livefyre/api/domain'
+require 'livefyre/core/collection'
+require 'livefyre/model/site_data'
+require 'livefyre/type/collection_type'
+require 'livefyre/validator/site_validator'
 
 module Livefyre
 	class Site
-		TYPE = %w(reviews sidenotes ratings counting liveblog livechat livecomments)
-
-		def initialize(network, id, key)
+    attr_accessor :network, :data
+    
+		def initialize(network, data)
 			@network = network
-			@id = id
-			@key = key
+      @data = data
     end
 
-    attr_reader :network
-    attr_reader :id
-    attr_reader :key
-
-		def build_collection_meta_token(title, article_id, url, options={})
-			raise ArgumentError, 'provided url is not a valid url' if !uri?(url)
-			raise ArgumentError, 'title length should be under 255 char' if title.length > 255
-			
-			collection_meta = {
-				url: url,
-				title: title,
-				articleId: article_id
-			}
-
-			if options.has_key?(:type) && !TYPE.include?(options[:type])
-        raise ArgumentError, 'type is not a recognized type. should be liveblog, livechat, livecomments, reviews, sidenotes, or an empty string'
-			end
-
-			JWT.encode(collection_meta.merge(options), @key)
-		end
-
-		def build_checksum(title, url, tags='')
-			raise ArgumentError, 'provided url is not a valid url' if !uri?(url)
-			raise ArgumentError, 'title length should be under 255 char' if title.length > 255
-			
-			collection_meta = { tags: tags, title: title, url: url }
-			Digest::MD5.new.update(collection_meta.to_json).hexdigest
-		end
-
-
-    def create_collection(title, article_id, url, options={})
-      uri = "#{Domain::quill(self)}/api/v3.0/site/#{@id}/collection/create/?sync=1"
-      data = {
-        articleId: article_id,
-        collectionMeta: build_collection_meta_token(title, article_id, url, options),
-        checksum: build_checksum(title, url, options.has_key?(:tags) ? options[:tags] : '')
-      }
-      headers = {:accepts => :json, :content_type => :json}
+    def self.init(network, id, key)
+      data = SiteData.new(id, key)
+      Site.new(network, SiteValidator::validate(data))
+    end
 
-      response = RestClient.post(uri, data.to_json, headers)
+    def build_comments_collection(title, article_id, url)
+      build_collection(CollectionType::COMMENTS, title, article_id, url)
+    end
 
-      if response.code == 200
-        return JSON.parse(response)['data']['collectionId']
-      end
+    def build_blog_collection(title, article_id, url)
+      build_collection(CollectionType::BLOG, title, article_id, url)
+    end
 
-      nil
+    def build_chat_collection(title, article_id, url)
+      build_collection(CollectionType::CHAT, title, article_id, url)
     end
 
-		def get_collection_content(article_id)
-			response = RestClient.get(
-					"#{Domain::bootstrap(self)}/bs3/#{@network.name}/#{@id}/#{Base64.encode64(article_id.to_s).chomp}/init",
-					:accepts => :json
-				)
-			response.code == 200 ? JSON.parse(response) : nil
-		end
+    def build_counting_collection(title, article_id, url)
+      build_collection(CollectionType::COUNTING, title, article_id, url)
+    end
 
-		def get_collection_id(article_id)
-			content = get_collection_content(article_id)
-			if content
-				content['collectionSettings']['collectionId']
-			end
+    def build_ratings_collection(title, article_id, url)
+      build_collection(CollectionType::RATINGS, title, article_id, url)
     end
 
-    def network_name
-			@network.network_name
+    def build_reviews_collection(title, article_id, url)
+      build_collection(CollectionType::REVIEWS, title, article_id, url)
     end
 
-    def build_livefyre_token
-      @network.build_livefyre_token
+    def build_sidenotes_collection(title, article_id, url)
+      build_collection(CollectionType::SIDENOTES, title, article_id, url)
     end
 
-		def get_urn
-			"#{@network.get_urn}:site=#{@id}"
-		end
+    def build_collection(type, title, article_id, url)
+      Collection::init(self, type, title, article_id, url)
+    end
 
-		def uri?(string)
-		  uri = Addressable::URI.parse(string)
-		  %w( ftp ftps http https ).include?(uri.scheme)
-		rescue Addressable::URI::BadURIError
-		  false
-		rescue Addressable::URI::InvalidURIError
-		  false
+		def urn
+			"#{@network.urn}:site=#{@data.id}"
 		end
 	end
 end

data/lib/livefyre/cursor/timeline_cursor.rb

@@ -0,0 +1,45 @@
+require 'livefyre/api/personalized_stream'
+require 'livefyre/model/cursor_data'
+require 'livefyre/validator/cursor_validator'
+
+module Livefyre
+	class TimelineCursor
+    attr_accessor :core, :data
+
+    def initialize(core, data)
+      @core = core
+      @data = data
+    end
+    
+    def self.init(core, resource, limit, date)
+      data = CursorData.new(resource, limit, date)
+      TimelineCursor.new(core, CursorValidator::validate(data))
+    end
+
+    def next
+      data = PersonalizedStream::get_timeline_stream(self, true)
+      cursor = data['meta']['cursor']
+
+      @data.next = cursor['hasNext']
+      @data.previous = cursor['next'] != nil
+      if @data.previous
+        @data.cursor_time = cursor['next']
+      end
+
+      data
+    end
+
+    def previous
+      data = PersonalizedStream::get_timeline_stream(self, false)
+      cursor = data['meta']['cursor']
+
+      @data.previous = cursor['hasPrev']
+      @data.next = cursor['prev'] != nil
+      if @data.next
+        @data.cursor_time = cursor['prev']
+      end
+
+      data
+    end
+	end
+end

data/lib/livefyre/{entity → dto}/subscription.rb

@@ -1,5 +1,9 @@
+require 'json'
+
 module Livefyre
 	class Subscription
+    attr_accessor :to, :by, :type, :created_at
+    
     def initialize(to, by, type, created_at=nil)
       @to = to
       @by = by
@@ -7,26 +11,20 @@ module Livefyre
       @created_at = created_at
     end
 
-    attr_reader :to
-    attr_reader :by
-    attr_reader :type
-    attr_reader :created_at
-
     def self.serialize_from_json(json)
       new(json['to'], json['by'], json['type'], json['createdAt'])
     end
 
-    def to_dict
-      dict = { :to => @to, :by => @by, :type => @type }
+    def to_json(options = {})
+      to_hash.to_json(options)
+    end
+
+    def to_hash
+      hash = { :to => @to, :by => @by, :type => @type }
       if @created_at != nil
-        dict[:createdAt] = @created_at
+        hash[:createdAt] = @created_at
       end
-      dict
+      hash
     end
-
-  end
-
-  module SubscriptionType
-    PERSONAL_STREAM = 1
   end
 end