smess 1.0.0

data/lib/smess/outputs/mblox.rb

@@ -0,0 +1,155 @@
+require 'uri'
+require 'httpi'
+
+module Smess
+  class Mblox
+    include Smess::Logging
+
+    def deliver_sms(sms)
+      return false unless sms.kind_of? Sms
+
+      parts = Smess.split_sms(sms.message.strip_nongsm_chars)
+      return false if parts[0].empty?
+
+      xml_params = {
+        subscriber_number: sms.to,
+        message: ""
+      }
+      # if we have several parts, send them as concatenated sms
+      if parts.length > 1
+        logger.info "Num Parts: #{parts.length.to_s}"
+        # create concat-sms UDH
+        ref_id = Random.new.rand(255).to_s(16).rjust(2,"0")
+        num_parts = parts.length
+        xml_params[:udh] = ":05:00:03:#{ref_id}:#{num_parts.to_s(16).rjust(2,'0')}:01" # {050003}{ff}{02}{01} {concat-command}{id to link all parts}{total num parts}{num of current part}
+      end
+
+      xml_params[:message] = parts.shift
+      # send first SMS... the one we return the result from...
+      result = send_one_sms( xml_params )
+      result[:data][:text] = sms.message.strip_nongsm_chars
+
+
+      # send additional parts if we have them
+      if parts.length > 0 && result[:response_code] != "-1"
+        more_results = []
+        parts.each_with_index do |part, i|
+          xml_params[:message] = part
+          xml_params[:udh]  = ":05:00:03:#{ref_id}:#{num_parts.to_s(16).rjust(2,'0')}:#{(i+2).to_s(16).rjust(2,'0')}"
+          more_results << send_one_sms( xml_params )
+        end
+        # we don't actually return the status for any of these which is cheating
+        logger.info more_results
+      end
+
+      result
+    end
+
+
+    def send_one_sms(xml_params)
+      xml = xml_data_for(xml_params)
+      body = "XMLDATA="+URI::encode( xml.encode("ISO-8859-1") ) # escape
+
+      request = HTTPI::Request.new
+      request.url = 'https://xml4.us.mblox.com:443/send'
+      request.headers["Content-Type"] = "application/x-www-form-urlencoded"
+      request.body = body
+
+      begin
+        HTTPI.log_level = :debug
+        response = HTTPI.post request
+
+      rescue Exception => e
+        logger.warn response
+        # connection problem or some error
+        result = {
+          response_code: '-1',
+          response: {
+            temporaryError: 'true',
+            responseCode: e.code,
+            responseText: e.message
+          },
+          data: {
+            to: xml_params[:subscriber_number],
+            text: xml_params[:message],
+            from: ENV["SMESS_MBLOX_SURE_ROUTE_SHORTCODE"]
+          }
+        }
+      else
+        response_data = Nori.parse(response.body)
+        response_code = response_code_for response_data
+        # Successful response
+        result = {
+          message_id: @message_id,
+          response_code: response_code,
+          response: response_data,
+          destination_address: xml_params[:subscriber_number],
+          data: {
+            to: xml_params[:subscriber_number],
+            text: xml_params[:message],
+            from: ENV["SMESS_MBLOX_SURE_ROUTE_SHORTCODE"]
+          }
+        }
+      end
+      result
+    end
+
+
+    def xml_data_for(xml_params)
+      Gyoku.convert_symbols_to :camelcase
+      '<?xml version="1.0"?>'+
+      Gyoku.xml( hash_data_for(xml_params) )
+    end
+
+    def hash_data_for(xml_params)
+      rand = (SecureRandom.random_number*100000000).to_i
+      @message_id = rand # "#{Time.now.to_i}#{xml_params.to}#{rand}"
+
+      xml_hash = {
+        notification_request: {
+          notification_header: {
+            partner_name: ENV["SMESS_MBLOX_SURE_ROUTE_USER"],
+            partner_password: ENV["SMESS_MBLOX_SURE_ROUTE_PASS"]
+          },
+          notification_list: {
+            notification: {
+              message: xml_params[:message],
+              profile: ENV["SMESS_MBLOX_SURE_ROUTE_PROFILE_ID"],
+              udh: xml_params.fetch(:udh,""),
+              sender_i_d: ENV["SMESS_MBLOX_SURE_ROUTE_SHORTCODE"],
+              # expire_date: "",
+              # operator: "",
+              # tariff: "",
+              subscriber: {
+                subscriber_number: xml_params[:subscriber_number],
+                session_id: ""
+              },
+              # tags: '<Tag Name=”Number”>56</Tag><Tag Name=”City”>Paris</Tag>',
+              # service_desc: "",
+              # content_type: "",
+              service_id: ENV["SMESS_MBLOX_SURE_ROUTE_SID"],
+              attributes!: { sender_i_d: { "Type" => "Shortcode" } }
+            },
+            attributes!: { notification: { "SequenceNumber" => "1", "MessageType" => "SMS" } } # FlashSMS
+          },
+          attributes!: { notification_list: { "BatchID" => @message_id } }
+        },
+        attributes!: {  notification_request: { "Version" => "3.5" } }
+      }
+      xml_hash[:notification_request][:notification_list][:notification].delete :udh unless xml_params.key? :udh
+      xml_hash
+    end
+
+    def response_code_for(response_data)
+      request_result_code = response_data[:notification_request_result][:notification_result_header][:request_result_code] rescue "-1"
+      return "request:#{request_result_code}" unless request_result_code == "0"
+
+      notification_result_code = response_data[:notification_request_result][:notification_result_list][:notification_result][:notification_result_code] rescue "-1"
+      return "notification:#{notification_result_code}" unless notification_result_code == "0"
+
+      subscriber_result_code = response_data[:notification_request_result][:notification_result_list][:notification_result][:subscriber_result][:subscriber_result_code] rescue "-1"
+      (subscriber_result_code == "0") ? subscriber_result_code : "subscriber:#{subscriber_result_code}"
+    end
+
+  end
+end

