Ziggeo 1.06 → 1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 44cfadc51a8a4831af6b9963799637a578792688
-  data.tar.gz: 968b38dee3416f98cf54c4d42cd7bb6d46418f5d
+  metadata.gz: 60c24bd2eae6716a724c20a49103f93a673174bf
+  data.tar.gz: f4bdc91094ae8448d61c087de9ae25879663c9d0
 SHA512:
-  metadata.gz: 9de05bd413549b5e7dc5b8564725d2b963add066cf8d960120f282bb4387f718a28097b4769404396de5599f25c76512c1b6fabe458a14642ac1005e1ad894ea
-  data.tar.gz: 2e903bc600db791fb4524cabe0db3ddaf516c727de8202fb92b7d56d9534c7d765a2c95766ae0bbdd289631344be5d0befa169ca7f6307ae2f7921e42df221da
+  metadata.gz: 9201ab2f973fd86ba6b6de6c577f156762d62961d692f1cf2e3c3830adb1cf95622515a57b0e236088e2f4ef5564d989a907768edbd5277f3118876c408265b8
+  data.tar.gz: afcffd6127cd5720d536a5828ea487b8751fc673d843d92bb87e9f194295a63b4021f77b6eb21037bca94fa7f5052c943c9dcfb70588540040c350ff810a0bea

data/README.md

@@ -1,6 +1,6 @@
-# Ziggeo Ruby Server SDK 1.06
+# Ziggeo Ruby Server SDK 1.7
 
