alula-ruby 0.50.1

data/lib/alula/oauth.rb

@@ -0,0 +1,118 @@
+require 'httparty'
+
+module Alula
+  class Oauth
+    include HTTParty
+
+    class << self
+      # Has pseudo attr readers :client_id, :client_secret, :api_url, :debug
+
+      def configure(**config)
+        self.api_url = config[:api_url]
+        self.client_id = config[:client_id]
+        self.client_secret = config[:client_secret]
+        self.debug = config[:debug] == true
+        nil
+      end
+
+      def authenticate(username: nil, password: nil, grant_type: :password, scopes: nil)
+        raise Alula::NotConfiguredError.new('did you forget to call Alula::Oauth.configure ?') unless api_url
+
+        raise Alula::NotConfiguredError.new('no scopes specified') if grant_type.to_sym == :client_credentials && (scopes.nil? || scopes == '')
+
+        opts = {
+          body: {
+            grant_type: grant_type.to_s,
+            client_id: client_id,
+            client_secret: client_secret,
+          }
+        }
+
+        if grant_type == :password
+          opts[:body][:username] = username if username
+          opts[:body][:password] = password if password
+        end
+
+        opts[:body][:scope] = scopes if grant_type.to_sym == :client_credentials
+
+        if self.debug
+          opts[:debug_output] = Alula.logger 
+          # sets the HTTParty logger
+          logger Alula.logger, :info
+        end
+
+        response = post(api_url + '/oauth/token', opts)
+
+        if response.ok?
+          Response.new(response.parsed_response)
+        else
+          Error.new(response.parsed_response)
+        end
+      end
+
+      def refresh(refresh_token:, access_token:)
+        opts = {
+          body: {
+            grant_type: 'refresh_token',
+            client_id: client_id,
+            client_secret: client_secret,
+            refresh_token: refresh_token,
+          },
+          headers: {
+            'Authorization:': "Bearer #{access_token}"
+          }
+        }
+
+        if self.debug == true
+          opts[:debug_output] = Alula.logger
+        end
+
+        response = post(api_url + '/oauth/token', opts)
+
+        if response.ok?
+          Response.new(response.parsed_response)
+        else
+          Error.new(response.parsed_response)
+        end
+      end
+
+      %i(api_url client_id client_secret debug).each do |prop|
+        define_method(prop) do
+          RequestStore.store["alula_#{prop}"]
+        end
+
+        define_method("#{prop}=") do |value|
+          RequestStore.store["alula_#{prop}"] = value
+        end
+      end
+    end
+
+    # Simple Oauth::Response reader object
+    class Response
+      attr_reader :token_type, :access_token, :expires_in, :expires_at, :refresh_token, :scope
+
+      def initialize(attributes)
+        @raw_response = attributes
+
+        @token_type = attributes['token_type']
+        @access_token = attributes['access_token']
+        @expires_in = attributes['expires_in']
+        @expires_at = Time.now + @expires_in
+        @refresh_token = attributes['refresh_token']
+        @scope = attributes['scope']
+      end
+    end
+
+    # Simple representation of an auth error
+    class Error
+      attr_reader :code, :error, :error_description, :raw_response
+
+      def initialize(attributes)
+        @raw_response = attributes
+        @code = attributes['code']
+        @error = attributes['error']
+        @error_description = attributes['error_description'] || attributes['message']
+      end
+    end
+  end
+end

data/lib/alula/pagination.rb

@@ -0,0 +1,25 @@
+module Alula
+  class Pagination
+    attr_reader :total, :number, :size
+
+    def initialize(meta_page_obj)
+      @total = meta_page_obj['total']
+      @number = meta_page_obj['number']
+      @size = meta_page_obj['size']
+    end
+
+    def has_next?
+      number < page_count
+    end
+
+    def has_prev?
+      number > 1
+    end
+
+    def page_count
+      (total.to_f / size.to_f).ceil
+    rescue ZeroDivisionError
+      0
+    end
+  end
+end

data/lib/alula/procedures/dealer_device_stats_proc.rb

@@ -0,0 +1,16 @@
+module Alula
+  class DealerDeviceStatsProc < Alula::RpcResource
+
+    class Response < Alula::RpcResponse
+    end
+
+    def self.call(dealer_id:)
+      request( 
+        http_method: :post,
+        path: '/rpc/v1/dealers/devices/stats/get',
+        payload: { dealerId: dealer_id },
+        handler: Response
+      )
+    end
+  end
+end

