em-smsified 0.2.0

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Jason Goecke
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,66 @@
+em-smsified
+========
+
+SMSified is a simple API for sending and receiving text messages using regular phone numbers or short codes. SMSified uses a simple REST interface based on the GSMA OneAPI standard and is backed by Voxeo - the worlds largest communications cloud. Ruby lib for consuming the SMSified OneAPI.
+
+This is a Ruby gem for consuming the SMSified OneAPI with EventMachine.
+
+This library was originally released by Tropo at http://github.com/smsified/smsified-ruby by Jason Goecke and John Dyer. It has been modified to work in the context of EventMachine by Kristian Kristensen.
+
+Installation
+------------
+
+	gem install em-smsified
+ 
+Example
+-------
+
+All of the API methods take an anonymous block which is the method called when the server returns. It yields the response so you can access the result of executing the API operation. The examples below illustrates this. If you don't care about the result of the operation, don't pass a block.
+
+Send an SMS:
+
+	require 'rubygems'
+	require 'em-smsified'
+	require 'eventmachine'
+
+	oneapi = Smsified::OneAPI.new(:username => 'user', :password => 'bug.fungus24')
+
+	EM.run do
+	       oneapi.send_sms :address => '14155551212', :message => 'Hi there!', :sender_address => '13035551212'
+	end
+
+
+Find a subscription:
+
+	require 'rubygems'
+	require 'smsified'
+	require 'eventmachine'
+
+	subscriptions = Smsified::Subscriptions.new(:username => 'user', :password => 'bug.fungus24')
+
+	EM.run do
+		subscriptions.inbound_subscriptions('17177455076')
+	end
+
+Parse the JSON for a callback Incoming Message:
+
+    require 'rubygems'
+    require 'smsified'
+
+    # Also require your favorite web framework such as Rails or Sinatra
+    incoming_message = Smsified::IncomingMessage.new json_body
+    puts incoming_message.date_time           # Wed May 11 18:05:54 UTC 2011
+    puts incoming_message.destination_address # '16575550100'
+    puts incoming_message.message             # 'Inbound test'
+    puts incoming_message.message_id          # 'ef795d3dac56a62fef3ff1852b0c123a'
+    puts incoming_message.sender_address      # '14075550100'
+
+Documentation
+-------------
+
+May be found at http://kristiankristensen.github.com/em-smsified & http://smsified.com.
+
+License
+-------
+
+MIT - See LICENSE.txt

data/examples/local_test.rb

@@ -0,0 +1,40 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__), '..', 'lib')
+require 'rubygems'
+require 'smsified'
+require 'yaml'
+require 'eventmachine'
+
+config = YAML.load(File.open('examples/config.yml'))
+
+
+EM.run do
+  Signal.trap("INT") { EM.stop}
+  Signal.trap("TRAP") { EM.stop}
+  
+  puts "Hit CTRL-C to stop"
+  puts "=================="
+  puts "Server started at " + Time.now.to_s
+
+  smsified = Smsified::OneAPI.new( :username       => config['smsified']['username'],
+                                   :password       => config['smsified']['password'],
+                                   :sender_address => '12892050134'
+                                   )
+
+
+  puts "Send SMS started " + Time.now.to_s
+
+#  smsified.send_sms(:message => 'Hello there!', 
+#               :address        => '19179712649',
+               #:notify_url     => config['postbin'],
+#               :sender_address => '12892050134') do |http|
+#    puts "Response returned " + Time.now.to_s
+#    puts http.data
+#    puts http.http
+#  end
+
+  puts "Reporting Request started " + Time.now.to_s
+    smsified.delivery_status(:request_id => 'e7e12f5d6870447a8599bb420e5e9a0d') do |resp|
+    puts "Response returned " + Time.now.to_s
+    puts resp.data
+  end
+end

data/examples/sending_and_subscribing.rb

