thron 0.7.0

data/lib/thron/gateway/content_category.rb

@@ -0,0 +1,32 @@
+require 'thron/gateway/session'
+
+module Thron
+  module Gateway
+    class ContentCategory < Session
+
+      PACKAGE = Package.new(:xcontents, :resources, self.service_name)
+
+      def self.routes
+        @routes ||= {
+          link_category_to_content: Route::factory(name: 'linkCategoryToContent', package: PACKAGE),
+          remove_category_from_content: Route::factory(name: 'removeCategoryToContent', package: PACKAGE)
+        }
+      end
+
+      self.routes.keys.each do |message|
+        define_method(message) do |options|
+          category_id = options[:category_id]
+          content_id = options[:content_id]
+          apply_acl = options.fetch(:apply_acl) { false }
+          query = { 
+            clientId: client_id,
+            categoryId: category_id,
+            contentId: content_id,
+            applyAcl: apply_acl
+          }
+          route(to: __callee__, query: query, token_id: token_id)
+        end
+      end
+    end
+  end
+end

data/lib/thron/gateway/content_list.rb

@@ -0,0 +1,40 @@
+require 'thron/gateway/session'
+
+module Thron
+  module Gateway
+    class ContentList < Session
+
+      PACKAGE = Package.new(:xcontents, :resources, self.service_name)
+
+      paginate :show_contents
+
+      def self.routes
+        @routes ||= {
+          show_contents: Route::factory(name: 'showContents', package: PACKAGE, verb: Route::Verbs::GET)
+        }
+      end
+
+      def show_contents(options = {})
+        category_id = options[:category_id]
+        locale = options[:locale]
+        criteria = options.fetch(:criteria) { {} }
+        recursive = options.fetch(:recursive) { true }
+        order_by = options.fetch(:order_by) { 'contentName_A' }
+        limit = options[:limit].to_i
+        offset = options[:offset].to_i
+        query = { 
+          clientId: client_id,
+          categoryId: category_id,
+          locale: locale,
+          searchOnSubCategories: recursive,
+          orderBy: order_by,
+          numberOfResult: limit,
+          offset: offset
+        }.merge(criteria)
+        route(to: __callee__, query: query, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('contents') { [] })
+        end
+      end
+    end
+  end
+end

data/lib/thron/gateway/dashboard.rb

