Ziggeo 1.01 → 1.2

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YjQxNTcwN2EyMjIyZTYxMjUxMTAwYzZmZDMxNjZiMTc4ZDkwZTRmNw==
-  data.tar.gz: !binary |-
-    NDRlYjVhNjJkZWI1ZjI3NmNlOThmNzExZDVkM2I1M2UyMTc1NDliNQ==
+SHA1:
+  metadata.gz: 612ed7455de95c4d5dda5f4aacf16185c77b8ce9
+  data.tar.gz: 97f59156819e6ee4266c26a578abe4d3f6ccc601
 SHA512:
-  metadata.gz: !binary |-
-    YzNhMGJmNDllN2E2NWYyNjk5NDZlMTM0ZGE2YjIwNWI4YWMwYTU4MmU0Y2Q0
-    ZGYyNDY5ZDJlMzY2Njk4MGVmNTllOTMxYTJhZTUzNzkxZDM2ZGNiZTYwZDli
-    ZTk4NjZiMWNhZmFmYmRhNjAyYmExMWViMjU3ZDRiNDVmODU4ZTg=
-  data.tar.gz: !binary |-
-    YWY1MjkyMjVmYmRmMzkwOWY0NjkyNTIwNjdlN2FkNDNkNzcwMmQ5NDdhNjY2
-    NzA0M2MyYjk0YmE4NTA3ZmUzMTE0ZDY5YzA0YTMzYjkwY2UzNThlMTgwYzU0
-    ODlhM2ExNDM5NTYxMmQ0NTZkNmIzODlmNDY5OTdiOTEyY2I0ODk=
+  metadata.gz: ab12a6038677cb7c74b39b1b6381ff7e6e86361a78b6bda6adf8c7ebb898d06895c878e7f24b0374dc10b24cc346805bc22b2a6c7b347553735b3edc4b2d2946
+  data.tar.gz: f111ddd0a335314da71872386f239969fdb6f8826a93f4e5792f9224710d8701cdac3f8f5ae52180cc7c5ba8801939ee121410f048f4bf7b93b595097f5bc4fd

data/README.md

@@ -1,12 +1,585 @@
-Ziggeo Ruby Server SDK
-======================
+# Ziggeo Ruby Server SDK 1.2
 
