thron 0.7.0

data/lib/thron/gateway/publishing_process.rb

@@ -0,0 +1,141 @@
+require 'thron/gateway/session'
+
+module Thron
+  module Gateway
+    class PublishingProcess < Session
+
+      PACKAGE = Package.new(:xadmin, :resources, self.service_name)
+
+      def self.routes
+        @routes ||= {
+          change_channel_status: Route::factory(name: 'changeChannelStatus', package: PACKAGE), 
+          create_content_for_channel: Route::factory(name: 'createContentForChannel', package: PACKAGE),
+          get_content_types: Route::factory(name: 'getContentTypes', package: PACKAGE),
+          new_content: Route::factory(name: 'newContent', package: PACKAGE),
+          new_live_event_content: Route::factory(name: 'newLiveEventContent', package: PACKAGE),
+          new_pagelet_content: Route::factory(name: 'newPageletContent', package: PACKAGE),
+          new_playlist_content: Route::factory(name: 'newPlayListContent', package: PACKAGE),
+          publish_channel: Route::factory(name: 'publishChannel', package: PACKAGE),
+          remove_channel: Route::factory(name: 'removeChannel', package: PACKAGE),
+          replace_thumbnail: Route::factory(name: 'replaceThumbnailInPublishedContent', package: PACKAGE),
+          unpublish_content: Route::factory(name: 'unpublishContent', package: PACKAGE),
+          update_pagelet_content: Route::factory(name: 'updatePageletContent', package: PACKAGE),
+          update_publishing_properties: Route::factory(name: 'updatePublishingProperties', package: PACKAGE)
+        }
+      end
+
+      def change_channel_status(options = {})
+        media_content_id = options[:media_content_id]
+        content_id = options[:content_id]
+        channel = options[:channel]
+        active = options.fetch(:active) { false }
+        body = { 
+          clientId: client_id,
+          mediaContentId: media_content_id,
+          xcontentId: content_id,
+          channel: channel,
+          active: active
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.extra(attribute: 'actionsInError')
+          response.body = Entity::Base::factory(response.body.fetch('content') { {} })
+        end
+      end
+
+      def get_content_types(options = {})
+        file_names = options[:file_names]
+        body = { 
+          clientId: client_id,
+          files: { fileNames: file_names }
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('fileContentTypes') { [] })
+        end
+      end
+
+      def unpublish_content(options = {})
+        media_content_id = options[:media_content_id]
+        content_id = options[:content_id]
+        force = options.fetch(:force) { false }
+        remove_source_files = options.fetch(:remove_source_files) { false }
+        body = { 
+          clientId: client_id,
+          mediaContentId: media_content_id,
+          xcontentId: content_id,
+          force: force,
+          removeSourceFiles: remove_source_files
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.extra(attribute: 'actionsInError')
+          response.body = Entity::Base::factory(response.body.fetch('content') { {} })
+        end
+      end
+
+      def update_pagelet_content(options = {})
+        media_content_id = options[:media_content_id]
+        content_id = options[:content_id]
+        body = options[:body]
+        mime_type = options[:mime_type]
+        body = { 
+          clientId: client_id,
+          mediaContentId: media_content_id,
+          xcontentId: content_id,
+          body: body,
+          mimeType: mime_type
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.extra(attribute: 'actionsInError')
+          response.body = Entity::Base::factory(response.body.fetch('content') { {} })
+        end
+      end
+
+      def update_publishing_properties(options = {})
+        media_content_id = options[:media_content_id]
+        content_id = options[:content_id]
+        properties = options[:properties]
+        body = { 
+          clientId: client_id,
+          mediaContentId: media_content_id,
+          xcontentId: content_id,
+          properties: properties
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.extra(attribute: 'actionsInError')
+          response.body = Entity::Base::factory(response.body.fetch('content') { {} })
+        end
+      end
+
+      %i[publish remove].each do |action|
+        define_method "#{action}_channel" do |options|
+          media_content_id = options.fetch(:media_content_id)
+          content_id = options.fetch(:content_id)
+          channel = options.fetch(:channel)
+          body = { 
+            clientId: client_id,
+            mediaContentId: media_content_id,
+            xcontentId: content_id,
+            channel: channel
+          }
+          route(to: __callee__, body: body, token_id: token_id) do |response|
+            response.extra(attribute: 'actionsInError')
+            response.body = Entity::Base::factory(response.body.fetch('content') { {} })
+          end
+        end
+      end
+
+      %i[create_content_for_channel new_content new_live_event_content new_pagelet_content new_playlist_content replace_thumbnail].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

data/lib/thron/gateway/repository.rb

@@ -0,0 +1,111 @@
+require 'thron/gateway/session'
+
+module Thron
+  module Gateway
+    class Repository < Session
+
+      base_uri "#{Config::thron::protocol}://#{Config::thron::client_id}-view.thron.com/api"
+
+      PACKAGE = Package.new(:xpackager, :resources, self.service_name)
+
+      paginate :get_ftp_file_list, :get_uploaded_file_list
+
+      def self.routes
+        @routes ||= {
+          add_files: Route::factory(name: 'addFilesToPlatform', package: PACKAGE),
+          add_s3_resource: Route::factory(name: 'addS3ResourceToPlatform', package: PACKAGE),
+          add_web_resource: Route::factory(name: 'addWebResourceToPlatform', package: PACKAGE),
+          delete_ftp_file: Route::factory(name: 'deleteFtpFile', package: PACKAGE),
+          delete_uploaded_file: Route::factory(name: 'deleteUploadedFile', package: PACKAGE),
+          get_ftp_file_list: Route::factory(name: 'getFtpFileList', package: PACKAGE),
+          get_quota_usage: Route::factory(name: 'getQuotaUsage', package: PACKAGE, verb: Route::Verbs::GET),
+          get_s3_credentials: Route::factory(name: 'getS3UploadCredentials', package: PACKAGE, verb: Route::Verbs::GET),
+          get_uploaded_file_list: Route::factory(name: 'getUploadedFileList', package: PACKAGE)
+        }
+      end
+
+      def add_files(options = {})
+        files = options[:files]
+        body = { 
+          clientId: client_id,
+          files: { files: files }
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body)
+        end
+      end
+
+      def add_s3_resource(options = {})
+        resource = options[:resource]
+        remove_resource = options.fetch(:remove_resource) { false }
+        body = { 
+          clientId: client_id,
+          resource: resource,
+          remove_resource_if_possible: remove_resource
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body)
+        end
+      end
+
+      def add_web_resource(options = {})
+        resource = options[:resource]
+        body = { 
+          clientId: client_id,
+          webResource: resource
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body)
+        end
+      end
+
+      %i[delete_ftp_file delete_uploaded_file].each do |message|
+        define_method(message) do |options|
+          file = options.fetch(:file)
+          body = { 
+            clientId: client_id,
+            file: file
+          }
+          route(to: __callee__, body: body, token_id: token_id)
+        end
+      end
+
+      %i[get_ftp_file_list get_uploaded_file_list].each do |message|
+        define_method(message) do |options|
+          criteria = options.fetch(:criteria) { {} }
+          order_by = options[:order_by]
+          offset = options[:offset].to_i
+          limit = options[:limit].to_i
+          body = { 
+            clientId: client_id,
+            criteria: criteria,
+            orderByField: order_by,
+            offset: offset.to_i,
+            numberOfResult: limit.to_i
+          }
+          route(to: __callee__, body: body, token_id: token_id) do |response|
+            response.body = Entity::Base::factory(response.body.fetch('uploadedFiles') { [] })
+          end
+        end
+      end
+
+      def get_quota_usage
+        query = { 
+          clientId: client_id,
+        }
+        route(to: __callee__, query: query, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body)
+        end
+      end
+
+      def get_s3_credentials
+        query = { 
+          clientId: client_id,
+        }
+        route(to: __callee__, query: query, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('credentials') { {} })
+        end
+      end
+    end
+  end
+end

data/lib/thron/gateway/session.rb

@@ -0,0 +1,15 @@
+require 'thron/gateway/base'
+require 'thron/pageable'
+
+module Thron
+  module Gateway
+    class Session < Base
+      include Pageable
+
+      def initialize(options = {})
+        token_id = options[:token_id]
+        @token_id = token_id
+      end
+    end
+  end
+end

data/lib/thron/gateway/users_group_manager.rb

@@ -0,0 +1,117 @@
+require 'thron/gateway/session'
+
+module Thron
+  module Gateway
+    class UsersGroupManager < Session
+
+      PACKAGE = Package.new(:xsso, :resources, self.service_name)
+
+      paginate :find_groups
+
+      def self.routes
+        @routes ||= {
+          create_group: Route::factory(name: 'createGroup', package: PACKAGE),
+          remove_group: Route::factory(name: 'removeGroup', package: PACKAGE),
+          group_detail: Route::factory(name: 'detailGroup', package: PACKAGE),
+          find_groups: Route::factory(name: 'findGroupsByProperties', package: PACKAGE),
+          link_users_to_group: Route::factory(name: 'linkUserToGroup', package: PACKAGE),
+          unlink_users_to_group: Route::factory(name: 'unlinkUserToGroup', package: PACKAGE),
+          update_group: Route::lazy_factory(name: 'update', package: PACKAGE),
+          update_group_external_id: Route::lazy_factory(name: 'updateExternalId', package: PACKAGE)
+        }
+      end
+
+      def create_group(options = {})
+        data = options[:data]
+        body = { 
+          clientId: client_id,
+          usersGroup: data
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('group') { {} })
+        end
+      end
+
+      def remove_group(options = {})
+        group_id = options[:group_id]
+        force = options.fetch(:force) { false }
+        body = { 
+          clientId: client_id,
+          groupId: group_id,
+          force: force
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def group_detail(options = {})
+        group_id = options[:group_id]
+        fields_option = options.fetch(:fields_option) { {} }
+        offset = options[:offset].to_i
+        limit = options[:limit].to_i
+        body = { 
+          clientId: client_id,
+          groupId: group_id,
+          offset: offset.to_i,
+          numberOfResult: limit.to_i,
+          fieldsOption: fields_option
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          group = response.body.delete('group') { {} }
+          response.body = Entity::Base::factory(response.body.merge!(group))
+        end
+      end
+
+      def find_groups(options = {})
+        criteria = options.fetch(:criteria) { {} }
+        order_by = options[:order_by]
+        fields_option = options.fetch(:fields_option) { {} }
+        offset = options[:offset].to_i
+        limit = options[:limit].to_i
+        body = { 
+          clientId: client_id,
+          criteria: criteria,
+          orderBy: order_by,
+          fieldsOption: fields_option,
+          offset: offset.to_i,
+          numberOfResult: limit.to_i
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('groups') { [] })
+        end
+      end
+
+      %i[link_users_to_group unlink_users_to_group].each do |name|
+        define_method(name) do |*options|
+          group_id = options.last[:group_id]
+          usernames = options.last[:usernames].to_a
+          body = { 
+            clientId: client_id,
+            userList: {
+              usernames: usernames
+            },
+            groupId: group_id
+          }
+          route(to: name, body: body, token_id: token_id)
+        end
+      end
+
+      def update_group(options = {})
+        group_id = options[:group_id]
+        data = options[:data]
+        body = {
+          update: data
+        }
+        route(to: __callee__, body: body, token_id: token_id, params: [client_id, group_id])
+      end
+
+      def update_group_external_id(options = {})
+        group_id = options[:group_id]
+        external_id = options[:external_id]
+        body = {
+          externalId: external_id
+        }
+        route(to: __callee__, body: body, token_id: token_id, params: [client_id, group_id])
+      end
+    end
+  end
+end

data/lib/thron/gateway/v_user_manager.rb

@@ -0,0 +1,195 @@
+require 'thron/gateway/session'
+require 'thron/entity/image'
+
+module Thron
+  module Gateway
+    class VUserManager < Session
+
+      PACKAGE = Package.new(:xsso, :resources, self.service_name)
+
+      paginate :find_users
+
+      def self.routes
+        @routes ||= {
+          create_user: Route::factory(name: 'create', package: PACKAGE),
+          user_detail: Route::factory(name: 'detail', package: PACKAGE, verb: Route::Verbs::GET),
+          find_users: Route::factory(name: 'findByProperties', package: PACKAGE),
+          check_credentials: Route::factory(name: 'login', package: PACKAGE),
+          temporary_token: Route::factory(name: 'resetPassword', package: PACKAGE),
+          update_password: Route::factory(name: 'changePassword', package: PACKAGE),
+          update_status: Route::factory(name: 'changeUserStatus', package: PACKAGE),
+          update_capabilities_and_roles: Route::factory(name: 'updateCapabilitiesAndRoles', package: PACKAGE),
+          update_external_id: Route::lazy_factory(name: 'updateExternalId', package: PACKAGE),
+          update_image: Route::factory(name: 'updateImage', package: PACKAGE),
+          update_settings: Route::factory(name: 'updateSettings', package: PACKAGE),
+          update_user: Route::lazy_factory(name: 'updateUser', package: PACKAGE),
+          upgrade_user: Route::factory(name: 'upgradeUser', package: PACKAGE)
+        }
+      end
+
+      def create_user(options = {})
+        username = options[:username]
+        password = options[:password]
+        data = options[:data]
+        body = { 
+          clientId: client_id,
+          newUser: {
+            username: username,
+            password: password
+          }
+        }.merge(data)
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('user') { {} })
+        end
+      end
+
+      def user_detail(options = {})
+        username = options[:username]
+        extra = options.fetch(:extra) { {} }
+        offset = options[:offset].to_i
+        limit = options[:limit].to_i
+        query = {
+          clientId: client_id,
+          username: username,
+          offset: offset.to_i,
+          numberOfResults: limit.to_i
+        }.merge(extra)
+        route(to: __callee__, query: query, token_id: token_id, dash: false) do |response|
+          user = response.body.delete('user') { {} }
+          response.body = Entity::Base::factory(response.body.merge!(user))
+        end
+      end
+
+      def find_users(options = {})
+        criteria = options.fetch(:criteria) { {} }
+        order_by = options[:order_by]
+        fields_option = options.fetch(:fields_option) { {} }
+        offset = options[:offset].to_i
+        limit = options[:limit].to_i
+        body = { 
+          clientId: client_id,
+          criteria: criteria,
+          orderBy: order_by,
+          fieldsOption: fields_option,
+          offset: offset.to_i,
+          numberOfResult: limit.to_i
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('users') { [] })
+        end
+      end
+
+      def check_credentials(options = {})
+        username = options[:username]
+        password = options[:password]
+        query = { 
+          clientId: client_id,
+          username: username,
+          password: password
+        }
+        route(to: __callee__, query: query, token_id: token_id, dash: false) do |response|
+          user = response.body.delete('user') { {} }
+          response.body = Entity::Base::factory(response.body.merge!(user))
+        end
+      end
+
+      def temporary_token(options = {})
+        username = options[:username]
+        body = { 
+          clientId: client_id,
+          username: username,
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = response.body['tmpToken']
+        end
+      end
+
+      def update_password(options = {})
+        username = options[:username]
+        password = options[:password]
+        query = { 
+          clientId: client_id,
+          username: username,
+          newpassword: password
+        }
+        route(to: __callee__, query: query, token_id: token_id, dash: false)
+      end
+
+      def update_status(options = {})
+        username = options[:username]
+        data = options[:data]
+        body = { 
+          clientId: client_id,
+          username: username,
+          properties: data
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def update_capabilities_and_roles(options = {})
+        username = options[:username]
+        capabilities = options[:capabilities]
+        body = { 
+          clientId: client_id,
+          username: username,
+          userCapabilities: capabilities
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def update_external_id(options = {})
+        username = options[:username]
+        external_id = options[:external_id]
+        body = {
+          externalId: external_id
+        }
+        route(to: __callee__, body: body, token_id: token_id, params: [client_id, username])
+      end
+
+      def update_image(options = {})
+        username = options[:username]
+        image = options[:image]
+        body = {
+          clientId: client_id,
+          username: username,
+          buffer: image
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def update_settings(options = {})
+        username = options[:username]
+        settings = options[:settings]
+        body = {
+          clientId: client_id,
+          username: username,
+          settings: settings
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def update_user(options = {})
+        username = options[:username]
+        data = options[:data]
+        body = {
+          update: data
+        }
+        route(to: __callee__, body: body, token_id: token_id, params: [client_id, username])
+      end
+
+      def upgrade_user(options = {})
+        username = options[:username]
+        password = options[:password]
+        data = options[:data]
+        body = { 
+          clientId: client_id,
+          username: username,
+          newPassword: password
+        }.merge(data)
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('user') { {} })
+        end
+      end
+    end
+  end
+end