proteus_client 0.0.7 → 1.0.1

data/lib/proteus_client.rb

@@ -3,6 +3,12 @@ require 'rest_client'
 
 require_relative 'proteus_client/config'
 require_relative 'proteus_client/proxy'
+require_relative 'proteus_client/representers/video'
+require_relative 'proteus_client/representers/recording'
+require_relative 'proteus_client/models/recording'
+require_relative 'proteus_client/models/video'
+require_relative 'proteus_client/models/thumbnail'
+require_relative 'proteus_client/models/version'
 
 # Provides an interface to use Proteus rest services features
 #
@@ -12,4 +18,4 @@ module ProteusClient
     @config ||= ProteusClient::Config.new
   end
 
-end
+end

data/lib/proteus_client/config.rb

@@ -2,11 +2,12 @@ module ProteusClient
 
   # Used to configure default values used for creating a ProteusClient::Proxy
   # @example Configuring values
-  #   ProteusClient.config.domain = "http://localhost:9292"
+  #   ProteusClient.config.root = "http://localhost:9292"
   #   ProteusClient.config.api_key= "api_key"
+  #   ProteusClient.config.account = "account"
   #
   class Config
-    attr_accessor :domain, :api_key
+    attr_accessor :root, :api_key, :account
   end
 
-end
+end

data/lib/proteus_client/models/recording.rb

@@ -0,0 +1,12 @@
+module ProteusClient
+  Recording = Struct.new(:id, :adobe_rtmpe_file, :adobe_rtmpe_write,
+                         :adobe_rtmpe_read, :generic_https) do
+
+    def initialize(options)
+      options.each do |key, value|
+        self[key.to_sym] = value
+      end
+    end
+
+  end
+end

data/lib/proteus_client/models/thumbnail.rb

@@ -0,0 +1,11 @@
+module ProteusClient
+  Thumbnail = Struct.new(:size, :url) do
+
+    def initialize(options)
+      options.each do |key, value|
+        self[key.to_sym] = value
+      end
+    end
+
+  end
+end

data/lib/proteus_client/models/version.rb

@@ -0,0 +1,11 @@
+module ProteusClient
+  Version = Struct.new(:url, :solution, :name) do
+
+    def initialize(options)
+      options.each do |key, value|
+        self[key.to_sym] = value
+      end
+    end
+
+  end
+end

data/lib/proteus_client/models/video.rb

@@ -0,0 +1,11 @@
+module ProteusClient
+  Video = Struct.new(:id, :thumbnails, :versions) do
+
+    def initialize(options)
+      options.each do |key, value|
+        self[key.to_sym] = value
+      end
+    end
+
+  end
+end

data/lib/proteus_client/proxy.rb

@@ -3,116 +3,97 @@ module ProteusClient
   # Provides an interface for Proteus REST service to encode videos
   # @example Creating a new proxy
   #   ProteusClient::Proxy.new
-  #   ProteusClient::Proxy.new({api_key: "api_key", domain: "http://localhost:9292"})
-  #
-  # @example Testing service
-  #   proteus_client.test_api #=> {message: 'Welcome to Proteus'}
+  #   ProteusClient::Proxy.new({account: "", api_key: "", root: "http://localhost:9292"})
   #
   # @example Calling a method
   #   proteus_client.create_video("video_id","type")
   #
   # @raise [APIKeyNotDefined] if api_key is not defined in ProteusClient.config or sent as param
-  # @raise [DomainNotDefined] if domain is not defined in ProteusClient.config or sent as param
+  # @raise [RootNotDefined] if root is not defined in ProteusClient.config or sent as param
   # @raise [RestClient::Exception] if status code returned from services is not in 200..207
   #
   class Proxy
 
     def initialize(options = {})
       options = {
+        account: ProteusClient.config.account,
         api_key: ProteusClient.config.api_key,
-        domain:  ProteusClient.config.domain
+        root:    ProteusClient.config.root
       }.merge(options)
 
-      raise "APIKeyNotDefined" unless options[:api_key]
-      raise "DomainNotDefined" unless options[:domain]
+      raise "AccountNotDefined" unless options[:account]
+      raise "APIKeyNotDefined"  unless options[:api_key]
+      raise "RootNotDefined"    unless options[:root]
 
-      @api_key = options[:api_key]
-      @domain  = RestClient::Resource.new(options[:domain])
+      @user     = options[:account]
+      @password = options[:api_key]
+      @root     = resource(options[:root]) 
     end
 
