monogoto_api 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 42f522d0958c03ff1086ed382b8f694d1b1fe7e20cb79104e8ca0761ecb83dd5
+  data.tar.gz: a2293409442e20edfc33aadb7a3fa8555126392862af211b604d08198925bfd4
+SHA512:
+  metadata.gz: 415b72e8b7716d44b591b9f2c3bca17e050c7166ea1d2a202cf2b203fc4c07531bac752b284ae50de3c1f24f85852614e9fc8d042ac563f6723b6b62ab16fbf1
+  data.tar.gz: 675830c19adfffcf1cd5ade14c1dea72349bc488cee1d6f834dca1f6ea12ddd631aab8e3cb5c52091a7c0cf2c6c259046e837c5392a581d9856fecf404fd6e16

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Zembia
+
+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/lib/monogoto_api/client.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "httparty"
+
+module MonogotoApi
+    class Client
+        include HTTParty
+
+        base_uri "https://console.monogoto.io"
+
+        def initialize(user, password)
+            auth = { "UserName" => user, "Password" => password }
+            jwt_response = self.class.post(
+                "/Auth",
+                body: auth.to_json, headers: { "Content-Type" => "application/json" }
+            )
+
+            @jwt         = jwt_response["token"]
+            @customer_id = jwt_response["CustomerId"]
+        end
+
+        def things
+            resp = get("/things", headers: auth_header)
+            MonogotoApi::Thing.parse_many(resp.parsed_response)
+        end
+
+        def thing(iccid)
+            resp = get("/thing/ThingId_ICCID_#{ iccid }", headers: auth_header)
+            MonogotoApi::Thing.parse(resp.parsed_response)
+        end
+
+        def thing_state(iccid)
+            get("/thing/ThingId_ICCID_#{ iccid }/state", headers: auth_header).body
+        end
+
+        def thing_session_status(iccid)
+            resp = get("/thing/status/?ThingIds=ThingId_ICCID_#{ iccid }", headers: auth_header)
+            MonogotoApi::SessionStatus.parse(resp.parsed_response)
+        end
+
+        def thing_events(iccid, limit: 20)
+            body = { "ThingIdELK" => "ThingId_ICCID_#{ iccid }", "limit" => limit }
+            # body.merge!(opts) if opts.any?
+            resp = post(
+                "/thing/searchCDR",
+                body:,
+                headers: apikey_headers
+            )
+            MonogotoApi::Event::List.parse(resp)
+        end
+
+        def thing_ping(iccid)
+            thing_data = thing(iccid)
+            resp = post(
+                "/thing/ThingId_ICCID_#{ iccid }/ping",
+                body: { "IPAddress" => thing_data.ip },
+                headers: apikey_headers
+            )
+            MonogotoApi::Ping::List.parse(resp)
+        end
+
+        def thing_refresh_connection(iccid)
+            resp = get("/thing/ThingId_ICCID_#{ iccid }/refreshConnection", headers: auth_header)
+            resp.success?
+        end
+
+        private
+
+        def auth_header
+            { Authorization: "Bearer #{ @jwt }" }
+        end
+
+        def apikey_headers
+            { Authorization: "Bearer #{ @jwt }", apikey: @customer_id }
+        end
+
+        def get(path, headers: {})
+            self.class.get(path, headers:)
+        end
+
+        def post(path, body: {}, headers: {})
+            self.class.post(path, body:, headers:)
+        end
+    end
+end

data/lib/monogoto_api/event/list.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module MonogotoApi
+    class Event
+        class List
+            attr_reader :events, :counter
+
+            def initialize
+                @events = []
+            end
+
+            # Push event element to events array
+            def push(event)
+                push_result = @events.push(event)
+                @counter = push_result.size
+                push_result
+            end
+
+            # Parser of API events response
+            def self.parse(resp_events)
+                list = new
+                resp_events.fetch("hits", {}).each { |event| list.push(MonogotoApi::Event.parse(event)) }
+                list
+            end
+        end
+    end
+end

data/lib/monogoto_api/event.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module MonogotoApi
+    class Event
+        attr_reader :severity, :msg, :msg_type, :timestamp, :data_type
+
+        def initialize(**attributes)
+            @severity  = attributes[:severity]
+            @msg       = attributes[:msg]
+            @msg_type  = attributes[:msg_type]
+            @timestamp = attributes[:timestamp]
+            @data_type = attributes[:data_type]
+        end
+
+        def self.parse(hash_event)
+            data_first = hash_event["_source"]
+            new(
+                severity: data_first["Severity"],
+                msg: data_first["message"],
+                msg_type: data_first["MessageType"],
+                timestamp: Time.at(data_first["Timestamp"] / 1_000),
+                data_type: data_first["EsDataType"]
+            )
+        end
+
+        def self.parse_many(hits)
+            output = []
+            hits.each { |pre_event| output.push(parse(pre_event)) }
+            output
+        end
+    end
+end

data/lib/monogoto_api/ip.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module MonogotoApi
+    class IP
+        attr_reader :ip, :ip_allocation_policy, :ip_lock, :ipv_type
+
+        def initialize(**attributes)
+            @ip                   = attributes[:ip]
+            @ip_allocation_policy = attributes[:ip_allocation_policy]
+            @ip_lock              = attributes[:ip_lock]
+            @ipv_type             = attributes[:ipv_type]
+        end
+
+        def self.parse_many(response)
+            output = []
+            response.each do |pre_ip|
+                output.push(parse(pre_ip))
+            end
+            output
+        end
+
+        def self.parse(hash_ip)
+            new(
+                ip: hash_ip["IP"],
+                ip_allocation_policy: hash_ip["IPAllocationPolicy"],
+                ip_lock: hash_ip["IPLock"],
+                ipv_type: hash_ip["IPvType"]
+            )
+        end
+    end
+end

