losant_rest 1.0.0

data/lib/losant_rest/orgs.rb

@@ -0,0 +1,92 @@
+module LosantRest
+
+  # Class containing all the actions for the Orgs Resource
+  class Orgs
+
+    def initialize(client)
+      @client = client
+    end
+
+    # Returns the organizations associated with the current user
+    #
+    # Parameters:
+    # *  {string} sortField - Field to sort the results by. Accepted values are: name, id, creationDate
+    # *  {string} sortDirection - Direction to sort the results by. Accepted values are: asc, desc
+    # *  {string} page - Which page of results to return
+    # *  {string} perPage - How many items to return per page
+    # *  {string} filterField - Field to filter the results by. Blank or not provided means no filtering. Accepted values are: name
+    # *  {string} filter - Filter to apply against the filtered field. Supports globbing. Blank or not provided means no filtering.
+    # *  {boolean} _actions - Return resource actions in response
+    # *  {boolean} _links - Return resource link in response
+    # *  {boolean} _embedded - Return embedded resources in response
+    #
+    # Responses:
+    # *  200 - Collection of organizations (https://api.losant.com/#/definitions/orgs)
+    #
+    # Errors:
+    # *  400 - Error if malformed request (https://api.losant.com/#/definitions/error)
+    def get(params = {})
+      params = Utils.symbolize_hash_keys(params)
+      query_params = { _actions: false, _links: true, _embedded: true }
+      headers = {}
+      body = nil
+
+
+      query_params[:sortField] = params[:sortField] if params.has_key?(:sortField)
+      query_params[:sortDirection] = params[:sortDirection] if params.has_key?(:sortDirection)
+      query_params[:page] = params[:page] if params.has_key?(:page)
+      query_params[:perPage] = params[:perPage] if params.has_key?(:perPage)
+      query_params[:filterField] = params[:filterField] if params.has_key?(:filterField)
+      query_params[:filter] = params[:filter] if params.has_key?(:filter)
+      query_params[:_actions] = params[:_actions] if params.has_key?(:_actions)
+      query_params[:_links] = params[:_links] if params.has_key?(:_links)
+      query_params[:_embedded] = params[:_embedded] if params.has_key?(:_embedded)
+
+      path = "/orgs"
+
+      @client.request(
+        method: :get,
+        path: path,
+        query: query_params,
+        headers: headers,
+        body: body)
+    end
+
+    # Create a new organization
+    #
+    # Parameters:
+    # *  {hash} organization - New organization information (https://api.losant.com/#/definitions/orgPost)
+    # *  {boolean} _actions - Return resource actions in response
+    # *  {boolean} _links - Return resource link in response
+    # *  {boolean} _embedded - Return embedded resources in response
+    #
+    # Responses:
+    # *  201 - Successfully created organization (https://api.losant.com/#/definitions/org)
+    #
+    # Errors:
+    # *  400 - Error if malformed request (https://api.losant.com/#/definitions/error)
+    def post(params = {})
+      params = Utils.symbolize_hash_keys(params)
+      query_params = { _actions: false, _links: true, _embedded: true }
+      headers = {}
+      body = nil
+
+      raise ArgumentError.new("organization is required") unless params.has_key?(:organization)
+
+      body = params[:organization] if params.has_key?(:organization)
+      query_params[:_actions] = params[:_actions] if params.has_key?(:_actions)
+      query_params[:_links] = params[:_links] if params.has_key?(:_links)
+      query_params[:_embedded] = params[:_embedded] if params.has_key?(:_embedded)
+
+      path = "/orgs"
+
+      @client.request(
+        method: :post,
+        path: path,
+        query: query_params,
+        headers: headers,
+        body: body)
+    end
+
+  end
+end

data/lib/losant_rest/utils.rb