data/lib/smess/outputs/mm7.rb

@@ -0,0 +1,122 @@
+module Smess
+
+  class Mm7
+    include Smess::Logging
+
+    def initialize
+
+      # SOAP defaults
+      @endpoint = "http://example.com/mms/mm7"
+
+      # MM7 defaults
+      @mm7ns = "http://www.3gpp.org/ftp/Specs/archive/23_series/23.140/schema/REL-6-MM7-1-2"
+      @mm7header = {
+        "mm7:TransactionID" => Time.now.strftime('%Y%m%d%H%M%S'),
+        :attributes! => {
+          "mm7:TransactionID" => {
+            "xmlns:mm7" => @mm7ns
+          }
+        }
+      }
+      @mm7body = {
+        "mm7:MM7Version" => "6.5.0",
+        "mm7:SenderIdentification" => {
+          "mm7:VASPID" => "",
+          "mm7:SenderAddress" => {}
+        },
+        "mm7:Recipients" => {
+          "mm7:To" => {
+            "mm7:Number" => ""
+          }
+        },
+        "mm7:ServiceCode" => "",
+        "mm7:LinkedID" => "",
+        "mm7:DeliveryReport" => "true",
+        "mm7:Subject" => "",
+        "mm7:Content/" => nil,
+        :attributes! => {"mm7:Content/" => {"href" => "cid:attachment_1"}}
+      }
+
+      @credentials = nil
+
+    end
+
+  private
+
+    def perform_operator_adaptation(msisdn)
+      # implement this method to do modify the message output
+    end
+
+    def soap_client
+      Savon.configure do |config|
+        config.log_level = :info
+        config.raise_errors = false
+      end
+
+
+      endpoint = @endpoint
+      mm7ns = @mm7ns
+      credentials = @credentials
+
+      client = Savon::Client.new do |wsdl, http|
+        wsdl.endpoint = endpoint
+        wsdl.namespace = mm7ns
+
+        http.open_timeout = 15
+        http.read_timeout = 60 # Won't set read timeout to 10 minutes!! (IPX are crazy)
+        http.auth.basic  credentials[:name], credentials[:pass] unless credentials.nil?
+      end
+      client
+    end
+
+    def get_response_hash_from(response)
+      response.to_hash[:submit_rsp]
+    end
+
+    def get_message_id_from hash
+      hash[:message_id] rescue ''
+    end
+
+    def parse_response(response)
+      logger.debug ' --- '
+      logger.debug response.http_error.to_hash
+      logger.debug ' --- '
+      # logger.debug response.success?
+      # logger.debug ' --- '
+      # logger.debug "#{response.http_error}, #{response.soap_fault }"
+      # logger.debug ' --- '
+
+      unless response.success?
+        result = {
+          :response_code => "-1",
+          :response => {
+            :responseCode => "-1",
+            :responseText => response.http_error? ? response.http_error.to_hash : response.soap_fault.to_hash
+          }
+        }
+
+        return result
+      end
+
+      hash = get_response_hash_from response
+      message_id = get_message_id_from hash
+
+      # any 1000 range code is a success, anything else is an error.
+      status_code = hash[:status][:status_code] rescue '-1'
+      if (1000..1999) === status_code.to_i
+        response_code = "0"
+      else
+        response_code = status_code
+        # LOG error here?
+      end
+
+      result = {
+        :message_id => message_id,
+        :response_code => response_code,
+        :response => hash
+      }
+
+    end
+
+  end
+end

