twilio-rails 1.0.0

data/lib/twilio/rails/phone/tree.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+module Twilio
+  module Rails
+    module Phone
+      # Implementation class for a phone tree. See {Twilio::Rails::Phone::BaseTree} for detailed documentation.
+      class Tree
+        attr_reader :name, :prompts, :config
+        attr_accessor :greeting, :unanswered_call, :finished_call
+
+        def initialize(tree_name)
+          @name = tree_name.to_s
+          raise Twilio::Rails::Phone::InvalidTreeError, "tree name cannot be blank" unless name.present?
+
+          @prompts = {}.with_indifferent_access
+          @config = {}.with_indifferent_access
+
+          # defaults
+          @config[:voice] = "male"
+          @config[:final_timeout_message] = "Goodbye."
+          @config[:final_timeout_attempts] = 3
+        end
+
+        # The fully qualified URL for the tree used by Twilio to make outbound calls.
+        #
+        # @return [String] The outbound URL for the phone tree.
+        def outbound_url
+          "#{ ::Twilio::Rails.config.host }#{ ::Twilio::Rails::Engine.routes.url_helpers.phone_outbound_path(tree_name: name, format: :xml) }"
+        end
+
+        # The fully qualified URL for the tree used by Twilio to be configured in the dashboard.
+        #
+        # @return [String] The inbound URL for the phone tree.
+        def inbound_url
+          "#{ ::Twilio::Rails.config.host }#{ ::Twilio::Rails::Engine.routes.url_helpers.phone_inbound_path(tree_name: name, format: :xml) }"
+        end
+
+        class Prompt
+          attr_reader :name, :messages, :gather, :after
+
+          def initialize(name:, message:, gather:, after:)
+            @name = name&.to_sym
+            raise Twilio::Rails::Phone::InvalidTreeError, "prompt name cannot be blank" if @name.blank?
+
+            @messages = if message.is_a?(Proc)
+              message
+            else
+              Twilio::Rails::Phone::Tree::MessageSet.new(message)
+            end
+
+            @gather = Twilio::Rails::Phone::Tree::Gather.new(gather) if gather.present?
+            @after = Twilio::Rails::Phone::Tree::After.new(after)
+          end
+        end
+
+        class After
+          attr_reader :messages, :prompt, :proc
+
+          def initialize(args)
+            case args
+            when Symbol, String
+              @prompt = args.to_sym
+            when Proc
+              @proc = args
+            when Hash
+              args = args.with_indifferent_access
+              @prompt = args[:prompt]&.to_sym
+              @hangup = !!args[:hangup]
+
+              @messages = if args[:message].is_a?(Proc)
+                args[:message]
+              else
+                Twilio::Rails::Phone::Tree::MessageSet.new(args[:message])
+              end
+
+              raise Twilio::Rails::Phone::InvalidTreeError, "cannot have both prompt: and hangup:" if @prompt && @hangup
+              raise Twilio::Rails::Phone::InvalidTreeError, "must have either prompt: or hangup:" unless @prompt || @hangup
+            else
+              raise Twilio::Rails::Phone::InvalidTreeError, "cannot parse :after from #{args.inspect}"
+            end
+          end
+
+          def hangup?
+            !!@hangup
+          end
+        end
+
+        class Gather
+          attr_reader :type, :args
+
+          def initialize(args)
+            case args
+            when Proc
+              @proc = args
+            when Hash
+              @args = args.with_indifferent_access
+              @type = @args.delete(:type)&.to_sym
+
+              raise Twilio::Rails::Phone::InvalidTreeError, "gather :type must be :digits, :voice, or :speech but was #{@type.inspect}" unless [:digits, :voice, :speech].include?(@type)
+
+              if digits?
+                @args[:timeout] ||= 5
+                @args[:number] ||= 1
+              elsif voice?
+                @args[:length] ||= 10
+                @args[:beep] = true unless @args.key?(:beep)
+                @args[:transcribe] = false unless @args.key?(:transcribe)
+                @args[:profanity_filter] = false unless @args.key?(:profanity_filter)
+              elsif speech?
+                @args[:language] ||= "en-US"
+              else
+                raise Twilio::Rails::Phone::InvalidTreeError, "gather :type must be :digits, :voice, or :speech but was #{@type.inspect}"
+              end
+            else
+              raise Twilio::Rails::Phone::InvalidTreeError, "cannot parse :gather from #{args.inspect}"
+            end
+          end
+
+          def digits?
+            type == :digits
+          end
+
+          def voice?
+            type == :voice
+          end
+
+          def speech?
+            type == :speech
+          end
+
+          def interrupt?
+            if @args.key?(:interrupt)
+              !!@args[:interrupt]
+            else
+              false
+            end
+          end
+        end
+
+        class Message
+          attr_reader :value, :voice, :block
+
+          def initialize(say: nil, play: nil, pause: nil, voice: nil, &block)
+            @say = say.presence
+            @play = play.presence
+            @pause = pause.presence.to_i
+            @pause = nil if @pause == 0
+            @voice = voice.presence
+            @block = block if block_given?
+
+            raise Twilio::Rails::Phone::InvalidTreeError, "must only have one of say: play: pause:" if (@say && @play) || (@say && @pause) || (@play && @pause)
+            raise Twilio::Rails::Phone::InvalidTreeError, "say: must be a string or proc" if @say && !(@say.is_a?(String) || @say.is_a?(Proc))
+            raise Twilio::Rails::Phone::InvalidTreeError, "play: must be a string or proc" if @play && !(@play.is_a?(String) || @play.is_a?(Proc))
+            raise Twilio::Rails::Phone::InvalidTreeError, "play: be a valid url but is #{ @play }" if @play && @play.is_a?(String) && !@play.match(/^https?:\/\/.+/)
+            raise Twilio::Rails::Phone::InvalidTreeError, "pause: must be over zero but is #{ @pause }" if @pause && @pause <= 0
+            raise Twilio::Rails::Phone::InvalidTreeError, "block is only valid for say:" if block_given? && (@play || @pause)
+          end
+
+          def say?
+            !!(@say || @block)
+          end
+
+          def play?
+            !!@play
+          end
+
+          def pause?
+            !!@pause
+          end
+
+          def value
+            @say || @play || @pause
+          end
+        end
+
+        class MessageSet
+          include Enumerable
+
+          def initialize(set)
+            @messages = []
+
+            # This whole chunk here feels like an incorrect level of abstraction. That it should be the caller's responsbiility
+            # to pass in the contents of `message:` and not a hash with `message:` as a key. But maybe it's ok to do it once
+            # here so the callsites can be cleaner passthroughs without doing the checks over and over.
+            if set.is_a?(Hash)
+              set = set.symbolize_keys
+              if set.key?(:message)
+                raise Twilio::Rails::Phone::InvalidTreeError, "MessageSet should never receive a hash with any key other than :message but received #{ set }" if set.keys != [:message]
+                set = set[:message]
+              end
+            end
+
+            set = [set] unless set.is_a?(Array)
+            set.each do |message|
+              next nil if message.blank?
+
+              if message.is_a?(Twilio::Rails::Phone::Tree::Message)
+                @messages << message
+              elsif message.is_a?(Proc)
+                @messages << message
+              elsif message.is_a?(String)
+                @messages << Twilio::Rails::Phone::Tree::Message.new(say: message)
+              elsif message.is_a?(Hash)
+                @messages << Twilio::Rails::Phone::Tree::Message.new(**message.symbolize_keys)
+              else
+                raise Twilio::Rails::Phone::InvalidTreeError, "message value #{ message } is not valid"
+              end
+            end
+          end
+
+          def each(&block)
+            @messages.each(&block)
+          end
+
+          def length
+            @messages.count
+          end
+
+          def first
+            @messages.first
+          end
+
+          def last
+            @messages.last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twilio/rails/phone/tree_macros.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+module Twilio
+  module Rails
+    module Phone
+      # This module is available as `macros` in context of generating phone trees. It provides a set of shortcuts for
+      # common or verboase actions. It can be extended with custom macros using the config option {Twilio::Rails::Configuration#include_phone_macros}
+      module TreeMacros
+        extend self
+
+        # Gather one digit, allowing the current speech to be interrupted and stopped when a digit is pressed, with a
+        # configurable timeout that defaults to 6 seconds.
+        #
+        # @param timeout [Integer] the number of seconds to wait for a digit before timing out, defaults to 6 seconds.
+        # @return [Hash] formatted to pass to `gather:`.
+        def digit_gather_interruptable(timeout: 6)
+          timeout = timeout.to_i.presence || 6
+          timeout = 6 if timeout < 1
+
+          {
+            type: :digits,
+            timeout: timeout.to_i.presence || 6,
+            number: 1,
+            interrupt: true,
+            finish_on_key: "",
+          }
+        end
+
+        # Split a number into its digits and join them with commas, in order for it to be read out as a list of digits.
+        # @example
+        #   digits(123)
+        #   "1, 2, 3"
+        #
+        # @param num [Integer, String] the integer number to split into digits.
+        # @return [String] the digits joined with commas.
+        def digits(num)
+          return "" if num.blank?
+          num.to_s.split("").join(", ")
+        end
+
+        # Pause for a number of seconds, defaults to 1 second. Useful when putting space between segments of speech.
+        #
+        # @param seconds [Integer] the number of seconds to pause for, defaults to 1 second.
+        # @return [Hash] formatted to pass to `message:`.
+        def pause(seconds=nil)
+          {
+            pause: (seconds.presence || 1),
+          }
+        end
+
+        # Format a list of choices such that they are a numbered list for a phone tree menu, and can be passed directly
+        # into a `say:`. This pairs perfectly with {#numbered_choice_response_includes?} for creating menus. The array
+        # of choices must be larger than 1 and less than 10, otherwise a {Twilio::Rails::Phone::Error} will be raised.
+        #
+        # @example
+        #   numbered_choices(["store hours", "accounting", "warehouse"])
+        #   [
+        #      "For store hours, press 1.",
+        #      "For accounting, press 2.",
+        #      "For store warehouse, press 3.",
+        #   ]
+        #
+        # @param choices [Array<String>] the list of choices in numbered order.
+        # @param prefix [String] the prefix to use before each choice, defaults to "For".
+        # @return [Array<String>] the list of choices with numbers and prefixes formatted for `say:`.
+        def numbered_choices(choices, prefix: nil)
+          raise Twilio::Rails::Phone::Error, "`numbered_choices` macro got an empty array" if choices.empty?
+          raise Twilio::Rails::Phone::Error, "`numbered_choices` macro cannot be more than 9" if choices.length > 9
+          prefix ||= "For"
+          choices.each_with_index.map { |choice, index| "#{ prefix } #{ choice }, press #{ index + 1 }." }.join(" ")
+        end
+
+        # Validates if the response object includes a digit that is within the range of the choices array. This pairs
+        # directly with {#numbered_choices} for creating menus and validating the input. The array of choices must be
+        # larger than 1 and less than 10, otherwise a {Twilio::Rails::Phone::Error} will be raised.
+        #
+        # @param choices [Array<String>] the list of choices in numbered order.
+        # @param response [Twilio::Rails::Phone::Models::Response] the response object to validate.
+        # @return [true, false] whether the response includes a digit that is within the range of the choices. Returns
+        # false also if there are no digits or the digit is out of range.
+        def numbered_choice_response_includes?(choices, response:)
+          raise Twilio::Rails::Phone::Error, "`numbered_choice_response_includes?` macro got an empty array" if choices.empty?
+          raise Twilio::Rails::Phone::Error, "`numbered_choice_response_includes?` macro cannot be more than 9" if choices.length > 9
+          !!(response.integer_digits && response.integer_digits > 0 && response.integer_digits <= choices.length)
+        end
+
+        # The list of configured answers that are considered "yes" from {Twilio::Rails::Configuration#yes_responses}.
+        #
+        # @return [Array<String>] the list of configured answers that are considered "yes".
+        def answers_yes
+          Twilio::Rails.config.yes_responses
+        end
+
+        # The list of configured answers that are considered "no" from {Twilio::Rails::Configuration#no_responses}.
+        #
+        # @return [Array<String>] the list of configured answers that are considered "no".
+        def answers_no
+          Twilio::Rails.config.no_responses
+        end
+
+        # Finds and validates the existence of a file in the `public` folder. Formats that link to include the
+        # configured hose from {Twilio::Rails::Configuration#host}, and returns a fully qualified URL to the file. This
+        # is useful for playing audio files in a `message:` block. If the file is not found
+        # {Twilio::Rails::Phone::Error} is raised.
+        #
+        # @param filename [String] the filename of the file to play located in the `public` folder.
+        # @return [String] the fully qualified URL to the file.
+        def public_file(filename)
+          filename = filename.gsub(/^\//, "")
+          local_path = ::Rails.public_path.join(filename)
+
+          if File.exist?(local_path)
+            "#{ ::Twilio::Rails.config.host }/#{ filename }"
+          else
+            raise Twilio::Rails::Phone::Error, "Cannot find public file '#{ filename }' at #{ local_path }"
+          end
+        end
+
+        # Wraps the result of {#public_file} in a hash that can be used directly as a `message:`.
+        #
+        # @param filename [String] the filename of the file to play located in the `public` folder.
+        # @return [Hash] formatted to pass to `message:`.
+        def play_public_file(filename)
+          { play: public_file(filename) }
+        end
+
+        # Expose a {Twilio::TwiML::Say} node to be used in a `message:` block. This can be used to form Speech Synthesis
+        # Markup Language (SSML) to be used with Amazon Polly. Note that SSML is only available with some Polly voices,
+        # and only some tags are supported. Twilio will return server errors if used incorrectly. See the Twilio
+        # documentation for more information:
+        # https://www.twilio.com/docs/voice/twiml/say/text-speech#ssml-with-amazon-polly
+        #
+        # @example
+        #   prompt :with_ssml,
+        #     message: macros.say { |say|
+        #       say.emphasis(words: "with emphasis.", level: 'moderate')
+        #       say.w(words: "A message.")
+        #       say.prosody(words: 'Thank you for calling.', pitch: '-10%', rate: '110%')
+        #     }
+        #
+        # @return [Twilio::Rails::Phone::Tree::Message] A message object passed the block that will yield a {Twilio::TwiML::Say} node
+        def say(&block)
+          Twilio::Rails::Phone::Tree::Message.new(&block)
+        end
+      end
+    end
+  end
+end

data/lib/twilio/rails/phone.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Twilio
+  module Rails
+    module Phone
+      # Base error class for errors relating to Twilio phone interactions.
+      class Error < ::Twilio::Rails::Error ; end
+
+      # Error raised when attempting to build a phone tree.
+      class InvalidTreeError < Error ; end
+    end
+  end
+end

data/lib/twilio/rails/phone_number.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Twilio
+  module Rails
+    # A phone number object that includes the country and some optional metadata.
+    class PhoneNumber
+      attr_reader :number, :country, :label, :project
+
+      # @param number [String] the phone number string.
+      # @param country [String] the country code.
+      # @param label [String, nil] an optional label for the phone number, such as its source or purpose.
+      # @param project [String, nil] an optional project identifier for grouping phone numbers.
+      def initialize(number:, country:, label: nil, project: nil)
+        @number = Twilio::Rails::Formatter.coerce_to_valid_phone_number(number)
+        raise Twilio::Rails::Phone::Error, "Invalid phone number '#{ number }'" unless @number
+        @country = country&.upcase
+        @label = label
+        @project = project.presence&.to_s
+      end
+
+      # @return [String] a human readable string representation of the phone number and its metadata.
+      def to_s
+        s = "Phone number #{ number } (#{ country })"
+        s = "#{ s } #{ label }" if label.present?
+        s = "#{ s } for #{ project }" if project.present?
+        s
+      end
+    end
+  end
+end

data/lib/twilio/rails/railtie.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module Twilio
+  module Rails
+    class Railtie < ::Rails::Railtie
+      config.before_initialize do
+        ActiveSupport::Inflector.inflections(:en) do |inflect|
+          inflect.acronym 'SMS'
+        end
+      end
+
+      config.after_initialize do |application|
+        # TODO: This should work but it does not. I think maybe it happens too late? The same line works if you add it directly to the `application.rb` of the app. It is needed for dev mode.
+        # application.config.hosts << Twilio::Rails.config.host_domain
+      end
+    end
+  end
+end

data/lib/twilio/rails/sms/delegated_responder.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+module Twilio
+  module Rails
+    module SMS
+      # Base class for SMS responders. To define a responder start by generating a sublcass.
+      #
+      #     rails generate twilio:rails:sms_responder ThankYou
+      #
+      # This will create a new class in `app/sms_responders/thank_you_responder.rb` which will subclass this class. It
+      # must be registered with the framework in the initializer for it to be available. The generator does this.
+      #
+      #     # config/initializers/twilio_rails.rb
+      #     config.sms_responders.register { ThankYouResponder }
+      #
+      # Then the responder must implement the {#handle?} and {#reply} methods. If the {#handle?} method returns true
+      # then the {#reply} method will be called to generate the body of the response, and send that message back as an
+      # SMS. Only one responder will be called for a given message.
+      #
+      # @example
+      #   class ThankYouResponder < ::Twilio::Rails::SMS::DelegatedResponder
+      #     def handle?
+      #       matches?(/thank you/)
+      #     end
+      #
+      #     def reply
+      #       "Thank you too!"
+      #     end
+      #   end
+      class DelegatedResponder
+        attr_reader :message, :sms_conversation
+
+        class << self
+          # Returns the name of the class, without the namespace or the `Responder` suffix.
+          #
+          # @return [String] the name of the responder.
+          def responder_name
+            self.name.demodulize.underscore.gsub(/_responder\Z/, "")
+          end
+        end
+
+        def initialize(message)
+          @message = message
+          @sms_conversation = message.sms_conversation
+        end
+
+        # Must be implemented by the subclass otherwise will raise a `NotImplementedError`. Returns true if this
+        # responder should handle the given message. If true then the {#reply} method will be called to generate the
+        # body of the response. It has access to the message and the conversation.
+        #
+        # @return [true, false] true if this responder should handle the given message.
+        def handle?
+          raise NotImplementedError
+        end
+
+        # Must be implemented by the subclass otherwise will raise a `NotImplementedError`. Returns the body of the
+        # message to be sent in response. Will only be called if {#handle?} returns true. It has access to the message
+        # and the conversation.
+        #
+        # @return [String, nil] the body of the response to be sent as SMS, or `nil` if no message should be sent.
+        def reply
+          raise NotImplementedError
+        end
+
+        protected
+
+        # @return [PhoneCaller, nil] the phone caller associated with the message, or `nil` if none is found.
+        def phone_caller
+          @phone_caller ||= PhoneCaller.find_by(phone_number: @sms_conversation.from_number)
+        end
+
+        # @return [String] the phone number associated with the message.
+        def inbound_phone_number
+          sms_conversation.number
+        end
+
+        # Checks if the received message body contains or matches the given matcher. The matcher can be a string,
+        # symbol, or number and it will match anywhere in the body ignoring case. The matcher can also be a regex and
+        # it will just call `Regexp#match?` on the body. Raises an error if the matcher cannot be handled.
+        #
+        # @param matcher [String, Symbol, Numeric, Regexp] the matcher to check against the message body.
+        # @return [true, false] true if the message body matches the given matcher.
+        def matches?(matcher)
+          body = message.body || ""
+
+          case matcher
+          when String, Numeric, Symbol
+            body.downcase.include?(matcher.to_s.downcase)
+          when Regexp
+            matcher.match?(body)
+          else
+            raise Twilio::Rails::SMS::InvalidResponderError, "unkown matcher #{matcher}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twilio/rails/sms/responder.rb

@@ -0,0 +1,33 @@
+
+# frozen_string_literal: true
+module Twilio
+  module Rails
+    module SMS
+      # The class responsible for pattern matching and delegating how to handle an incoming SMS. Called by
+      # {Twilio::Rails::SMS::Twiml::MessageOperation} to generate the body of the response. For a given message it
+      # iterates over all registered `sms_responders` and replies with the first one that handles, or raises if none
+      # are found to handle the message.
+      class Responder
+        attr_reader :message, :sms_conversation
+
+        def initialize(message)
+          @message = message
+          @sms_conversation = message.sms_conversation
+        end
+
+        # Iterates over all registered `sms_responders` and replies with the first one that handles, or raises if none
+        # are found to handle the message.
+        #
+        # @return [String] the body of the response.
+        def respond
+          Twilio::Rails.config.sms_responders.all.each do |name, responder_class|
+            responder = responder_class.new(message)
+            return responder.reply if responder.handle?
+          end
+
+          raise Twilio::Rails::SMS::InvalidResponderError, "No responder found for message_id=#{ message.id } : #{ message.body }"
+        end
+      end
+    end
+  end
+end

data/lib/twilio/rails/sms.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Twilio
+  module Rails
+    module SMS
+      # Base error class for errors relating to Twilio phone interactions.
+      class Error < ::Twilio::Rails::Error ; end
+
+      # Error raised when a responder is unable to handle an SMS message.
+      class InvalidResponderError < Error ; end
+    end
+  end
+end

data/lib/twilio/rails/version.rb

@@ -0,0 +1,5 @@
+module Twilio
+  module Rails
+    VERSION = "1.0.0"
+  end
+end

data/lib/twilio/rails.rb

@@ -0,0 +1,89 @@
+require "active_operation"
+require "twilio-ruby"
+require "faraday"
+
+require "twilio/rails/version"
+require "twilio/rails/engine"
+
+module Twilio
+  module Rails
+    # Base error class for all errors raised by the Twilio::Rails gem. Every error is a subclass of this one.
+    class Error < StandardError ; end
+  end
+end
+
+require "twilio/rails/railtie"
+require "twilio/rails/configuration"
+require "twilio/rails/formatter"
+require "twilio/rails/phone_number"
+require "twilio/rails/client"
+
+require "twilio/rails/phone"
+require "twilio/rails/phone/tree"
+require "twilio/rails/phone/base_tree"
+require "twilio/rails/phone/tree_macros"
+
+require "twilio/rails/sms"
+require "twilio/rails/sms/responder"
+require "twilio/rails/sms/delegated_responder"
+
+require "twilio/rails/concerns/has_phone_number"
+require "twilio/rails/concerns/has_time_scopes"
+require "twilio/rails/concerns/has_direction"
+require "twilio/rails/models/phone_caller"
+require "twilio/rails/models/recording"
+require "twilio/rails/models/phone_call"
+require "twilio/rails/models/response"
+require "twilio/rails/models/sms_conversation"
+require "twilio/rails/models/message"
+
+module Twilio
+  module Rails
+    class << self
+
+      # Read and write accessible configuration object. In most cases this should only be read after the app has been
+      # initialized. See {Twilio::Rails::Configuration} for more information.
+      #
+      # @return [Twilio::Rails::Configuration] the config object for the engine.
+      def config
+        @config ||= ::Twilio::Rails::Configuration.new
+      end
+
+      # Called in the `config/initializers/twilio_rails.rb` file to configure the engine. This yields the {.config}
+      # object above and then calls {Twilio::Rails::Configuration#validate!} to ensure the configuration is valid.
+      #
+      # @yield [Twilio::Rails::Configuration] the configuration object.
+      # @return [nil]
+      def setup
+        config.setup!
+        yield(config)
+        config.validate!
+        nil
+      end
+
+      # Abstraction for the framework to notify of an important exception that has occurred. This safely calls the
+      # configured `config.exception_notifier` or does nothing if it is set to `nil`. This does not catch, handle, or
+      # prevent the exception from raising.
+      #
+      # @param exception [Exception] the exception that has occurred.
+      # @param message [String] a description of the exception, defaults to `exception.message` if blank.
+      # @param context [Hash] a hash of arbitrary additional context to include in the notification.
+      # @param exception_binding [Binding] the binding of where the exception is being notified.
+      # @return [true, false] if an exception has been successfully notified.
+      def notify_exception(exception, message: nil, context: {}, exception_binding: nil)
+        if config.exception_notifier
+          begin
+            message = message.presence || exception.message
+            config.exception_notifier.call(exception, message, context, exception_binding)
+            true
+          rescue => e
+            config.logger.tagged(self.class) { |l| l.error("ExceptionNotifier failed to notify of exception=#{ exception.inspect } message=#{ message.inspect } context=#{ context.inspect }") }
+            false
+          end
+        else
+          false
+        end
+      end
+    end
+  end
+end