-    def test_api
-      response = submit_request(:get, '/')
-
-      { message: response.body }
-    end
+    def create_recordings
+      recordings = link(@root, 'proteus:recordings') 
 
-    def create_video_locations(id = nil)
-      params = id ? {id: id} : {}
+      response   = resource(recordings).post({})
+      properties = Representers::Recording.new(response).to_hash
 
-      video_locations =
-        submit_request_and_parse_json(:post, '/video_locations', params)
-      format_video_locations(video_locations)
+      ProteusClient::Recording.new(properties)
     end
 
-    def create_multiple_video_locations(count)
-      video_locations =
-        submit_request_and_parse_json(:post, '/video_locations',
-                                      count: count)
-      video_locations.map { |v| format_video_locations(v) }
-    end
+    def get_recording(id)
+      url       = link(@root, 'proteus:recording')
+      recording = expand_templated_route(url, 'id', id)
 
-    def create_video(video_locations_id, type)
-      body = 
-        submit_request_and_parse_json(:post, '/videos',
-                                      video_locations_id: video_locations_id,
-                                      type: type)
+      response   = resource(recording).get
+      properties = Representers::Recording.new(response).to_hash
 
-      { video_id: body['_id'], url: body['url'] }
+      ProteusClient::Recording.new(properties)
     end
 
-    def create_video_versions(video_id, output_type, settings = nil)
-      params = {}
-      params[:version_settings] = settings if settings
-      params[:output_type]      = output_type
+    def create_video(url, solution, version_name)
+      videos   = link(@root, 'proteus:videos')
 
-      submit_request(:post, "/videos/#{video_id}/versions", params)
+      params     = { url: url, solution: solution, version_name: version_name }
+      response   = resource(videos).post(params)
+      properties = Representers::Video.new(response).to_hash
 
-      { message: 'success' }
+      ProteusClient::Video.new(properties)
     end
 
-    def get_video(video_id)
-      submit_request_and_parse_json(:get, "/videos/#{video_id}")
-    end
+    def get_video(id)
+      url   = link(@root, 'proteus:video')
+      video = expand_templated_route(url, 'id', id)
+
+      response   = resource(video).get
+      properties = Representers::Video.new(response).to_hash
 
-    def get_videos(video_ids)
-      submit_request_and_parse_json(:get_raw, "/videos", ids: video_ids)
+      ProteusClient::Video.new(properties)
     end
 
-    def get_video_locations(video_locations_id)
-      url = "/video_locations/#{video_locations_id}"
-      submit_request_and_parse_json(:get, url)
+    def create_version(video_id, version_name, solution)
+      url      = link(@root, 'proteus:video')
+      video    = expand_templated_route(url, 'id', video_id)
+      versions = link(resource(video), 'proteus:video:versions')
+      
+      params   = { version_name: version_name, solution: solution }
+      response = resource(versions).post(params)
+      
+      {message: 'success'}
     end
 
     private
 
-    def submit_request_and_parse_json(method, route, params = {})
-      response = submit_request(method, route, params)
-      JSON.parse(response)
+    def resource(url)
+      RestClient::Resource.new(url, content_type: :json, 
+                               user: @user, password: @password)
     end
 
-    def submit_request(method, route, params = {})
-      params = { :api_key => @api_key }.merge(params)
-
-      case method
-      when :get
-        @domain[route].get(params: params)
-      when :get_raw
-        string_params = RestClient::Payload::UrlEncoded.new(params).to_s
-        @domain["#{route}?#{string_params}"].get()
-      when :post
-        @domain[route].post(params, content_type: :json)
-        else
-          raise 'Undefined method'
-        end
+    def link(resource, link)
+      JSON.parse(resource.get)['_links'][link]['href']
     end
 
-    def format_video_locations(video_locations)
-      urls = { direct: video_locations['url_direct'] ,
-               stream: video_locations['url_stream'] }
-
-      { video_locations_id: video_locations['_id'], urls: urls }
+    def expand_templated_route(url, key, value)
+      url.gsub("{/#{key.to_s}}", "/#{value}")
     end
 
   end
-
 end

data/lib/proteus_client/representers/recording.rb

@@ -0,0 +1,23 @@
+module ProteusClient
+  module Representers
+    class Recording
+     
+      def initialize(raw_response)
+        response = JSON.parse(raw_response)
+
+        @properties = { 
+          id: response['id'],
+          adobe_rtmpe_file:  response['_links']['adobe_rtmpe:file']['href'],
+          adobe_rtmpe_write: response['_links']['adobe_rtmpe:write']['href'],
+          adobe_rtmpe_read:  response['_links']['adobe_rtmpe:read']['href'],
+          generic_https:     response['_links']['generic_https']['href']
+        }
+      end
+     
+      def to_hash
+        @properties
+      end
+
+    end 
+  end
+end

