thron 0.7.0

data/lib/thron/entity/image.rb

@@ -0,0 +1,30 @@
+module Thron
+  module Entity
+    class Image < Base
+      def initialize(hash = {})
+        super
+        @path = hash.delete(:path)
+        if valid_path?
+          fetch_mime_type
+          fetch_buffer
+        end
+      end
+
+      private
+
+      def valid_path?
+        File.readable?(@path.to_s)
+      end
+
+      def fetch_mime_type
+        @table[:mime_type] ||= `file -b --mime-type #{@path}`.to_s.chomp
+        new_ostruct_member(:mime_type)
+      end
+
+      def fetch_buffer
+        @table[:buffer] ||= File.binread(@path).unpack('c*')
+        new_ostruct_member(:buffer)
+      end
+    end
+  end
+end

data/lib/thron/gateway/access_manager.rb

@@ -0,0 +1,69 @@
+require 'thron/gateway/base'
+
+module Thron
+  module Gateway
+    class AccessManager < Base
+
+      PACKAGE = Package.new(:xsso, :resources, self.service_name)
+
+      def self.routes
+        @routes ||= {
+          login: Route::factory(name: 'login', package: PACKAGE, params: [client_id]),
+          logout: Route::factory(name: 'logout', package: PACKAGE, params: [client_id], type: Route::Types::PLAIN, accept: Route::Types::PLAIN),
+          validate_capabilities: Route::factory(name: 'validateCapability', package: PACKAGE, params: [client_id], type: Route::Types::PLAIN, accept: Route::Types::PLAIN),
+          validate_roles: Route::factory(name: 'validateRole', package: PACKAGE, params: [client_id], type: Route::Types::PLAIN, accept: Route::Types::PLAIN),
+          validate_token: Route::factory(name: 'validateToken', package: PACKAGE, params: [client_id])
+        }
+      end
+
+      def login(options = {})
+        query = {
+          username: options[:username],
+          password: options[:password]
+        }
+        route(to: __callee__, query: query, dash: false) do |response|
+          response.body = Entity::Base::factory(response.body)
+          @token_id = response.body.token_id
+        end
+      end
+
+      def logout
+        check_session
+        route(to: __callee__, token_id: token_id, dash: false) do |response|
+          @token_id = nil
+        end
+      end
+
+      def validate_capabilities(options = {})
+        capabilities = options.fetch(:capabilities) { [] }
+        check_session
+        query = {
+          capabilities: capabilities.join(',')
+        }
+        route(to: __callee__, query: query, token_id: @token_id, dash: false)
+      end
+
+      def validate_roles(options = {})
+        roles = options.fetch(:roles) { [] }
+        xor = options.fetch(:xor) { false }
+        check_session
+        separator = xor ? '|' : ','
+        query = {
+          role: roles.join(separator)
+        }
+        route(to: __callee__, query: query, token_id: @token_id, dash: false)
+      end
+
+      def validate_token(options = {})
+        username = options[:username]
+        check_session
+        query = {
+          username: username
+        }
+        route(to: __callee__, query: query, token_id: @token_id, dash: false) do |response|
+          response.body = Entity::Base::factory(response.body)
+        end
+      end
+    end
+  end
+end

data/lib/thron/gateway/apps.rb

