globe_connect 1.0.1

data/lib/globe_connect/authentication.rb

@@ -0,0 +1,39 @@
+class Authentication < Base
+
+  ACCESS_TOKEN_URL  = 'https://developer.globelabs.com.ph/oauth/access_token'
+  REDIRECT_URL      = 'https://developer.globelabs.com.ph/dialog/oauth?app_id=%s'
+
+  # Requests for an access token based on the given app id, app secret, and code
+  # that was returned after logging in via WebForm
+  #
+  # @param string app_id
+  # @param string app_secret
+  # @param string code
+  # @return json
+  def get_access_token(app_id, app_secret, code)
+    url = ACCESS_TOKEN_URL
+
+    # set body
+    query = {
+      "app_id"      => app_id,
+      "app_secret"  => app_secret,
+      "code"        => code
+    }
+
+    # hash it
+    payload = URI.encode(query.map{|k,v| "#{k}=#{v}"}.join("&"))
+
+    # send post request
+    response = send_post_request(url, payload, 'application/x-www-form-urlencoded')
+
+    return JSON.parse(response)
+  end
+
+  # Generates the url where the application/user will login
+  #
+  # @param string app_id
+  # @return string
+  def get_access_url(app_id)
+    return sprintf(REDIRECT_URL, app_id)
+  end
+end

data/lib/globe_connect/base.rb

@@ -0,0 +1,58 @@
+class Base
+
+  # Sends request via GET method
+  #
+  # @param string url
+  # @param mixed  payload
+  # @return json
+  def send_get_request(url, payload = nil)
+    # set the uri
+    url = URI(url)
+
+    # set http settings
+    http              = Net::HTTP.new(url.host, url.port)
+    http.use_ssl      = true
+    http.verify_mode  = OpenSSL::SSL::VERIFY_NONE
+
+    # set request
+    request                   = Net::HTTP::Get.new(url)
+    request['content-type']   = 'application/json'
+    request['cache-control']  = 'no-cache'
+
+    # send the request and get whatever is the response
+    response = http.request(request)
+
+    # return whatever the result
+    return response.read_body
+  end
+
+  # Sends request via POST method
+  #
+  # @param string url
+  # @param mixed  payload
+  # @param string content_type
+  # @return json
+  def send_post_request(url, payload, content_type = 'application/json')
+    # set the uri
+    url = URI(url)
+
+    # set http settings
+    http              = Net::HTTP.new(url.host, url.port)
+    http.use_ssl      = true
+    http.verify_mode  = OpenSSL::SSL::VERIFY_NONE
+
+    # set request
+    request                   = Net::HTTP::Post.new(url)
+    request["content-type"]   = content_type
+    request["cache-control"]  = 'no-cache'
+
+    # set the payload
+    request.body = payload
+
+    # send the request and get whatever is the response
+    response = http.request(request)
+
+    # return the response by reading the body
+    return response.read_body
+  end
+end

data/lib/globe_connect/location_query.rb

@@ -0,0 +1,29 @@
+class LocationQuery < Base
+
+  LOCATION_URL = 'https://devapi.globelabs.com.ph/location/v1/queries/location?access_token=%s&address=%s&requestedAccuracy=%s'
+
+  attr_accessor :access_token
+
+  # Starts up whenever the class is being called.
+  #
+  # @param string access_token
+  # @return LocationQuery
+  def initialize(access_token)
+    @access_token = access_token
+  end
+
+  # Fetches the geolocation of a given address.
+  #
+  # @param string address
+  # @param int    accuracy
+  # @return json
+  def get_location(address, accuracy = 10)
+    # prepare the request url
+    url = sprintf(LOCATION_URL, @access_token, address, accuracy)
+
+    # set get request
+    response = send_get_request(url)
+
+    return JSON.parse(response)
+  end
+end

data/lib/globe_connect/payment.rb