data/lib/alula/procedures/dealer_restore_proc.rb

@@ -0,0 +1,25 @@
+##
+# dealerId   string  GUID of the dealer to operate on
+# 
+  
+# Method: dealers.restore
+module Alula
+  class DealerRestoreProc < Alula::RpcResource
+
+    class Response < Alula::RpcResponse
+    end
+
+    def self.call(dealer_id:)
+      payload = {
+        dealerId: dealer_id,
+      }
+
+      request( 
+        http_method: :post,
+        path: '/rpc/v1/dealers/restore',
+        payload: payload,
+        handler: Response
+      )
+    end
+  end
+end

data/lib/alula/procedures/dealer_suspend_proc.rb

@@ -0,0 +1,25 @@
+##
+# dealerId   string  GUID of the dealer to operate on
+# 
+  
+# Method: dealers.suspend
+module Alula
+  class DealerSuspendProc < Alula::RpcResource
+
+    class Response < Alula::RpcResponse
+    end
+
+    def self.call(dealer_id:)
+      payload = {
+        dealerId: dealer_id,
+      }
+
+      request( 
+        http_method: :post,
+        path: '/rpc/v1/dealers/suspend',
+        payload: payload,
+        handler: Response
+      )
+    end
+  end
+end

data/lib/alula/procedures/device_assign_proc.rb

@@ -0,0 +1,23 @@
+module Alula
+  class DeviceAssignProc < Alula::RpcResource
+
+    class Response < Alula::RpcResponse
+    end
+
+    def self.call(customer_id:, device_id:, pin: nil)
+      payload = {
+        customerId: customer_id,
+        deviceId: device_id,
+      }
+
+      payload[:pin] = pin unless pin.nil?
+
+      request( 
+        http_method: :post,
+        path: '/rpc/v1/devices/assign',
+        payload: payload,
+        handler: Response
+      )
+    end
+  end
+end

data/lib/alula/procedures/device_cellular_history_proc.rb

@@ -0,0 +1,33 @@
+#
+# deviceId string Device ID (36-char UUID)
+# startAt string The earliest date to include in the results. 	format: date-time
+# stopAt string The latest date to include in the results. 	format: date-time
+#
+
+# Method: devices.register
+module Alula
+  class DeviceCellularHistoryProc < Alula::RpcResource
+    ONE_DAY = 86_400
+    class Response < Alula::RpcResponse
+    end
+
+    def self.call(device_id:, start_at: nil, stop_at: nil)
+      # Helpers to set start/stop if only one is passed
+      seven_days_in_seconds = Alula::DeviceCellularHistoryProc::ONE_DAY * 7
+
+      stop_at = start_at + seven_days_in_seconds if stop_at.nil?
+      start_at = stop_at - seven_days_in_seconds if start_at.nil?
+
+      request(
+        http_method: :post,
+        path: '/rpc/v1/devices/cellular/history/get',
+        payload: {
+          deviceId: device_id,
+          startAt: start_at.utc.iso8601,
+          stopAt: stop_at.utc.iso8601
+        },
+        handler: Response
+      )
+    end
+  end
+end

data/lib/alula/procedures/device_rateplan_get_proc.rb

@@ -0,0 +1,21 @@
+# Method: devices.rateplan.get
+module Alula
+  class DeviceRatePlanGetProc < Alula::RpcResource
+
+    class Response < Alula::RpcResponse
+    end
+
+    def self.call(device_id:)
+      payload = {
+        deviceId: device_id
+      }
+
+      request(
+        http_method: :post,
+        path: '/rpc/v1/devices/rateplan/get',
+        payload: payload,
+        handler: Response
+      )
+    end
+  end
+end

data/lib/alula/procedures/device_register_proc.rb

@@ -0,0 +1,31 @@
+##
+# crc   string  4 digit number; hexadecimal for Helix devices, decimal otherwise  
+# dealerId  string  Dealer ID (36-character UUID)   
+# mac   string  MAC address (hex, transmission order, colon/slash separated)  
+# skipPartnerClaim  boolean   Set to true to skip Helix partner configuration   [true, false]
+# 
+  
+# Method: devices.register
+module Alula
+  class DeviceRegisterProc < Alula::RpcResource
+
+    class Response < Alula::RpcResponse
+    end
+
+    def self.call(mac:, dealer_id:, crc:, skip_partner_claim: false)
+      payload = {
+        mac: mac,
+        crc: crc,
+        dealerId: dealer_id,
+        skipPartnerClaim: skip_partner_claim
+      }
+
+      request( 
+        http_method: :post,
+        path: '/rpc/v1/devices/register',
+        payload: payload,
+        handler: Response
+      )
+    end
+  end
+end

