thron 0.7.0

data/lib/thron/gateway/client.rb

@@ -0,0 +1,59 @@
+require 'thron/gateway/session'
+
+module Thron
+  module Gateway
+    class Client < Session
+
+      PACKAGE = Package.new(:xcontents, :resources, self.service_name)
+
+      def self.routes
+        @routes ||= {
+          client_detail: Route::factory(name: 'detailClient', package: PACKAGE, verb: Route::Verbs::GET),
+          update_audit_duration_days: Route::factory(name: 'updateAuditDurationDays', package: PACKAGE),
+          enable_secure_connection: Route::factory(name: 'updateSecureConnectionEnabled', package: PACKAGE),
+          trash_properties_older_than: Route::factory(name: 'updateTrashProperties', package: PACKAGE)
+        }
+      end
+
+      def client_detail
+        query = { 
+          clientId: client_id,
+        }
+        route(to: __callee__, query: query, token_id: token_id) do |response|
+          name = response.body.delete('name')
+          name_hash = name ? { name: name } : {}
+          response.body = Entity::Base::factory(response.body.fetch('properties') { {} }.merge!(name_hash))
+        end
+      end
+      
+      def update_audit_duration_days(options = {})
+        days = options[:days]
+        body = { 
+          clientId: client_id,
+          auditDurationDays: days.to_i
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def enable_secure_connection(options = {})
+        enabled = options[:enabled]
+        body = { 
+          clientId: client_id,
+          secureConnectionEnabled: !!enabled
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def trash_properties_older_than(options = {})
+        days = options[:days]
+        body = { 
+          clientId: client_id,
+          properties: {
+            removeContentsOlderThan: days.to_i
+          }
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+    end
+  end
+end

data/lib/thron/gateway/comment.rb

@@ -0,0 +1,76 @@
+require 'thron/gateway/session'
+
+module Thron
+  module Gateway
+    class Comment < Session
+
+      PACKAGE = Package.new(:xcontents, :resources, self.service_name)
+
+      paginate :list_comments
+
+      def self.routes
+        @routes ||= {
+          comment_detail: Route::factory(name: 'detail', package: PACKAGE, verb: Route::Verbs::GET),
+          list_comments: Route::factory(name: 'getComments', package: PACKAGE, verb: Route::Verbs::GET),
+          insert_comment: Route::factory(name: 'insertComment', package: PACKAGE),
+          report_comment_abuse: Route::factory(name: 'reportAbuse', package: PACKAGE)
+        }
+      end
+
+      def comment_detail(options = {})
+        comment_id = options[:comment_id]
+        query = { 
+          clientId: client_id,
+          commentId: comment_id
+        }
+        route(to: __callee__, query: query, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('comment') { {} })
+        end
+      end
+
+      def list_comments(options = {})
+        criteria = options.fetch(:criteria) { {} }
+        locale = options[:locale]
+        order_by = options[:order_by]
+        offset = options[:offset].to_i
+        limit = options[:limit].to_i
+        order_by = order_by ? { orderBy: order_by } : {}
+        query = { 
+          clientId: client_id,
+          locale: locale,
+          offset: offset,
+          numberOfResults: limit
+        }.merge(criteria).merge(order_by)
+        route(to: __callee__, query: query, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('comments') { [] })
+        end
+      end
+
+      def insert_comment(options = {})
+        content_id = options[:content_id]
+        data = options[:data]
+        category_id = options[:category_id]
+        body = { 
+          clientId: client_id,
+          contentId: content_id,
+          comment: data,
+          categoryIdForAcl: category_id
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('comment') { {} })
+        end
+      end
+
+      def report_comment_abuse(options = {})
+        comment_id = options[:comment_id]
+        user_id = options[:user_id]
+        query = { 
+          clientId: client_id,
+          commentId: comment_id,
+          userId: user_id
+        }
+        route(to: __callee__, query: query, token_id: token_id)
+      end
+    end
+  end
+end

data/lib/thron/gateway/contact.rb

@@ -0,0 +1,120 @@
+require 'thron/gateway/session'
+
+module Thron
+  module Gateway
+    class Contact < Session
+
+      base_uri "#{Config::thron::protocol}://#{Config::thron::client_id}-view.thron.com/contactunit"
+
+      PACKAGE = Package.new(:xcontact, :resources, self.service_name)
+
+      paginate :list_contacts, :list_contact_keys
+
+      def self.routes
+        @routes ||= {
+          add_contact_key: Route::factory(name: 'addKey', package: PACKAGE, params: [client_id]),
+          contact_detail: Route::factory(name: 'detail', package: PACKAGE, verb: Route::Verbs::GET, params: [client_id]),
+          insert_contact: Route::factory(name: 'insert', package: PACKAGE, params: [client_id]),
+          list_contacts: Route::factory(name: 'list', package: PACKAGE, params: [client_id]),
+          list_contact_keys: Route::factory(name: 'listKey', package: PACKAGE, params: [client_id]),
+          remove_contact_key: Route::factory(name: 'removeKey', package: PACKAGE, params: [client_id]),
+          update_contact: Route::factory(name: 'update', package: PACKAGE, params: [client_id])
+        }
+      end
+
+      def add_contact_key(options = {})
+        contact_id = options[:contact_id]
+        ik = options[:ik]
+        body = { 
+          contactId: contact_id,
+          ik: ik
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('item') { {} })
+        end
+      end
+
+      def contact_detail(options = {})
+        contact_id = options[:contact_id]
+        query = { 
+          contactId: contact_id,
+        }
+        route(to: __callee__, query: query, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('item') { {} })
+        end
+      end
+
+      def insert_contact(options = {})
+        name = options[:name]
+        ik = options[:ik]
+        body = { 
+          value: {
+            ik: ik,
+            name: name
+          }
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('item') { {} })
+        end
+      end
+
+      def list_contacts(options = {})
+        criteria = options.fetch(:criteria) { {} }
+        option = options.fetch(:option) { {} }
+        offset = options[:offset].to_i
+        limit = options[:limit].to_i
+        body = { 
+          criteria: criteria,
+          option: option,
+          offset: offset,
+          limit: limit
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('items') { [] })
+        end
+      end
+
+      def list_contact_keys(options = {})
+        search_key = options[:search_key]
+        offset = options[:offset].to_i
+        limit = options[:limit].to_i
+        body = { 
+          criteria: {
+            searchKey: search_key
+          },
+          offset: offset,
+          limit: limit
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = response.body.fetch('items') { [] }
+        end
+      end
+
+      def remove_contact_key(options = {})
+        contact_id = options[:contact_id]
+        key = options[:key]
+        body = { 
+          contactId: contact_id,
+          key: key
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('item') { {} })
+        end
+      end
+
+      def update_contact(options = {})
+        contact_id = options[:contact_id]
+        name = options[:name]
+        body = { 
+          contactId: contact_id,
+          update: {
+            name: name
+          }
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('item') { {} })
+        end
+      end
+    end
+  end
+end

data/lib/thron/gateway/content.rb

@@ -0,0 +1,267 @@
+require 'thron/gateway/session'
+
+module Thron
+  module Gateway
+    class Content < Session
+
+      PACKAGE = Package.new(:xcontents, :resources, self.service_name)
+
+      paginate :find_contents
+
+      def self.routes
+        @routes ||= {
+          add_content_for_locale: Route::factory(name: 'addContent4Locale', package: PACKAGE),
+          add_content_pretty_id: Route::factory(name: 'addContentPrettyId', package: PACKAGE),
+          add_player_embed_code: Route::factory(name: 'addPlayerEmbedCode', package: PACKAGE),
+          add_linked_content: Route::factory(name: 'addLinkedContent', package: PACKAGE),
+          add_linked_contents: Route::factory(name: 'addLinkedContents', package: PACKAGE),
+          content_detail: Route::factory(name: 'detail', package: PACKAGE, verb: Route::Verbs::GET),
+          find_contents: Route::factory(name: 'findByProperties', package: PACKAGE),
+          move_linked_content: Route::factory(name: 'moveLinkedContent', package: PACKAGE),
+          remove_content_for_locale: Route::factory(name: 'removeContent4Locale', package: PACKAGE),
+          remove_content_pretty_id: Route::factory(name: 'removeContentPrettyId', package: PACKAGE),
+          remove_linked_contents: Route::factory(name: 'removeLinkedContents', package: PACKAGE),
+          remove_player_embed_code: Route::factory(name: 'removePlayerEmbedCode', package: PACKAGE),
+          update_available_solutions: Route::factory(name: 'updateAvailableSolutions', package: PACKAGE),
+          update_content: Route::factory(name: 'updateContent', package: PACKAGE),
+          update_content_for_locale: Route::factory(name: 'updateContent4Locale', package: PACKAGE),
+          update_content_pretty_id: Route::factory(name: 'updateContentPrettyId', package: PACKAGE),
+          update_player_embed_code: Route::factory(name: 'updatePlayerEmbedCode', package: PACKAGE),
+          update_player_embed_codes: Route::factory(name: 'updatePlayerEmbedCodes', package: PACKAGE),
+          update_user_specific_values: Route::factory(name: 'updateUserSpecificValues', package: PACKAGE)
+        }
+      end
+
+      %w[add update].each do |action|
+        define_method("#{action}_content_for_locale") do |options|
+          content_id = options[:content_id]
+          locale = options[:locale]
+          category_id = options[:category_id]
+          body = { 
+            client: {
+              clientId: client_id
+            },
+            contentId: content_id,
+            detail: locale,
+            categoryIdForAcl: category_id
+          }
+          route(to: __callee__, body: body, token_id: token_id)
+        end
+
+        define_method("#{action}_content_pretty_id") do |options|
+          content_id = options[:content_id]
+          pretty_id = options[:pretty_id]
+          category_id = options[:category_id]
+          body = { 
+            clientId: client_id,
+            contentId: content_id,
+            prettyId: pretty_id,
+            categoryIdForAcl: category_id
+          }
+          route(to: __callee__, body: body, token_id: token_id)
+        end
+
+        define_method("#{action}_player_embed_code") do |options|
+          content_id = options[:content_id]
+          data = options[:data]
+          body = { 
+            clientId: client_id,
+            contentId: content_id,
+            embedCode: data
+          }
+          route(to: __callee__, body: body, token_id: token_id)
+        end
+      end
+
+      def add_linked_content(options = {})
+        content_id = options[:content_id]
+        data = options[:data]
+        category_id = options[:category_id]
+        body = { 
+          clientId: client_id,
+          contentId: content_id,
+          linkedContent: data,
+          categoryIdForAcl: category_id
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def add_linked_contents(options = {})
+        content_id = options[:content_id]
+        contents = options[:contents]
+        category_id = options[:category_id]
+        body = { 
+          clientId: client_id,
+          contentId: content_id,
+          linkedContents: {
+            contents: contents
+          },
+          categoryIdForAcl: category_id
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def content_detail(options = {})
+        content_id = options[:content_id]
+        extra = options.fetch(:extra) { {} }
+        locale = options[:locale]
+        access_key = options[:access_key]
+        query = { 
+          clientId: client_id,
+          contentId: content_id,
+          locale: locale,
+          pkey: access_key
+        }.merge(extra)
+        route(to: __callee__, query: query, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body)
+        end
+      end
+
+      def find_contents(options = {})
+        criteria = options.fetch(:criteria) { {} }
+        field_option = options.fetch(:field_option) { {} }
+        locale = options[:locale]
+        div_area = options[:div_area]
+        order_by = options[:order_by]
+        offset = options[:offset].to_i
+        limit = options[:limit].to_i
+        body = { 
+          client: {
+            clientId: client_id
+          },
+          criteria: criteria,
+          contentFieldOption: field_option,
+          locale: locale,
+          divArea: div_area,
+          orderBy: order_by,
+          offset: offset.to_i,
+          numberOfresults: limit.to_i
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('contents') { [] })
+        end
+      end
+      
+      def move_linked_content(options = {})
+        content_id = options[:content_id]
+        from = options[:from].to_i
+        to = options[:to].to_i
+        link_type = options[:link_type]
+        body = { 
+          clientId: client_id,
+          xcontentId: content_id,
+          oldPosition: from.to_i,
+          newPosition: to.to_i,
+          linkType: link_type
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def remove_content_for_locale(options = {})
+        content_id = options[:content_id]
+        locale = options[:locale]
+        query = { 
+          clientId: client_id,
+          contentId: content_id,
+          locale: locale
+        }
+        route(to: __callee__, query: query, token_id: token_id)
+      end
+
+      def remove_content_pretty_id(options = {})
+        content_id = options[:content_id]
+        locale = options[:locale]
+        category_id = options[:category_id]
+        body = { 
+          clientId: client_id,
+          contentId: content_id,
+          locale: locale,
+          categoryIdForAcl: category_id
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def remove_linked_contents(options = {})
+        content_id = options[:content_id]
+        criteria = options.fetch(:criteria) { {} }
+        category_id = options[:category_id]
+        body = { 
+          clientId: client_id,
+          contentId: content_id,
+          criteria: criteria,
+          categoryIdForAcl: category_id
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def remove_player_embed_code(options = {})
+        content_id = options[:content_id]
+        player_id = options[:player_id]
+        body = { 
+          clientId: client_id,
+          contentId: content_id,
+          embedCodeId: player_id
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def update_available_solutions(options = {})
+        content_id = options[:content_id]
+        solutions = options[:solutions].to_a
+        category_id = options[:category_id]
+        body = { 
+          clientId: client_id,
+          contentId: content_id,
+          contentValues: {
+            availableInSolutions: solutions
+          },
+          categoryIdForAcl: category_id
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def update_content(options = {})
+        content_id = options[:content_id]
+        data = options[:data]
+        category_id = options[:category_id]
+        body = { 
+          clientId: client_id,
+          contentId: content_id,
+          contentValues: data,
+          categoryIdForAcl: category_id
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def update_player_embed_codes(options = {})
+        content_id = options[:content_id]
+        players = options[:players]
+        category_id = options[:category_id]
+        body = { 
+          clientId: client_id,
+          contentId: content_id,
+          embedCodes: {
+            embedCodes: players
+          },
+          categoryIdForAcl: category_id
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def update_user_specific_values(options = {})
+        username = options[:username]
+        content_id = options[:content_id]
+        data = options[:data]
+        category_id = options[:category_id]
+        body = { 
+          clientId: client_id,
+          username: username,
+          contentId: content_id,
+          contentParams: data,
+          categoryIdForAcl: category_id
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+    end
+  end
+end