@@ -0,0 +1,91 @@
+require 'thron/gateway/session'
+
+module Thron
+  module Gateway
+    class Apps < Session
+
+      PACKAGE = Package.new(:xadmin, :resources, self.service_name)
+
+      def self.routes
+        @routes ||= {
+          app_detail: Route::factory(name: 'appDetail', package: PACKAGE),
+          list_apps: Route::factory(name: 'appsList', package: PACKAGE),
+          find_apps: Route::factory(name: 'findByProperties', package: PACKAGE),
+          login_app: Route::factory(name: 'loginApp', package: PACKAGE, verb: Route::Verbs::GET),
+          login_snippet: Route::factory(name: 'loginSnippet', package: PACKAGE, verb: Route::Verbs::GET),
+          su: Route::factory(name: 'su', package: PACKAGE, accept: Route::Types::PLAIN)
+        }
+      end
+
+      def app_detail(options = {})
+        app_id = options[:app_id]
+        body = { 
+          clientId: client_id,
+          appId: app_id
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('app') { {} })
+        end
+      end
+
+      def list_apps(options = {})
+        criteria = options.fetch(:criteria) { {} }
+        body = { 
+          clientId: client_id,
+          criteria: criteria
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('apps') { [] })
+        end
+      end
+
+      def find_apps(options = {})
+        criteria = options.fetch(:criteria) { {} }
+        body = { 
+          clientId: client_id,
+          criteria: criteria
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('apps') { [] })
+        end
+      end
+
+      def login_app(options = {})
+        app_id = options[:app_id]
+        query = {
+          clientId: client_id,
+          appId: app_id
+        }
+        route(to: __callee__, query: query, token_id: token_id, dash: false) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('app') { {} })
+        end
+      end
+
+      def login_snippet(options = {})
+        app_id = options[:app_id]
+        snippet_id = options[:snippet_id]
+        query = {
+          clientId: client_id,
+          appId: app_id,
+          snippetId: snippet_id,
+        }
+        route(to: __callee__, query: query, token_id: token_id, dash: false) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('snippet') { {} })
+        end
+      end
+
+      def su(options = {})
+        app_id = options[:app_id]
+        username = options[:username]
+        body = { 
+          clientId: client_id,
+          appId: app_id,
+          username: username
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body)
+        end
+      end
+    end
+  end
+end

data/lib/thron/gateway/apps_admin.rb