@@ -0,0 +1,22 @@
+module LosantRest
+  class Utils
+    def self.symbolize_hash_keys(hash)
+      Hash[hash.dup.map { |k, v| [k.to_sym, v] }]
+    end
+
+    def self.fix_query_arrays(value)
+      if value.respond_to?(:to_ary)
+        value = value.to_ary.map.with_index.to_a.to_h.invert
+      end
+
+      if value.respond_to?(:to_hash)
+        value = value.to_hash
+        value.each do |k, v|
+          value[k] = fix_query_arrays(v)
+        end
+      end
+
+      value
+    end
+  end
+end

data/lib/losant_rest/version.rb

@@ -0,0 +1,3 @@
+module LosantRest
+  VERSION = "1.0.0"
+end

data/lib/losant_rest/webhook.rb

@@ -0,0 +1,128 @@
+module LosantRest
+
+  # Class containing all the actions for the Webhook Resource
+  class Webhook
+
+    def initialize(client)
+      @client = client
+    end
+
+    # Deletes a webhook
+    #
+    # Parameters:
+    # *  {string} applicationId - ID associated with the application
+    # *  {string} webhookId - ID associated with the webhook
+    # *  {boolean} _actions - Return resource actions in response
+    # *  {boolean} _links - Return resource link in response
+    # *  {boolean} _embedded - Return embedded resources in response
+    #
+    # Responses:
+    # *  200 - If webhook was successfully deleted (https://api.losant.com/#/definitions/success)
+    #
+    # Errors:
+    # *  400 - Error if malformed request (https://api.losant.com/#/definitions/error)
+    # *  404 - Error if webhook was not found (https://api.losant.com/#/definitions/error)
+    def delete(params = {})
+      params = Utils.symbolize_hash_keys(params)
+      query_params = { _actions: false, _links: true, _embedded: true }
+      headers = {}
+      body = nil
+
+      raise ArgumentError.new("applicationId is required") unless params.has_key?(:applicationId)
+      raise ArgumentError.new("webhookId is required") unless params.has_key?(:webhookId)
+
+      query_params[:_actions] = params[:_actions] if params.has_key?(:_actions)
+      query_params[:_links] = params[:_links] if params.has_key?(:_links)
+      query_params[:_embedded] = params[:_embedded] if params.has_key?(:_embedded)
+
+      path = "/applications/#{params[:applicationId]}/webhooks/#{params[:webhookId]}"
+
+      @client.request(
+        method: :delete,
+        path: path,
+        query: query_params,
+        headers: headers,
+        body: body)
+    end
+
+    # Retrieves information on a webhook
+    #
+    # Parameters:
+    # *  {string} applicationId - ID associated with the application
+    # *  {string} webhookId - ID associated with the webhook
+    # *  {boolean} _actions - Return resource actions in response
+    # *  {boolean} _links - Return resource link in response
+    # *  {boolean} _embedded - Return embedded resources in response
+    #
+    # Responses:
+    # *  200 - Webhook information (https://api.losant.com/#/definitions/webhook)
+    #
+    # Errors:
+    # *  400 - Error if malformed request (https://api.losant.com/#/definitions/error)
+    # *  404 - Error if webhook was not found (https://api.losant.com/#/definitions/error)
+    def get(params = {})
+      params = Utils.symbolize_hash_keys(params)
+      query_params = { _actions: false, _links: true, _embedded: true }
+      headers = {}
+      body = nil
+
+      raise ArgumentError.new("applicationId is required") unless params.has_key?(:applicationId)
+      raise ArgumentError.new("webhookId is required") unless params.has_key?(:webhookId)
+
+      query_params[:_actions] = params[:_actions] if params.has_key?(:_actions)
+      query_params[:_links] = params[:_links] if params.has_key?(:_links)
+      query_params[:_embedded] = params[:_embedded] if params.has_key?(:_embedded)
+
+      path = "/applications/#{params[:applicationId]}/webhooks/#{params[:webhookId]}"
+
+      @client.request(
+        method: :get,
+        path: path,
+        query: query_params,
+        headers: headers,
+        body: body)
+    end
+
+    # Updates information about a webhook
+    #
+    # Parameters:
+    # *  {string} applicationId - ID associated with the application
+    # *  {string} webhookId - ID associated with the webhook
+    # *  {hash} webhook - Object containing new properties of the webhook (https://api.losant.com/#/definitions/webhookPatch)
+    # *  {boolean} _actions - Return resource actions in response
+    # *  {boolean} _links - Return resource link in response
+    # *  {boolean} _embedded - Return embedded resources in response
+    #
+    # Responses:
+    # *  200 - Updated webhook information (https://api.losant.com/#/definitions/webhook)
+    #
+    # Errors:
+    # *  400 - Error if malformed request (https://api.losant.com/#/definitions/error)
+    # *  404 - Error if webhook was not found (https://api.losant.com/#/definitions/error)
+    def patch(params = {})
+      params = Utils.symbolize_hash_keys(params)
+      query_params = { _actions: false, _links: true, _embedded: true }
+      headers = {}
+      body = nil
+
+      raise ArgumentError.new("applicationId is required") unless params.has_key?(:applicationId)
+      raise ArgumentError.new("webhookId is required") unless params.has_key?(:webhookId)
+      raise ArgumentError.new("webhook is required") unless params.has_key?(:webhook)
+
+      body = params[:webhook] if params.has_key?(:webhook)
+      query_params[:_actions] = params[:_actions] if params.has_key?(:_actions)
+      query_params[:_links] = params[:_links] if params.has_key?(:_links)
+      query_params[:_embedded] = params[:_embedded] if params.has_key?(:_embedded)
+
+      path = "/applications/#{params[:applicationId]}/webhooks/#{params[:webhookId]}"
+
+      @client.request(
+        method: :patch,
+        path: path,
+        query: query_params,
+        headers: headers,
+        body: body)
+    end
+
+  end
+end

