xip 0.0.1 → 2.0.0.beta2

data/lib/xip/controller/nlp.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Xip
+  class Controller
+    module Nlp
+
+      extend ActiveSupport::Concern
+
+      included do
+        # Memoized in order to prevent multiple requests to the NLP provider
+        def perform_nlp!
+          Xip::Logger.l(
+            topic: :nlp,
+            message: "User #{current_session_id} -> Performing NLP."
+          )
+
+          unless Xip.config.nlp_integration.present?
+            raise Xip::Errors::ConfigurationError, "An NLP integration has not yet been configured (Xip.config.nlp_integration)"
+          end
+
+          @nlp_result ||= begin
+            nlp_client = nlp_client_klass.new
+            @nlp_result = @current_message.nlp_result = nlp_client.understand(
+              query: current_message.message
+            )
+
+            if Xip.config.log_all_nlp_results
+              Xip::Logger.l(
+                topic: :nlp,
+                message: "User #{current_session_id} -> NLP Result: #{@nlp_result.parsed_result.inspect}"
+              )
+            end
+
+            @nlp_result
+          end
+        end
+
+        private
+
+        def nlp_client_klass
+          integration = Xip.config.nlp_integration.to_s.titlecase
+          klass = "Xip::Nlp::#{integration}::Client"
+          klass.classify.constantize
+        end
+      end
+
+    end
+  end
+end

