live_paper 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bac85ce7d86248d235c457c1de2d84cd715f0175
-  data.tar.gz: 8acc4818c69b8b792806353966964655a6c5b1db
+  metadata.gz: e0be6ece34f4d51cf32f7ea78ffaae9d6c8543b3
+  data.tar.gz: b3838914f2bbaca46a1af9d87d259612186849f0
 SHA512:
-  metadata.gz: 6289ddfcf77c671e5876bf5765fe5b6d9c3289277c80a6127890d9759f1fe39c3326c9e6289560f284b77da8d2876c26975f7ffc5cf2b854d675c2375e955db2
-  data.tar.gz: ffbbda4ee49a0d1ee245efc4166c63b0a82b8d89c1dc4cf81dd4472f2f3f2bca632b63159288a11c492f783ee8b867f04dec7f421d8349e1bdef3de95f4833c6
+  metadata.gz: 4956d0c6516a9f2778e2e84c2958a4ebc50b981fa9fce39dd2260b8ef00b07016834d13b43f14858c2f72a3ba516501c6058baca22fa50f8564d2b3310291346
+  data.tar.gz: bde0081f9039ec48fb5354cee3fdf5c062967a7f2cd3ca85bd5fab44ea7cda3067e3b68f99305895c4256c1e36e413159983159b7692713f6ec8dbf805545aa8

data/Rakefile

@@ -1,2 +1,10 @@
+require 'rspec/core/rake_task'
 require "bundler/gem_tasks"
 
+# Default directory to look in is `/specs`
+# Run with `rake spec`
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = ['--color', '--format', 'documentation']
+end
+
+task :default => :spec

data/lib/live_paper.rb

@@ -1,6 +1,15 @@
+require "live_paper/base_object"
+require "live_paper/http_client"
+require "live_paper/image"
+require "live_paper/link"
+require "live_paper/payoff"
+require "live_paper/wm_trigger"
+require "live_paper/qr_trigger"
+require "live_paper/short_trigger"
 require "live_paper/version"
 require 'base64'
 require 'rest-client'
+require 'json'
 
 module LivePaper
 
@@ -12,7 +21,8 @@ module LivePaper
 
   class LivePaperSession
     def initialize(auth)
-      authorize(auth)
+      #todo: tdd, verify hash
+      $lpp_basic_auth = Base64.strict_encode64("#{auth[:id]}:#{auth[:secret]}")
     end
 
     def smart_link(dest, image=nil)
@@ -32,129 +42,30 @@ module LivePaper
     end
 
     def shorten(dest)
-      #returns shortened url
-      trig = trigger "shorturl"
-      payoff = url_payoff dest
-      link(trig, payoff)
-
-      trig["link"].select { |item| item["rel"] == "shortURL" }.first["href"]
+      t=ShortTrigger.create(name: 'short trigger')
+      p=Payoff.create(name: 'name', type: Payoff::TYPE[:WEB], url: dest)
+      Link.create(payoff_id: p.id, trigger_id: t.id, name: "link")
+      t.short_url
     end
 
     def qr_bytes(dest)
-      #returns shortened url
-      trig = trigger "qrcode"
-      payoff = url_payoff dest
-      link(trig, payoff)
-
-      img_loc = trig["link"].select { |item| item["rel"] == "image" }.first["href"]
-      resp = RestClient.get(img_loc, {Authorization: api_headers[:Authorization], Accept: 'image/png'})
-      resp.body
+      t=QrTrigger.create(name: 'QR code trigger')
+      p=Payoff.create(name: 'name', type: Payoff::TYPE[:WEB], url: dest)
+      Link.create(payoff_id: p.id, trigger_id: t.id, name: "link")
+      t.download_qrcode
     end
 
     def watermark_bytes(dest, image_url)
-      image = upload_image image_url
+      image = Image.upload image_url
 