data/lib/proteus_client/representers/video.rb

@@ -0,0 +1,46 @@
+module ProteusClient
+  module Representers
+    class Video
+
+      def initialize(raw_response)
+        response         = JSON.parse(raw_response)
+        versions_hash    = response['_embedded']['proteus:video:versions']
+        thumbnails_hash  = response['_embedded']['proteus:video:thumbnails']
+
+        @properties = { 
+          id:         response['id'],
+          thumbnails: create_thumbnails(thumbnails_hash),
+          versions:   create_versions(versions_hash)
+        }
+      end
+
+      def to_hash
+        @properties
+      end
+
+      private
+
+      def create_thumbnails(thumbnails_hash)
+        thumbnails_hash.map do |hash|
+          options = {
+            size: hash['name'],
+            url:  hash['_links']['alternate']['href']
+          }
+          ProteusClient::Thumbnail.new(options)
+        end
+      end
+
+      def create_versions(versions_hash)
+        versions_hash.map do |hash|
+          options = {
+            name:     hash['name'],
+            solution: hash['solution'],
+            url:      hash['_links']['alternate']['href']
+          }
+          ProteusClient::Version.new(options)
+        end
+      end
+
+    end 
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: proteus_client
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-02 00:00:00.000000000 Z
+date: 2013-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -43,6 +43,22 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.6.7
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -75,16 +91,53 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: It provides an interface to use proteus features
 email: 1.27201@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/proteus_client.rb
+- lib/proteus_client/representers/recording.rb
+- lib/proteus_client/representers/video.rb
+- lib/proteus_client/models/recording.rb
+- lib/proteus_client/models/thumbnail.rb
+- lib/proteus_client/models/version.rb
+- lib/proteus_client/models/video.rb
 - lib/proteus_client/config.rb
 - lib/proteus_client/proxy.rb
-- spec/proteus_client_spec.rb
+- lib/proteus_client.rb
 homepage: https://github.com/solojavier/proteus_client
 licenses: []
 post_install_message: 
@@ -109,6 +162,5 @@ rubygems_version: 1.8.21
 signing_key: 
 specification_version: 3
 summary: Ruby client to use proteus rest service
-test_files:
-- spec/proteus_client_spec.rb
+test_files: []
 has_rdoc: 

data/spec/proteus_client_spec.rb