data/lib/xip/controller/replies.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+module Xip
+  class Controller
+    module Replies
+
+      extend ActiveSupport::Concern
+
+      included do
+
+        class_attribute :_preprocessors, default: [:erb]
+        class_attribute :_replies_path, default: [Xip.root, 'bot', 'replies']
+
+        def send_replies(custom_reply: nil, inline: nil)
+          service_reply = load_service_reply(
+            custom_reply: custom_reply,
+            inline: inline
+          )
+
+          # Determine if we start at the beginning or somewhere else
+          reply_range = calculate_reply_range
+          offset = reply_range.first
+
+          @previous_reply = nil
+          service_reply.replies.slice(reply_range).each_with_index do |reply, i|
+            # Updates the lock with the current position of the reply
+            lock_session!(
+              session_slug: current_session.get_session,
+              position: i + offset # Otherwise this won't account for explicit starting points
+            )
+
+            begin
+              send_reply(reply: reply)
+            rescue Xip::Errors::UserOptOut => e
+              user_opt_out_handler(msg: e.message)
+              return
+            rescue Xip::Errors::InvalidSessionID => e
+              invalid_session_id_handler(msg: e.message)
+              return
+            end
+
+            @previous_reply = reply
+          end
+
+          @progressed = :sent_replies
+        ensure
+          release_lock!
+        end
+
+        private
+
+          def send_reply(reply:)
+            if !reply.delay? && Xip.config.auto_insert_delays
+              # if it's the first reply in the service_reply or the previous reply
+              # wasn't a custom delay, then insert a delay
+              if @previous_reply.blank? || !@previous_reply.delay?
+                send_reply(reply: Reply.dynamic_delay)
+              end
+            end
+
+            # Support randomized replies for text and speech replies.
+            # We select one before handing the reply off to the driver.
+            if reply['text'].is_a?(Array)
+              reply['text'] = reply['text'].sample
+            end
+
+            handler = reply_handler.new(
+              recipient_id: current_message.sender_id,
+              reply: reply
+            )
+
+            translated_reply = handler.send(reply.reply_type)
+            client = service_client.new(reply: translated_reply)
+            client.transmit
+
+            log_reply(reply) if Xip.config.transcript_logging
+
+            # If this was a 'delay' type of reply, we insert the delay
+            if reply.delay?
+              insert_delay(duration: reply['duration'])
+            end
+          end
+
+          def insert_delay(duration:)
+            begin
+              sleep_duration = if duration == 'dynamic'
+                dyn_duration = dynamic_delay(previous_reply: @previous_reply)
+
+                Xip.config.dynamic_delay_muliplier * dyn_duration
+              else
+                Float(duration)
+              end
+
+              sleep(sleep_duration)
+            rescue ArgumentError, TypeError
+              raise(ArgumentError, 'Invalid duration specified. Duration must be a Numeric')
+            end
+          end
+
+          def load_service_reply(custom_reply:, inline:)
+            if inline.present?
+              Xip::ServiceReply.new(
+                recipient_id: current_session_id,
+                yaml_reply: inline,
+                preprocessor: :none,
+                context: nil
+              )
+            else
+              yaml_reply, preprocessor = action_replies(custom_reply)
+
+              Xip::ServiceReply.new(
+                recipient_id: current_session_id,
+                yaml_reply: yaml_reply,
+                preprocessor: preprocessor,
+                context: binding
+              )
+            end
+          end
+
+          def service_client
+            begin
+              Kernel.const_get("Xip::Services::#{current_service.classify}::Client")
+            rescue NameError
+              raise(Xip::Errors::ServiceNotRecognized, "The service '#{current_service}' was not recognized")
+            end
+          end
+
+          def reply_handler
+            begin
+              Kernel.const_get("Xip::Services::#{current_service.classify}::ReplyHandler")
+            rescue NameError
+              raise(Xip::Errors::ServiceNotRecognized, "The service '#{current_service}' was not recognized")
+            end
+          end
+
+          def replies_folder
+            current_session.flow_string.underscore.pluralize
+          end
+
+          def reply_dir
+            [*self._replies_path, replies_folder]
+          end
+
+          def base_reply_filename
+            "#{current_session.state_string}.yml"
+          end
+
+          def reply_filenames(custom_reply_filename=nil)
+            reply_filename = if custom_reply_filename.present?
+              custom_reply_filename
+            else
+              base_reply_filename
+            end
+
+            service_filename = [reply_filename, current_service].join('+')
+
+            # Service-specific filenames take precedance (returned first)
+            [service_filename, reply_filename]
+          end
+
+          def find_reply_and_preprocessor(custom_reply)
+            selected_preprocessor = :none
+
+            if custom_reply.present?
+              dir_and_file = custom_reply.rpartition(File::SEPARATOR)
+              _dir = dir_and_file.first
+              _file = "#{dir_and_file.last}.yml"
+              _replies_dir = [*self._replies_path, _dir]
+              possible_filenames = reply_filenames(_file)
+              reply_file_path = File.join(_replies_dir, _file)
+              service_reply_path = File.join(_replies_dir, reply_filenames(_file).first)
+            else
+              _replies_dir = *reply_dir
+              possible_filenames = reply_filenames
+              reply_file_path = File.join(_replies_dir, base_reply_filename)
+              service_reply_path = File.join(_replies_dir, reply_filenames.first)
+            end
+
+            # Check if the service_filename exists
+            # If so, we can skip checking for a preprocessor
+            if File.exist?(service_reply_path)
+              return service_reply_path, selected_preprocessor
+            end
+
+            # Cycles through possible preprocessor and variant combinations
+            # Early returns for performance
+            for preprocessor in self.class._preprocessors do
+              for reply_filename in possible_filenames do
+                selected_filepath = File.join(_replies_dir, [reply_filename, preprocessor.to_s].join('.'))
+                if File.exist?(selected_filepath)
+                  reply_file_path = selected_filepath
+                  selected_preprocessor = preprocessor
+                  return reply_file_path, selected_preprocessor
+                end
+              end
+            end
+
+            return reply_file_path, selected_preprocessor
+          end
+
+          def action_replies(custom_reply=nil)
+            reply_path, selected_preprocessor = find_reply_and_preprocessor(custom_reply)
+
+            begin
+              file_contents = File.read(reply_path)
+            rescue Errno::ENOENT
+              raise(Xip::Errors::ReplyNotFound, "Could not find reply: '#{reply_path}'")
+            end
+
+            return file_contents, selected_preprocessor
+          end
+
+          def user_opt_out_handler(msg:)
+            if self.respond_to?(:handle_opt_out, true)
+              self.send(:handle_opt_out)
+              Xip::Logger.l(
+                topic: current_service,
+                message: "User #{current_session_id} opted out. [#{msg}]"
+              )
+            else
+              Xip::Logger.l(
+                topic: :err,
+                message: "User #{current_session_id} unhandled exception due to opt-out."
+              )
+            end
+
+            do_nothing
+          end
+
+          def invalid_session_id_handler(msg:)
+            if self.respond_to?(:handle_invalid_session_id, true)
+              self.send(:handle_invalid_session_id)
+              Xip::Logger.l(
+                topic: current_service,
+                message: "User #{current_session_id} has an invalid session_id. [#{msg}]"
+              )
+            else
+              Xip::Logger.l(
+                topic: :err,
+                message: "User #{current_session_id} unhandled exception due to invalid session_id."
+              )
+            end
+
+            do_nothing
+          end
+
+          def calculate_reply_range
+            # if an explicit starting point is specified, use that until the
+            # end of the range, otherwise start at the beginning
+            if @pos.present?
+              (@pos..-1)
+            else
+              (0..-1)
+            end
+          end
+
+          def log_reply(reply)
+            message = case reply.reply_type
+                      when 'text'
+                        reply['text']
+                      when 'speech'
+                        reply['speech']
+                      when 'ssml'
+                        reply['ssml']
+                      when 'delay'
+                        '<typing indicator>'
+                      else
+                        "<#{reply.reply_type}>"
+                      end
+
+            Xip::Logger.l(
+              topic: current_service,
+              message: "User #{current_session_id} -> Sending: #{message}"
+            )
+          end
+
+      end # instance methods
+
+    end
+  end
+end