-      trig = trigger "watermark", watermark: {imageURL: image, resolution: "75", strength: "10"}
-      payoff = url_payoff dest
-      link(trig, payoff)
-
-      img_loc = trig["link"].select { |item| item["rel"] == "image" }.first["href"]
-      resp = RestClient.get(img_loc, Authorization: api_headers[:Authorization])
-      resp.body
+      t=WmTrigger.create(name: 'watermark', watermark: {strength: 10, resolution: 75, imageURL: image})
+      p=Payoff.create(name: 'name', type: Payoff::TYPE[:WEB], url: dest)
+      Link.create(payoff_id: p.id, trigger_id: t.id, name: "link")
+      t.download_watermark
     rescue Exception => e
       puts "Exception!"
       puts e.response
     end
 
-    private
-    def upload_image(img)
-      uri='https://storage.livepaperapi.com/objects/v1/files'
-      # return the original img uri if it is LPP storage
-      if img.include? uri
-        return img
-      end
-      begin
-        src_image = RestClient.get(img, Accept: 'image/jpg')
-        response = RestClient.post uri,
-                                   src_image.body,
-                                   Authorization: api_headers[:Authorization],
-                                   content_type: 'image/jpg'
-        response.headers[:location]
-      rescue Exception => e
-        puts "Exception! ******\n#{e}"
-        img
-      end
-    end
-
-    def trigger(type="shorturl", options={})
-      body = {
-          trigger: {
-              name: "trigger",
-              type: type,
-              expiryDate: Time.now + (365 * 24 * 60 * 60)
-          }.merge(options)
-      }
-      create_resource('trigger', body)
-    end
-
-    def url_payoff(dest)
-      body = {
-          payoff: {
-              name: "payoff",
-              URL: dest
-          }
-      }
-      create_resource('payoff', body)
-    end
-
-    def link(trigger, payoff)
-      body = {
-          link: {
-              name: "link",
-              payoffId: payoff["id"],
-              triggerId: trigger["id"]
-          }
-      }
-      create_resource('link', body)
-    end
-
-    def authorize(auth)
-      uri = "#{LP_API_HOST}/auth/token"
-      body = "grant_type=client_credentials&scope=all"
-
-      basic_auth = Base64.strict_encode64("#{auth[:id]}:#{auth[:secret]}")
-
-      begin
-        response = RestClient.post uri, body,
-                                   :content_type => 'application/x-www-form-urlencoded',
-                                   Accept: 'application/json',
-                                   Authorization: "Basic #{basic_auth}"
-      rescue Exception => e
-        puts "Exception!"
-        puts e.response
-      end
-
-      body = JSON.parse(response.body)
-      @token=body["accessToken"]
-    end
-
-    def api_headers
-      {Authorization: "Bearer #{@token}",
-       content_type: 'application/json',
-       Accept: 'application/json'
-      }
-    end
-
-    def create_resource(resource, body)
-      uri= "https://www.livepaperapi.com/api/v1/#{resource}s"
-      response = RestClient.post uri, body.to_json, api_headers
-      JSON.parse(response.body)[resource]
-    rescue Exception => e
-      puts "Exception!"
-      puts e.response
-      nil
-    end
-
   end
-
 end

data/lib/live_paper/base_object.rb

