telestream_cloud 1.0.0

data/lib/telestream_cloud/flip.rb

@@ -0,0 +1,9 @@
+module TelestreamCloud
+
+  class Flip
+    def factories
+      TelestreamCloud::Factory
+    end
+  end
+
+end

data/lib/telestream_cloud/modules/associations.rb

@@ -0,0 +1,55 @@
+module TelestreamCloud
+  module Associations
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def has_one(relation_name)
+        # for example creates : @video ||= VideoScope.new(self)
+
+        define_method relation_name do
+          param_id = "#{relation_name}_id"
+          if instance_var = instance_variable_get("@#{relation_name}")
+            instance_var
+          else
+            @associations ||= []
+            @associations << relation_name
+            instance_variable_set("@#{relation_name}",
+              TelestreamCloud::const_get(relation_name.to_s.capitalize).find(send(param_id.to_sym)))
+          end
+        end
+      end
+
+      def has_many(relation_name)
+        # for example creates : @encodings ||= EncodingScope.new(self)
+
+        define_method relation_name do
+          model_name = "#{relation_name.to_s[0..-2].capitalize}"
+          if instance_var = instance_variable_get("@#{relation_name}")
+            instance_var
+          else
+            @associations ||= []
+            @associations << relation_name
+            instance_variable_set("@#{relation_name}",
+              TelestreamCloud::const_get("#{model_name}Scope").new(self))
+          end
+        end
+      end
+
+      alias :belongs_to :has_one
+
+    end
+
+    private
+    def reset_associations
+      if @associations
+        @associations.each do |a|
+          instance_variable_set("@#{a}",nil)
+        end
+      end
+    end
+
+  end
+end

data/lib/telestream_cloud/modules/builders.rb

@@ -0,0 +1,45 @@
+module TelestreamCloud
+  module Builders
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def create(attributes={})
+       resource = build_resource(attributes)
+       yield resource if block_given?
+
+       resource.create
+       resource
+      end
+
+      def create!(attributes={})
+        resource = build_resource(attributes)
+        yield resource if block_given?
+
+        resource.create!
+        resource
+      end
+
+      private
+      
+      def build_resource(attributes)
+        TelestreamCloud::const_get("#{sti_name}").new(attributes.merge('factory_id' => factory.id))
+      end
+    end
+
+    def create
+      raise "Can't create attribute. Already have an id=#{attributes['id']}" if attributes['id']
+      uri = replace_pattern_with_self_variables(self.class.many_path)
+      response = connection.post(uri, attributes)
+      load_and_reset(response)
+    end
+
+    def create!
+      create || raise(errors.last)
+    end
+
+  end
+end

data/lib/telestream_cloud/modules/destroyers.rb

@@ -0,0 +1,25 @@
+module TelestreamCloud
+  module Destroyers
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def delete(id)
+        uri = create_rest_url(one_path,{:id =>id})
+        response = connection.delete(uri)
+        !!response['deleted']
+      end
+      
+    end
+
+    def delete
+      uri = replace_pattern_with_self_variables(self.class.one_path)
+      response = connection.delete(uri)
+      !!response['deleted']
+    end
+
+  end
+end

data/lib/telestream_cloud/modules/factory_connection.rb

@@ -0,0 +1,7 @@
+module TelestreamCloud
+  module FactoryConnection
+    def connection
+      factory.connection
+    end
+  end
+end

data/lib/telestream_cloud/modules/finders.rb

@@ -0,0 +1,68 @@
+module TelestreamCloud
+  module Finders
+
+    def self.included(base)
+      base.extend(FindOne)
+      base.extend(FindMany)
+    end
+    
+    module FindOne
+
+      def find(id)
+        raise 'find method requires a correct value' if id.nil? || id == ''
+        find_by_path(one_path, {:id => id})
+      end
+
+      def find_object_by_path(url, map={})
+        rest_url = create_rest_url(url, map)
+        params = extract_unmapped_variables(url, map)
+        connection.get(rest_url, params)
+      end
+
+      def find_by_path(url, map={})
+        object = find_object_by_path(url, map)
+        kclass = TelestreamCloud::const_get("#{sti_name}")
+
+        if object.is_a?(Array)
+          object.map{|o| kclass.new(o)}
+        elsif object['id']
+          kclass.new(object)
+        else
+          raise APIError.new(object)
+        end
+      end
+
+    end
+
+    module FindMany
+
+      def find_by(map)
+        all(map).first
+      end
+
+      def all(map={})
+        find_by_path(many_path, map)
+      end
+
+      private
+
+      def find_all_by_has_many(relation_name, relation_value)
+         map = {}
+         map[relation_name.to_sym] = relation_value
+         has_many_path = build_hash_many_path(many_path, relation_name)
+         find_by_path(has_many_path, map)
+      end
+
+      def method_missing(method_symbol, *arguments)
+        method_name = method_symbol.to_s
+        if method_name =~ /^find_all_by_([_a-zA-Z]\w*)$/
+          find_all_by_has_many($1, arguments.pop)
+        else
+          super
+        end
+      end
+
+    end
+
+  end
+end