-Ziggeo API (http://ziggeo.com) allows you to integrate video recording and playback with only
-two lines of code in your site, service or app. This is the Ruby Server SDK repository. It's open source,
-so if you want to improve on it, feel free to add a pull request.
+Ziggeo API (https://ziggeo.com) allows you to integrate video recording and playback with only
+two lines of code in your site, service or app. This is the Ruby Server SDK repository.
+
+Pull requests welcome.
+
+
+## Installation
 
 For Rails applications, you can simply install this repository as a gem.
 
 gem "Ziggeo"
 
-Copyright (c) 2014-2015 Ziggeo
+
+## Client-Side Integration
+
+For the client-side integration, you need to add these assets to your html file:
+
+```html 
+<link rel="stylesheet" href="//assets-cdn.ziggeo.com/v2-stable/ziggeo.css" />
+<script src="//assets-cdn.ziggeo.com/v2-stable/ziggeo.js"></script>
+```
+
+Then, you need to specify your api token:
+```html 
+<script>
+    var ziggeoApplication = new ZiggeoApi.V2.Application({
+        token: "APPLICATION_TOKEN"
+    });
+</script>
+```
+
+You can specify other global options, [see here](https://ziggeo.com/docs).
+
+To fire up a recorder on your page, add:
+```html 
+<ziggeorecorder></ziggeorecorder>
+``` 
+
+To embed a player for an existing video, add:
+```html 
+<ziggeoplayer ziggeo-video='video-token'></ziggeoplayer>
+``` 
+
+For the full documentation, please visit [ziggeo.com](https://ziggeo.com/docs).
+
+
+
+## Server-Side Integration
+
+You can integrate the Server SDK as follows:
+
+```ruby 
+@ziggeo = Ziggeo.new("*token*", "*private_key*", "*encryption_key*") 
+```
+
+
+## Server-Side Methods
+
+### Videos  
+
+The videos resource allows you to access all single videos. Each video may contain more than one stream. 
+ 
+
+#### Index 
+ 
+Query an array of videos (will return at most 50 videos by default). Newest videos come first. 
+
+```ruby 
+ziggeo.videos().index(arguments = nil) 
+``` 
+ 
+Arguments 
+- limit: *Limit the number of returned videos. Can be set up to 100.* 
+- skip: *Skip the first [n] entries.* 
+- reverse: *Reverse the order in which videos are returned.* 
+- states: *Filter videos by state* 
+- tags: *Filter the search result to certain tags, encoded as a comma-separated string* 
+
+
+#### Count 
+ 
+Get the video count for the application. 
+
+```ruby 
+ziggeo.videos().count(arguments = nil) 
+``` 
+ 
+Arguments 
+- states: *Filter videos by state* 
+- tags: *Filter the search result to certain tags, encoded as a comma-separated string* 
+
+
+#### Get 
+ 
+Get a single video by token or key. 
+
+```ruby 
+ziggeo.videos().get(token_or_key) 
+``` 
+ 
+
+
+#### Get Bulk 
+ 
+Get multiple videos by tokens or keys. 
+
+```ruby 
+ziggeo.videos().get_bulk(arguments = nil) 
+``` 
+ 
+Arguments 
+- tokens_or_keys: *Comma-separated list with the desired videos tokens or keys (Limit: 100 tokens or keys).* 
+
+
+#### Download Video 
+ 
+Download the video data file 
+
+```ruby 
+ziggeo.videos().download_video(token_or_key) 
+``` 
+ 
+
+
+#### Download Image 
+ 
+Download the image data file 
+
+```ruby 
+ziggeo.videos().download_image(token_or_key) 
+``` 
+ 
+
+
+#### Push To Service 
+ 
+Push a video to a provided push service. 
+
+```ruby 
+ziggeo.videos().push_to_service(token_or_key, arguments = nil) 
+``` 
+ 
+Arguments 
+- pushservicetoken: *Push Services's token (from the Push Services configured for the app)* 
+
+
+#### Apply Effect 
+ 
+Apply an effect profile to a video. 
+
+```ruby 
+ziggeo.videos().apply_effect(token_or_key, arguments = nil) 
+``` 
+ 
+Arguments 
+- effectprofiletoken: *Effect Profile token (from the Effect Profiles configured for the app)* 
+
+
+#### Update 
+ 
+Update single video by token or key. 
+
+```ruby 
+ziggeo.videos().update(token_or_key, arguments = nil) 
+``` 
+ 
+Arguments 
+- min_duration: *Minimal duration of video* 
+- max_duration: *Maximal duration of video* 
+- tags: *Video Tags* 
+- key: *Unique (optional) name of video* 
+- volatile: *Automatically removed this video if it remains empty* 
+- expiration_days: *After how many days will this video be deleted* 
+
+
+#### Update Bulk 
+ 
+Update multiple videos by token or key. 
+
+```ruby 
+ziggeo.videos().update_bulk(arguments = nil) 
+``` 
+ 
+Arguments 
+- tokens_or_keys: *Comma-separated list with the desired videos tokens or keys (Limit: 100 tokens or keys).* 
+- min_duration: *Minimal duration of video* 
+- max_duration: *Maximal duration of video* 
+- tags: *Video Tags* 
+- volatile: *Automatically removed this video if it remains empty* 
+- expiration_days: *After how many days will this video be deleted* 
+
+
+#### Delete 
+ 
+Delete a single video by token or key. 
+
+```ruby 
+ziggeo.videos().delete(token_or_key) 
+``` 
+ 
+
+
+#### Create 
+ 
+Create a new video. 
+
+```ruby 
+ziggeo.videos().create(arguments = nil, file = nil) 
+``` 
+ 
+Arguments 
+- file: *Video file to be uploaded* 
+- min_duration: *Minimal duration of video* 
+- max_duration: *Maximal duration of video* 
+- tags: *Video Tags* 
+- key: *Unique (optional) name of video* 
+- volatile: *Automatically removed this video if it remains empty* 
+
+
+#### Analytics 
+ 
+Get analytics for a specific videos with the given params 
+
+```ruby 
+ziggeo.videos().analytics(token_or_key, arguments = nil) 
+``` 
+ 
+Arguments 
+- from: *A UNIX timestamp in microseconds used as the start date of the query* 
+- to: *A UNIX timestamp in microseconds used as the end date of the query* 
+- date: *A UNIX timestamp in microseconds to retrieve data from a single date. If set, it overwrites the from and to params.* 
+- query: *The query you want to run. It can be one of the following: device_views_by_os, device_views_by_date, total_plays_by_country, full_plays_by_country, total_plays_by_hour, full_plays_by_hour, total_plays_by_browser, full_plays_by_browser* 
+
+
+### Streams  
+
+The streams resource allows you to directly access all streams associated with a single video. 
+ 
+
+#### Index 
+ 
+Return all streams associated with a video 
+
+```ruby 
+ziggeo.streams().index(video_token_or_key, arguments = nil) 
+``` 
+ 
+Arguments 
+- states: *Filter streams by state* 
+
+
+#### Get 
+ 
+Get a single stream 
+
+```ruby 
+ziggeo.streams().get(video_token_or_key, token_or_key) 
+``` 
+ 
+
+
+#### Download Video 
+ 
+Download the video data associated with the stream 
+
+```ruby 
+ziggeo.streams().download_video(video_token_or_key, token_or_key) 
+``` 
+ 
+
+
+#### Download Image 
+ 
+Download the image data associated with the stream 
+
+```ruby 
+ziggeo.streams().download_image(video_token_or_key, token_or_key) 
+``` 
+ 
+
+
+#### Push To Service 
+ 
+Push a stream to a provided push service. 
+
+```ruby 
+ziggeo.streams().push_to_service(video_token_or_key, token_or_key, arguments = nil) 
+``` 
+ 
+Arguments 
+- pushservicetoken: *Push Services's token (from the Push Services configured for the app)* 
+
+
+#### Delete 
+ 
+Delete the stream 
+
+```ruby 
+ziggeo.streams().delete(video_token_or_key, token_or_key) 
+``` 
+ 
+
+
+#### Create 
+ 
+Create a new stream 
+
+```ruby 
+ziggeo.streams().create(video_token_or_key, arguments = nil, file = nil) 
+``` 
+ 
+Arguments 
+- file: *Video file to be uploaded* 
+
+
+#### Attach Image 
+ 
+Attaches an image to a new stream 
+
+```ruby 
+ziggeo.streams().attach_image(video_token_or_key, token_or_key, arguments = nil, file = nil) 
+``` 
+ 
+Arguments 
+- file: *Image file to be attached* 
+
+
+#### Attach Video 
+ 
+Attaches a video to a new stream 
+
+```ruby 
+ziggeo.streams().attach_video(video_token_or_key, token_or_key, arguments = nil, file = nil) 
+``` 
+ 
+Arguments 
+- file: *Video file to be attached* 
+
+
+#### Bind 
+ 
+Closes and submits the stream 
+
+```ruby 
+ziggeo.streams().bind(video_token_or_key, token_or_key, arguments = nil) 
+``` 
+ 
+
+
+### Authtokens  
+
+The auth token resource allows you to manage authorization settings for video objects. 
+ 
+
+#### Get 
+ 
+Get a single auth token by token. 
+
+```ruby 
+ziggeo.authtokens().get(token) 
+``` 
+ 
+
+
+#### Update 
+ 
+Update single auth token by token. 
+
+```ruby 
+ziggeo.authtokens().update(token_or_key, arguments = nil) 
+``` 
+ 
+Arguments 
+- volatile: *Will this object automatically be deleted if it remains empty?* 
+- hidden: *If hidden, the token cannot be used directly.* 
+- expiration_date: *Expiration date for the auth token* 
+- usage_experitation_time: *Expiration time per session* 
+- session_limit: *Maximal number of sessions* 
+- grants: *Permissions this tokens grants* 
+
+
+#### Delete 
+ 
+Delete a single auth token by token. 
+
+```ruby 
+ziggeo.authtokens().delete(token_or_key) 
+``` 
+ 
+
+
+#### Create 
+ 
+Create a new auth token. 
+
+```ruby 
+ziggeo.authtokens().create(arguments = nil) 
+``` 
+ 
+Arguments 
+- volatile: *Will this object automatically be deleted if it remains empty?* 
+- hidden: *If hidden, the token cannot be used directly.* 
+- expiration_date: *Expiration date for the auth token* 
+- usage_experitation_time: *Expiration time per session* 
+- session_limit: *Maximal number of sessions* 
+- grants: *Permissions this tokens grants* 
+
+
+### EffectProfiles  
+
+The effect profiles resource allows you to access and create effect profiles for your app. Each effect profile may contain one process or more. 
+ 
+
+#### Create 
+ 
+Create a new effect profile. 
+
+```ruby 
+ziggeo.effectProfiles().create(arguments = nil) 
+``` 
+ 
+Arguments 
+- key: *Effect profile key.* 
+- title: *Effect profile title.* 
+
+
+#### Index 
+ 
+Get list of effect profiles. 
+
+```ruby 
+ziggeo.effectProfiles().index(arguments = nil) 
+``` 
+ 
+Arguments 
+- limit: *Limit the number of returned effect profiles. Can be set up to 100.* 
+- skip: *Skip the first [n] entries.* 
+- reverse: *Reverse the order in which effect profiles are returned.* 
+
+
+#### Get 
+ 
+Get a single effect profile 
+
+```ruby 
+ziggeo.effectProfiles().get(token_or_key) 
+``` 
+ 
+
+
+#### Delete 
+ 
+Delete the effect profile 
+
+```ruby 
+ziggeo.effectProfiles().delete(token_or_key) 
+``` 
+ 
+
+
+### EffectProfileProcess  
+
+The process resource allows you to directly access all process associated with a single effect profile. 
+ 
+
+#### Index 
+ 
+Return all processes associated with a effect profile 
+
+```ruby 
+ziggeo.effectProfileProcess().index(effect_token_or_key, arguments = nil) 
+``` 
+ 
+Arguments 
+- states: *Filter streams by state* 
+
+
+#### Get 
+ 
+Get a single process 
+
+```ruby 
+ziggeo.effectProfileProcess().get(effect_token_or_key, token_or_key) 
+``` 
+ 
+
+
+#### Delete 
+ 
+Delete the process 
+
+```ruby 
+ziggeo.effectProfileProcess().delete(effect_token_or_key, token_or_key) 
+``` 
+ 
+
+
+#### Create Filter Process 
+ 
+Create a new filter effect process 
+
+```ruby 
+ziggeo.effectProfileProcess().create_filter_process(effect_token_or_key, arguments = nil) 
+``` 
+ 
+Arguments 
+- effect: *Effect to be applied in the process* 
+
+
+#### Create Watermark Process 
+ 
+Attaches an image to a new stream 
+
+```ruby 
+ziggeo.effectProfileProcess().create_watermark_process(effect_token_or_key, arguments = nil, file = nil) 
+``` 
+ 
+Arguments 
+- file: *Image file to be attached* 
+- vertical: *Specify the vertical position of your watermark (a value between 0.0 and 1.0)* 
+- horizontal: *Specify the horizontal position of your watermark (a value between 0.0 and 1.0)* 
+- scale: *Specify the image scale of your watermark (a value between 0.0 and 1.0)* 
+
+
+### Webhooks  
+
+The webhooks resource allows you to create or delete webhooks related to a given application. 
+ 
+
+#### Create 
+ 
+Create a new webhook for the given url to catch the given events. 
+
+```ruby 
+ziggeo.webhooks().create(arguments = nil) 
+``` 
+ 
+Arguments 
+- target_url: *The url that will catch the events* 
+- encoding: *Data encoding to be used by the webhook to send the events.* 
+- events: *Comma-separated list of the events the webhook will catch. They must be valid webhook type events.* 
+
+
+#### Delete 
+ 
+Delete a webhook using its URL. 
+
+```ruby 
+ziggeo.webhooks().delete(arguments = nil) 
+``` 
+ 
+Arguments 
+- target_url: *The url that will catch the events* 
+
+
+### Analytics  
+
+The analytics resource allows you to access the analytics for the given application 
+ 
+
+#### Get 
+ 
+Get analytics for the given params 
+
+```ruby 
+ziggeo.analytics().get(arguments = nil) 
+``` 
+ 
+Arguments 
+- from: *A UNIX timestamp in microseconds used as the start date of the query* 
+- to: *A UNIX timestamp in microseconds used as the end date of the query* 
+- date: *A UNIX timestamp in microseconds to retrieve data from a single date. If set, it overwrites the from and to params.* 
+- query: *The query you want to run. It can be one of the following: device_views_by_os, device_views_by_date, total_plays_by_country, full_plays_by_country, total_plays_by_hour, full_plays_by_hour, total_plays_by_browser, full_plays_by_browser* 
+
+
+
+
+
+## License
+
+Copyright (c) 2013-2018 Ziggeo
+ 
+Apache 2.0 License

data/lib/Ziggeo.rb

@@ -7,11 +7,11 @@ require_relative "classes/ZiggeoConfig"
 require_relative "classes/ZiggeoConnect"
 require_relative "classes/ZiggeoVideos"
 require_relative "classes/ZiggeoStreams"
+require_relative "classes/ZiggeoEffectProfiles"
+require_relative "classes/ZiggeoEffectProfileProcess"
 require_relative "classes/ZiggeoAuthtokens"
 require_relative "classes/ZiggeoAuth"
 
-# TODO: https://github.com/nicksieger/multipart-post
-
 class Ziggeo
 
   attr_accessor :token, :private_key, :encryption_key, :config, :connect
@@ -23,6 +23,8 @@ class Ziggeo
     @connect = ZiggeoConnect.new(self)
     @videos = nil
     @streams = nil
+    @effectProfiles = nil
+    @effectProfileProcess = nil
     @authtokens = nil
     @auth = nil
     if (ENV["ZIGGEO_URL"] != nil)
@@ -49,6 +51,20 @@ class Ziggeo
     return @streams
   end
 
+  def effectProfiles()
+    if (@effectProfiles == nil)
+      @effectProfiles = ZiggeoEffectProfiles.new(self)
+    end
+    return @effectProfiles
+  end
+
+  def effectProfileProcess()
+    if (@effectProfileProcess == nil)
+      @effectProfileProcess = ZiggeoEffectProfileProcess.new(self)
+    end
+    return @effectProfileProcess
+  end
+
   def authtokens()
     if (@authtokens == nil)
       @authtokens = ZiggeoAuthtokens.new(self)

data/lib/classes/ZiggeoAnalytics.rb

@@ -0,0 +1,11 @@
+class ZiggeoAnalytics
+
+  def initialize(application)
+    @application = application
+  end
+
+  def get(data = nil)
+    return @application.connect.postJSON('/analytics/get', data)
+  end
+
+end

data/lib/classes/ZiggeoConfig.rb

@@ -1,7 +1,10 @@
 class ZiggeoConfig
-  attr_accessor :server_api_url
+  attr_accessor :server_api_url, :request_timeout, :request_timeout_per_mb, :regions
 
   def initialize()
+    @request_timeout = 30 # seconds
+    @request_timeout_per_mb = 20 # seconds per MB of uploaded file
     @server_api_url = "https://srvapi.ziggeo.com"
+    @regions = {"r1" => "https://srvapi-eu-west-1.ziggeo.com", }
   end
 end

data/lib/classes/ZiggeoConnect.rb

@@ -1,5 +1,7 @@
 require 'net/http'
 require 'json'
+require 'httparty'
+require 'httmultiparty'
 
 class ZiggeoConnect
   def initialize(application)
@@ -7,37 +9,50 @@ class ZiggeoConnect
   end
 
   def request(method, path, data = nil, file = nil)
-    url = URI.parse(@application.config.server_api_url + '/v1' + path)
-    if (method == "GET")
-      if (data != nil)
-        url.query = URI.encode_www_form(data)
+    server_api_url = @application.config.server_api_url
+    regions = @application.config.regions
+    regions.each do |key, value|
+      if (@application.token.start_with?(key))
+        server_api_url = value
       end
-      req = Net::HTTP::Get.new(url.to_s)
-    elsif (method == "POST")
-      req = Net::HTTP::Post.new(url.to_s)
-      if (data != nil)
-      req.set_form_data(data)
+    end
+
+    url = URI.parse(server_api_url + '/v1' + path)
+    auth = { username: @application.token, password: @application.private_key }
+    timeout_in_seconds = @application.config.request_timeout.to_i
+
+    method.downcase!
+    allowed_methods = %w(get post delete)
+    return unless allowed_methods.include?(method)
+    if (file.nil?)
+      if (method == "get")
+        begin
+          HTTParty.send(method, url.to_s, query: data, basic_auth: auth, timeout: timeout_in_seconds).body
+        rescue Net::ReadTimeout => error
+          self.timeout_error_message timeout_in_seconds, error
+        end
+      else
+        begin
+          HTTParty.send(method, url.to_s, body: data, basic_auth: auth, timeout: timeout_in_seconds).body
+        rescue Net::ReadTimeout => error
+          self.timeout_error_message timeout_in_seconds, error
+        end
       end
-    elsif (method == "DELETE")
-      req = Net::HTTP::Delete.new(url.to_s)
-      if (data != nil)
-      req.set_form_data(data)
+    else
+      data = data.nil? ? {} : data;
+      data["file"] = File.new(file)
+      timeout_in_seconds = ( ( File.size(file).to_f / 2**20 ).round(0) * @application.config.request_timeout_per_mb.to_i ).to_i;
+
+      begin
+        HTTMultiParty.send(method, url.to_s, body: data, basic_auth: auth, timeout: timeout_in_seconds).body
+      rescue Net::ReadTimeout => error
+        self.timeout_error_message timeout_in_seconds, error
       end
     end
-    req.basic_auth(@application.token, @application.private_key)
-    http = Net::HTTP.new(url.host, url.port)
-    if (url.scheme == "https")
-      http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-    end
-    res = http.start() {|agent|
-      agent.request(req)
-    }
-    return res.body
   end
 
   def requestJSON(method, path, data = nil, file = nil)
-    return JSON.parse self.request(method, path, data, file)
+    return JSON.parse(self.request(method, path, data, file))
   end
 
   def get(path, data = nil, file = nil)
@@ -64,4 +79,12 @@ class ZiggeoConnect
     return self.requestJSON("DELETE", path, data, file)
   end
 
+  protected
+
+  def timeout_error_message( timeout_in_seconds, error )
+    puts "Error source: " + error.message
+    puts "Server not responding. Host: #{@application.config.server_api_url} not responded in #{timeout_in_seconds} seconds."
+    exit(1)
+  end
+
 end

data/lib/classes/ZiggeoEffectProfileProcess.rb

@@ -0,0 +1,27 @@
+class ZiggeoEffectProfileProcess
+
+  def initialize(application)
+    @application = application
+  end
+
+  def index(effect_token_or_key, data = nil)
+    return @application.connect.getJSON('/effects/' + effect_token_or_key + '/process', data)
+  end
+
+  def get(effect_token_or_key, token_or_key)
+    return @application.connect.getJSON('/effects/' + effect_token_or_key + '/process/' + token_or_key + '')
+  end
+
+  def delete(effect_token_or_key, token_or_key)
+    return @application.connect.delete('/effects/' + effect_token_or_key + '/process/' + token_or_key + '')
+  end
+
+  def create_filter_process(effect_token_or_key, data = nil)
+    return @application.connect.postJSON('/effects/' + effect_token_or_key + '/process/filter', data)
+  end
+
+  def create_watermark_process(effect_token_or_key, data = nil, file = nil)
+    return @application.connect.postJSON('/effects/' + effect_token_or_key + '/process/watermark', data, file)
+  end
+
+end

data/lib/classes/ZiggeoEffectProfiles.rb

@@ -0,0 +1,23 @@
+class ZiggeoEffectProfiles
+
+  def initialize(application)
+    @application = application
+  end
+
+  def create(data = nil)
+    return @application.connect.postJSON('/effects/', data)
+  end
+
+  def index(data = nil)
+    return @application.connect.getJSON('/effects/', data)
+  end
+
+  def get(token_or_key)
+    return @application.connect.getJSON('/effects/' + token_or_key + '')
+  end
+
+  def delete(token_or_key)
+    return @application.connect.delete('/effects/' + token_or_key + '')
+  end
+
+end

data/lib/classes/ZiggeoStreams.rb

@@ -20,6 +20,10 @@ class ZiggeoStreams
     return @application.connect.get('/videos/' + video_token_or_key + '/streams/' + token_or_key + '/image')
   end
 
+  def push_to_service(video_token_or_key, token_or_key, data = nil)
+    return @application.connect.postJSON('/videos/' + video_token_or_key + '/streams/' + token_or_key + '/push', data)
+  end
+
   def delete(video_token_or_key, token_or_key)
     return @application.connect.delete('/videos/' + video_token_or_key + '/streams/' + token_or_key + '')
   end
@@ -28,4 +32,16 @@ class ZiggeoStreams
     return @application.connect.postJSON('/videos/' + video_token_or_key + '/streams', data, file)
   end
 
+  def attach_image(video_token_or_key, token_or_key, data = nil, file = nil)
+    return @application.connect.postJSON('/videos/' + video_token_or_key + '/streams/' + token_or_key + '/image', data, file)
+  end
+
+  def attach_video(video_token_or_key, token_or_key, data = nil, file = nil)
+    return @application.connect.postJSON('/videos/' + video_token_or_key + '/streams/' + token_or_key + '/video', data, file)
+  end
+
+  def bind(video_token_or_key, token_or_key)
+    return @application.connect.postJSON('/videos/' + video_token_or_key + '/streams/' + token_or_key + '/bind')
+  end
+
 end

data/lib/classes/ZiggeoVideos.rb

@@ -8,10 +8,18 @@ class ZiggeoVideos
     return @application.connect.getJSON('/videos/', data)
   end
 
+  def count(data = nil)
+    return @application.connect.getJSON('/videos/count', data)
+  end
+
   def get(token_or_key)
     return @application.connect.getJSON('/videos/' + token_or_key + '')
   end
 
+  def get_bulk(data = nil)
+    return @application.connect.postJSON('/videos/get_bulk', data)
+  end
+
   def download_video(token_or_key)
     return @application.connect.get('/videos/' + token_or_key + '/video')
   end
@@ -20,10 +28,22 @@ class ZiggeoVideos
     return @application.connect.get('/videos/' + token_or_key + '/image')
   end
 
+  def push_to_service(token_or_key, data = nil)
+    return @application.connect.postJSON('/videos/' + token_or_key + '/push', data)
+  end
+
+  def apply_effect(token_or_key, data = nil)
+    return @application.connect.postJSON('/videos/' + token_or_key + '/effect', data)
+  end
+
   def update(token_or_key, data = nil)
     return @application.connect.postJSON('/videos/' + token_or_key + '', data)
   end
 
+  def update_bulk(data = nil)
+    return @application.connect.postJSON('/videos/update_bulk', data)
+  end
+
   def delete(token_or_key)
     return @application.connect.delete('/videos/' + token_or_key + '')
   end
@@ -32,4 +52,8 @@ class ZiggeoVideos
     return @application.connect.postJSON('/videos/', data, file)
   end
 
+  def analytics(token_or_key, data = nil)
+    return @application.connect.postJSON('/videos/' + token_or_key + '/analytics', data)
+  end
+
 end

data/lib/classes/ZiggeoWebhooks.rb

@@ -0,0 +1,15 @@
+class ZiggeoWebhooks
+
+  def initialize(application)
+    @application = application
+  end
+
+  def create(data = nil)
+    return @application.connect.post('/api/hook', data)
+  end
+
+  def delete(data = nil)
+    return @application.connect.post('/api/removehook', data)
+  end
+
+end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: Ziggeo
 version: !ruby/object:Gem::Version
-  version: '1.01'
+  version: '1.2'
 platform: ruby
 authors:
 - Ziggeo, Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-04 00:00:00.000000000 Z
-dependencies: []
+date: 2018-05-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.5
+- !ruby/object:Gem::Dependency
+  name: httmultiparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: The Ziggeo Ruby and Rails Server SDK.
 email:
 - support@ziggeo.com
@@ -19,15 +47,19 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/Ziggeo.rb
+- lib/classes/ZiggeoAnalytics.rb
 - lib/classes/ZiggeoAuth.rb
 - lib/classes/ZiggeoAuthtokens.rb
 - lib/classes/ZiggeoConfig.rb
 - lib/classes/ZiggeoConnect.rb
+- lib/classes/ZiggeoEffectProfileProcess.rb
+- lib/classes/ZiggeoEffectProfiles.rb
 - lib/classes/ZiggeoStreams.rb
 - lib/classes/ZiggeoVideos.rb
-homepage: http://ziggeo.com
+- lib/classes/ZiggeoWebhooks.rb
+homepage: https://ziggeo.com
 licenses:
-- MIT
+- Apache-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -35,17 +67,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: The Ziggeo ServerSDK gem.