@@ -0,0 +1,65 @@
+class Payment < Base
+
+  CHARGE_URL          = 'https://devapi.globelabs.com.ph/payment/v1/transactions/amount?access_token=%s'
+  LAST_REFERENCE_URL  = 'https://devapi.globelabs.com.ph/payment/v1/transactions/getLastRefCode?app_id=%s&app_secret=%s'
+
+  attr_accessor :access_token, :app_id, :app_secret
+
+  # Starts up whenever the class is being called.
+  #
+  # @param string app_id
+  # @param string app_secret
+  # @param string access_token
+  # @return Payment
+  def initialize(app_id, app_secret, access_token = nil)
+    @app_id       = app_id
+    @app_secret   = app_secret
+    @access_token = access_token
+  end
+
+  # Sends payment request.
+  #
+  # @param float  amount
+  # @param string description
+  # @param string end_user_id
+  # @param string reference_code
+  # @param string transaction_operation_status
+  # @return json
+  def send_payment_request(amount, description, end_user_id, reference_code, transaction_operation_status)
+    # set the request url
+    url = sprintf(CHARGE_URL, @access_token)
+
+    # make sure that amount has 2 decimal places
+    amount = '%.2f' % amount
+
+    # set the payload
+    payload = {
+      "amount"                      => amount.to_s,
+      "description"                 => description,
+      "endUserId"                   => end_user_id,
+      "referenceCode"               => reference_code,
+      "transactionOperationStatus"  => transaction_operation_status
+    }
+
+    # convert to JSON
+    payload = JSON.generate(payload)
+
+    # send post request
+    response = send_post_request(url, payload)
+
+    return JSON.parse(response)
+  end
+
+  # Get last reference code request.
+  #
+  # @return json
+  def get_last_reference_code
+    # set the url
+    url = sprintf(LAST_REFERENCE_URL, @app_id, @app_secret)
+
+    # send response
+    response = send_get_request(url)
+
+    return JSON.parse(response)
+  end
+end

data/lib/globe_connect/sms.rb

@@ -0,0 +1,90 @@
+class Sms < Base
+
+  SEND_SMS_URL    = 'https://devapi.globelabs.com.ph/smsmessaging/v1/outbound/%s/requests?access_token=%s'
+  BINARY_SMS_URL  = 'https://devapi.globelabs.com.ph/binarymessaging/v1/outbound/%s/requests?access_token=%s'
+
+  attr_accessor :access_token, :short_code
+
+  # Starts up whenever the class is being called.
+  #
+  # @param string access_token
+  # @param string short_code
+  # @return Sms
+  def initialize(access_token, short_code)
+    @access_token = access_token
+    @short_code   = short_code
+  end
+
+  # Sends a binary sms based on the given address
+  #
+  # @param string address
+  # @param string message
+  # @param string header
+  # @param string encoding
+  # @return json
+  def send_binary_message(address, message, header, encoding = nil)
+    # format url
+    url = sprintf(BINARY_SMS_URL, @short_code, @access_token)
+
+    # prepare the payload
+    payload = {
+      "outboundBinaryMessageRequest" => {
+        "userDataHeader"        => header,
+        "dataCodingScheme"      => 1,
+        "address"               => address,
+        "senderAddress"         => @short_code,
+        "access_token"          => @access_token,
+        "outboundBinaryMessage" => {
+            "message" => message
+        },
+      }
+    }
+
+    # convert to JSON
+    payload = JSON.generate(payload)
+
+    # send post request
+    response = send_post_request(url, payload)
+
+    return JSON.parse(response)
+  end
+
+  # Sends a sms based on the given address
+  #
+  # @param string address
+  # @param string message
+  # @param mixed  client_correlator
+  # @return json
+  def send_message(address, message, client_correlator = nil)
+    # set the address format
+    addressFormat = 'tel:%s'
+
+    # format url
+    url = sprintf(SEND_SMS_URL, @short_code, @access_token)
+
+    # set the address
+    address = sprintf(addressFormat, address)
+
+    # set the sender
+    sender = sprintf(addressFormat, @short_code)
+
+    # prepare the payload
+    payload = {
+      'outboundSMSMessageRequest' => {
+        'senderAddress'           => sender,
+        'address'                 => [address],
+        'outboundSMSTextMessage'  => {
+          'message' => message
+        },
+      }
+    }
+
+    # convert to JSON
+    payload = JSON.generate(payload)
+
+    # send post request
+    response = send_post_request(url, payload)
+
+    return JSON.parse(response)
+  end
+end

data/lib/globe_connect/subscriber.rb