@@ -0,0 +1,68 @@
+##
+# Run this file from the smsified root dir, ie. :
+# ruby examples/sending_and_subscribing.rb
+#
+# Remember to copy config.yml.sample to config.yml and insert your SMSified credentials
+# Also you need to change the "sender_address" parameter below to your registered SMSified number, and the "receiver_address" to the mobile number you want to send texts to.
+#
+
+$LOAD_PATH.unshift(File.dirname(__FILE__), '..', 'lib')
+require 'rubygems'
+require 'smsified'
+require 'yaml'
+require 'eventmachine'
+
+config = YAML.load(File.open('examples/config.yml'))
+
+smsified = EventMachine::Smsified::OneAPI.new(:username => config['smsified']['username'],
+                                              :password => config['smsified']['password'])
+
+sender_address = '14157044517'
+receiver_address = '17177455076'
+
+EM.run do
+  Signal.trap("INT") { EM.stop}
+  Signal.trap("TRAP") { EM.stop}
+  
+  puts "Hit CTRL-C to stop"
+  puts "=================="
+  puts "Server started at " + Time.now.to_s
+  
+  
+  puts "Send an SMS to one address " + Time.now.to_s
+  smsified.send_sms( :message        => 'Hello there!', 
+                     :address        => receiver_address,
+                     :notify_url     => config['postbin'],
+                     :sender_address => sender_address) do |result|
+    puts result.data.inspect
+    puts result.http.inspect
+  end     
+  
+  puts "Send an SMS to multiple addresses" + Time.now.to_s
+  smsified.send_sms( :message        => 'Hello there, multiple recipients!', 
+                     :address        => [receiver_address, receiver_address],
+                     :notify_url     => config['postbin'],
+                     :sender_address => sender_address) do |result|
+    puts "Response returned " + Time.now.to_s
+    puts result.data.inspect
+    puts result.http.inspect
+  end
+
+  puts "Create in inbound subscription" + Time.now.to_s
+  smsified.create_inbound_subscription( sender_address, 
+                                        :notify_url => config['postbin']
+                                       ) do |result|
+    puts "Response returned " + Time.now.to_s
+    puts result.data.inspect
+    puts result.http.inspect
+  end
+
+  puts "Get some of your sent SMS details" + Time.now.to_s
+  smsified.search_sms( 'start=2011-11-14&end=2011-11-15') do |result|
+    puts "Response returned " + Time.now.to_s
+    puts result.data.inspect
+    puts result.data.inspect
+  end
+end                                
+
+

data/lib/em-smsified/base.rb

@@ -0,0 +1,100 @@
+module EventMachine
+  module Smsified
+    SMSIFIED_ONEAPI_PUBLIC_URI = 'https://api.smsified.com/v1'
+    SMSIFIED_HTTP_HEADERS      = { 'Content-Type' => 'application/x-www-form-urlencoded','Accept'=>'application/json' }
+
+    class Base
+      attr_reader :base_uri, :auth, :destination_address, :sender_address
+
+      ##
+      # Intantiate a new class to work with OneAPI
+      # 
+      # @param [required, Hash] params to create the user
+      # @option params [required, String] :username username to authenticate with
+      # @option params [required, String] :password to authenticate with
+      # @option params [optional, String] :base_uri of an alternative location of SMSified
+      # @option params [optional, String] :destination_address to use with subscriptions
+      # @option params [optional, String] :sender_address to use with subscriptions
+      # @option params [optional, Boolean] :debug to turn on the HTTparty debugging to stdout
+      # @raise [ArgumentError] if :username is not passed as an option
+      # @raise [ArgumentError] if :password is not passed as an option
+      def initialize(options)
+        raise ArgumentError, 'an options Hash is required' if !options.instance_of?(Hash)
+        raise ArgumentError, ':username required' if options[:username].nil?
+        raise ArgumentError, ':password required' if options[:password].nil?
+        
+        @base_uri = options[:base_uri] || SMSIFIED_ONEAPI_PUBLIC_URI
+        @auth = { :username => options[:username], :password => options[:password] }
+        
+        @destination_address = options[:destination_address]
+        @sender_address      = options[:sender_address]
+      end
+
+      ##
+      # HTTP GET's a request
+      # @param [required, String] :url to GET from
+      #
+      def get(url, headers)
+        conn = create_connection_object(url)
+
+        http = conn.get(:head => add_authorization_to_header(headers, @auth))
+
+        action = proc do
+          response = Response.new(http.response.parsed, http)#.response.raw)
+          yield response if block_given?
+        end
+
+        http.callback &action
+        http.errback &action 
+      end
+
+      ##
+      # HTTP DELETE's a request
+      # @param [required, String] :url to GET from
+      #
+      def delete(url, headers)
+        conn = create_connection_object(url)
+
+        http = conn.delete(:head => add_authorization_to_header(headers, @auth))
+
+        action = proc do
+          response = Response.new(http.response.parsed, http)#.response.raw)
+          yield response if block_given?
+        end
+
+        http.callback &action
+        http.errback &action 
+      end
+
+      ##
+      # HTTP POST's a request
+      # @param [required, String] :url to GET from
+      #
+      def post(url, body, headers)
+        conn = create_connection_object(url)
+
+        http = conn.post(:body => body,
+                         :head => add_authorization_to_header(headers, @auth))
+
+        action = proc do
+          response = Response.new(http.response.parsed, http)#.response.raw)
+          yield response if block_given?
+        end
+
+        http.callback &action
+        http.errback &action 
+      end
+
+      private
+      def create_connection_object(url)
+        conn = EM::HttpRequest.new(SMSIFIED_ONEAPI_PUBLIC_URI + url)
+        conn.use JSONify
+        return conn
+      end
+
+      def add_authorization_to_header(headers, auth)
+        return headers.merge({'Authorization' => [auth[:username], auth[:password]]})
+      end
+    end
+  end
+end