@@ -0,0 +1,82 @@
+require_relative 'http_client'
+require 'json'
+
+module LivePaper
+  class BaseObject
+    extend HttpClient
+    attr_accessor :id, :name, :date_created, :date_modified
+
+    def assign_attributes(data)
+      data.each do |key, value|
+        method = "#{underscore key.to_s}="
+        public_send(method, value) if respond_to?(method)
+      end unless data.empty?
+    end
+
+    def initialize(data={})
+      assign_attributes data
+    end
+
+    def self.create(data)
+      self.new(data).save
+    end
+
+    def save
+      validate_attributes!
+      BaseObject.request_handling_auth(self.class.api_url, 'POST') do |request|
+        response = BaseObject.send_request(request, 'application/json', create_body.to_json)
+        parse(response.body)
+      end unless present? @id
+      self
+    end
+
+    def self.find(id)
+      request_handling_auth("#{api_url}/#{id}", 'GET') do |request|
+        response = send_request(request, 'application/json')
+        parse response.body
+      end rescue nil
+    end
+
+    def self.parse(data)
+      self.new().parse(data)
+    end
+
+    def parse(data)
+      raise NotImplementedError
+    end
+
+    def self.api_url
+      raise NotImplementedError
+    end
+
+    protected
+    def all_present?(array)
+      array.all? { |e| present? e } rescue false
+    end
+
+    def all_keys_present?(hash, keys)
+      keys.all? { |e| present? hash[e] } rescue false
+    end
+
+    def present?(obj)
+      !(obj.respond_to?(:empty?) ? obj.empty? : !obj)
+    end
+
+    def underscore(camel_cased_word)
+      camel_cased_word.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+        gsub(/([a-z\d])([A-Z])/, '\1_\2').
+        tr("-", "_").
+        downcase
+    end
+
+    private
+    def validate_attributes!
+      raise NotImplementedError
+    end
+
+    def create_body
+      raise NotImplementedError
+    end
+  end
+end

data/lib/live_paper/http_client.rb

@@ -0,0 +1,80 @@
+require 'open-uri'
+require 'net/https'
+
+class NotAuthenticatedError < Exception
+end
+
+module LivePaper
+  module HttpClient
+    LP_API_HOST="https://www.livepaperapi.com"
+    AUTH_URL = "#{LP_API_HOST}/auth/token"
+
+    def send_request(request, content_type = nil, body = nil)
+      request['Content-type'] = content_type if content_type
+      request.body = body if body
+      response = @http.request(request)
+      check_response(response)
+      response
+    end
+
+    def check_response(response)
+      status = response.code.to_i
+      raise NotAuthenticatedError.new("Unauthorized") if status == 401
+      unless Array(200..201).include?(status)
+        raise "Request failed with code #{status}"
+      end
+    end
+
+    def request_handling_auth(url, method)
+      tries = 0
+      begin
+        request_access_token unless @access_token
+        request = http_request(url, method)
+        request['Authorization'] = "Bearer #{@access_token}"
+        yield request
+      rescue NotAuthenticatedError => e
+        tries += 1
+        if tries < 3
+          @access_token = nil
+          retry
+        else
+          raise e
+        end
+      end
+    end
+
+    def request_access_token
+      request = http_request(AUTH_URL, 'POST')
+      request['Authorization'] = "Basic #{$lpp_basic_auth}"
+      request['Content-Type'] = 'application/x-www-form-urlencoded'
+      request.body = 'grant_type=client_credentials&scope=all'
+      response = @http.request(request)
+      parsed = JSON.parse(response.body)
+      @access_token = parsed['accessToken']
+    end
+
+    def http_request(url, method)
+      uri = URI.parse(url)
+      set_http uri
+
+      case method.to_s.upcase
+        when 'POST'
+          Net::HTTP::Post.new(uri.request_uri)
+        when 'GET'
+          Net::HTTP::Get.new(uri.request_uri)
+        else
+          raise "Method '#{method}' not supported."
+      end
+    end
+
+    private
+    def set_http(uri)
+      http_params = [uri.host, uri.port]
+      http_params.concat ENV['HTTP_PROXY'].gsub('http://', '').split(':') unless ENV['HTTP_PROXY'].to_s.empty?
+
+      @http = Net::HTTP.new(*http_params)
+      @http.use_ssl = true
+      @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+  end
+end

data/lib/live_paper/image.rb

