docomo-nlu 0.1.1

data/lib/docomo-nlu.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'docomo-nlu/version'
+require 'docomo-nlu/config'
+require 'activeresource'
+require 'faraday'
+
+module DocomoNlu
+  autoload :Spontaneous,  'docomo-nlu/spontaneous'
+  autoload :Management,   'docomo-nlu/management'
+end

data/lib/docomo-nlu/config.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'active_support/configurable'
+module DocomoNlu
+  def self.configure
+    yield @config ||= DocomoNlu::Configuration.new
+  end
+
+  def self.config
+    @config
+  end
+
+  class Configuration
+    include ActiveSupport::Configurable
+    config_accessor :nlu_host
+    config_accessor :nlu_version
+    config_accessor :admin_access_token
+  end
+
+  configure do |config|
+    config.nlu_host = 'http://nlu-external-dev-977165653.ap-northeast-1.elb.amazonaws.com'
+    config.nlu_version = 'v2.2'
+    config.admin_access_token = 'NLP f68518ed5a40907ec6b754caeaadc32b0af4920f69955c22749e38e17946ea57'
+  end
+end

data/lib/docomo-nlu/management.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module DocomoNlu
+  module Management
+    autoload :Account,            'docomo-nlu/management/account'
+    autoload :AIMLBase,           'docomo-nlu/management/aiml_base'
+    autoload :Base,               'docomo-nlu/management/base'
+    autoload :Bot,                'docomo-nlu/management/bot'
+    autoload :Config,             'docomo-nlu/management/config'
+    autoload :DefaultPredicate,   'docomo-nlu/management/default_predicate'
+    autoload :MultipartBase,      'docomo-nlu/management/multipart_base'
+    autoload :Map,                'docomo-nlu/management/map'
+    autoload :NGWord,             'docomo-nlu/management/ng_word'
+    autoload :OKWord,             'docomo-nlu/management/ok_word'
+    autoload :OrganizationMember, 'docomo-nlu/management/organization_member'
+    autoload :Organization,       'docomo-nlu/management/organization'
+    autoload :PredicateName,      'docomo-nlu/management/predicate_name'
+    autoload :ProjectMember,      'docomo-nlu/management/project_member'
+    autoload :Project,            'docomo-nlu/management/project'
+    autoload :Property,           'docomo-nlu/management/property'
+    autoload :Provider,           'docomo-nlu/management/provider'
+    autoload :ScenarioProject,    'docomo-nlu/management/scenario_project'
+    autoload :ScenarioUtil,       'docomo-nlu/management/scenario_util'
+    autoload :Scenario,           'docomo-nlu/management/scenario'
+    autoload :Set,                'docomo-nlu/management/set'
+    autoload :TaskProject,        'docomo-nlu/management/task_project'
+  end
+end

data/lib/docomo-nlu/management/account.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module DocomoNlu
+  module Management
+    class Account < Base
+      self.element_name = 'accounts'
+      self.prefix = "/management/#{DocomoNlu.config.nlu_version}/"
+
+      # Parameter for create
+      # {
+      #     "accountName": "your account name",
+      #     "password": "your account password",
+      #     "description": "account description",
+      #     "authorization": 2,
+      #     "enable": true
+      # }
+
+      def self.count
+        response_body = JSON.parse(connection.get("#{prefix}#{element_name}/count", headers).body)
+        response_body['count']
+      end
+
+      def to_json(options = {})
+        attributes.delete('accountId')
+        attributes.delete('createDate')
+        attributes.delete('loginDate')
+        attributes.delete('id')
+        super
+      end
+    end
+  end
+end