@@ -0,0 +1,153 @@
+require 'thron/gateway/session'
+
+module Thron
+  module Gateway
+    class AppsAdmin < Session
+
+      PACKAGE = Package.new(:xadmin, :resources, self.service_name)
+
+      def self.routes
+        @routes ||= {
+          add_group_app: Route::factory(name: 'addGroupApp', package: PACKAGE),
+          add_snippet: Route::factory(name: 'addSnippet', package: PACKAGE),
+          add_user_app: Route::factory(name: 'addUserApp', package: PACKAGE),
+          create_app: Route::factory(name: 'create', package: PACKAGE),
+          remove_app: Route::factory(name: 'remove', package: PACKAGE),
+          remove_group_app: Route::factory(name: 'removeGroupApp', package: PACKAGE),
+          remove_snippet: Route::factory(name: 'removeSnippet', package: PACKAGE),
+          remove_user_app: Route::factory(name: 'removeUserApp', package: PACKAGE),
+          update_app: Route::factory(name: 'updateApp', package: PACKAGE),
+          update_snippet: Route::factory(name: 'updateSnippet', package: PACKAGE)
+        }
+      end
+
+      def add_group_app(options = {})
+        app_id = options[:app_id]
+        group_id = options[:group_id]
+        capabilities = options[:capabilities]
+        body = { 
+          clientId: client_id,
+          appId: app_id,
+          groupId: group_id,
+          userCaps: capabilities
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def add_snippet(options = {})
+        app_id = options[:app_id]
+        data = options[:data]
+        capabilities = options[:capabilities]
+        body = { 
+          clientId: client_id,
+          appId: app_id,
+          snippet: data,
+          caps: capabilities
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('snippet') { {} })
+        end
+      end
+
+      def add_user_app(options = {})
+        app_id = options[:app_id]
+        username = options[:username]
+        capabilities = options[:capabilities]
+        body = { 
+          clientId: client_id,
+          appId: app_id,
+          username: username,
+          userCaps: capabilities
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def create_app(options = {})
+        data = options[:data]
+        options = options.fetch(:options) { {} }
+        body = { 
+          clientId: client_id,
+          app: data,
+          options: options
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('app') { {} })
+        end
+      end
+
+      def remove_app(options = {})
+        app_id = options[:app_id]
+        body = { 
+          clientId: client_id,
+          appId: app_id
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def remove_group_app(options = {})
+        app_id = options[:app_id]
+        group_id = options[:group_id]
+        body = { 
+          clientId: client_id,
+          appId: app_id,
+          groupId: group_id
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def remove_snippet(options = {})
+        app_id = options[:app_id]
+        snippet_id = options[:snippet_id]
+        body = { 
+          clientId: client_id,
+          appId: app_id,
+          snippetId: snippet_id
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def remove_user_app(options = {})
+        app_id = options[:app_id]
+        username = options[:username]
+        body = { 
+          clientId: client_id,
+          appId: app_id,
+          username: username
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def update_app(options = {})
+        app_id = options[:app_id]
+        data = options[:data]
+        capabilities = options[:capabilities]
+        body = { 
+          clientId: client_id,
+          appId: app_id,
+          update: data,
+          caps: capabilities
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('app') { {} })
+        end
+      end
+
+      def update_snippet(options = {})
+        app_id = options[:app_id]
+        snippet_id = options[:snippet_id]
+        data = options[:data]
+        capabilities = options[:capabilities]
+        body = { 
+          clientId: client_id,
+          appId: app_id,
+          snippetId: snippet_id,
+          snippet: data,
+          caps: capabilities
+        }
+        route(to: __callee__, body: body, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('snippet') { {} })
+        end
+      end
+    end
+  end
+end

data/lib/thron/gateway/base.rb

@@ -0,0 +1,41 @@
+require 'httparty'
+require 'thron/entity/base'
+require 'thron/routable'
+
+module Thron
+  module Gateway
+    Package = Struct::new(:name, :domain, :service) do
+      def to_s
+        "#{name}/#{domain}/#{service}"
+      end
+    end
+
+    class NoActiveSessionError < StandardError; end
+
+    class Base
+      include Routable
+
+      base_uri "#{Config::thron::protocol}://#{Config::thron.client_id}-view.4me.it/api"
+
+      NO_ACTIVE_SESSION = "Please provide a valid token ID"
+
+      def self.service_name
+        self.name.split('::').last.downcase
+      end
+
+      def self.client_id
+        @client_id ||= Config.thron.client_id
+      end
+
+      attr_accessor :token_id
+
+      def client_id
+        self.class.client_id
+      end
+
+      def check_session
+        fail NoActiveSessionError, NO_ACTIVE_SESSION unless token_id
+      end
+    end
+  end
+end

data/lib/thron/gateway/category.rb

@@ -0,0 +1,210 @@
+require 'thron/gateway/session'
+
+module Thron
+  module Gateway
+    class Category < Session
+
+      PACKAGE = Package.new(:xcontents, :resources, self.service_name)
+
+      paginate :find_categories
+
+      def self.routes
+        @routes ||= {
+          create_category: Route::factory(name: 'createCategory', package: PACKAGE),
+          create_system_category: Route::factory(name: 'createSystemCategory', package: PACKAGE),
+          add_category_for_locale: Route::factory(name: 'addCategory4Locale', package: PACKAGE),
+          add_category_pretty_id: Route::factory(name: 'addCategoryPrettyId', package: PACKAGE),
+          find_categories: Route::factory(name: 'findByProperties2', package: PACKAGE),
+          category_detail: Route::factory(name: 'getCategory', package: PACKAGE, verb: Route::Verbs::GET),
+          remove_category: Route::factory(name: 'removeCategory', package: PACKAGE),
+          remove_category_for_locale: Route::factory(name: 'removeCategory4Locale', package: PACKAGE),
+          remove_category_pretty_id: Route::factory(name: 'removeCategoryPrettyId', package: PACKAGE),
+          set_parent_category: Route::factory(name: 'setParentId', package: PACKAGE),
+          update_category: Route::factory(name: 'updateCategory', package: PACKAGE),
+          update_category_for_locale: Route::factory(name: 'updateCategory4Locale', package: PACKAGE),
+          update_category_pretty_id: Route::factory(name: 'updateCategoryPrettyId', package: PACKAGE)
+        }
+      end
+
+      def create_category(options = {})
+        parent_id = options[:parent_id]
+        locale = options[:locale]
+        is_private = options.fetch(:is_private) { false }
+        solution = options[:solution]
+        data = options[:data]
+        body = { 
+          client: {
+            clientId: client_id
+          },
+          upCatId: parent_id,
+          catLocales: locale,
+          isPrivate: is_private,
+          private: is_private,
+          solution: solution,
+          options: data
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def create_system_category(options = {})
+        category_id = options[:category_id]
+        parent_id = options[:parent_id]
+        locale = options[:locale]
+        data = options[:data]
+        body = { 
+          client: {
+            clientId: client_id
+          },
+          newCategoryId: category_id,
+          upCatId: parent_id,
+          catLocales: locale,
+          options: data
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def add_category_for_locale(options = {})
+        category_id = options[:category_id]
+        locale = options[:locale]
+        body = { 
+          client: {
+            clientId: client_id
+          },
+          catId: category_id,
+          catLocale: locale
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def add_category_pretty_id(options = {})
+        category_id = options[:category_id]
+        pretty_id = options[:pretty_id]
+        body = { 
+          clientId: client_id,
+          categoryId: category_id,
+          prettyId: pretty_id
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def find_categories(options = {})
+        criteria = options.fetch(:criteria) { {} }
+        locale = options[:locale]
+        order_by = options[:order_by]
+        offset = options[:offset].to_i
+        limit = options[:limit].to_i
+        body = { 
+          client: {
+            clientId: client_id
+          },
+          properties: criteria,
+          locale: locale,
+          orderBy: 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('categories') { [] })
+        end
+      end
+
+      def category_detail(options = {})
+        category_id = options[:category_id]
+        recursive = options.fetch(:recursive) { false }
+        locale = options[:locale]
+        query = { 
+          clientId: client_id,
+          categoryId: category_id,
+          cascade: recursive,
+          locale: locale
+        }
+        route(to: __callee__, query: query, token_id: token_id) do |response|
+          response.body = Entity::Base::factory(response.body.fetch('category') { {} })
+        end
+      end
+
+      def remove_category(options = {})
+        category_id = options[:category_id]
+        recursive = options.fetch(:recursive) { false }
+        query = { 
+          clientId: client_id,
+          catId: category_id,
+          cascade: recursive
+        }
+        route(to: __callee__, query: query, token_id: token_id, dash: false)
+      end
+
+      def remove_category_for_locale(options = {})
+        category_id = options[:category_id]
+        locale = options[:locale]
+        body = { 
+          client: {
+            clientId: client_id
+          },
+          catId: category_id,
+          locale: locale
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def remove_category_pretty_id(options = {})
+        category_id = options[:category_id]
+        locale = options[:locale]
+        body = { 
+          clientId: client_id,
+          categoryId: category_id,
+          locale: locale
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def set_parent_category(options = {})
+        category_id = options[:category_id]
+        parent_id = options[:parent_id]
+        query = { 
+          clientId: client_id,
+          categoryId: category_id,
+          categoryParentId: parent_id
+        }
+        route(to: __callee__, query: query, token_id: token_id, dash: false)
+      end
+
+      def update_category(options = {})
+        category_id = options[:category_id]
+        data = options[:data]
+        body = { 
+          client: {
+            clientId: client_id
+          },
+          categoryId: category_id,
+          update: data
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def update_category_for_locale(options = {})
+        category_id = options[:category_id]
+        locale = options[:locale]
+        body = { 
+          client: {
+            clientId: client_id
+          },
+          catId: category_id,
+          property: locale
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+
+      def update_category_pretty_id(options = {})
+        category_id = options[:category_id]
+        pretty_id = options[:pretty_id]
+        body = { 
+          clientId: client_id,
+          categoryId: category_id,
+          prettyId: pretty_id
+        }
+        route(to: __callee__, body: body, token_id: token_id)
+      end
+    end
+  end
+end