data/lib/em-smsified/helpers.rb

@@ -0,0 +1,61 @@
+module EventMachine
+  module Smsified
+    module Helpers
+      private
+      
+      ##
+      # Camelcases the options
+      def camelcase_keys(options)
+        options = options.clone
+        
+        if options[:destination_address]
+          options[:destinationAddress] = options[:destination_address]
+          options.delete(:destination_address)
+        end
+        
+        if options[:notify_url]
+          options[:notifyURL] = options[:notify_url]
+          options.delete(:notify_url)
+        end
+        
+        if options[:client_correlator]
+          options[:clientCorrelator] = options[:client_correlator]
+          options.delete(:client_correlator)
+        end
+        
+        if options[:callback_data]
+          options[:callbackData] = options[:callback_data]
+          options.delete(:callback_data)
+        end
+        
+        options
+      end
+      
+      ##
+      # Builds the necessary query string
+      def build_query_string(options)
+        options = camelcase_keys(options)
+        
+        query = ''
+
+        options.each do |k,v|
+          if k == :address
+            if RUBY_VERSION.to_f == 1.9
+              if v.instance_of?(String)
+                v.each_line { |address| query += "#{ '&' if query != '' }address=#{CGI.escape address}" }
+              else
+                v.each { |address| query += "#{ '&' if query != '' }address=#{CGI.escape address}" }
+              end
+            else
+              v.each { |address| query += "#{ '&' if query != '' }address=#{CGI.escape address}" }
+            end
+          else
+            query += "#{ '&' if query != '' }#{k.to_s}=#{CGI.escape v}"
+          end
+        end
+
+        query
+      end
+    end
+  end
+end

data/lib/em-smsified/incoming_message.rb

@@ -0,0 +1,35 @@
+module EventMachine
+  module Smsified
+    class IncomingMessage
+      attr_reader :date_time, :destination_address, :message, :message_id, :sender_address, :json
+      
+      ##
+      # Intantiate a new object to provide convenience methods on an Incoming Message
+      # http://www.smsified.com/sms-api-documentation/receiving
+      # 
+      # @param [required, String] valid JSON for an Incoming Message to be parsed
+      # @return [Object] the parsed incoming message
+      # @raise [ArgumentError] if json is not valid JSON or an Incoming Message type
+      # @example 
+      #   incoming_message = IncomingMessage.new(json)
+      #   puts incoming_message.message # foobar
+      def initialize(json)
+        begin
+          @json                = JSON.parse json
+          
+          contents             = @json['inboundSMSMessageNotification']['inboundSMSMessage']
+          
+          @date_time           = Time.parse contents['dateTime']
+          @destination_address = contents['destinationAddress']
+          @message             = contents['message']
+          @message_id          = contents['messageId']
+          @sender_address      = contents['senderAddress']
+        rescue => error
+          raise MessageError, "Not valid JSON or IncomingMessage"
+        end
+      end
+      
+      class MessageError < StandardError; end
+    end
+  end
+end