data/lib/monogoto_api/ping/list.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module MonogotoApi
+    class Ping
+        class List
+            attr_reader :pings
+
+            def initialize
+                @pings = []
+            end
+
+            # Push ping element to pings array
+            def push(ping)
+                @pings.push(ping)
+            end
+
+            # Parser of API ping response
+            # "/thing/ThingId_ICCID_#{ iccid }/ping"
+            def self.parse(hash_pings)
+                list = new
+                hash_pings.each { |ping| list.push(MonogotoApi::Ping.parse(ping)) }
+                list
+            end
+
+            # Extract packet loss counter of ping list
+            def packet_loss
+                @pings.map(&:packet_loss).max
+            end
+
+            # Extract received counter of ping list
+            def received
+                @pings.map(&:received).max
+            end
+
+            # Check if are any packet loss in any ping
+            def ok?
+                packet_loss.zero?
+            end
+        end
+    end
+end

data/lib/monogoto_api/ping.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module MonogotoApi
+    class Ping
+        attr_reader :host, :size, :ttl, :time, :sent, :received, :packet_loss
+
+        def initialize(**attributes)
+            @host        = attributes[:host]
+            @size        = attributes[:size]
+            @ttl         = attributes[:ttl]
+            @time        = attributes[:time]
+            @sent        = attributes[:sent]
+            @received    = attributes[:received]
+            @packet_loss = attributes[:packet_loss]
+        end
+
+        def self.parse_many(response)
+            output = []
+            response.each do |pre_ip|
+                output.push(parse(pre_ip))
+            end
+            output
+        end
+
+        # Parser of single element of API ping response
+        def self.parse(hash_ping)
+            new(
+                host: hash_ping["host"],
+                size: hash_ping["size"].to_i,
+                ttl: hash_ping["ttl"].to_i,
+                time: hash_ping["time"],
+                sent: hash_ping["sent"].to_i,
+                received: hash_ping["received"].to_i,
+                packet_loss: hash_ping["packetLoss"].to_i
+            )
+        end
+    end
+end

data/lib/monogoto_api/session_status.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module MonogotoApi
+    class SessionStatus
+        attr_reader :connection, :provision
+
+        def initialize(**attributes)
+            @provision = attributes[:provision]
+            @connection = attributes[:connection]
+        end
+
+        def self.parse(hash_session)
+            data_first = hash_session["Data"].first
+            new(
+                provision: data_first["ProvisionStatus"],
+                connection: data_first["ConnectionStatus"]
+            )
+        end
+    end
+end

data/lib/monogoto_api/thing.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module MonogotoApi
+    # Thing refer to Monogoto SIM
+    class Thing
+        attr_reader :iccid, :imei, :operator, :state, :name, :ips
+
+        def initialize(**attributes)
+            @iccid    = attributes[:iccid]
+            @imei     = attributes[:imei]
+            @operator = attributes[:operator]
+            @state    = attributes[:state]
+            @name     = attributes[:name]
+            @ips      = attributes[:ips]
+        end
+
+        def self.parse_many(response)
+            output = []
+            response.each do |pre_thing|
+                output.push(parse(pre_thing))
+            end
+            output
+        end
+
+        def self.parse(hash_thing)
+            ips = MonogotoApi::IP.parse_many(hash_thing["IPs"])
+            new(
+                imei: hash_thing["IMEI"],
+                name: hash_thing["ThingName"],
+                iccid: hash_thing["ExternalUniqueId"],
+                operator: hash_thing["MnoName"],
+                state: hash_thing["State"],
+                ips:
+            )
+        end
+
+        def ip
+            @ips.first.ip
+        end
+    end
+end

data/lib/monogoto_api/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MonogotoApi
+    VERSION = "0.3.1"
+end

data/lib/monogoto_api.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "monogoto_api/client"
+require_relative "monogoto_api/event"
+require_relative "monogoto_api/event/list"
+require_relative "monogoto_api/ip"
+require_relative "monogoto_api/ping"
+require_relative "monogoto_api/ping/list"
+require_relative "monogoto_api/session_status"
+require_relative "monogoto_api/thing"
+require_relative "monogoto_api/version"
+
+module MonogotoApi
+    class << self
+    end
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: monogoto_api
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- Javier Contreras Ferrada
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.21.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.21.0
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Unofficial Ruby gem for Monogoto API. Monogoto is a IoT connectivity
+  management platform
+email:
+- javier.contreras@zembia.cl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/monogoto_api.rb
+- lib/monogoto_api/client.rb
+- lib/monogoto_api/event.rb
+- lib/monogoto_api/event/list.rb
+- lib/monogoto_api/ip.rb
+- lib/monogoto_api/ping.rb
+- lib/monogoto_api/ping/list.rb
+- lib/monogoto_api/session_status.rb
+- lib/monogoto_api/thing.rb
+- lib/monogoto_api/version.rb
+homepage: https://github.com/zembia/monogoto_api_ruby
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Unofficial Ruby gem for Monogoto API
+test_files: []