videojuicer-vj-sdk 0.1.5 → 0.1.12

data/lib/videojuicer/criterion/base.rb

@@ -0,0 +1,56 @@
+module Videojuicer
+  module Criterion
+    def self.model_map
+      { :date_criteria        => Videojuicer::Criterion::DateRange,
+        :geolocation_criteria => Videojuicer::Criterion::Geolocation,
+        :request_criteria     => Videojuicer::Criterion::Request,
+        :time_criteria        => Videojuicer::Criterion::Time,
+        :week_day_criteria    => Videojuicer::Criterion::WeekDay
+      }
+    end
+    
+    class Base
+      def self.inherited(base)
+        base.send(:include, Videojuicer::Resource)
+        base.send(:extend, Videojuicer::Criterion::Base::ClassMethods)
+        base.send(:include, Videojuicer::Criterion::Base::InstanceMethods)
+      end
+      
+      module ClassMethods
+        def singular_name
+          "criterion"
+        end
+        
+        def base_path(options={})
+          "/criteria/#{self.to_s.split("::").last.snake_case}"
+        end
+        
+        def get(*args); raise NoMethodError; end
+        def all(*args); raise NoMethodError; end
+        def first(*args); raise NoMethodError; end
+      end
+      
+      module InstanceMethods
+        def save(*args); raise NoMethodError; end
+        def destroy(*args); raise NoMethodError; end
+        def ==(other); self.attributes == other.attributes; end
+        def eql?(other); self.attributes.eql?(other.attributes) end
+        def matcher_attributes;  end
+        
+        def matcher_attributes
+          result = {}
+          self.matcher_keys.each do |key|
+            result[key] = self.send(key)
+          end
+          return result
+        end
+        
+        def matcher_keys
+          raise NoMethodError, "Matcher Attributes needs to be implemented for #{self.class}";
+        end
+
+      end
+            
+    end
+  end
+end

data/lib/videojuicer/criterion/date_range.rb

@@ -1,24 +1,14 @@
+require File.join(File.dirname(__FILE__), "base")
+
 module Videojuicer
   module Criterion
-    class DateRange
-      include Videojuicer::Resource
-      include Videojuicer::Exceptions
-    
+    class DateRange < Base
+      
       property :until, DateTime
-      property :after, DateTime
-      property :created_at, DateTime
-      property :updated_at, DateTime
-
-      def self.plural_name
-        "criteria"
-      end
-
-      def self.singular_name
-        "criterion"
-      end
+      property :from, DateTime
       
-      def self.base_path
-        "/criteria/date_range"
+      def matcher_keys
+        [:until, :from]
       end
     end
   end

data/lib/videojuicer/criterion/geolocation.rb

@@ -1,27 +1,18 @@
+require File.join(File.dirname(__FILE__), "base")
+
 module Videojuicer
   module Criterion
-    class Geolocation
-      include Videojuicer::Resource
-      include Videojuicer::Exceptions
-    
-      property :city,     String
-      property :region,   String
-      property :country,  String
-      #property :exclude,  Boolean
-      property :created_at, DateTime
-      property :updated_at, DateTime
-
-      def self.plural_name
-        "criteria"
-      end
-
-      def self.singular_name
-        "criterion"
-      end
+    class Geolocation < Base
+      
+      property :country,            String
+      property :region,             String
+      property :city,               String
+      property :exclude,            Boolean
       
-      def self.base_path
-        "/criteria/geolocation"
+      def matcher_keys
+        [:country, :region, :city, :exclude]
       end
+
     end
   end
 end

data/lib/videojuicer/criterion/request.rb

@@ -1,23 +1,14 @@
+require File.join(File.dirname(__FILE__), "base")
+
 module Videojuicer
   module Criterion