@@ -0,0 +1,120 @@
+require 'thron/gateway/session'
+
+module Thron
+  module Gateway
+    class Dashboard < Session
+
+      PACKAGE = Package.new(:xadmin, :resources, self.service_name)
+
+      def self.routes
+        @routes ||= {
+          change_contents_owner: Route::factory(name: 'changeContentsOwner', package: PACKAGE),
+          download_source_file: Route::factory(name: 'downloadSourceFile', package: PACKAGE, verb: Route::Verbs::GET),
+          migrate_user_stuff: Route::factory(name: 'migrateUserStuff', package: PACKAGE),
+          propagate_acl_to_sub_categories: Route::factory(name: 'propagateAclToSubCategories', package: PACKAGE),
+          replace_source_files: Route::factory(name: 'replaceSourceFiles', package: PACKAGE),
+          reset_content_user_preferences: Route::factory(name: 'resetUserPreferences', package: PACKAGE),
+          trash_contents: Route::factory(name: 'trashContent', package: PACKAGE),
+          untrash_contents: Route::factory(name: 'untrashContent', package: PACKAGE)
+        }
+      end
+
+      def change_contents_owner(options = {})
+        contents = options[:contents]
+        body = { 
+          clientId: client_id,
+          contents: contents
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def download_source_file(options = {})
+        content_id = options[:content_id]
+        save_as = options[:save_as]
+        query = { 
+          clientId: client_id,
+          tokenId: token_id,
+          xcontentId: content_id,
+          saveAs: save_as
+        }
+        route(to: __callee__, query: query, token_id: token_id)
+      end
+
+      def migrate_user_stuff(options = {})
+        user_id1 = options[:user_id1]
+        user_id2 = options[:user_id2]
+        remove_user_id1 = options.fetch(:remove_user_id1) { false }
+        body = { 
+          clientId: client_id,
+          userId1: user_id1,
+          userId2: user_id2,
+          removeUserId1: remove_user_id1
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def propagate_acl_to_sub_categories(options = {})
+        category_id = options[:category_id]
+        acls = options[:acls]
+        force = options.fetch(:force) { false }
+        body = { 
+          clientId: client_id,
+          categoryId: category_id,
+          acls: acls,
+          force: force
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def replace_source_files(options = {})
+        media_content_id = options[:media_content_id]
+        content_id = options[:content_id]
+        file_ids = options[:file_ids]
+        remove_original_files = options.fetch(:remove_original_files) { false }
+        body = { 
+          clientId: client_id,
+          mediaContentId: media_content_id,
+          xcontentId: content_id,
+          sourceFiles: { repositoryFileIds: file_ids },
+          removeOriginalFiles: remove_original_files
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def reset_content_user_preferences(options = {})
+        content_id = options[:content_id]
+        body = { 
+          clientId: client_id,
+          xcontentId: content_id
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def trash_contents(options = {})
+        contents = options[:contents]
+        body = { 
+          clientId: client_id,
+          contentList: { contentsToTrash: contents.map(&:payload) }
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.extra(attribute: 'contentsInIssue')
+        end
+      end
+      
+      def untrash_contents(options = {})
+        new_user_id = options[:new_user_id]
+        content_ids = options[:content_ids]
+        body = { 
+          clientId: client_id,
+          contentList: { 
+            newUserId: new_user_id,
+            xcontentIds: content_ids
+          }
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.extra(attribute: 'contentsInIssue')
+        end
+      end
+    end
+  end
+end

data/lib/thron/gateway/delivery.rb

@@ -0,0 +1,122 @@
+require 'thron/gateway/session'
+
+module Thron
+  module Gateway
+    class Delivery < Session
+
+      PACKAGE = Package.new(:xcontents, :resources, self.service_name)
+
+      paginate :content_cuepoints, :downloadable_contents, :playlist_contents, :recommended_contents
+
+      def self.routes
+        @routes ||= {
+          content_metadata: Route::factory(name: 'getContentDetail', package: PACKAGE, verb: Route::Verbs::GET),
+          content_cuepoints: Route::factory(name: 'getCuePoints', package: PACKAGE, verb: Route::Verbs::GET),
+          downloadable_contents: Route::factory(name: 'getDownloadableContents', package: PACKAGE, verb: Route::Verbs::GET),
+          playlist_contents: Route::factory(name: 'getPlaylistContents', package: PACKAGE, verb: Route::Verbs::GET),
+          recommended_contents: Route::factory(name: 'getRecommendedContents', package: PACKAGE, verb: Route::Verbs::GET),
+          content_subtitles: Route::factory(name: 'getSubTitles', package: PACKAGE, verb: Route::Verbs::GET, accept: Route::Types::PLAIN),
+          content_thumbnail: Route::lazy_factory(name: 'getThumbnail', package: PACKAGE, verb: Route::Verbs::GET)
+        }
+      end
+
+      def content_metadata(options = {})
+        content_id = options[:content_id]
+        criteria = options.fetch(:criteria) { {} }
+        query = { 
+          clientId: client_id,
+          xcontentId: content_id
+        }.merge!(criteria)
+        route(to: __callee__, query: query, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body)
+        end
+      end
+
+      def content_cuepoints(options = {})
+        content_id = options[:content_id]
+        criteria = options.fetch(:criteria) { {} }
+        offset = options[:offset].to_i
+        limit = options[:limit].to_i
+        query = { 
+          clientId: client_id,
+          xcontentId: content_id,
+          offset: offset,
+          numberOfResult: limit
+        }.merge!(criteria)
+        route(to: __callee__, query: query, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('cuePoints') { [] })
+        end
+      end
+
+      def downloadable_contents(options = {})
+        content_id = options[:content_id]
+        criteria = options.fetch(:criteria) { {} }
+        offset = options[:offset].to_i
+        limit = options[:limit].to_i
+        query = { 
+          clientId: client_id,
+          xcontentId: content_id,
+          offset: offset,
+          numberOfResult: limit
+        }.merge!(criteria)
+        route(to: __callee__, query: query, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('contents') { [] })
+        end
+      end
+
+      def playlist_contents(options = {})
+        content_id = options[:content_id]
+        criteria = options.fetch(:criteria) { {} }
+        offset = options[:offset].to_i
+        limit = options[:limit].to_i
+        query = { 
+          clientId: client_id,
+          xcontentId: content_id,
+          offset: offset,
+          numberOfResult: limit
+        }.merge!(criteria)
+        route(to: __callee__, query: query, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('contents') { [] })
+        end
+      end
+
+      def recommended_contents(options = {})
+        content_id = options[:content_id]
+        pkey = options[:pkey]
+        criteria = options.fetch(:criteria) { { admin: true } }
+        offset = options[:offset].to_i
+        limit = options[:limit].to_i
+        query = { 
+          clientId: client_id,
+          xcontentId: content_id,
+          pkey: pkey,
+          offset: offset,
+          numberOfResult: limit
+        }.merge!(criteria)
+        route(to: __callee__, query: query, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('contents') { [] })
+        end
+      end
+
+      def content_subtitles(options = {})
+        content_id = options[:content_id]
+        locale = options[:locale]
+        criteria = options.fetch(:criteria) { {} }
+        query = { 
+          clientId: client_id,
+          xcontentId: content_id,
+          locale: locale
+        }.merge!(criteria)
+        route(to: __callee__, query: query, token_id: token_id)
+      end
+
+      def content_thumbnail(options = {})
+        content_id = options[:content_id]
+        div_area = options[:div_area]
+        route(to: __callee__, token_id: token_id, params: [client_id, div_area, content_id]) do |response|
+          response.body = Entity::Base::factory(response.body)
+        end
+      end
+    end
+  end
+end

data/lib/thron/gateway/device.rb

@@ -0,0 +1,58 @@
+require 'thron/gateway/session'
+
+module Thron
+  module Gateway
+    class Device < Session
+
+      base_uri "#{Config::thron::protocol}://#{Config::thron::client_id}-device.thron.com/api"
+
+      PACKAGE = Package.new(:xdevice, :resources, self.service_name)
+
+      def self.routes
+        @routes ||= {
+          connect_device: Route::factory(name: 'connect', package: PACKAGE),
+          disconnect_device: Route::factory(name: 'disconnect', package: PACKAGE),
+          get_device: Route::factory(name: 'get', package: PACKAGE, verb: Route::Verbs::GET, params: [client_id])
+        }
+      end
+
+      def connect_device(options = {})
+        device_id = options[:device_id]
+        ik = options[:ik]
+        contact_name = options[:contact_name]
+        body = { 
+          clientId: client_id,
+          deviceId: device_id,
+          ik: ik,
+          contactName: contact_name
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body)
+        end
+      end
+
+      def disconnect_device(options = {})
+        device_id = options[:device_id]
+        contact_id = options[:contact_id]
+        body = { 
+          clientId: client_id,
+          deviceId: device_id,
+          contactId: contact_id
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body)
+        end
+      end
+
+      def get_device(options = {})
+        device_id = options[:device_id]
+        query = { 
+          deviceId: device_id,
+        }
+        route(to: __callee__, query: query, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body)
+        end
+      end
+    end
+  end
+end

data/lib/thron/gateway/metadata.rb

@@ -0,0 +1,68 @@
+require 'thron/gateway/session'
+
+module Thron
+  module Gateway
+    class Metadata < Session
+
+      PACKAGE = Package.new(:xcontents, :resources, self.service_name)
+
+      def self.routes
+        @routes ||= {
+          insert_metadata: Route::factory(name: 'insertMetadata', package: PACKAGE),
+          remove_all_metadata: Route::factory(name: 'removeAllMetadata', package: PACKAGE),
+          remove_metadata: Route::factory(name: 'removeMetadata', package: PACKAGE),
+          update_metadata: Route::factory(name: 'updateMetadata', package: PACKAGE),
+          update_single_metadata: Route::factory(name: 'updateSingleMetadata', package: PACKAGE)
+        }
+      end
+
+      def insert_metadata(options = {})
+        content_id = options[:content_id]
+        data = options[:data]
+        category_id = options[:category_id]
+        body = { 
+          client: { clientId: client_id },
+          contentId: content_id,
+          metadata: data,
+          categoryIdForAcl: category_id
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def remove_all_metadata(options = {})
+        content_id = options[:content_id]
+        body = { 
+          clientId: client_id,
+          contentId: content_id
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def update_metadata(options = {})
+        content_id = options[:content_id]
+        data_list = options[:data_list]
+        category_id = options[:category_id]
+        body = { 
+          clientId: client_id,
+          contentId: content_id,
+          metadata: { metadata: data_list },
+          categoryIdForAcl: category_id
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+      
+      %w[remove update_single].each do |action|
+        define_method("#{action}_metadata") do |options|
+          content_id = options[:content_id]
+          data = options[:data]
+          body = { 
+            clientId: client_id,
+            contentId: content_id,
+            metadata: data
+          }
+          route(to: __callee__, body: body, token_id: token_id)
+        end
+      end
+    end
+  end
+end

data/lib/thron/gateway/publish_in_weebo_express.rb

@@ -0,0 +1,39 @@
+require 'thron/gateway/session'
+
+module Thron
+  module Gateway
+    class PublishInWeeboExpress < Session
+
+      PACKAGE = Package.new(:xadmin, :resources, self.service_name)
+
+      def self.routes
+        @routes ||= {
+          publish_audio: Route::factory(name: 'publishAudio', package: PACKAGE),
+          publish_content_in_channels: Route::factory(name: 'publishContentInChannels', package: PACKAGE),
+          publish_document: Route::factory(name: 'publishDocument', package: PACKAGE),
+          publish_image: Route::factory(name: 'publishImage', package: PACKAGE),
+          publish_live_event: Route::factory(name: 'publishLiveEvent', package: PACKAGE),
+          publish_pagelet: Route::factory(name: 'publishPagelet', package: PACKAGE),
+          publish_playlist: Route::factory(name: 'publishPlayList', package: PACKAGE),
+          publish_program: Route::factory(name: 'publishProgram', package: PACKAGE),
+          publish_video: Route::factory(name: 'publishVideo', package: PACKAGE),
+          upload_and_publish: Route::factory(name: 'uploadAndPublish', package: PACKAGE)
+        }
+      end
+
+      self.routes.keys.each do |message|
+        define_method(message) do |options|
+          data = options[:data]
+          body = { 
+            clientId: client_id,
+            param: data
+          }
+          route(to: message, body: body, token_id: token_id) do |response|
+            response.extra(attribute: 'actionsInError')
+            response.body = Entity::Base::factory(response.body.fetch('content') { {} })
+          end
+        end
+      end
+    end
+  end
+end