data/lib/alula/procedures/device_signal_add_proc.rb

@@ -0,0 +1,42 @@
+module Alula
+  class DeviceSignalAddProc < Alula::RpcResource
+
+    class Response < Alula::RpcResponse
+      def initialize(response)
+        super(response)
+        #
+        # This RPC response gives a new EventLog item
+        data = response.data['result']['data'][0]
+        @data = Alula::DeviceEventLog.new(data['id'], data['attributes'])
+      end
+    end
+
+    def self.call(action:, customer_id:, dealer_id:, device_id:, group_id:, log_format:,
+                  mac:, relay_status:, signal_account_number:, signal_event_code:, signal_event_qualifier:,
+                  signal_partition:, signal_user_zone:, sn:)
+      payload = {
+        action: action,
+        customerId: customer_id,
+        dealerId: dealer_id,
+        deviceId: device_id,
+        groupId: group_id,
+        logFormat: log_format,
+        mac: mac,
+        relayStatus: relay_status,
+        signalAccountNumber: signal_account_number,
+        signalEventCode: signal_event_code,
+        signalEventQualifier: signal_event_qualifier,
+        signalPartition: signal_partition,
+        signalUserZone: signal_user_zone,
+        sn: sn,
+      }
+
+      request( 
+        http_method: :post,
+        path: '/rpc/v1/devices/signal/add',
+        payload: payload,
+        handler: Response
+      )
+    end
+  end
+end

data/lib/alula/procedures/device_signal_delivered_proc.rb

@@ -0,0 +1,31 @@
+module Alula
+  class DeviceSignalDeliveredProc < Alula::RpcResource
+
+    class Response < Alula::RpcResponse
+      def initialize(response)
+        super(response)
+        #
+        # This RPC response gives an updated EventLog item
+        data = response.data['result']['data'][0]
+        @data = Alula::DeviceEventLog.new(data['id'], data['attributes'])
+      end
+    end
+
+    def self.call(dealer_id:, device_id:, group_id:, log_format:, mac:)
+      payload = {
+        dealerId: dealer_id,
+        deviceId: device_id,
+        groupId: group_id,
+        logFormat: log_format,
+        mac: mac,
+      }
+
+      request( 
+        http_method: :post,
+        path: '/rpc/v1/devices/signal/delivered',
+        payload: payload,
+        handler: Response
+      )
+    end
+  end
+end

data/lib/alula/procedures/device_signal_update_proc.rb

@@ -0,0 +1,32 @@
+module Alula
+  class DeviceSignalUpdateProc < Alula::RpcResource
+
+    class Response < Alula::RpcResponse
+      def initialize(response)
+        super(response)
+        #
+        # This RPC response gives an updated EventLog item
+        data = response.data['result']['data'][0]
+        @data = Alula::DeviceEventLog.new(data['id'], data['attributes'])
+      end
+    end
+
+    def self.call(dealer_id:, device_id:, group_id:, log_format:, mac:, relay_status:)
+      payload = {
+        dealerId: dealer_id,
+        deviceId: device_id,
+        groupId: group_id,
+        logFormat: log_format,
+        mac: mac,
+        relayStatus: relay_status,
+      }
+
+      request( 
+        http_method: :post,
+        path: '/rpc/v1/devices/signal/update',
+        payload: payload,
+        handler: Response
+      )
+    end
+  end
+end

data/lib/alula/procedures/device_unassign_proc.rb

@@ -0,0 +1,16 @@
+module Alula
+  class DeviceUnassignProc < Alula::RpcResource
+
+    class Response < Alula::RpcResponse
+    end
+
+    def self.call(device_id:)
+      request( 
+        http_method: :post,
+        path: '/rpc/v1/devices/unassign',
+        payload: { deviceId: device_id },
+        handler: Response
+      )
+    end
+  end
+end

data/lib/alula/procedures/device_unregister_proc.rb

@@ -0,0 +1,21 @@
+module Alula
+  class DeviceUnregisterProc < Alula::RpcResource
+
+    class Response < Alula::RpcResponse
+    end
+
+    def self.call(mac:, deactivate:)
+      payload = {
+        mac: mac,
+        deactivate: deactivate,
+      }
+
+      request( 
+        http_method: :post,
+        path: '/rpc/v1/devices/unregister',
+        payload: payload,
+        handler: Response
+      )
+    end
+  end
+end