-    class Request
-      include Videojuicer::Resource
-      include Videojuicer::Exceptions
-
-      property :referrer, String
-      property :created_at, DateTime
-      property :updated_at, DateTime
-
-      def self.plural_name
-        "criteria"
-      end
-
-      def self.singular_name
-        "criterion"
-      end
+    class Request < Base
+      
+      property :referrer,           String, :nullable => false
+      property :exclude,            Boolean
       
-      def self.base_path
-        "/criteria/request"
+      def matcher_keys
+        [:referrer, :exclude]
       end
     end
   end

data/lib/videojuicer/criterion/time.rb

@@ -1,24 +1,14 @@
+require File.join(File.dirname(__FILE__), "base")
+
 module Videojuicer
   module Criterion
-    class Time
-      include Videojuicer::Resource
-      include Videojuicer::Exceptions
-    
-      property :until, String
-      property :after, String
-      property :created_at, DateTime
-      property :updated_at, DateTime
-
-      def self.plural_name
-        "criteria"
-      end
-
-      def self.singular_name
-        "criterion"
-      end
+    class Time < Base
+      
+      property :until, DateTime
+      property :from, DateTime
       
-      def self.base_path
-        "/criteria/time"
+      def matcher_keys
+        [:until, :from]
       end
     end
   end

data/lib/videojuicer/criterion/week_day.rb

@@ -1,23 +1,19 @@
+require File.join(File.dirname(__FILE__), "base")
+
 module Videojuicer
   module Criterion
-    class WeekDay
-      include Videojuicer::Resource
-      include Videojuicer::Exceptions
-    
-      property :day, Integer
-      property :created_at, DateTime
-      property :updated_at, DateTime
-
-      def self.plural_name
-        "criteria"
-      end
-
-      def self.singular_name
-        "criterion"
-      end
+    class WeekDay < Base
+      property :monday,             Boolean
+      property :tuesday,            Boolean
+      property :wednesday,          Boolean
+      property :thursday,           Boolean
+      property :friday,             Boolean
+      property :saturday,           Boolean
+      property :sunday,             Boolean
+      property :exclude,            Boolean
       
-      def self.base_path
-        "/criteria/week_day"
+      def matcher_keys
+        [:monday, :tuesday, :wednesday, :thursday, :friday, :saturday, :sunday, :exclude]
       end
     end
   end

data/lib/videojuicer/oauth/request_proxy.rb

@@ -62,7 +62,7 @@ module Videojuicer
         end
         
         # Generate the HTTP Request and handle the response
-        url = "#{protocol}://#{host}:#{port}#{path}"
+        url = "#{host_stub}#{path}"
         request = request_class_for_method(method).new("#{path}?#{query_string}")        
         # Generate the multipart body and headers
         if multipart_params.any?          
@@ -85,6 +85,8 @@ module Videojuicer
         begin
           #response = HTTPClient.send(method, url, multipart_params)
           response = Net::HTTP.start(host, port) {|http| http.request(request) }
+        rescue EOFError => e
+          raise "EOF error when accessing #{url.inspect}"
         rescue Errno::ECONNREFUSED => e
           raise "Could not connect to #{url.inspect}"
         end
@@ -92,6 +94,10 @@ module Videojuicer
         return handle_response(response, request)
       end
       
+      def host_stub
+        "#{protocol}://#{host}:#{port}"
+      end
+      
       # Handles an HTTPResponse object appropriately. Redirects are followed, 
       # error states raise errors and success responses are returned directly.
       def handle_response(response, request)
@@ -105,35 +111,35 @@ module Videojuicer
           response
         when 401
           # Authentication problem
-          response_error Unauthenticated, response
+          response_error Unauthenticated, request, response
         when 403
           # Attempted to perform a forbidden action
-          response_error Forbidden, response
+          response_error Forbidden, request, response
         when 404
           # Resource URL not valid
-          response_error NoResource, response
+          response_error NoResource, request, response
         when 406
           # Excuse me WTF r u doin
-          response_error NotAcceptable, response
+          response_error NotAcceptable, request, response
         when 411
           # App-side server error where request is not properly constructed.