data/lib/smess/outputs/smsglobal.rb

@@ -0,0 +1,70 @@
+require 'uri'
+require 'httpi'
+
+module Smess
+  class Smsglobal
+    include Smess::Logging
+
+    def deliver_sms(sms)
+      return false unless sms.kind_of? Sms
+
+      url = "https://www.smsglobal.com/http-api.php"
+      from = sms.originator || ENV["SMESS_SMSGLOBAL_SENDER_ID"]
+
+      params = {
+        action: "sendsms",
+        user: ENV["SMESS_SMSGLOBAL_USER"],
+        password: ENV["SMESS_SMSGLOBAL_PASS"],
+        from: from,
+        to: sms.to,
+        text: sms.message.strip_nongsm_chars,
+        maxsplit: "3"
+      }
+
+      request = HTTPI::Request.new
+      request.url = url
+      request.body = params
+
+      begin
+        HTTPI.log_level = :debug
+        response = HTTPI.post request
+
+      rescue Exception => e
+        logger.warn response
+        # connection problem or some error
+        result = {
+          response_code: '-1',
+          response: {
+            temporaryError: 'true',
+            responseCode: e.code,
+            responseText: e.message
+          },
+          data: {
+            to: sms.to,
+            text: sms.message.strip_nongsm_chars,
+            from: from
+          }
+        }
+      else
+        first_response = response.body.split(/\r\n/).first.split(";")
+        response_code = first_response.first.split(':').last.to_i
+        message_id = first_response.last.split('SMSGlobalMsgID:').last
+
+        # Successful response
+        result = {
+          message_id: message_id,
+          response_code: response_code.to_s,
+          response: response.body,
+          destination_address: sms.to,
+          data: {
+            to: sms.to,
+            text: sms.message.strip_nongsm_chars,
+            from: from
+          }
+        }
+      end
+      result
+    end
+
+  end
+end

data/lib/smess/outputs/test.rb

@@ -0,0 +1,31 @@
+module Smess
+  class Test
+
+    @@instance = nil
+    @delivery_result = {
+      :response_code => '-1',
+      :response  => {
+        :temporaryError =>'true',
+        :responseCode => '-1',
+        :responseText => 'No delivery result set in test output object.'
+      }
+    }
+    class << self; attr_accessor :delivery_result end
+    attr_reader :sms, :mms
+
+    def initialize
+      @@instance = self
+    end
+
+    def self.instance
+      @@instance
+    end
+
+    def deliver_sms(sms)
+      return false unless sms.kind_of? Sms
+      @sms = sms
+      self.class.delivery_result
+    end
+
+  end
+end

data/lib/smess/outputs/twilio.rb

@@ -0,0 +1,69 @@
+require 'twilio-ruby'
+
+module Smess
+  class Twilio
+    include Smess::Logging
+
+    def deliver_sms(sms)
+      return false unless sms.kind_of? Sms
+
+      parts = Smess.separate_sms sms.message.strip_nongsm_chars
+      return false if parts[0].empty?
+
+      @client = ::Twilio::REST::Client.new(ENV["SMESS_TWILIO_SID"], ENV["SMESS_TWILIO_AUTH_TOKEN"])
+
+
+      results = []
+      while parts.length > 0
+        results << send_one_sms(sms, parts.shift)
+      end
+      results[0][:data][:text] = sms.message.strip_nongsm_chars
+      results[0]
+    end
+
+    def send_one_sms(sms, message)
+      begin
+        response = @client.account.sms.messages.create({
+          from: ENV["SMESS_TWILIO_FROM"],
+          to: "+#{sms.to}",
+          body: message,
+          status_callback: ENV["SMESS_TWILIO_CALLBACK_URL"]
+        })
+      rescue Exception => e
+        logger.warn response
+        # connection problem or some error
+        result = {
+          response_code: '-1',
+          response: {
+            temporaryError: 'true',
+            responseCode: e.code,
+            responseText: e.message
+          },
+          data: {
+            to: sms.to,
+            text: message,
+            from: ENV["SMESS_TWILIO_FROM"]
+          }
+        }
+      else
+        response_code = response.status
+        response_code = "0" unless response.status == "failed"
+        # Successful response
+        result = {
+          message_id: response.sid,
+          response_code: response_code.to_s,
+          response: MultiJson.load(@client.last_response.body),
+          destination_address: sms.to,
+          data: {
+            to: sms.to,
+            text: message,
+            from: ENV["SMESS_TWILIO_FROM"]
+          }
+        }
+      end
+      result
+    end
+
+
+  end
+end