data/lib/em-smsified/oneapi.rb

@@ -0,0 +1,49 @@
+module EventMachine
+  module Smsified
+    class OneAPI < Base
+      include Helpers
+      include SubscriptionsModule
+      include ReportingModule
+
+      ##
+      # @example 
+      #   one_api = OneAPI.new :username => 'user', :password => '123'
+      def initialize(options)
+        super(options)
+      end
+      
+      ##
+      # Send an SMS to one or more addresses
+      #
+      # @param [required, Hash] params to send an sms
+      # @option params [required, String] :address to send the SMS to
+      # @option params [required, String] :message to send with the SMS
+      # @option params [optional, String] :sender_address to use with subscriptions, required if not provided on initialization of OneAPI
+      # @option params [optional, String] :notify_url to send callbacks to
+      # @param 
+      # @return [Object] A Response Object with http and data instance methods
+      # @raise [ArgumentError] if :sender_address is not passed as an option when not passed on object creation
+      # @raise [ArgumentError] if :address is not provided as an option
+      # @raise [ArgumentError] if :message is not provided as an option
+      # @example 
+      #   one_api.send_sms :address => '14155551212', :message => 'Hi there!', :sender_address => '13035551212'
+      #   one_api.send_sms :address => ['14155551212', '13035551212'], :message => 'Hi there!', :sender_address => '13035551212'
+      #   one_api.send_sms(:address => '14155551212', :message => 'Hi there!', :sender_address => '13035551212') do |result| ... end
+      def send_sms(options, &blk)
+        raise ArgumentError, 'an options Hash is required' if !options.instance_of?(Hash)
+        raise ArgumentError, ':sender_address is required' if options[:sender_address].nil? && @sender_address.nil?
+        raise ArgumentError, ':address is required' if options[:address].nil?
+        raise ArgumentError, ':message is required' if options[:message].nil?
+        
+        options[:sender_address] = options[:sender_address] || @sender_address
+        query_options = options.clone
+        query_options.delete(:sender_address)
+        query_options = camelcase_keys(query_options)
+
+        post("/smsmessaging/outbound/#{options[:sender_address]}/requests",
+             build_query_string(query_options),
+             SMSIFIED_HTTP_HEADERS, &blk)
+      end
+    end
+  end
+end

data/lib/em-smsified/reporting.rb