data/lib/docomo-nlu/management/aiml_base.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+# download([:aiml,:dat,:archive],scenarioId)
+# GET /{projectId}/bots/{botId}/aiml/{scenarioId}
+# GET /{projectId}/bots/{botId}/dat
+# GET /{projectId}/bots/{botId}/archive
+
+# upload([:aiml,:dat,:archive],filepath)
+# /{projectId}/bots/{botId}/aiml
+# /{projectId}/bots/{botId}/dat
+# /{projectId}/bots/{botId}/archive
+
+# Not supported
+# GET /{projectId}/bots/{botId}/archive/aiml
+
+require 'tempfile'
+module DocomoNlu
+  module Management
+    class AIMLBase < Base
+      def download(extra_path = '')
+        prefix_options[:bot_id] ||= botId
+        @attributes[:file] = self.class.download(prefix_options, extra_path).file
+      end
+
+      def upload(file)
+        prefix_options[:bot_id] ||= botId
+        self.class.upload(file, prefix_options)
+      end
+
+      def compile
+        prefix_options[:bot_id] ||= botId
+        self.class.compile(prefix_options)
+      end
+
+      def transfer
+        prefix_options[:bot_id] ||= botId
+        self.class.deploy_request(prefix_options)
+      end
+
+      def deploy
+        prefix_options[:bot_id] ||= botId
+        self.class.deploy(prefix_options)
+      end
+
+      class << self
+        def download(prefix_options, extra_path = '')
+          conn = Faraday.new(url: site.to_s, ssl: { verify: false }) do |builder|
+            builder.adapter :net_http
+          end
+          conn.headers['Authorization'] = access_token
+          response = conn.get("#{FileModel.collection_path(prefix_options)}/#{extra_path}")
+
+          if check_response(response)
+            instantiate_record({}, prefix_options).tap do |record|
+              record.file = Tempfile.open(['docomo-nlu', ".#{prefix_options[:method].to_s.gsub(/archive/, 'zip')}"]) do |f|
+                f.write response.body
+                f
+              end
+            end
+          end
+        end
+
+        def upload(file, prefix_options)
+          conn = Faraday.new(url: site.to_s, ssl: { verify: false }) do |builder|
+            builder.request :multipart # マルチパートでデータを送信
+            builder.request :url_encoded
+            builder.adapter :net_http
+          end
+          conn.headers['Authorization'] = access_token
+          params = {
+            uploadFile: Faraday::UploadIO.new(file.path, 'text/plain')
+          }
+          response = conn.put FileModel.collection_path(prefix_options), params
+          check_response(response)
+        end
+
+        def compile(prefix_options)
+          return if deploy_request(:compile, prefix_options)  != ''
+        end
+
+        def transfer(prefix_options)
+          return if deploy_request(:transfer, prefix_options) != ''
+        end
+
+        def deploy_request(method, prefix_options)
+          response_body = JSON.parse(connection.post(Scenario.element_path(method, prefix_options), '', headers).body)
+          # Sometimes, API returns wrong url, replace correct path.
+          URI.parse(response_body['statusUri']).path.gsub!(/NLPManagementAPI/, "management/#{DocomoNlu.config.nlu_version}")
+        end
+
+        def deploy(prefix_options)
+          # compile and status check
+          compile_status = false
+          check_path = deploy_request(:compile, prefix_options)
+          while check_path && compile_status != 'Completed'
+            sleep(0.2)
+            compile_status = check_status(:compile, check_path)
+            raise ActiveResource::ServerError if %w[ErrorFinish NotCompiled].include?(compile_status)
+          end
+
+          # transfer and status check
+          transfer_status = false
+          check_path = deploy_request(:transfer, prefix_options)
+          while check_path && transfer_status != 'Completed'
+            sleep(0.2)
+            transfer_status = check_status(:transfer, check_path)
+            raise ActiveResource::ServerError if %w[ErrorFinish NotTransfered].include?(transfer_status)
+          end
+          true
+        end
+
+        def check_status(method, path)
+          case method
+          when :compile   then JSON.parse(connection.get(path, headers).body)['status']
+          when :transfer  then JSON.parse(connection.get(path, headers).body)['transferStatusResponses'][0]['status']
+          end
+        end
+      end
+
+      class FileModel < Base
+        self.element_name = ''
+        self.prefix = "/management/#{DocomoNlu.config.nlu_version}/projects/:project_id/bots/:bot_id/:method"
+      end
+    end
+  end
+end

data/lib/docomo-nlu/management/base.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module DocomoNlu
+  module Management
+    class Base < ActiveResource::Base
+      ## For Dynamically generated headers via http://rmosolgo.github.io/blog/2014/02/05/dynamically-generated-headers-for-activeresource-requests/
+      cattr_accessor :static_headers
+      cattr_accessor :access_token
+
+      ## Dynamic headers
+      self.static_headers = headers
+
+      ## Admin Accesstoken
+      self.access_token = DocomoNlu.config.admin_access_token
+
+      ## Setting Endpoint.
+      self.site = DocomoNlu.config.nlu_host
+
+      ## Remove format in path (remove .json)
+      self.include_format_in_path = false
+
+      ## Setting Format
+      self.format = :json
+
+      ## Get NLPManagement's AccessToken.
+      def login(accountName, password)
+        request_body = { accountName: accountName, password: password }.to_json
+        response_body = JSON.parse(connection.post("/management/#{DocomoNlu.config.nlu_version}/login", request_body, self.class.headers).body)
+        self.access_token = response_body['accessToken']
+      end
+
+      ## Delete NLPManagement's AccessToken.
+      def logout
+        res = connection.get("/management/#{DocomoNlu.config.nlu_version}/logout", self.class.headers) if access_token.present?
+        raise ActiveResource::BadRequest, 'Invalid access token' unless res
+
+        self.access_token = nil
+        true
+      end
+
+      ## Override. Insert generated id to parameter 'id' after save or create
+      def id_from_response(response)
+        ActiveSupport::JSON.decode(response.body)["#{self.class.to_s.split('::').last.downcase!}Id"] if response.body.present?
+      end
+
+      class << self
+        def instantiate_collection(collection, original_params = {}, prefix_options = {})
+          if collection.is_a?(Hash)
+            collection = if collection.empty? || collection.first[1].nil?
+                           []
+                         else
+                           [collection]
+                         end
+          elsif collection[0].is_a?(String)
+            collection = [{ params: collection }]
+          end
+          super
+        end
+
+        def instantiate_record(record, prefix_options = {})
+          record = record[0] if record.is_a?(Array)
+          resource_id = record["#{to_s.split('::').last.downcase!}Id"]
+          record['id'] = resource_id if resource_id
+          super
+        end
+
+        def headers
+          new_headers = static_headers.clone
+          new_headers['Authorization'] = access_token
+          new_headers
+        end
+
+        def check_response(response)
+          case response.status
+          when 400       then raise ActiveResource::BadRequest, response
+          when 401       then raise ActiveResource::UnauthorizedAccess, response
+          when 403       then raise ActiveResource::ForbiddenAccess, response
+          when 404       then raise ActiveResource::ResourceNotFound, response
+          when 409       then raise ActiveResource::ResourceConflict, response
+          when 503       then raise ActiveResource::ServerError, response
+          when 200..204  then true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docomo-nlu/management/bot.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DocomoNlu
+  module Management
+    class Bot < AIMLBase
+      self.element_name = 'bots'
+      self.prefix = "/management/#{DocomoNlu.config.nlu_version}/projects/:project_id/"
+
+      # Parameter for create
+      # {
+      #   "botId": "botid",
+      #   "scenarioProjectId", "DSU",
+      #   "language": "ja-JP",
+      #   "description": "hello"
+      # }
+    end
+  end
+end