data/lib/telestream_cloud/modules/router.rb

@@ -0,0 +1,62 @@
+module TelestreamCloud
+  module Router
+    VAR_PATTERN = /:\w+/
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def resource_path
+        @url || "/#{sti_name.downcase}s"
+      end
+
+      def match(url)
+        @url = url
+      end
+
+      def many_path
+        resource_path
+      end
+
+      def one_path
+        resource_path + "/:id"
+      end
+
+      def build_hash_many_path(end_path, relation_attr)
+        relation_class_name = relation_attr[0..relation_attr.rindex("_id")-1].capitalize
+        prefix_path = TelestreamCloud::const_get(relation_class_name).resource_path + "/:" + relation_attr
+        prefix_path + end_path
+      end
+
+      def create_rest_url(url, map)
+        new_url = replace_pattern_with_variables(url, map)
+        json_path(new_url).gsub('factorys', 'factories')
+      end
+
+      private
+
+      def replace_pattern_with_variables(url, map)
+        new_url = url.clone
+        new_url.gsub(VAR_PATTERN){|key| map[key[1..-1].to_sym] || map[key[1..-1].to_s]}
+      end
+      
+      def extract_unmapped_variables(url, map)
+        params = map.clone
+        url.scan(VAR_PATTERN).map{|key| params.reject!{|k,v| k==key[1..-1] } }
+        params
+      end
+
+      def json_path(uri)
+        uri + ".json"
+      end
+    end
+
+    def replace_pattern_with_self_variables(url)
+      self.class.create_rest_url(url, attributes)
+    end
+
+  end
+end
+

data/lib/telestream_cloud/modules/updatable.rb

@@ -0,0 +1,31 @@
+module TelestreamCloud
+  module Updatable
+
+    def save
+      new? ? create : update
+    end
+
+    def save!
+      save || raise(errors.last)
+    end
+
+    def update_attribute(name, value)
+      send("#{name}=".to_sym, value) && save
+    end
+
+    def update_attributes(attributes)
+      load(attributes) && save
+    end
+
+    def update_attributes!(attributes)
+      update_attributes(attributes) || raise(errors.last)
+    end
+
+    def update
+      uri = replace_pattern_with_self_variables(self.class.one_path)
+      response = connection.put(uri, @changed_attributes)
+      load_and_reset(response)
+    end
+
+  end
+end

data/lib/telestream_cloud/modules/video_state.rb

@@ -0,0 +1,16 @@
+module TelestreamCloud
+  module VideoState
+    def success?
+      @attributes['status'] == 'success'
+    end
+
+    def processing?
+      @attributes['status'] == 'processing'
+    end
+
+    def fail?
+      @attributes['status'] == 'fail'
+    end
+
+  end
+end

data/lib/telestream_cloud/proxies/encoding_scope.rb

@@ -0,0 +1,56 @@
+module TelestreamCloud
+  class EncodingScope < Scope
+
+    def initialize(parent)
+      super(parent, Encoding)
+    end
+
+    def non_delegate_methods
+      super + [:status, :profile_id, :profile_name, :video, :page, :per_page, :[]]
+    end
+
+    def page(this_page)
+      @scoped_attributes[:page] = this_page
+      self
+    end
+
+    def per_page(this_per_page)
+      @scoped_attributes[:per_page] = this_per_page
+      self
+    end
+
+    def video(this_video_id)
+      @scoped_attributes[:video_id] = this_video_id
+      self
+    end
+
+    def status(this_status)
+      @scoped_attributes[:status] = this_status
+      self
+    end
+
+    def profile(this_profile_id)
+      @scoped_attributes[:profile_id] = this_profile_id
+      self
+    end
+
+    def profile_name(this_profile_name)
+      @scoped_attributes[:profile_name] = this_profile_name 
+      self
+    end
+
+    def find_by_profile_name(this_profile_name)
+      @scoped_attributes[:profile_name] = this_profile_name
+      trigger_request.first
+    end
+
+    def [](index)
+      if(index.is_a? String)
+        proxy_found.select{|e| e.profile_name == index}[0]
+      else
+        proxy_found[index]
+      end
+    end
+
+  end
+end