-Ziggeo API (http://ziggeo.com) allows you to integrate video recording and playback with only
+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.
@@ -18,30 +18,33 @@ gem "Ziggeo"
 For the client-side integration, you need to add these assets to your html file:
 
 ```html 
-<link rel="stylesheet" href="//assets-cdn.ziggeo.com/v1-latest/ziggeo.css" /> 
-<script src="//assets-cdn.ziggeo.com/v1-latest/ziggeo.js"></script> 
+<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>
-	ZiggeoApi.token = "APPLICATION_TOKEN"; 
+    var ziggeoApplication = new ZiggeoApi.V2.Application({
+        token: "APPLICATION_TOKEN"
+    });
 </script>
 ```
 
-You can specify other global options, [see here](http://ziggeo.com/docs).
+You can specify other global options, [see here](https://ziggeo.com/docs).
 
 To fire up a recorder on your page, add:
 ```html 
-<ziggeo></ziggeo> 
+<ziggeorecorder></ziggeorecorder>
 ``` 
 
 To embed a player for an existing video, add:
 ```html 
-<ziggeo ziggeo-video='video-token'></ziggeo> 
+<ziggeoplayer ziggeo-video='video-token'></ziggeoplayer>
 ``` 
 
-For the full documentation, please visit [ziggeo.com](http://ziggeo.com/docs).
+For the full documentation, please visit [ziggeo.com](https://ziggeo.com/docs).
+
 
 
 ## Server-Side Integration
@@ -56,7 +59,7 @@ You can integrate the Server SDK as follows:
 ## Server-Side Methods
 
 ### Videos  
- 
+
 The videos resource allows you to access all single videos. Each video may contain more than one stream. 
  
 
@@ -73,7 +76,20 @@ Arguments
 - 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* 
+- 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 
@@ -86,6 +102,31 @@ 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).* 
+
+
+#### Stats Bulk 
+ 
+Get stats for multiple videos by tokens or keys. 
+
+```ruby 
+ziggeo.videos().stats_bulk(arguments = nil) 
+``` 
+ 
+Arguments 
+- tokens_or_keys: *Comma-separated list with the desired videos tokens or keys (Limit: 100 tokens or keys).* 
+- summarize: *Boolean. Set it to TRUE to get the stats summarized. Set it to FALSE to get the stats for each video in a separate array. Default: TRUE.* 
+
+
 #### Download Video 
  
 Download the video data file 
@@ -106,6 +147,52 @@ ziggeo.videos().download_image(token_or_key)
  
 
 
+#### Get Stats 
+ 
+Get the video's stats 
+
+```ruby 
+ziggeo.videos().get_stats(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)* 
+
+
+#### Apply Meta 
+ 
+Apply a meta profile to a video. 
+
+```ruby 
+ziggeo.videos().apply_meta(token_or_key, arguments = nil) 
+``` 
+ 
+Arguments 
+- metaprofiletoken: *Meta Profile token (from the Meta Profiles configured for the app)* 
+
+
 #### Update 
  
 Update single video by token or key. 
@@ -123,6 +210,23 @@ Arguments
 - 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. 
@@ -150,8 +254,23 @@ Arguments
 - volatile: *Automatically removed this video if it remains empty* 
 
 
-### Streams  
+#### 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. 
  
 
@@ -197,6 +316,18 @@ 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 
@@ -254,7 +385,7 @@ 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. 
  
 
@@ -312,11 +443,297 @@ Arguments
 - 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)* 
+
+
+### MetaProfiles  
+
+The meta profiles resource allows you to access and create meta profiles for your app. Each meta profile may contain one process or more. 
+ 
+
+#### Create 
+ 
+Create a new meta profile. 
+
+```ruby 
+ziggeo.metaProfiles().create(arguments = nil) 
+``` 
+ 
+Arguments 
+- key: *Meta Profile profile key.* 
+- title: *Meta Profile profile title.* 
+
+
+#### Index 
+ 
+Get list of meta profiles. 
+
+```ruby 
+ziggeo.metaProfiles().index(arguments = nil) 
+``` 
+ 
+Arguments 
+- limit: *Limit the number of returned meta profiles. Can be set up to 100.* 
+- skip: *Skip the first [n] entries.* 
+- reverse: *Reverse the order in which meta profiles are returned.* 
+
+
+#### Get 
+ 
+Get a single meta profile 
+
+```ruby 
+ziggeo.metaProfiles().get(token_or_key) 
+``` 
+ 
+
+
+#### Delete 
+ 
+Delete the meta profile 
+
+```ruby 
+ziggeo.metaProfiles().delete(token_or_key) 
+``` 
+ 
+
+
+### MetaProfileProcess  
+
+The process resource allows you to directly access all process associated with a single meta profile. 
+ 
+
+#### Index 
+ 
+Return all processes associated with a meta profile 
+
+```ruby 
+ziggeo.metaProfileProcess().index(meta_token_or_key) 
+``` 
+ 
+
+
+#### Get 
+ 
+Get a single process 
+
+```ruby 
+ziggeo.metaProfileProcess().get(meta_token_or_key, token_or_key) 
+``` 
+ 
+
+
+#### Delete 
+ 
+Delete the process 
+
+```ruby 
+ziggeo.metaProfileProcess().delete(meta_token_or_key, token_or_key) 
+``` 
+ 
+
+
+#### Create Video Analysis Process 
+ 
+Create a new video analysis meta process 
+
+```ruby 
+ziggeo.metaProfileProcess().create_video_analysis_process(meta_token_or_key) 
+``` 
+ 
+
+
+#### Create Audio Transcription Process 
+ 
+Create a new audio transcription meta process 
+
+```ruby 
+ziggeo.metaProfileProcess().create_audio_transcription_process(meta_token_or_key) 
+``` 
+ 
+
+
+#### Create Nsfw Process 
+ 
+Create a new nsfw filter meta process 
+
+```ruby 
+ziggeo.metaProfileProcess().create_nsfw_process(meta_token_or_key, arguments = nil) 
+``` 
+ 
+Arguments 
+- nsfw_action: *One of the following three: approve, reject, nothing.* 
+
+
+### 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-2016 Ziggeo
+Copyright (c) 2013-2018 Ziggeo
  
-Apache 2.0 License
+Apache 2.0 License

data/lib/Ziggeo.rb

@@ -5,60 +5,106 @@ require 'cgi'
 
 require_relative "classes/ZiggeoConfig"
 require_relative "classes/ZiggeoConnect"
+require_relative "classes/ZiggeoAuth"
 require_relative "classes/ZiggeoVideos"
 require_relative "classes/ZiggeoStreams"
 require_relative "classes/ZiggeoAuthtokens"
-require_relative "classes/ZiggeoAuth"
+require_relative "classes/ZiggeoEffectProfiles"
+require_relative "classes/ZiggeoEffectProfileProcess"
+require_relative "classes/ZiggeoMetaProfiles"
+require_relative "classes/ZiggeoMetaProfileProcess"
+require_relative "classes/ZiggeoWebhooks"
+require_relative "classes/ZiggeoAnalytics"
 
 class Ziggeo
 
-  attr_accessor :token, :private_key, :encryption_key, :config, :connect
-  def initialize(token = nil, private_key = nil, encryption_key = nil)
-    @token = token
-    @private_key = private_key
-    @encryption_key = encryption_key
-    @config = ZiggeoConfig.new()
-    @connect = ZiggeoConnect.new(self)
-    @videos = nil
-    @streams = nil
-    @authtokens = nil
-    @auth = nil
-    if (ENV["ZIGGEO_URL"] != nil)
-      uri = URI.parse(ENV["ZIGGEO_URL"])
-      @config.server_api_url = uri.scheme + "://" + uri.host + ":" + uri.port.to_s
-      @token = uri.user
-      @private_key = uri.password
-      query = CGI::parse(uri.query)
-      @encryption_key = query["encryption_key"]
-    end
-  end
+    attr_accessor :token, :private_key, :encryption_key, :config, :connect
 
-  def videos()
-    if (@videos == nil)
-      @videos = ZiggeoVideos.new(self)
+    def initialize(token = nil, private_key = nil, encryption_key = nil)
+        @token = token
+        @private_key = private_key
+        @encryption_key = encryption_key
+        @config = ZiggeoConfig.new()
+        @connect = ZiggeoConnect.new(self)
+        @auth = nil
+        @videos = nil
+        @streams = nil
+        @authtokens = nil
+        @effectProfiles = nil
+        @effectProfileProcess = nil
+        @metaProfiles = nil
+        @metaProfileProcess = nil
+        @webhooks = nil
+        @analytics = nil
+        if (ENV["ZIGGEO_URL"] != nil)
+            uri = URI.parse(ENV["ZIGGEO_URL"])
+            @config.server_api_url = uri.scheme + "://" + uri.host + ":" + uri.port.to_s
+            @token = uri.user
+            @private_key = uri.password
+            query = CGI::parse(uri.query)
+            @encryption_key = query["encryption_key"]
+        end
     end
-    return @videos
-  end
 
-  def streams()
-    if (@streams == nil)
-      @streams = ZiggeoStreams.new(self)
-    end
-    return @streams
-  end
+    def auth()
+        if (@auth == nil)
+            @auth = ZiggeoAuth.new(self)
+        end
+        return @auth    end
 
-  def authtokens()
-    if (@authtokens == nil)
-      @authtokens = ZiggeoAuthtokens.new(self)
-    end
-    return @authtokens
-  end
+    def videos()
+        if (@videos == nil)
+            @videos = ZiggeoVideos.new(self)
+        end
+        return @videos    end
+
+    def streams()
+        if (@streams == nil)
+            @streams = ZiggeoStreams.new(self)
+        end
+        return @streams    end
+
+    def authtokens()
+        if (@authtokens == nil)
+            @authtokens = ZiggeoAuthtokens.new(self)
+        end
+        return @authtokens    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 metaProfiles()
+        if (@metaProfiles == nil)
+            @metaProfiles = ZiggeoMetaProfiles.new(self)
+        end
+        return @metaProfiles    end
+
+    def metaProfileProcess()
+        if (@metaProfileProcess == nil)
+            @metaProfileProcess = ZiggeoMetaProfileProcess.new(self)
+        end
+        return @metaProfileProcess    end
+
+    def webhooks()
+        if (@webhooks == nil)
+            @webhooks = ZiggeoWebhooks.new(self)
+        end
+        return @webhooks    end
+
+    def analytics()
+        if (@analytics == nil)
+            @analytics = ZiggeoAnalytics.new(self)
+        end
+        return @analytics    end
 
-  def auth()
-    if (@auth == nil)
-      @auth = ZiggeoAuth.new(self)
-    end
-    return @auth
-  end
 
 end

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

@@ -9,18 +9,46 @@ class ZiggeoConnect
   end
 
   def request(method, path, data = nil, file = nil)
-    url = URI.parse(@application.config.server_api_url + '/v1' + path)
+    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
+    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?)
-      HTTParty.send(method, url.to_s, body: data, basic_auth: auth).body
+      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
     else
       data = data.nil? ? {} : data;
       data["file"] = File.new(file)
-      HTTMultiParty.send(method, url.to_s, body: data, basic_auth: auth).body
-    end    
+      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
   end
 
   def requestJSON(method, path, data = nil, file = nil)
@@ -51,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/ZiggeoMetaProfileProcess.rb

@@ -0,0 +1,31 @@
+class ZiggeoMetaProfileProcess
+
+  def initialize(application)
+    @application = application
+  end
+
+  def index(meta_token_or_key)
+    return @application.connect.getJSON('/metaprofiles/' + meta_token_or_key + '/process')
+  end
+
+  def get(meta_token_or_key, token_or_key)
+    return @application.connect.getJSON('/metaprofiles/' + meta_token_or_key + '/process/' + token_or_key + '')
+  end
+
+  def delete(meta_token_or_key, token_or_key)
+    return @application.connect.delete('/metaprofiles/' + meta_token_or_key + '/process/' + token_or_key + '')
+  end
+
+  def create_video_analysis_process(meta_token_or_key)
+    return @application.connect.postJSON('/metaprofiles/' + meta_token_or_key + '/process/analysis')
+  end
+
+  def create_audio_transcription_process(meta_token_or_key)
+    return @application.connect.postJSON('/metaprofiles/' + meta_token_or_key + '/process/transcription')
+  end
+
+  def create_nsfw_process(meta_token_or_key, data = nil)
+    return @application.connect.postJSON('/metaprofiles/' + meta_token_or_key + '/process/nsfw', data)
+  end
+
+end

data/lib/classes/ZiggeoMetaProfiles.rb

@@ -0,0 +1,23 @@
+class ZiggeoMetaProfiles
+
+  def initialize(application)
+    @application = application
+  end
+
+  def create(data = nil)
+    return @application.connect.postJSON('/metaprofiles/', data)
+  end
+
+  def index(data = nil)
+    return @application.connect.getJSON('/metaprofiles/', data)
+  end
+
+  def get(token_or_key)
+    return @application.connect.getJSON('/metaprofiles/' + token_or_key + '')
+  end
+
+  def delete(token_or_key)
+    return @application.connect.delete('/metaprofiles/' + 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

data/lib/classes/ZiggeoVideos.rb

@@ -8,10 +8,22 @@ 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 stats_bulk(data = nil)
+    return @application.connect.postJSON('/videos/stats_bulk', data)
+  end
+
   def download_video(token_or_key)
     return @application.connect.get('/videos/' + token_or_key + '/video')
   end
@@ -20,10 +32,30 @@ class ZiggeoVideos
     return @application.connect.get('/videos/' + token_or_key + '/image')
   end
 
+  def get_stats(token_or_key)
+    return @application.connect.getJSON('/videos/' + token_or_key + '/stats')
+  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 apply_meta(token_or_key, data = nil)
+    return @application.connect.postJSON('/videos/' + token_or_key + '/metaprofile', 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 +64,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,41 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: Ziggeo
 version: !ruby/object:Gem::Version
-  version: '1.06'
+  version: '1.7'
 platform: ruby
 authors:
 - Ziggeo, Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-11 00:00:00.000000000 Z
+date: 2018-08-27 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.
@@ -45,17 +45,23 @@ executables: []
 extensions: []
 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/ZiggeoMetaProfileProcess.rb
+- lib/classes/ZiggeoMetaProfiles.rb
 - lib/classes/ZiggeoStreams.rb
 - lib/classes/ZiggeoVideos.rb
-- lib/Ziggeo.rb
-- README.md
-homepage: http://ziggeo.com
+- lib/classes/ZiggeoWebhooks.rb
+homepage: https://ziggeo.com
 licenses:
-- Apache 2.0
+- Apache-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -63,17 +69,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.0.14
+rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
 summary: The Ziggeo ServerSDK gem.