data/lib/losant_rest/webhooks.rb

@@ -0,0 +1,98 @@
+module LosantRest
+
+  # Class containing all the actions for the Webhooks Resource
+  class Webhooks
+
+    def initialize(client)
+      @client = client
+    end
+
+    # Returns the webhooks for an application
+    #
+    # Parameters:
+    # *  {string} applicationId - ID associated with the application
+    # *  {string} sortField - Field to sort the results by. Accepted values are: name, id, creationDate
+    # *  {string} sortDirection - Direction to sort the results by. Accepted values are: asc, desc
+    # *  {string} page - Which page of results to return
+    # *  {string} perPage - How many items to return per page
+    # *  {string} filterField - Field to filter the results by. Blank or not provided means no filtering. Accepted values are: name
+    # *  {string} filter - Filter to apply against the filtered field. Supports globbing. Blank or not provided means no filtering.
+    # *  {boolean} _actions - Return resource actions in response
+    # *  {boolean} _links - Return resource link in response
+    # *  {boolean} _embedded - Return embedded resources in response
+    #
+    # Responses:
+    # *  200 - Collection of webhooks (https://api.losant.com/#/definitions/webhooks)
+    #
+    # Errors:
+    # *  400 - Error if malformed request (https://api.losant.com/#/definitions/error)
+    # *  404 - Error if application was not found (https://api.losant.com/#/definitions/error)
+    def get(params = {})
+      params = Utils.symbolize_hash_keys(params)
+      query_params = { _actions: false, _links: true, _embedded: true }
+      headers = {}
+      body = nil
+
+      raise ArgumentError.new("applicationId is required") unless params.has_key?(:applicationId)
+
+      query_params[:sortField] = params[:sortField] if params.has_key?(:sortField)
+      query_params[:sortDirection] = params[:sortDirection] if params.has_key?(:sortDirection)
+      query_params[:page] = params[:page] if params.has_key?(:page)
+      query_params[:perPage] = params[:perPage] if params.has_key?(:perPage)
+      query_params[:filterField] = params[:filterField] if params.has_key?(:filterField)
+      query_params[:filter] = params[:filter] if params.has_key?(:filter)
+      query_params[:_actions] = params[:_actions] if params.has_key?(:_actions)
+      query_params[:_links] = params[:_links] if params.has_key?(:_links)
+      query_params[:_embedded] = params[:_embedded] if params.has_key?(:_embedded)
+
+      path = "/applications/#{params[:applicationId]}/webhooks"
+
+      @client.request(
+        method: :get,
+        path: path,
+        query: query_params,
+        headers: headers,
+        body: body)
+    end
+
+    # Create a new webhook for an application
+    #
+    # Parameters:
+    # *  {string} applicationId - ID associated with the application
+    # *  {hash} webhook - New webhook information (https://api.losant.com/#/definitions/webhookPost)
+    # *  {boolean} _actions - Return resource actions in response
+    # *  {boolean} _links - Return resource link in response
+    # *  {boolean} _embedded - Return embedded resources in response
+    #
+    # Responses:
+    # *  201 - Successfully created webhook (https://api.losant.com/#/definitions/webhook)
+    #
+    # Errors:
+    # *  400 - Error if malformed request (https://api.losant.com/#/definitions/error)
+    # *  404 - Error if application was not found (https://api.losant.com/#/definitions/error)
+    def post(params = {})
+      params = Utils.symbolize_hash_keys(params)
+      query_params = { _actions: false, _links: true, _embedded: true }
+      headers = {}
+      body = nil
+
+      raise ArgumentError.new("applicationId is required") unless params.has_key?(:applicationId)
+      raise ArgumentError.new("webhook is required") unless params.has_key?(:webhook)
+
+      body = params[:webhook] if params.has_key?(:webhook)
+      query_params[:_actions] = params[:_actions] if params.has_key?(:_actions)
+      query_params[:_links] = params[:_links] if params.has_key?(:_links)
+      query_params[:_embedded] = params[:_embedded] if params.has_key?(:_embedded)
+
+      path = "/applications/#{params[:applicationId]}/webhooks"
+
+      @client.request(
+        method: :post,
+        path: path,
+        query: query_params,
+        headers: headers,
+        body: body)
+    end
+
+  end
+end