@@ -0,0 +1,59 @@
+module EventMachine
+  module Smsified
+    module ReportingModule    
+      ##
+      # Get the delivery status of an outstanding SMS request
+      #
+      # @param [required, Hash] params to get the delivery status
+      # @option params [required, String] :request_id to fetch the status for
+      # @option params [optional, String] :sender_address used to send the SMS, required if not provided on initialization of OneAPI
+      # @return [Object] A Response Object with http and data instance methods
+      # @raise [ArgumentError] of :sender_address is not passed here when not passed on instantiating the object
+      # @example
+      #   one_api.delivery_status :request_id => 'f359193765f6a3149ca76a4508e21234', :sender_address => '14155551212'
+      def delivery_status(options, &blk)
+        raise ArgumentError, 'an options Hash is required' if !options.instance_of?(Hash)
+        raise ArgumentError, ':sender_address is required' if options[:sender_address].nil? && @sender_address.nil?
+        
+        options[:sender_address] = options[:sender_address] || @sender_address
+
+        get("/smsmessaging/outbound/#{options[:sender_address]}/requests/#{options[:request_id]}/deliveryInfos", SMSIFIED_HTTP_HEADERS, &blk)
+      end
+      
+      ##
+      # Retrieve a single SMS
+      # 
+      # @param [required, String] message_id of the message to retrieve
+      # @return [Object] A Response Object with http and data instance methods
+      # @example
+      #   reporting.retrieve_sms '74ae6147f915eabf87b35b9ea30c5916'
+      def retrieve_sms(message_id, &blk)
+        get("/messages/#{message_id}", SMSIFIED_HTTP_HEADERS, &blk)
+      end
+      
+      ##
+      # Retrieve multiple SMS messages based on a query string
+      # 
+      # @param [required, String] query_string to search SMS messages for
+      # @return [Object] A Response Object with http and data instance methods
+      # @example
+      #   reporting.search_sms 'start=2011-02-14&end=2011-02-15'
+      def search_sms(query_string, &blk)
+        get("/messages?#{query_string}", SMSIFIED_HTTP_HEADERS, &blk)
+      end
+    end
+
+
+    class Reporting < Base
+      include ReportingModule
+      ##
+      # Intantiate a new class to work with reporting
+      # 
+      # @example
+      #   subscription = Subscription.new :username => 'user', :password => '123'
+      def initialize(options)
+        super(options)
+      end
+    end
+  end
+end

data/lib/em-smsified/response.rb

@@ -0,0 +1,41 @@
+module EventMachine
+  module Smsified
+
+    ##
+    # Functions as a proxy on the EventMachine HTTP Response so you can get the raw and parsed response
+    #
+    class ResponseProxy
+      attr_reader :raw, :parsed
+
+      def initialize(parsed, raw)
+        @parsed = parsed
+        @raw = raw
+      end
+    end
+
+    ##
+    # Used by em-http-request to parse the JSON coming in
+    #
+    class JSONify
+      def response(resp)
+        resp.response = ResponseProxy.new(Yajl::Parser.parse(resp.response), resp.response)
+      end
+    end
+
+    ##
+    # The result object from the API. Used to access the parsed and raw HTTP response.
+    #
+    class Response
+      attr_reader :data, :http
+      
+      ##
+      # Provides the standard response for the library
+      #
+      # @param [Object] an HTTParty result object
+      def initialize(parsed, raw)
+        @data = parsed
+        @http = raw
+      end
+    end
+  end
+end

data/lib/em-smsified/subscriptions.rb