data/lib/docomo-nlu/management/config.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module DocomoNlu
+  module Management
+    class Config < Base
+      self.element_name = 'configs'
+      self.prefix = "/management/#{DocomoNlu.config.nlu_version}/projects/:project_id/bots/:bot_id/"
+
+      # {
+      #   "dialogTimeout": 300,
+      #   "replyTimeout": 300,
+      #   "xxxxUrl": "http://xxx",
+      #   "yyyyUrl": "http://xxx",
+      #   "sensitiveInfo": "aa.bb, ccc.ddd...",
+      #   "sraix" : [true|false],
+      #   "taskServerUrl": "http://xxx"
+      # }
+
+      def destroy(keys)
+        self.id = keys.join(',')
+        super()
+      end
+    end
+  end
+end

data/lib/docomo-nlu/management/default_predicate.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DocomoNlu
+  module Management
+    class DefaultPredicate < Base
+      self.element_name = 'defaultPredicates'
+      self.prefix = "/management/#{DocomoNlu.config.nlu_version}/projects/:project_id/bots/:bot_id/"
+
+      def destroy(keys)
+        self.id = keys.join(',')
+        super()
+      end
+    end
+  end
+end

data/lib/docomo-nlu/management/map.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module DocomoNlu
+  module Management
+    class Map < MultipartBase
+      self.element_name = 'maps'
+      self.prefix = "/management/#{DocomoNlu.config.nlu_version}/projects/:project_id/bots/:bot_id/"
+    end
+  end
+end

data/lib/docomo-nlu/management/multipart_base.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+module DocomoNlu
+  module Management
+    class MultipartBase < Base
+      def save
+        self.class.create(attributes[:file], prefix_options)
+      end
+
+      def destroy
+        self.id = try(:category)
+        super
+      end
+
+      class << self
+        def create(file, prefix_options)
+          check_prefix_options(prefix_options)
+          raise ActiveResource::BadRequest, '' unless file.instance_of?(File)
+
+          upload(file, prefix_options)
+        end
+
+        def find(*arguments)
+          scope   = arguments.slice!(0)
+          options = arguments.slice!(0) || {}
+
+          prefix_options, = split_options(options[:params])
+          check_prefix_options(prefix_options)
+
+          case scope
+          when :all then download(nil, prefix_options)
+          else download(scope, prefix_options)
+          end
+        end
+
+        def where(clauses = {})
+          raise ArgumentError, "expected a clauses Hash, got #{clauses.inspect}" unless clauses.is_a? Hash
+          category = clauses[:category]
+          find(category, params: clauses)
+        end
+
+        private
+
+        def download(category = nil, prefix_options)
+          extention = category.blank? ? '.zip' : '.map'
+
+          conn = Faraday.new(url: site.to_s, ssl: { verify: false }) do |builder|
+            builder.adapter :net_http
+          end
+          conn.headers['Authorization'] = access_token
+
+          response = conn.get(element_path(category, prefix_options))
+
+          if check_response(response)
+            instantiate_record({}, prefix_options).tap do |record|
+              record.file = Tempfile.open(['docomo-nlu', extention]) do |f|
+                f.write response.body
+                f
+              end
+              record.category = category
+            end
+          end
+        end
+
+        def upload(file, prefix_options)
+          conn = Faraday.new(url: site.to_s, ssl: { verify: false }) do |builder|
+            builder.request :multipart # マルチパートでデータを送信
+            builder.request :url_encoded
+            builder.adapter :net_http
+          end
+          conn.headers['Authorization'] = access_token
+          params = {
+            uploadFile: Faraday::UploadIO.new(file.path, 'text/plain')
+          }
+          response = conn.put collection_path(prefix_options), params
+          check_response(response)
+        end
+      end
+    end
+  end
+end