data/lib/losant_rest.rb

@@ -0,0 +1,43 @@
+require_relative "losant_rest/version"
+require_relative "losant_rest/error"
+require_relative "losant_rest/utils"
+require_relative "losant_rest/access_token"
+require_relative "losant_rest/access_tokens"
+require_relative "losant_rest/application"
+require_relative "losant_rest/application_key"
+require_relative "losant_rest/application_keys"
+require_relative "losant_rest/applications"
+require_relative "losant_rest/auth"
+require_relative "losant_rest/dashboard"
+require_relative "losant_rest/dashboards"
+require_relative "losant_rest/data"
+require_relative "losant_rest/device"
+require_relative "losant_rest/device_recipe"
+require_relative "losant_rest/device_recipes"
+require_relative "losant_rest/devices"
+require_relative "losant_rest/event"
+require_relative "losant_rest/events"
+require_relative "losant_rest/flow"
+require_relative "losant_rest/flows"
+require_relative "losant_rest/me"
+require_relative "losant_rest/org"
+require_relative "losant_rest/orgs"
+require_relative "losant_rest/webhook"
+require_relative "losant_rest/webhooks"
+require_relative "losant_rest/client"
+
+module LosantRest
+
+  def self.client
+    @client ||= Client.new
+  end
+
+  def self.method_missing(sym, *args, &block)
+    self.client.__send__(sym, *args, &block)
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    self.client.respond_to?(method_name, include_private)
+  end
+
+end

data/losant_rest.gemspec