data/lib/xip/controller/unrecognized_message.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Xip
+  class Controller
+    module UnrecognizedMessage
+
+      extend ActiveSupport::Concern
+
+      included do
+
+        def run_unrecognized_message(err:)
+          err_message = "The message \"#{current_message.message}\" was not recognized in the original context."
+
+          Xip::Logger.l(
+            topic: 'unrecognized_message',
+            message: err_message
+          )
+
+          unless defined?(UnrecognizedMessagesController)
+            Xip::Logger.l(
+              topic: 'unrecognized_message',
+              message: 'Running catch_all; UnrecognizedMessagesController not defined.'
+            )
+
+            run_catch_all(err: err)
+            return false
+          end
+
+          unrecognized_msg_controller = UnrecognizedMessagesController.new(
+            service_message: current_message
+          )
+
+          begin
+            # Run handle_unrecognized_message action
+            unrecognized_msg_controller.handle_unrecognized_message
+
+            if unrecognized_msg_controller.progressed?
+              Xip::Logger.l(
+                topic: 'unrecognized_message',
+                message: 'A match was detected. Skipping catch-all.'
+              )
+            else
+              # Log, but we don't want to run the catch_all for a poorly
+              # coded UnrecognizedMessagesController
+              Xip::Logger.l(
+                topic: 'unrecognized_message',
+                message: 'Did not send replies, update session, or step'
+              )
+            end
+          rescue StandardError => e
+            # Run the catch_all directly since we're already in an unrecognized
+            # message state
+            run_catch_all(err: e)
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/xip/core_ext.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir.glob(File.expand_path('core_ext/*.rb', __dir__)).each do |path|
+  require path
+end

data/lib/xip/core_ext/numeric.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Numeric
+
+  def states
+    self
+  end
+  alias :state :states
+
+end

data/lib/xip/core_ext/string.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class String
+
+  EXCLUDED_CHARS = %w[" ' . , ! ? ( ) - _ ` ‘ ’ “ ”].freeze
+  EXCLUDED_CHARS_ESC = EXCLUDED_CHARS.map { |c| "\\#{c}" }
+  EXCLUDED_CHARS_RE = /#{EXCLUDED_CHARS_ESC.join('|')}/
+
+  # Removes blank padding and double+single quotes
+  def normalize
+    self.upcase.strip
+  end
+
+  def without_punctuation
+    self.gsub(EXCLUDED_CHARS_RE, '')
+  end
+
+end

data/lib/xip/dispatcher.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Xip
+
+  # Responsible for coordinating incoming messages
+  #  1. Receives incoming request params
+  #  2. Initializes respective service request handler
+  #  3. Processes params through service request handler (might be async)
+  #  4. Inits base XipController with state params returned from the service
+  #     request handler
+  #  5. Returns an HTTP response to be returned to the requestor
+  class Dispatcher
+
+    attr_reader :service, :params, :headers, :message_handler
+
+    def initialize(service:, params:, headers:)
+      @service = service
+      @params = params
+      @headers = headers
+      @message_handler = message_handler_klass.new(
+        params: params,
+        headers: headers
+      )
+    end
+
+    def coordinate
+      message_handler.coordinate
+    end
+
+    def process
+      service_message = message_handler.process
+
+      if Xip.config.transcript_logging
+        log_incoming_message(service_message)
+      end
+
+      bot_controller = BotController.new(service_message: service_message)
+      bot_controller.route
+    end
+
+    private
+
+      def message_handler_klass
+        begin
+          Kernel.const_get("Xip::Services::#{service.classify}::MessageHandler")
+        rescue NameError
+          raise(Xip::Errors::ServiceNotRecognized, "The service '#{service}' was not recognized")
+        end
+      end
+
+      def log_incoming_message(service_message)
+        message = if service_message.location.present?
+                    "Received: <user shared location>"
+                  elsif service_message.attachments.present?
+                    "Received: <user sent attachment>"
+                  elsif service_message.payload.present?
+                    "Received Payload: #{service_message.payload}"
+                  else
+                    "Received Message: #{service_message.message}"
+                  end
+
+        Xip::Logger.l(
+          topic: 'user',
+          message: "User #{service_message.sender_id} -> #{message}"
+        )
+      end
+  end
+end