@@ -0,0 +1,32 @@
+require_relative 'base_object'
+require 'rest-client'
+
+module LivePaper
+  class Image
+  extend HttpClient
+
+    attr_accessor :url
+
+    API_URL = 'https://storage.livepaperapi.com/objects/v1/files'
+
+    def self.upload(img)
+      # return the original img uri if it is LivePaper storage
+      if img.include? API_URL
+        return img
+      end
+      begin
+        src_image = RestClient.get(img, Accept: 'image/jpg')
+        request_access_token unless @access_token
+        response = RestClient.post API_URL,
+                                   src_image.body,
+                                   Authorization: "Bearer #{@access_token}",
+                                   content_type: 'image/jpg'
+        response.headers[:location]
+      rescue Exception => e
+        puts "Exception! ******\n#{e}"
+        img
+      end
+    end
+
+  end
+end

data/lib/live_paper/link.rb

@@ -0,0 +1,46 @@
+require_relative 'base_object'
+
+module LivePaper
+  class Link < BaseObject
+    attr_accessor :payoff_id, :trigger_id, :analytics
+
+    def parse(data)
+      data = JSON.parse(data, symbolize_names: true)[:link]
+      assign_attributes data
+      @analytics = get_link_for data, 'analytics'
+      self
+    end
+
+    def payoff
+      @payoff ||= LivePaper::Payoff.find @payoff_id
+    end
+
+    def trigger
+      #todo: need to get the right object created here!!!
+      @trigger ||= LivePaper::WmTrigger.find @trigger_id
+    end
+
+    def self.api_url
+      "#{LP_API_HOST}/api/v1/links"
+    end
+
+    private
+    def validate_attributes!
+      raise ArgumentError, 'Required Attributes needed: name, payoff_id and trigger_id.' unless all_present? [@name, @payoff_id, @trigger_id]
+    end
+
+    def create_body
+      {
+        link: {
+          name: @name,
+          triggerId: @trigger_id,
+          payoffId: @payoff_id
+        }
+      }
+    end
+
+    def get_link_for(data, rel)
+      data[:link].find { |obj| obj[:rel] == rel }[:href] rescue ''
+    end
+  end
+end

data/lib/live_paper/payoff.rb

@@ -0,0 +1,78 @@
+require_relative 'base_object'
+
+module LivePaper
+  class Payoff < BaseObject
+    attr_accessor :type, :url, :data_type, :data
+
+    TYPE = {
+      WEB: 'WEB_PAYOFF',
+      RICH: 'RICH_PAYOFF'
+    }
+
+    def parse(data)
+      data = JSON.parse(data, symbolize_names: true)[:payoff]
+      assign_attributes(data)
+      send(present?(data[:richPayoff]) ? :parse_richpayoff : :parse_webpayoff, data)
+      self
+    end
+
+    def self.api_url
+      "#{LP_API_HOST}/api/v1/payoffs"
+    end
+
+    private
+    def validate_attributes!
+      raise ArgumentError, 'Required Attributes needed: name, type, url.' unless all_present? [@name, @type, @url]
+      raise ArgumentError, 'Required Attributes needed: data_type, data.' if @type == TYPE[:RICH] and !all_present? [@data_type, @data]
+    end
+
+    def parse_richpayoff(data)
+      data = data[:richPayoff]
+
+      @type = TYPE[:RICH]
+      @url = data[:public][:url]
+      @data_type = data[:private][:'content-type']
+      @data = JSON.parse(Base64.decode64(data[:private][:data]), symbolize_names: true) rescue nil
+    end
+
+    def parse_webpayoff(data)
+      @type = TYPE[:WEB]
+      @url = data[:URL]
+    end
+
+    def create_body
+      {
+        payoff: case @type
+          when TYPE[:WEB]
+            create_webpayoff_body
+          when TYPE[:RICH]
+            create_richpayoff_body
+          else
+            raise ArgumentError, 'Type unknown.'
+        end
+      }
+    end
+
+    def create_webpayoff_body
+      {
+        name: @name,
+        URL: @url
+      }
+    end
+
+    def create_richpayoff_body
+      {
+        name: @name,
+        richPayoff: {
+          version: 1,
+          private: {
+            :'content-type' => @data_type,
+            :data => @data
+          },
+          public: {url: @url}
+        }
+      }
+    end
+
+  end
+end