@@ -1,242 +0,0 @@
-require 'simplecov'
-SimpleCov.start
-
-require 'stubs'
-require_relative '../lib/proteus_client'
-
-describe ProteusClient::Proxy do
-
-  let(:api_key) { "api_key" }
-
-  let(:proteus_client_wrong_api) do
-    described_class.new(domain: 'http://localhost:9292', api_key: 'wrong_api')
-  end
-
-  let(:proteus_client) do
-    ProteusClient.config.domain  = 'http://localhost:9292'
-    ProteusClient.config.api_key = 'api_key'
-    described_class.new()
-  end
-
-  it "creates a new instance of proteus with correct api_key" do
-    proteus_client
-    ProteusClient.config.api_key.should == api_key
-  end
-
-  context 'call to test_api' do
-
-    before(:all) do
-      stub_response(:get, '/', 200, 'Welcome to proteus')
-      @response = proteus_client.test_api
-    end
-
-    it "returns correct message" do
-      @response[:message].should == 'Welcome to proteus'
-    end
-
-  end
-
-  context 'call to create_video_locations'do
-
-    before(:all) do
-      stub_create_video_locations
-      @response = proteus_client.create_video_locations
-    end
-
-    it "returns a hash" do
-      @response.class.should == Hash
-    end
-
-    it "returns video_locations_id" do
-      @response[:video_locations_id].should == '4fe0f752831a9d08bb000010'
-    end
-
-    it "returns urls" do
-      @response[:urls].should ==
-        { direct: 'direct/4fe0f752831a9d08bb000010.flv',
-          stream: 'stream/4fe0f752831a9d08bb000010.flv'}
-    end
-    
-    it "creates with id sent" do
-      id = '4fe0f752831a9d08bb000011'
-      stub_create_video_locations_with_id(id)
-      response = proteus_client.create_video_locations(id)
-
-      response[:video_locations_id].should == id
-    end
-
-  end
-
-  context 'call to create_multiple_video_locations' do
-
-    before(:all) do
-      stub_create_multiple_video_locations
-      @response = proteus_client.create_multiple_video_locations(2)
-    end
-
-    it "returns an array with two hashes" do
-      @response.class.should    == Array
-      @response.size.should     == 2
-      @response[0].class.should == Hash
-    end
-
-    it "returns video_locations_id" do
-      @response[0][:video_locations_id].should == '4fe0f752831a9d08bb000010'
-    end
-
-    it "returns urls" do
-      @response[0][:urls].should ==
-          { direct: 'direct/4fe0f752831a9d08bb000010.flv',
-            stream: 'stream/4fe0f752831a9d08bb000010.flv'}
-    end
-
-  end
-
-  context 'call to create_video'do
-
-    before(:all) do
-      stub_create_video
-      @response = proteus_client.
-        create_video('4fe0f752831a9d08bb000010','direct')
-    end
-
-    it "returns a hash" do
-      @response.class.should == Hash
-    end
-
-    it "returns video url" do
-      @response[:url].should == 'direct/4fe0f752831a9d08bb000010.flv'
-    end
-
-  end
-
-  context 'call to create_video_versions'do
-
-    context 'with valid id' do
-
-      before(:all) do
-        stub_response_with_params(:post, '/videos/4fe0f752831a9d08bb000010/versions',
-                      200, '', output_type: 'direct')
-        @response = proteus_client.
-          create_video_versions('4fe0f752831a9d08bb000010', 'direct')
-      end
-
-      it "returns success message" do
-        @response[:message].should == 'success'
-      end
-
-    end
-
-    context 'with valid id and type' do
-
-      before(:all) do
-        stub_response_with_params(:post, '/videos/4fe0f752831a9d08bb000010/versions',
-                      200, '', version_settings: 'mobile', output_type: 'stream')
-        @response = proteus_client.
-          create_video_versions('4fe0f752831a9d08bb000010', 'stream', 'mobile')
-      end
-
-      it "returns true" do
-        @response[:message].should == 'success'
-      end
-
-    end
-
-  end
-
-  context 'call to get_video'do
-
-    before(:all) do
-      stub_get_video
-      @response = proteus_client.get_video('4fe0f752831a9d08bb000010')
-    end
-
-    it "returns a hash" do
-      @response.class.should == Hash
-    end
-
-    it "returns video with correct format" do
-      @response['url'].class.should         == String
-      @response['duration'].class.should    == Fixnum
-      @response['versions'].class.should    == Array
-      @response['versions'][0].class.should == Hash
-    end
-
-  end
-
-  context 'call to get_videos' do
-
-    before(:all) do
-      stub_get_videos
-      @response = proteus_client.get_videos(%w{4fe0f752831a9d08bb000010
-                                            4fe0f752831a9d08bb000010})
-    end
-
-    it "returns an array with hashes" do
-      @response.class.should       == Array
-      @response.size.should        == 2
-      @response.first.class.should == Hash
-    end
-
-    it "returns videos with correct format" do
-      video = @response.first
-
-      video['url'].class.should         == String
-      video['duration'].class.should    == Fixnum
-      video['versions'].class.should    == Array
-      video['versions'][0].class.should == Hash
-    end
-
-  end
-
-  context 'call to get_video_locations' do
-
-    context 'with valid arguments' do
-
-      before(:all) do
-        stub_get_video_locations
-        @response = proteus_client.
-          get_video_locations('4fe0f752831a9d08bb000010')
-      end
-
-      it "returns a hash" do
-        @response.class.should == Hash
-      end
-
-      it "returns video with correct format" do
-        @response['url_direct'].class.should == String
-        @response['url_stream'].class.should == String
-      end
-
-    end
-
-  end
-
-  context 'submit request' do
-
-    it 'call with :get works returns a correct response' do
-      stub_resource(:get)
-      proteus_client.send(:submit_request, :get, '/', {})
-        .class.should == String
-    end
-
-    it 'call with :post works returns a correct response' do
-      stub_resource(:post)
-      proteus_client.send(:submit_request, :post, '/', {})
-        .class.should == String
-    end
-
-    it 'call with :get works returns a correct response' do
-      stub_resource(:get)
-      proteus_client.send(:submit_request, :get_raw, '/', {})
-        .class.should == String
-    end
-
-    it 'call with not defined method works raises exception' do
-      lambda { proteus_client.send(:submit_request, :put, '/', {}) }.
-        should raise_error
-    end
-
-  end
-
-end