gupshup-rb 0.1.7.1 → 0.1.8

data/lib/gupshup-rb/framework/rest/version.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Gupshup
+  module REST
+    class Version
+      attr_accessor :domain
+
+      class RecordStream
+        include Enumerable
+
+        def initialize(page, limit: nil, page_limit: nil)
+          @page = page
+          @limit = limit
+          @page_limit = page_limit
+        end
+
+        def each
+          current_record = 0
+          current_page = 1
+
+          while @page
+            @page.each do |record|
+              yield record
+              current_record += 1
+              return nil if @limit && @limit <= current_record
+            end
+
+            return nil if @page_limit && @page_limit <= current_page
+
+            @page = @page.next_page
+            current_page += 1
+          end
+        end
+      end
+
+      def initialize(domain)
+        @domain = domain
+        @version = nil
+      end
+
+      def absolute_url(uri)
+        @domain.absolute_url(relative_uri(uri))
+      end
+
+      def relative_uri(uri)
+        "#{@version.chomp('/').gsub(/^\//, '')}/#{uri.chomp('/').gsub(/^\//, '')}"
+      end
+
+      def request(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+        url = relative_uri(uri)
+        params = params.delete_if { |_k, v| v.nil? }
+        data = data
+        @domain.request(method, url, params, data, headers, auth, timeout)
+      end
+
+      def exception(response, header)
+        Gupshup::REST::RestError.new(header, response)
+      end
+
+      def fetch(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        response = request(
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+
+        # Note that 3XX response codes are allowed for fetches.
+        if response.status_code < 200 || response.status_code >= 400
+          raise exception(response, 'Unable to fetch record')
+        end
+
+        response.body
+      end
+
+      def update(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        response = request(
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+
+        if response.status_code < 200 || response.status_code >= 300
+          raise exception(response, 'Unable to update record')
+        end
+
+        response.body
+      end
+
+      def delete(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        response = request(
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+
+        if response.status_code < 200 || response.status_code >= 300
+          raise exception(response, 'Unable to delete record')
+        end
+
+        response.status_code == 204
+      end
+
+      def read_limits(limit = nil, page_size = nil)
+        unless limit.nil? || page_size
+          page_size = limit
+        end
+
+        {
+          limit: limit || nil,
+          page_size: page_size || nil
+        }
+      end
+
+      def page(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        request(
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+      end
+
+      def stream(page, limit: nil, page_limit: nil)
+        RecordStream.new(page, limit: limit, page_limit: page_limit)
+      end
+
+      def create(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        response = request(method, uri, params, data, headers, auth, timeout)
+
+        if response.status_code < 200 || response.status_code >= 300
+          raise exception(response, 'Unable to create record')
+        end
+
+        response.body
+      end
+    end
+  end
+end

data/lib/gupshup-rb/framework/serialize.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Gupshup
+  def self.serialize_iso8601_date(date)
+    if date.eql?(:unset)
+      date
+    elsif date.is_a?(Date)
+      date.iso8601
+    elsif date.is_a?(Time)
+      date.strftime('%Y-%m-%d')
+    elsif date.is_a?(String)
+      date
+    end
+  end
+
+  def self.serialize_iso8601_datetime(date)
+    if date.eql?(:unset)
+      date
+    elsif date.is_a?(Date)
+      Time.new(date.year, date.month, date.day).utc.iso8601
+    elsif date.is_a?(Time)
+      date.utc.iso8601
+    elsif date.is_a?(String)
+      date
+    end
+  end
+
+  def self.deserialize_rfc2822(date)
+    Time.rfc2822(date) unless date.nil?
+  end
+
+  def self.deserialize_iso8601_date(date)
+    Date.parse(date) unless date.nil?
+  end
+
+  def self.deserialize_iso8601_datetime(date)
+    Time.parse(date) unless date.nil?
+  end
+
+  def self.serialize_object(object)
+    if object.is_a?(Hash) || object.is_a?(Array)
+      JSON.generate(object)
+    else
+      object
+    end
+  end
+
+  def self.flatten(map, result = {}, previous = [])
+    map.each do |key, value|
+      if value.is_a? Hash
+        self.flatten(value, result, previous + [key])
+      else
+        result[(previous + [key]).join('.')] = value
+      end
+    end
+
+    result
+  end
+
+  def self.prefixed_collapsible_map(map, prefix)
+    result = {}
+    if map.is_a? Hash
+      flattened = self.flatten(map)
+      result = {}
+      flattened.each do |key, value|
+        result[prefix + '.' + key] = value
+      end
+    end
+
+    result
+  end
+
+  def self.serialize_list(input_list)
+    return input_list unless input_list.is_a? Array
+    result = []
+    input_list.each do |e|
+      result.push yield e
+    end
+    result
+  end
+end

data/lib/gupshup-rb/framework/values.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Gupshup
+  class Values
+    def self.of(hash)
+      hash.delete_if { |_, v| v.eql?(:unset) }
+    end
+  end
+end

data/lib/gupshup-rb/http/http_client.rb

@@ -0,0 +1,53 @@
+
+require 'faraday'
+
+module Gupshup
+  module HTTP
+    class Client
+      attr_accessor :adapter
+      attr_reader :last_response, :last_request
+      def initialize
+        @adapter = Faraday.default_adapter
+      end
+
+      def _request(request)
+        @connection = Faraday.new(url: "#{request.host}:#{request.port.to_s}", ssl: { verify: true }) do |f|
+          f.request :url_encoded
+          f.adapter @adapter
+          f.headers = request.headers
+        end
+        @last_request = request
+        @last_response = nil
+        response = send(request)
+        if response.status == 504
+          object = { message: 'Request timeout', code: 504 }.to_json
+        elsif response.body && !response.body.empty?
+          object = response.body
+        elsif response.status == 400
+          object = { message: 'Bad request', code: 400 }.to_json
+        end
+
+        gupshup_response = Gupshup::Response.new(response.status, object, headers: response.headers)
+        @last_response = gupshup_response
+
+        gupshup_response
+      end
+
+      def send(request)
+        @connection.send(request.method.downcase.to_sym,
+                         request.url,
+                         request.method == 'GET' ? request.params : request.data)
+      rescue Faraday::Error => e
+        raise Gupshup::REST::GupshupError, e
+      end
+
+      def request(host, port, method, url, data = {}, headers = {}, params = {}, auth = nil, timeout = nil)
+        request = Gupshup::Request.new(host, port, method, url, params, data, headers)
+        _request(request)
+
+      end
+    end
+  end
+end
+
+

data/lib/gupshup-rb/http.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir[File.join(__dir__, 'http/**/*.rb')].sort.each do |file|
+  require file
+end

data/lib/gupshup-rb/rest/api/v1/message.rb

@@ -0,0 +1,59 @@
+module Gupshup
+  module REST
+    class Api < Domain
+      class V1 < Version
+        class MessageList < ListResource
+          ##
+          # Initialize the MessageList
+          # @param [Version] version Version that contains the resource
+          # @param [String] src_name The SID 
+          # @return [MessageList] MessageList
+          # def initialize(version, src_name: nil, content_type, from, apikey)
+          def initialize(version, src_name: nil)
+            super(version)
+
+            # Path Solution
+            @solution = {src_name: src_name}
+            @uri = "https://api.gupshup.io/sm/api/v1/msg"
+            @base_url = 'https://api.gupshup.io'
+            @path = '/sm/api/v1/msg'
+
+            @channel = 'whatsapp'
+        
+          end
+          def create(to: nil, from: :unset, body: :unset, media_url: :unset, content_type: :unset, src_name: :unset, api_key: :unset)
+            headers = { 'apikey' => api_key}
+            binding.local_variables.each do |var_name|
+              var_value = binding.local_variable_get(var_name)
+              puts "#{var_name}: #{var_value}"
+            end
+
+            #case message_params[:type]
+            #when 'text'
+            #else
+              send_text_message(headers, from, to, body, src_name)
+            #end
+            #end
+
+
+          end
+
+          # @param [Object] destination
+          def send_text_message(headers, from, to, body, src_name)
+            payload = {'type' => 'text',
+                      'text' => body }.to_json
+            data = { 'channel' => @channel,
+                    'destination' => to,
+                    'source' => from,
+                    'src.name' => src_name,
+                    'message' => payload }
+            r = Gupshup::HTTP::Client.new
+            r.request(host = @base_url, port = 443, method = 'POST', url = @path, data = data, headers = headers)
+            
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/gupshup-rb/rest/api/v1.rb

@@ -0,0 +1,29 @@
+
+module Gupshup
+  module REST
+    class Api
+      class V1 < Version
+        ##
+        # Initialize the V1 version of Api
+        def initialize(domain)
+          super
+          @version = 'v1'
+          @solution = {}
+        end
+
+        def messages(sid=:unset)
+          raise ArgumentError, 'sid cannot be nil' if sid.nil?
+
+          @messages = V1::MessageList.new(@version, src_name: @solution[:sid], )
+
+          @messages
+        end
+        ##
+        # Provide a user friendly representation
+        def to_s
+          '<Gupshup::REST::Api::V1>'
+        end
+      end
+    end
+  end
+end

data/lib/gupshup-rb/rest/api.rb

@@ -0,0 +1,245 @@
+##
+# This code was generated by
+# \ / _    _  _|   _  _
+#  | (_)\/(_)(_|\/| |(/_  v1.0.0
+#       /       /
+#
+# frozen_string_literal: true
+
+module Gupshup
+  module REST
+    class Api < Domain
+      ##
+      # Initialize the Api Domain
+      def initialize(gupshup)
+        super
+
+        @uri = "https://api.gupshup.io/sm/api/v1/msg"
+
+        # Versions
+        @v2010 = nil
+      end
+
+      ##
+      # Version v2010 of api
+      def v2010
+        @v2010 ||= V2010.new self
+      end
+
+      ##
+      # Account provided as the authenticating account
+      def account
+        self.v2010.account
+      end
+
+      ##
+      # @param [String] sid A 34 character string that uniquely identifies this
+      #   resource.
+      # @return [Gupshup::REST::Api::V2010::AccountInstance] if sid was passed.
+      # @return [Gupshup::REST::Api::V2010::AccountList]
+      def accounts(sid=:unset)
+        self.v2010.accounts(sid)
+      end
+
+      ##
+      # @param [String] sid The unique string that that we created to identify the
+      #   Address resource.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::AddressInstance] if sid was passed.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::AddressList]
+      def addresses(sid=:unset)
+        self.account.addresses(sid)
+      end
+
+      ##
+      # @param [String] sid The unique string that that we created to identify the
+      #   Application resource.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::ApplicationInstance] if sid was passed.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::ApplicationList]
+      def applications(sid=:unset)
+        self.account.applications(sid)
+      end
+
+      ##
+      # @param [String] connect_app_sid The SID that we assigned to the Connect App.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::AuthorizedConnectAppInstance] if connect_app_sid was passed.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::AuthorizedConnectAppList]
+      def authorized_connect_apps(connect_app_sid=:unset)
+        self.account.authorized_connect_apps(connect_app_sid)
+      end
+
+      ##
+      # @param [String] country_code The
+      #   {ISO-3166-1}[https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2] country code of
+      #   the country.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::AvailablePhoneNumberCountryInstance] if country_code was passed.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::AvailablePhoneNumberCountryList]
+      def available_phone_numbers(country_code=:unset)
+        self.account.available_phone_numbers(country_code)
+      end
+
+      ##
+      # @return [Gupshup::REST::Api::V2010::AccountContext::BalanceInstance]
+      def balance
+        self.account.balance()
+      end
+
+      ##
+      # @param [String] sid The unique string that we created to identify this Call
+      #   resource.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::CallInstance] if sid was passed.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::CallList]
+      def calls(sid=:unset)
+        self.account.calls(sid)
+      end
+
+      ##
+      # @param [String] sid The unique string that that we created to identify this
+      #   Conference resource.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::ConferenceInstance] if sid was passed.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::ConferenceList]
+      def conferences(sid=:unset)
+        self.account.conferences(sid)
+      end
+
+      ##
+      # @param [String] sid The unique string that that we created to identify the
+      #   ConnectApp resource.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::ConnectAppInstance] if sid was passed.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::ConnectAppList]
+      def connect_apps(sid=:unset)
+        self.account.connect_apps(sid)
+      end
+
+      ##
+      # @param [String] sid The unique string that that we created to identify this
+      #   IncomingPhoneNumber resource.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::IncomingPhoneNumberInstance] if sid was passed.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::IncomingPhoneNumberList]
+      def incoming_phone_numbers(sid=:unset)
+        self.account.incoming_phone_numbers(sid)
+      end
+
+      ##
+      # @param [String] sid The unique string that that we created to identify the Key
+      #   resource.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::KeyInstance] if sid was passed.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::KeyList]
+      def keys(sid=:unset)
+        self.account.keys(sid)
+      end
+
+      ##
+      # @param [String] sid The unique string that that we created to identify the
+      #   Message resource.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::MessageInstance] if sid was passed.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::MessageList]
+      def messages(sid=:unset)
+        self.account.messages(sid)
+      end
+
+      ##
+      # @return [Gupshup::REST::Api::V2010::AccountContext::NewKeyInstance]
+      def new_keys
+        self.account.new_keys()
+      end
+
+      ##
+      # @return [Gupshup::REST::Api::V2010::AccountContext::NewSigningKeyInstance]
+      def new_signing_keys
+        self.account.new_signing_keys()
+      end
+
+      ##
+      # @param [String] sid The unique string that that we created to identify the
+      #   Notification resource.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::NotificationInstance] if sid was passed.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::NotificationList]
+      def notifications(sid=:unset)
+        self.account.notifications(sid)
+      end
+
+      ##
+      # @param [String] sid The unique string that that we created to identify the
+      #   OutgoingCallerId resource.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::OutgoingCallerIdInstance] if sid was passed.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::OutgoingCallerIdList]
+      def outgoing_caller_ids(sid=:unset)
+        self.account.outgoing_caller_ids(sid)
+      end
+
+      ##
+      # @param [String] sid The unique string that that we created to identify this
+      #   Queue resource.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::QueueInstance] if sid was passed.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::QueueList]
+      def queues(sid=:unset)
+        self.account.queues(sid)
+      end
+
+      ##
+      # @param [String] sid The unique string that that we created to identify the
+      #   Recording resource.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::RecordingInstance] if sid was passed.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::RecordingList]
+      def recordings(sid=:unset)
+        self.account.recordings(sid)
+      end
+
+      ##
+      # @param [String] sid The sid
+      # @return [Gupshup::REST::Api::V2010::AccountContext::SigningKeyInstance] if sid was passed.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::SigningKeyList]
+      def signing_keys(sid=:unset)
+        self.account.signing_keys(sid)
+      end
+
+      ##
+      # @return [Gupshup::REST::Api::V2010::AccountContext::SipInstance]
+      def sip
+        self.account.sip()
+      end
+
+      ##
+      # @param [String] sid The unique string that that we created to identify this
+      #   ShortCode resource.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::ShortCodeInstance] if sid was passed.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::ShortCodeList]
+      def short_codes(sid=:unset)
+        self.account.short_codes(sid)
+      end
+
+      ##
+      # @return [Gupshup::REST::Api::V2010::AccountContext::TokenInstance]
+      def tokens
+        self.account.tokens()
+      end
+
+      ##
+      # @param [String] sid The unique string that that we created to identify the
+      #   Transcription resource.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::TranscriptionInstance] if sid was passed.
+      # @return [Gupshup::REST::Api::V2010::AccountContext::TranscriptionList]
+      def transcriptions(sid=:unset)
+        self.account.transcriptions(sid)
+      end
+
+      ##
+      # @return [Gupshup::REST::Api::V2010::AccountContext::UsageInstance]
+      def usage
+        self.account.usage()
+      end
+
+      ##
+      # @return [Gupshup::REST::Api::V2010::AccountContext::ValidationRequestInstance]
+      def validation_requests
+        self.account.validation_requests()
+      end
+
+      ##
+      # Provide a user friendly representation
+      def to_s
+        '#<Gupshup::REST::Api>'
+      end
+    end
+  end
+end