-          response_error ContentLengthRequired, response
+          response_error ContentLengthRequired, request, response
         when 500..600
           # Remote application failure
-          response_error RemoteApplicationError, response
+          response_error RemoteApplicationError, request, response
         else
-          response_error UnhandledHTTPStatus, response
+          response_error UnhandledHTTPStatus, request, response
         end
       end
       
       # Handles the response as an error of the desired type.
-      def response_error(exception_klass, response)
+      def response_error(exception_klass, request, response)
         begin
           e = JSON.parse(response.body)
           e = e["error"]
           raise exception_klass, "#{e["message"]} \n #{(e["backtrace"] || []).join("\n")}"
         rescue JSON::ParserError
-          raise exception_klass, "#{exception_klass.to_s} : Response code was #{response.code}"
+          raise exception_klass, "#{exception_klass.to_s} : Response code was #{response.code} for request: #{request.path}"
         end
         
       end
@@ -206,13 +212,13 @@ module Videojuicer
       
       # Calculates and returns the signature secret to be used for this proxy object.
       def signature_secret
-        [consumer_secret, token_secret].collect {|e| CGI.escape(e.to_s)}.join("&")
+        [consumer_secret, token_secret].collect {|e| CGI.rfc3986_escape(e.to_s)}.join("&")
       end
       
       # Returns the unencrypted signature base string for this proxy object and the 
       # given request properties.
       def signature_base_string(method, path, params)
-        s = [method.to_s.upcase, "#{protocol}://#{host}#{path}", normalize_params(params)].collect {|e| CGI.escape(e)}.join("&")
+        s = [method.to_s.upcase, "#{protocol}://#{host}#{path}", normalize_params(params)].collect {|e| CGI.rfc3986_escape(e)}.join("&")
       end
       
       # Returns a string representing a normalised parameter hash. Supports nesting for
@@ -220,7 +226,7 @@ module Videojuicer
       # the key 'bar inside {:foo=>{:bar=>"baz"}} will be named foo[bar] in the signature
       # and in the eventual request object.
       def normalize_params(params, *hash_path)
-        flatten_params(params).sort {|a,b| a.to_s <=> b.to_s}.collect {|k, v| "#{CGI.escape(k)}=#{CGI.escape(v.to_s)}" }.join("&")
+        flatten_params(params).sort {|a,b| a.to_s <=> b.to_s}.collect {|k, v| "#{CGI.rfc3986_escape(k)}=#{CGI.rfc3986_escape(v.to_s)}" }.join("&")
       end
       
       def flatten_params(params, *hash_path)

data/lib/videojuicer/presentation.rb

@@ -1,6 +1,7 @@
 module Videojuicer
   class Presentation
     include Videojuicer::Resource
+    include Videojuicer::Resource::Embeddable
     include Videojuicer::Exceptions
     
     property :slug,               String
@@ -28,5 +29,10 @@ module Videojuicer
 
     property :tag_list,           String
    
+    def permalink
+      proxy = proxy_for(config)
+      "#{proxy.host_stub}/presentations/#{id}.html?seed_name=#{seed_name}".gsub(":80/","/")
+    end
+   
   end 
 end

data/lib/videojuicer/promo/base.rb