data/lib/alula/procedures/upload_touchpad_branding_proc.rb

@@ -0,0 +1,24 @@
+module Alula
+  class UploadTouchpadBrandingProc < Alula::RpcResource
+    class Response < Alula::RpcResponse
+    end
+
+    def self.call(dealer_id:, branding_file:)
+      payload = {
+        dealerId: dealer_id,
+        brandingFile: branding_file
+      }
+
+      request(
+        http_method: :post,
+        path: '/upload/v1/dealers/branding/touchpad',
+        payload: payload,
+        handler: Response,
+        wrap: false,
+        opts: {
+          multipart: true
+        }
+      )
+    end
+  end
+end

data/lib/alula/procedures/user_plansvideo_price_get.rb

@@ -0,0 +1,21 @@
+# Method: devices.rateplan.get
+module Alula
+  class UserPlansVideoPriceGetProc < Alula::RpcResource
+
+    class Response < Alula::RpcResponse
+    end
+
+    def self.call(user_id:)
+      payload = {
+        userId: user_id
+      }
+
+      request(
+        http_method: :post,
+        path: '/rpc/v1/users/plansvideo/price/get',
+        payload: payload,
+        handler: Response
+      )
+    end
+  end
+end

data/lib/alula/procedures/user_transfer_accept.rb

@@ -0,0 +1,19 @@
+module Alula
+  class UserTransferAccept < Alula::RpcResource
+
+    class Response < Alula::RpcResponse
+    end
+
+    def self.call(transfer_id:, description:)
+      request( 
+        http_method: :post,
+        path: '/rpc/v1/users/transfer/accept',
+        payload: {
+          id: transfer_id,
+          description: description,
+        },
+        handler: Response
+      )
+    end
+  end
+end

data/lib/alula/procedures/user_transfer_authorize.rb

@@ -0,0 +1,18 @@
+module Alula
+  class UserTransferAuthorize < Alula::RpcResource
+
+    class Response < Alula::RpcResponse
+    end
+
+    def self.call(transfer_id:)
+      request( 
+        http_method: :post,
+        path: '/rpc/v1/users/transfer/authorize',
+        payload: {
+          id: transfer_id
+        },
+        handler: Response
+      )
+    end
+  end
+end

data/lib/alula/procedures/user_transfer_cancel.rb

@@ -0,0 +1,18 @@
+module Alula
+  class UserTransferCancel < Alula::RpcResource
+
+    class Response < Alula::RpcResponse
+    end
+
+    def self.call(transfer_id:)
+      request( 
+        http_method: :post,
+        path: '/rpc/v1/users/transfer/cancel',
+        payload: {
+          id: transfer_id
+        },
+        handler: Response
+      )
+    end
+  end
+end

data/lib/alula/procedures/user_transfer_deny.rb

@@ -0,0 +1,19 @@
+module Alula
+  class UserTransferDeny < Alula::RpcResource
+
+    class Response < Alula::RpcResponse
+    end
+
+    def self.call(transfer_id:, description:)
+      request( 
+        http_method: :post,
+        path: '/rpc/v1/users/transfer/deny',
+        payload: {
+          id: transfer_id,
+          reason: description,
+        },
+        handler: Response
+      )
+    end
+  end
+end

data/lib/alula/procedures/user_transfer_reject.rb

@@ -0,0 +1,19 @@
+module Alula
+  class UserTransferReject < Alula::RpcResource
+
+    class Response < Alula::RpcResponse
+    end
+
+    def self.call(transfer_id:, description:)
+      request( 
+        http_method: :post,
+        path: '/rpc/v1/users/transfer/reject',
+        payload: {
+          id: transfer_id,
+          reason: description,
+        },
+        handler: Response
+      )
+    end
+  end
+end

data/lib/alula/procedures/user_transfer_request.rb

@@ -0,0 +1,19 @@
+module Alula
+  class UserTransferRequest < Alula::RpcResource
+
+    class Response < Alula::RpcResponse
+    end
+
+    def self.call(customer_id:, dealer_id:)
+      request( 
+        http_method: :post,
+        path: '/rpc/v1/users/transfer/request',
+        payload: {
+          customerId: customer_id,
+          dealerId: dealer_id
+        },
+        handler: Response
+      )
+    end
+  end
+end