@@ -0,0 +1,43 @@
+class Subscriber < Base
+
+  SUBSCRIBER_BALANCE_URL  = 'https://devapi.globelabs.com.ph/location/v1/queries/balance?access_token=%s&address=%s'
+  RELOAD_AMOUNT_URL       = 'https://devapi.globelabs.com.ph/location/v1/queries/reload_amount?access_token=%s&address=%s'
+
+  attr_accessor :access_token
+
+  # Starts up whenever the class is being called.
+  #
+  # @param string access_token
+  # @return Subscriber
+  def initialize(access_token)
+    @access_token = access_token
+  end
+
+  # Get subscriber balance request.
+  #
+  # @param string address
+  # @return json
+  def get_subscriber_balance(address)
+    # set the request url
+    url = sprintf(SUBSCRIBER_BALANCE_URL, @access_token, address)
+
+    # send post request
+    response = send_get_request(url)
+
+    return JSON.parse(response)
+  end
+
+  # Get subscriber reload amount.
+  #
+  # @param address
+  # @return json
+  def get_subscriber_reload_amount(address)
+    # set the request url
+    url = sprintf(RELOAD_AMOUNT_URL, @access_token, address)
+
+    # send post request
+    response = send_get_request(url)
+
+    return JSON.parse(response)
+  end
+end

data/lib/globe_connect/ussd.rb

@@ -0,0 +1,77 @@
+class Ussd < Base
+
+  SEND_URL  = 'https://devapi.globelabs.com.ph/ussd/v1/outbound/%s/send/requests?access_token=%s'
+  REPLY_URL = 'https://devapi.globelabs.com.ph/ussd/v1/outbound/%s/reply/requests?access_token=%s'
+
+  attr_accessor :access_token, :short_code
+
+  # Starts up whenever the class is being called.
+  #
+  # @param string access_token
+  # @param string short_code
+  # @return Ussd
+  def initialize(access_token, short_code)
+    @access_token = access_token
+    @short_code   = short_code
+  end
+
+  # @param string address
+  # @param string message
+  # @param boolean flash
+  # @return json
+  def send_ussd_request(address, message, flash)
+    # set the request url
+    url = sprintf(SEND_URL, @short_code, @access_token)
+
+    # set the payload
+    payload = {
+      "outboundUSSDMessageRequest" => {
+        "outboundUSSDMessage" => {
+            "message" => message
+        },
+        "address"       => address,
+        "senderAddress" => @short_code,
+        "flash"         => flash
+      }
+    }
+
+    # convert to JSON
+    payload = JSON.generate(payload)
+
+    # send post request
+    response = send_post_request(url, payload)
+
+    return JSON.parse(response)
+  end
+
+  # @param string address
+  # @param string message
+  # @param string session_id
+  # @param boolean flash
+  # @return json
+  def reply_ussd_request(address, message, session_id, flash)
+    # set the request url
+    url = sprintf(REPLY_URL, @short_code, @access_token)
+
+    # set the payload
+    payload = {
+      "outboundUSSDMessageRequest" => {
+        "outboundUSSDMessage" => {
+            "message" => message
+        },
+        "address"       => address,
+        "senderAddress" => @short_code,
+        "sessionID"     => session_id,
+        "flash"         => flash
+      }
+    }
+
+    # convert to JSON
+    payload = JSON.generate(payload)
+
+    # send post request
+    response = send_post_request(url, payload)
+
+    return JSON.parse(response)
+  end
+end

data/lib/globe_connect/version.rb

@@ -0,0 +1,3 @@
+module GlobeConnect
+  VERSION = "1.0.1"
+end

data/lib/globe_connect/voice.rb