@@ -0,0 +1,25 @@
+$LOAD_PATH.push(File.expand_path("../lib", __FILE__))
+require "losant_rest/version"
+
+Gem::Specification.new do |gem|
+  gem.name          = "losant_rest"
+  gem.authors       = ["Michael Kuehl"]
+  gem.email         = ["hello@losant.com"]
+  gem.summary       = %q{Provides a simple ruby wrapper around the Losant REST API}
+  gem.description   = %q{Easily use the Losant IoT Platform through its REST API with Ruby}
+  gem.homepage      = "https://github.com/Losant/losant-rest-ruby"
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ["lib"]
+  gem.version       = LosantRest::VERSION
+  gem.licenses      = ["MIT"]
+
+  gem.required_ruby_version = ">= 2.1"
+
+  gem.add_dependency "httparty", "~> 0.13.0"
+
+  gem.add_development_dependency "minitest", "~> 5.9"
+  gem.add_development_dependency "rake", "~> 11"
+  gem.add_development_dependency "webmock", "~> 2.1"
+end

data/schemas/accessToken.json

@@ -0,0 +1,52 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "pattern": "^[A-Fa-f\\d]{24}$"
+    },
+    "accessTokenId": {
+      "type": "string",
+      "pattern": "^[A-Fa-f\\d]{24}$"
+    },
+    "userId": {
+      "type": "string",
+      "pattern": "^[A-Fa-f\\d]{24}$"
+    },
+    "name": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 255
+    },
+    "creationDate": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "lastUpdated": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "expirationDate": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "scope": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "status": {
+      "type": "string",
+      "enum": [
+        "active",
+        "inactive"
+      ]
+    },
+    "token": {
+      "type": "string",
+      "minLength": 1
+    }
+  }
+}

data/schemas/accessTokenPatch.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 255
+    },
+    "status": {
+      "type": "string",
+      "enum": [
+        "active",
+        "inactive"
+      ]
+    }
+  },
+  "additionalProperties": false
+}

data/schemas/accessTokenPost.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 255
+    },
+    "expirationDate": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "scope": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "status": {
+      "type": "string",
+      "enum": [
+        "active",
+        "inactive"
+      ]
+    }
+  },
+  "additionalProperties": false,
+  "required": [
+    "name"
+  ]
+}

data/schemas/accessTokens.json

@@ -0,0 +1,65 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "object",
+  "properties": {
+    "items": {
+      "type": "array",
+      "items": {
+        "title": "Access Token",
+        "description": "Schema for a single Access Token",
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^[A-Fa-f\\d]{24}$"
+          },
+          "accessTokenId": {
+            "type": "string",
+            "pattern": "^[A-Fa-f\\d]{24}$"
+          },
+          "userId": {
+            "type": "string",
+            "pattern": "^[A-Fa-f\\d]{24}$"
+          },
+          "name": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 255
+          },
+          "creationDate": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "lastUpdated": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "expirationDate": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "scope": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "status": {
+            "type": "string",
+            "enum": [
+              "active",
+              "inactive"
+            ]
+          },
+          "token": {
+            "type": "string",
+            "minLength": 1
+          }
+        }
+      }
+    },
+    "count": {
+      "type": "integer"
+    }
+  }
+}

data/schemas/application.json

@@ -0,0 +1,65 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "pattern": "^[A-Fa-f\\d]{24}$"
+    },
+    "applicationId": {
+      "type": "string",
+      "pattern": "^[A-Fa-f\\d]{24}$"
+    },
+    "creationDate": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "lastUpdated": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "ownerId": {
+      "type": "string",
+      "pattern": "^[A-Fa-f\\d]{24}$"
+    },
+    "ownerType": {
+      "type": "string",
+      "enum": [
+        "user",
+        "organization"
+      ]
+    },
+    "name": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 255
+    },
+    "description": {
+      "type": "string",
+      "maxLength": 32767
+    },
+    "summary": {
+      "type": "object",
+      "properties": {
+        "deviceCount": {
+          "type": "number"
+        },
+        "flowCount": {
+          "type": "number"
+        },
+        "webhookCount": {
+          "type": "number"
+        },
+        "eventCount": {
+          "type": "number"
+        },
+        "keyCount": {
+          "type": "number"
+        },
+        "deviceRecipeCount": {
+          "type": "number"
+        }
+      }
+    }
+  }
+}