data/lib/telestream_cloud/proxies/profile_scope.rb

@@ -0,0 +1,7 @@
+module TelestreamCloud
+  class ProfileScope < Scope
+    def initialize(parent)
+      super(parent, Profile)
+    end
+  end
+end

data/lib/telestream_cloud/proxies/proxy.rb

@@ -0,0 +1,27 @@
+module TelestreamCloud
+  class Proxy
+    include TelestreamCloud::Router::ClassMethods
+    include TelestreamCloud::Builders::ClassMethods
+    
+    include TelestreamCloud::Finders::FindMany
+    include TelestreamCloud::Finders::FindOne
+
+    include TelestreamCloud::FactoryConnection
+
+    attr_accessor :parent, :klass
+
+    def initialize(parent, klass)
+      @parent = parent
+      @klass = klass
+    end
+
+    def factory
+      @parent.is_a?(Factory) ? @parent : @parent.factory
+    end
+
+    def sti_name
+      klass.sti_name
+    end
+
+  end
+end

data/lib/telestream_cloud/proxies/scope.rb

@@ -0,0 +1,94 @@
+require 'forwardable'
+
+module TelestreamCloud
+  class Scope < Proxy
+    extend Forwardable
+
+    def respond_to?(method)
+      scoped_methods = [].methods.map{|i| i.to_sym} - non_delegate_methods + [:reload, :non_delegate_methods]
+      !(scoped_methods).include?(method.to_sym)
+    end
+
+    def non_delegate_methods
+       [:nil?, :send, :object_id, :respond_to?, :class, :find, :find_by, :create, :create!, :all, :factory, :connection]
+    end
+
+    def initialize(parent, klass)
+      super
+
+      initialize_scope_attributes
+      initialize_scopes
+    end
+
+    # Overide the function to set the factory_id as the same as the scope
+    def find_by_path(url, map={})
+      object = find_object_by_path(url, map)
+
+      if object.is_a?(Array)
+        object.map{|o| klass.new(o.merge('factory_id' => factory.id))}
+      elsif object['id']
+        klass.new(object.merge('factory_id' => factory.id))
+      else
+        raise APIError.new(object)
+      end
+    end
+
+    def create(attributes)
+      scoped_attrs = attributes.merge(@scoped_attributes)
+      super(scoped_attrs)
+    end
+
+    def create!(attributes)
+      scoped_attrs = attributes.merge(@scoped_attributes)
+      super(scoped_attrs)
+    end
+
+    def all(attributes={})
+      @scoped_attributes.merge!(attributes)
+      trigger_request
+    end
+
+    def reload
+      @found = trigger_request
+    end
+    
+    private
+
+    def initialize_scope_attributes
+      @scoped_attributes={}
+      if @parent.is_a?(TelestreamCloud::Resource)
+        @scoped_attributes[parent_relation_name.to_sym] = @parent.id
+      end
+    end
+
+    def proxy_found
+      @found ||= trigger_request
+    end
+
+    def initialize_scopes
+      ([].methods + [:to_json]).each do |m|
+        unless m.to_s =~ /^__/ || non_delegate_methods.include?(m.to_sym)
+          self.class.class_eval do
+            def_delegators :proxy_found, m.to_sym
+          end
+        end
+      end
+    end
+
+    def trigger_request
+      if @parent.is_a?(Resource)
+        path = build_hash_many_path(many_path, parent_relation_name)
+      else
+        path = many_path
+      end
+
+      find_by_path(path, @scoped_attributes)
+    end
+
+    def parent_relation_name
+      "#{@parent.class.sti_name.downcase}_id"
+    end
+    
+  end
+end
+