@@ -0,0 +1,423 @@
+class Voice
+  def initialize(params = {}, &block)
+    # say can be stacked and we need to save the things here
+    @say = Array.new
+
+    # initialize things
+    @response = { :tropo => Array.new }
+
+    @building = true
+  end
+
+  def ask(params = {}, instance = false, &block)
+    hash    = nil
+    params  = set_recognizer(params)
+
+    if params.kind_of? Array
+      # multiple instance of ask so just return it
+      return params
+    else
+      # build hash
+      hash = build_action('ask', params)
+    end
+
+    if instance || params.key?(:instance)
+      return hash[:ask]
+    end
+
+    @response[:tropo] << hash
+  end
+
+  def call(params={}, &block)
+    if block_given?
+      create_nested_hash('call', params)
+      instance_exec(&block)
+      @response[:tropo] << @nested_hash
+    else
+      hash = build_action('call', params)
+      @response[:tropo] << hash
+    end
+
+    if @building.nil?
+      return render
+    end
+  end
+
+  def choices(params={}, instance = false)
+    hash = build_action('choices', params)
+
+    if @nested_hash
+      @nested_hash[@nested_name.to_sym].merge!(hash)
+    else
+      # check if this is an instance, if it is we return the builded hash
+      if instance
+        return hash[:choices]
+      end
+
+      @response[:tropo] << hash
+
+      if @building.nil?
+        return render
+      end
+    end
+  end
+
+  def connect(params={}, instance = false)
+    hash = build_action('connect', params)
+
+    if @nested_hash
+      @nested_hash[@nested_name.to_sym].merge!(hash)
+    else
+      # check if this is an instance, if it is we return the builded hash
+      if instance
+        return hash[:connect]
+      end
+
+      @response[:tropo] << hash
+
+      if @building.nil?
+        return render
+      end
+    end
+  end
+
+  def conference(params={}, &block)
+    if block_given?
+      create_nested_hash('conference', params)
+      instance_exec(&block)
+      @response[:tropo] << @nested_hash
+    else
+      hash = build_action('conference', params)
+      @response[:tropo] << hash
+    end
+
+    if @building.nil?
+      return render
+    end
+  end
+
+  def hangup
+    @response[:tropo] << { :hangup => nil }
+    if @building.nil?
+      return render
+    end
+  end
+
+  def headers(params = {}, instance = false, &block)
+    response = Array.new
+
+    if block_given?
+      create_nested_hash('headers', params)
+      instance_exec(&block)
+      response = @nested_hash
+    else
+      hash = build_action('headers', params)
+      response = hash
+    end
+
+    # are we using the headers just to generate the header?
+    if instance
+      # return the headers
+      return response[:headers]
+    end
+
+    @response[:tropo] << response
+  end
+
+  def join_prompt(params = {}, instance = false, &block)
+    hash = build_action('join_prompt', params)
+
+    if @nested_hash
+      @nested_hash[@nested_name.to_sym].merge!(hash)
+    else
+      # check if this is an instance, if it is we return the builded hash
+      if instance
+        return hash[:join_prompt]
+      end
+
+      @response[:tropo] << hash
+
+      if @building.nil?
+        return render
+      end
+    end
+  end
+
+  def leave_prompt(params = {}, instance = false, &block)
+    hash = build_action('leave_prompt', params)
+
+    if @nested_hash
+      @nested_hash[@nested_name.to_sym].merge!(hash)
+    else
+      # check if this is an instance, if it is we return the builded hash
+      if instance
+        return hash[:leave_prompt]
+      end
+
+      @response[:tropo] << hash
+
+      if @building.nil?
+        return render
+      end
+    end
+  end
+
+  def machine_detection(params = {}, &block)
+    if block_given?
+      create_nested_hash('machine_detection', params)
+      instance_exec(&block)
+      @response[:tropo] << @nested_hash
+    else
+      hash = build_action('machine_detection', params)
+      @response[:tropo] << hash
+    end
+
+    if @building.nil?
+      return render
+    end
+  end
+
+  def message(params={}, &block)
+    if block_given?
+      create_nested_hash('message', params)
+      instance_exec(&block)
+      @response[:tropo] << @nested_hash
+    else
+      hash = build_action('message', params)
+      @response[:tropo] << hash
+    end
+
+    if @building.nil?
+      return render
+    end
+  end
+
+  def on(params={}, instance = false, &block)
+    if params.kind_of? Array
+      # multiple instance, just return it
+      return params
+    end
+
+    # build it
+    hash = build_action('on', params)
+
+    if instance
+      return hash
+    end
+
+    # push to the main array
+    @response[:tropo] << { :on => hash }
+  end
+
+  def record(params={}, &block)
+    if block_given?
+      create_nested_hash('record', params)
+      instance_exec(&block)
+      @response[:tropo] << @nested_hash
+    else
+      hash = build_action('record', params)
+      @response[:tropo] << hash
+    end
+
+    if @building.nil?
+      return render
+    end
+  end
+
+  def render
+    # check for stacked says
+    if @say.any?
+      # check how many we have
+      if @say.count > 1
+        @response[:tropo] << { :say => @say }
+      else
+        @response[:tropo] << { :say => @say[0] }
+      end
+    end
+
+    return JSON.pretty_generate(@response)
+  end
+
+  def redirect(params={})
+    hash = build_action('redirect', params)
+    @response[:tropo] << hash
+
+    if @building.nil?
+      return render
+    end
+  end
+
+  def reject
+    @response[:tropo] << { :reject => nil }
+
+    if @building.nil?
+      return render
+    end
+  end
+
+  def say(value = nil, params = {}, instance = false)
+    if value.kind_of? String
+      params[:value] = value
+    elsif value.kind_of? Hash
+      params = value
+    elsif value.kind_of? Array
+      params = value
+    else
+      # we'll stop here, there's nothing to do.
+      return
+    end
+
+    if params.kind_of? Array
+      hash = Array.new
+      params.each do |param|
+        param = set_recognizer(param)
+        hash.push(build_action('say', param)[:say])
+      end
+    elsif params.kind_of? Hash
+      param = set_recognizer(params)
+      hash = build_action('say', param)
+    else
+      params = set_recognizer(params)
+      hash = build_action('say', params)
+    end
+
+    # check if this is an instance, if it is we return the builded hash
+    if instance
+      return hash[:say]
+    end
+
+    # save everything in the say attribute
+    # check first if the hash is an array
+    if hash.kind_of? Array
+      @say = hash
+    else
+      @say << hash[:say]
+    end
+
+    # if @nested_hash && @nested_on_hash.nil?
+    #   @nested_hash[@nested_name.to_sym].merge!(response)
+    # elsif @nested_on_hash
+    #   @nested_on_hash[:on][@nested_on_hash_cnt].merge!(response)
+    #   @nested_on_hash_cnt += 1
+    # else
+    if @building.nil?
+      return render
+    end
+    # end
+  end
+
+  def start_recording(params={})
+    if block_given?
+      create_nested_hash('start_recording', params)
+      instance_exec(&block)
+      @response[:tropo] << @nested_hash
+    else
+      hash = build_action('start_recording', params)
+      @response[:tropo] << hash
+    end
+
+    if @building.nil?
+      return render
+    end
+  end
+
+  def stop_recording
+    @response[:tropo] << { :stopRecording => nil }
+    render_response if @building.nil?
+  end
+
+  def transcription(params = {}, instance = false, &block)
+    hash = build_action('transcription', params)
+
+    if @nested_hash
+      @nested_hash[@nested_name.to_sym].merge!(hash)
+    else
+      # check if this is an instance, if it is we return the builded hash
+      if instance
+        return hash[:transcription]
+      end
+
+      @response[:tropo] << hash
+
+      if @building.nil?
+        return render
+      end
+    end
+  end
+
+  def transfer(params={}, &block)
+    if block_given?
+      create_nested_hash('transfer', params)
+      instance_exec(&block)
+      @response[:tropo] << @nested_hash
+    else
+      hash = build_action('transfer', params)
+      @response[:tropo] << hash
+    end
+
+    if @building.nil?
+      return render
+    end
+  end
+
+  def wait(params={}, &block)
+    if block_given?
+      create_nested_hash('wait', params)
+      instance_exec(&block)
+      @response[:tropo] << @nested_hash
+    else
+      hash = build_action('wait', params)
+      @response[:tropo] << hash
+    end
+
+    if @building.nil?
+      return render
+    end
+  end
+
+  # Here goes our private functions
+  private
+  def build_action(action, params)
+    if action == 'on'
+      return build_elements(params)
+    else
+      return { action.to_sym => build_elements(params) }
+    end
+  end
+
+  def build_elements(params)
+    hash = Hash.new
+
+    params.each_pair do |k,v|
+      if k.to_s.include? "_"
+        k = camelize(k.to_s)
+        k = k.to_sym if k
+      end
+      hash.merge!({ k => v })
+    end
+
+    return hash
+  end
+
+  def camelize(string)
+    split_string = string.split('_')
+    return_string = split_string[0] + split_string[1].capitalize
+    return_string = return_string + split_string[2].capitalize if split_string[2]
+
+    return return_string
+  end
+
+  def create_nested_hash(name, params)
+    @nested_hash = build_action(name, params)
+    @nested_name = name
+  end
+
+  def create_on_hash
+    @on_hash ||= { :on => Array.new }
+  end
+
+  def set_recognizer(params)
+    params.merge!({ :recognizer => @recognizer }) if params[:recognizer].nil? && @recognizer
+    return params
+  end
+end