@@ -0,0 +1,72 @@
+module Videojuicer
+  module Promo
+    def self.model_map
+      { :audio  => Videojuicer::Promo::Audio,
+        :images => Videojuicer::Promo::Image,
+        :texts  => Videojuicer::Promo::Text,
+        :videos => Videojuicer::Promo::Video
+      }
+    end
+    
+    class Base
+      
+      def self.inherited(base)
+        base.send(:include, Videojuicer::Resource)
+        base.send(:extend, Videojuicer::Promo::Base::ClassMethods)
+        base.send(:include, Videojuicer::Promo::Base::InstanceMethods)
+        
+        base.property :campaign_policy_id,  Integer
+        base.property :asset_id,            Integer
+        base.property :role,                String
+        base.property :href,                String
+      end
+      
+      module ClassMethods
+        def singular_name
+          "promo"
+        end
+        
+        def base_path(options={})
+          "/promos/#{self.to_s.split("::").last.snake_case}"
+        end
+        
+        def get(*args); raise NoMethodError; end
+        def all(*args); raise NoMethodError; end
+        def first(*args); raise NoMethodError; end
+      end
+      
+      module InstanceMethods
+        def save(*args); raise NoMethodError; end
+        def destroy(*args); raise NoMethodError; end
+        def asset
+          Videojuicer::Asset.const_get(self.class.to_s.split("::").last).get(asset_id)
+        end
+        def matcher_keys
+          [:campaign_policy_id, :asset_id, :role, :href]
+        end
+        def matcher_attributes
+          matcher_keys.inject({}) do |memo, attr|
+            memo.update(attr => self.send(attr))
+          end
+        end
+      end
+            
+    end
+    
+    class Audio < Base
+    end
+
+    class Image < Base
+    end
+
+    class Text < Base
+    end
+    
+    class Video < Base
+    end
+    
+    class Heart < Base
+    end
+    
+  end
+end

data/lib/videojuicer/resource/base.rb

@@ -17,6 +17,7 @@ module Videojuicer
       include Videojuicer::OAuth::ProxyFactory
       include Videojuicer::Resource::Inferrable
       include Videojuicer::Resource::PropertyRegistry
+      include Videojuicer::Resource::Types
       include Videojuicer::Resource::Relationships::BelongsTo
             
       def self.included(base)
@@ -57,9 +58,9 @@ module Videojuicer
         proxy = proxy_for(config)
         param_key = self.class.parameter_name
         response =  if new_record?
-                      proxy.post(resource_path(:validate), param_key=>returnable_attributes)
+                      proxy.post(resource_path(:validate, :nested=>false), param_key=>returnable_attributes)
                     else
-                      proxy.put(resource_path(:validate), param_key=>returnable_attributes)
+                      proxy.put(resource_path(:validate, :nested=>false), param_key=>returnable_attributes)
                     end
                     
         # Parse and handle response
@@ -98,20 +99,11 @@ module Videojuicer
         return save
       end
       
-      # Returns the appropriate resource path for this object.
-      # If the object is a new record, then the root object type path
-      # will be given. If the object is not new (has an ID) then the
-      # specific ID will be used.
-      def resource_path(action=nil)
-        action_stem = (action)? "/#{action}" : ""
-        (new_record?)? self.class.resource_path(action) : "#{self.class.resource_path}/#{id}#{action_stem}.json"
-      end
-      
       # Makes a call to the API for the current attributes on this object.
       # Overwrites the current instance attribute values.
       def reload
         raise NoResource, "Cannot load remote attributes for new records" if new_record?
-        response = proxy_for(config).get(resource_path)
+        response = proxy_for(config).get(resource_path(nil, :nested=>false))
         return validate_response(response)
       end
       
@@ -135,7 +127,7 @@ module Videojuicer
         def all(options={})
           # Get a proxy
           options = (options.empty?)? {} : {parameter_name=>options} # FIXME this is a hacky workaround for singleton scope.
-          response = instance_proxy.get(resource_path, options)
+          response = instance_proxy.get(base_path(:nested=>false), options)
           op = JSON.parse(response.body)
           
           items = (op["items"] rescue op) # If "items" is on the returned object then this is a collection hash.
@@ -151,11 +143,21 @@ module Videojuicer
           all(options.merge(:limit=>1)).first
         end
         
+        def create(attrs={})
+          o = new(attrs)
+          o.save
+          return o
+        end
+        
         # Fetches an object given an ID. Straight forward.
         def get(id)
           o = new(:id=>id)
-          o.reload
-          o
+          begin
+            o.reload 
+            o
+          rescue Videojuicer::Exceptions::NoResource
+            nil
+          end
         end
         
         def destroy(id)