@@ -0,0 +1,137 @@
+module EventMachine
+  module Smsified
+    module SubscriptionsModule
+      ##
+      # Creates an inbound subscription
+      # 
+      # @param [required, String] destination_address to subscribe to
+      # @param [required, Hash] params to send an sms
+      # @option params [optional, String] :notify_url to send callbacks to
+      # @option params [optional, String] :client_correlator to update
+      # @option params [optional, String] :callback_data to update
+      # @return [Object] A Response Object with http and data instance methods
+      # @param [required, String] notify_url to send callbacks to
+      # @return [Object] A Response Object with http and data instance methods
+      # @example
+      #   subscriptions.create_inbound_subscription('tel:+14155551212', :notify_url => 'http://foobar.com')
+      def create_inbound_subscription(destination_address, options, &blk)
+        query = options.merge({ :destination_address => destination_address })
+        
+        post("/smsmessaging/inbound/subscriptions", 
+             camelcase_keys(query),
+             SMSIFIED_HTTP_HEADERS, &blk
+             )
+
+      end
+      
+      ##
+      # Creates an outbound subscription
+      # 
+      # @param [required, String] sender_address to subscribe to
+      # @option params [optional, String] :notify_url to send callbacks to
+      # @option params [optional, String] :client_correlator to update
+      # @option params [optional, String] :callback_data to update
+      # @return [Object] A Response Object with http and data instance methods
+      # @example
+      #   subscriptions.create_outbound_subscription('tel:+14155551212', :notify_url => 'http://foobar.com')    
+      def create_outbound_subscription(sender_address, options, &blk)
+        post("/smsmessaging/outbound/#{sender_address}/subscriptions", 
+             build_query_string(options),
+             SMSIFIED_HTTP_HEADERS, &blk
+             )
+      end
+      
+      ##
+      # Deletes an inbound subscription
+      # 
+      # @param [required, String] subscription_id to delete
+      # @return [Object] A Response Object with http and data instance methods
+      # @example
+      #   subscriptions.delete_inbound_subscription('89edd71c1c7f3d349f9a3a4d5d2d410c')
+      def delete_inbound_subscription(subscription_id, &blk)
+        delete("/smsmessaging/inbound/subscriptions/#{subscription_id}", SMSIFIED_HTTP_HEADERS, &blk)
+      end
+      
+      ##
+      # Deletes an outbound subscription
+      # 
+      # @param [required, String] subscription_id to delete
+      # @return [Object] A Response Object with http and data instance methods
+      # @example
+      #   subscriptions.delete_outbound_subscription('89edd71c1c7f3d349f9a3a4d5d2d410c')
+      def delete_outbound_subscription(sender_address, &blk)
+        delete("/smsmessaging/outbound/subscriptions/#{sender_address}", SMSIFIED_HTTP_HEADERS, &blk)
+      end
+      
+      ##
+      # Fetches the inbound subscriptions
+      #
+      # @param [required, String] destination_address to fetch the subscriptions for
+      # @return [Object] A Response Object with http and data instance methods
+      # @example
+      #   subscriptions.inbound_subscriptions('tel:+14155551212')
+      def inbound_subscriptions(destination_address, &blk)
+        get("/smsmessaging/inbound/subscriptions?destinationAddress=#{destination_address}",  SMSIFIED_HTTP_HEADERS, &blk)
+      end
+
+      ##
+      # Fetches the outbound subscriptions
+      #
+      # @param [required, String] sender_address to fetch the subscriptions for
+      # @return [Object] A Response Object with http and data instance methods
+      # @example
+      #   subscriptions.outbound_subscriptions('tel:+14155551212')
+      def outbound_subscriptions(sender_address, &blk)
+        get("/smsmessaging/outbound/subscriptions?senderAddress=#{sender_address}", SMSIFIED_HTTP_HEADERS, &blk)
+      end
+      
+      ##
+      # Updates an inbound subscription
+      # 
+      # @option params [required, String] subscription_id updating
+      # @param [required, Hash] params to update the inbound subscription with
+      # @option params [optional, String] :notify_url to send callbacks to
+      # @option params [optional, String] :client_correlator to update
+      # @option params [optional, String] :callback_data to update
+      # @return [Object] A Response Object with http and data instance methods
+      # @example
+      #   subscriptions.update_inbound_subscription('89edd71c1c7f3d349f9a3a4d5d2d410c', :notify_url => 'foobar')
+      def update_inbound_subscription(subscription_id, options, &blk)
+        post("/smsmessaging/inbound/subscriptions/#{subscription_id}", 
+             build_query_string(options),
+             SMSIFIED_HTTP_HEADERS, &blk
+             )
+      end
+      
+      ##
+      # Updates an outbound subscription
+      # 
+      # @option params [required, String] sender_address updating
+      # @param [required, Hash] params to update the outbound subscription with
+      # @option params [optional, String] :notify_url to send callbacks to
+      # @option params [optional, String] :client_correlator to update
+      # @option params [optional, String] :callback_data to update
+      # @return [Object] A Response Object with http and data instance methods
+      # @example
+      #   subscriptions.update_outbound_subscription('tel:+14155551212', :notify_url => 'foobar')
+      def update_outbound_subscription(sender_address, options, &blk)
+        post("/smsmessaging/outbound/#{sender_address}/subscriptions",                                   build_query_string(options), 
+             SMSIFIED_HTTP_HEADERS, &blk
+             )
+      end
+    end
+
+    class Subscriptions < Base
+      include Helpers
+      include SubscriptionsModule        
+      ##
+      # Intantiate a new class to work with subscriptions
+      # 
+      # @example
+      #   subscription = Subscription.new :username => 'user', :password => '123'
+      def initialize(options)
+        super(options)
+      end
+    end
+  end
+end