flowthings 0.1.1

data/lib/flowthings/crud/base.rb

@@ -0,0 +1,41 @@
+require 'flowthings/utils/crud_utils'
+
+module Flowthings
+  module Crud
+    module Base
+      include Flowthings::CrudUtils
+
+      def create(data, params={})
+        path = mk_path
+        params = mk_params(params)
+        data = mk_data(data)
+
+        platform_post(path, params=params, data=data)
+      end
+
+      def read(id, params={})
+        path = mk_path({id: id})
+        params = mk_params(params)
+
+        platform_get(path, params=params)
+      end
+
+      def update(id, data, params={})
+        path = mk_path(id: id)
+        params = mk_params(params)
+        data = mk_data(data)
+
+        platform_put(path, params=params, data=data)
+      end
+
+      def destroy(id, params={})
+        path = mk_path({id: id})
+        params = mk_params(params)
+
+        platform_delete(path, params=params)
+      end
+
+      alias_method :delete, :destroy
+    end
+  end
+end

data/lib/flowthings/crud/extended_methods.rb

@@ -0,0 +1,26 @@
+module Flowthings
+  module Crud
+    module ExtendedMethods
+      def delete_all(params={})
+      end
+
+      def find_many(filters={}, params={})
+        path = mk_path
+        params = mk_params(params)
+        data = []
+
+        @flowIds.each do flowId
+          if filters[flowId]
+            data << {"flowId" => flowId,
+                     "params" => filters[flowId]}
+          else
+            data << {"flowId" => flowId}
+          end
+        end
+
+
+        platform_mget(path, params=params, data=data)
+      end
+    end
+  end
+end

data/lib/flowthings/crud/find.rb

@@ -0,0 +1,13 @@
+module Flowthings
+  module Crud
+    module Find
+      def find(params={})
+        path_params = {}
+        path = mk_path(path_params)
+        params = mk_params(params)
+
+        platform_get(path, params=params)
+      end
+    end
+  end
+end

data/lib/flowthings/crud/member_update.rb

@@ -0,0 +1,14 @@
+module Flowthings
+  module Crud
+    module MemberUpdate
+      def member_update(id, member_name, data, params)
+        path = mk_path({tail: member_name,
+                        id: id})
+        params = mk_params(params)
+        data = mk_data(data)
+
+        platform_put(path, params=params, data=data)
+      end
+    end
+  end
+end

data/lib/flowthings/crud/simulate.rb

@@ -0,0 +1,13 @@
+module Flowthings
+  module Crud
+    module Simulate
+      def simulate(data, params={})
+        path = mk_path({tail: "simulate"})
+        params = mk_params(params)
+        data = mk_data(data)
+
+        platform_post(path, params=params, data=data)
+      end
+    end
+  end
+end

data/lib/flowthings/error.rb

@@ -0,0 +1,30 @@
+module Flowthings
+  class Error < StandardError
+    def initialize(message="")
+      if message
+        super(message)
+      end
+    end
+  end
+
+  class Error::HttpError < Flowthings::Error
+    attr_reader :http_headers
+
+    def initialize(message, http_headers="")
+      @http_headers = http_headers
+      super(message)
+    end
+  end
+
+  class Error::ObjectError         < Flowthings::Error; end
+
+  class Error::ServerError        < Error::HttpError; end
+  class Error::ServiceUnavailable < Error::ServerError; end
+
+  class Error::ClientError        < Error::HttpError; end
+  class Error::Forbidden          < Error::ClientError; end
+  class Error::NotFound           < Error::ClientError; end
+  class Error::BadRequest         < Error::ClientError; end
+  class Error::RequestTooLarge    < Error::ClientError; end
+
+end

data/lib/flowthings/platform_objects/api_task.rb

@@ -0,0 +1,6 @@
+require 'flowthings/platform_objects/platform_object_interface'
+
+module Flowthings
+  class ApiTask < PlatformObjectInterface
+  end
+end

data/lib/flowthings/platform_objects/drop.rb

@@ -0,0 +1,29 @@
+require 'flowthings/platform_objects/platform_object_interface'
+require 'flowthings/crud/extended_methods'
+require 'flowthings/crud/find'
+require 'flowthings/crud/member_update'
+require 'flowthings/crud/aggregate'
+
+module Flowthings
+
+  class Drop < PlatformObjectInterface
+    include Flowthings::Crud::ExtendedMethods
+    include Flowthings::Crud::Find
+    include Flowthings::Crud::MemberUpdate
+    include Flowthings::Crud::Aggregate
+
+    attr_accessor :flowId
+
+    def initialize(flowId, connection, options={})
+      if flowId.kind_of? Array
+        @flowIds = flowId
+      else
+        @flowId = flowId
+      end
+
+      super connection, options
+    end
+
+  end
+
+end

data/lib/flowthings/platform_objects/flow.rb

@@ -0,0 +1,12 @@
+require 'flowthings/platform_objects/platform_object_interface'
+require 'flowthings/crud/find'
+require 'flowthings/crud/member_update'
+
+module Flowthings
+
+  class Flow < PlatformObjectInterface
+    include Flowthings::Crud::Find
+    include Flowthings::Crud::MemberUpdate
+  end
+
+end

data/lib/flowthings/platform_objects/group.rb

@@ -0,0 +1,10 @@
+require 'flowthings/platform_objects/platform_object_interface'
+require 'flowthings/crud/find'
+
+module Flowthings
+
+  class Group < PlatformObjectInterface
+    include Flowthings::Crud::Find
+  end
+
+end

data/lib/flowthings/platform_objects/identity.rb

@@ -0,0 +1,10 @@
+require 'flowthings/platform_objects/platform_object_interface'
+require 'flowthings/crud/find'
+
+module Flowthings
+
+  class Identity < PlatformObjectInterface
+    include Flowthings::Crud::Find
+  end
+
+end

data/lib/flowthings/platform_objects/mqtt.rb

@@ -0,0 +1,8 @@
+require 'flowthings/platform_objects/platform_object_interface'
+
+module Flowthings
+
+  class Mqtt < PlatformObjectInterface
+  end
+
+end

data/lib/flowthings/platform_objects/platform_object_interface.rb

@@ -0,0 +1,44 @@
+require 'flowthings/request'
+require 'flowthings/connection'
+require 'flowthings/crud/base'
+require 'flowthings/error'
+
+module Flowthings
+
+  class PlatformObjectInterface
+
+    include Flowthings::Request
+    include Flowthings::Crud::Base
+
+    @path_array = []
+
+    # make a class variable here, a hash,
+    # that holds all the various endpoints in it
+
+    # then make a call here to query the object type
+    # and give it the right endpoint function type.
+
+    def initialize(connection, options={})
+      check_platform_object
+
+      Configuration::VALID_CONFIG_KEYS.each do |key|
+        instance_variable_set("@#{key}", options[key])
+      end
+
+      @connection = connection
+
+      @account_name=options[:account_name]
+      @account_token=options[:account_token]
+    end
+
+
+    private
+    def check_platform_object
+      if self.class == PlatformObjectInterface
+        raise Flowthings::Error::ObjectError, "Use the actual platform objects"
+      end
+    end
+
+  end
+
+end

data/lib/flowthings/platform_objects/share.rb

@@ -0,0 +1,9 @@
+require 'flowthings/platform_objects/platform_object_interface'
+
+module Flowthings
+
+  class Share < PlatformObjectInterface
+    undef_method :update
+  end
+
+end

data/lib/flowthings/platform_objects/token.rb

@@ -0,0 +1,9 @@
+require 'flowthings/platform_objects/platform_object_interface'
+
+module Flowthings
+
+  class Token < PlatformObjectInterface
+    undef_method :update
+  end
+
+end

data/lib/flowthings/platform_objects/track.rb

@@ -0,0 +1,12 @@
+require 'flowthings/platform_objects/platform_object_interface'
+require 'flowthings/crud/find'
+require 'flowthings/crud/simulate'
+
+module Flowthings
+
+  class Track < PlatformObjectInterface
+    include Flowthings::Crud::Find
+    include Flowthings::Crud::Simulate
+  end
+
+end

data/lib/flowthings/request.rb

@@ -0,0 +1,59 @@
+require 'net/http'
+require 'uri'
+require 'json'
+require 'flowthings/response/raise_errors'
+
+module Flowthings
+  module Request
+
+    include Flowthings::Response::RaiseErrors
+
+    private
+
+    def platform_get(path, params={}, options={})
+      request(:get, path, params, options)
+    end
+
+    def platform_post(path, data, params={}, options={})
+      request(:post, path, params, options, data=data)
+    end
+
+    def platform_put(path, data, params={}, options={})
+      request(:put, path, params, options, data=data)
+    end
+
+    def platform_mget(path, data, params={}, options={})
+      request(:mget, path, params, options, data=data)
+    end
+
+    def platform_delete(path, params={}, options={})
+      request(:delete, path, params, options)
+    end
+
+    def request(method, path, params, options, data={})
+
+      case method.to_sym
+      when :get, :delete
+        response = @connection.request(path: path,
+                        query: params,
+                        method: method.to_sym)
+      when :post, :put, :mget
+        body = params unless params.empty?
+        body = JSON.generate(body)
+        response = @connection.request(path: path,
+                        query: params,
+                        method: method.to_sym,
+                        body: body)
+      end
+
+      raise_error(response)
+
+
+      response = response.data
+
+      response = JSON.parse response[:body]
+      response = response["body"]
+    end
+
+  end
+end

data/lib/flowthings/response/platform_response.rb

@@ -0,0 +1,16 @@
+module Flowthings
+  class PlatformResponse
+    attr_reader :head, :body, :full_message, :errors, :status, :response_headers, :excon_object
+
+    def initialize(response)
+      @excon_object = response
+      @status = response.status
+      @response_headers = response.headers
+      @full_message = response.body
+      @head = @full_message["head"]
+      @body = @full_message["body"]
+      @errors = @head["errors"]
+    end
+
+  end
+end

data/lib/flowthings/response/raise_errors.rb

@@ -0,0 +1,42 @@
+require 'json'
+
+module Flowthings
+  module Response
+    module RaiseErrors
+
+      private
+      def raise_error(response)
+
+        begin
+          body = JSON.parse response[:body]
+        rescue JSON::ParserError => e
+          body = response[:body]
+        end
+
+        status = response[:status].to_i
+
+        head = body["head"]
+        errors = head["errors"]
+
+
+        case status
+        when 400
+          raise Flowthings::Error::BadRequest.new errors, head
+        when 403
+          raise Flowthings::Error::NotFound.new errors, head
+        when 404
+          raise Flowthings::Error::NotFound.new errors, head
+        when 413
+          raise Flowthings::Error::Forbidden.new errors, head
+        when 500
+          raise Flowthings::Error::ServerError.new errors, head
+        when 503
+          raise Flowthings::Error::ServiceUnavailable.new "503 no service is available to handle this request", head
+        end
+
+      end
+
+
+    end
+  end
+end

data/lib/flowthings/utils/crud_utils.rb

@@ -0,0 +1,96 @@
+module Flowthings
+  module CrudUtils
+    private
+    def mk_data(data, params = {})
+      data
+    end
+
+    def mk_path(params = {})
+      service_path = {
+        "Flowthings::Drop" => "drop",
+        "Flowthings::Flow" => "flow",
+        "Flowthings::Track" => "track",
+        "Flowthings::Identity" => "identity",
+        "Flowthings::Token" => "token",
+        "Flowthings::Share" => "share",
+        "Flowthings::Group" => "group",
+        "Flowthings::ApiTask" => "api-task",
+        "Flowthings::Mqtt" => "mqtt"
+      }
+
+      path = [@platform_version, @account_name, service_path[self.class.name]]
+
+      if @flowId
+        path << @flowId
+      end
+
+      if params[:id]
+        path << params[:id]
+      end
+
+      # a tail is somethings we put after the id on the flow.
+      # "/aggregate" would be an example
+      if params[:tail]
+        path << params[:tail]
+      end
+
+      path = "/" + path.join('/')
+    end
+
+    def mk_regex()
+
+    end
+
+    def mk_params(params = {})
+
+      made_params = {}
+
+      if params[:start]
+        made_params[:start] = params[:start]
+      end
+
+      if params[:limit]
+        made_params[:limit] = params[:limit]
+      end
+
+      if params[:sort]
+        made_params[:sort] = params[:sort]
+      end
+
+      if params[:order]
+        made_params[:order] = params[:order]
+      end
+
+      if params[:only]
+        made_params[:only] = params[:only]
+      end
+
+      if params[:refs]
+        made_params[:refs] = 1
+      end
+
+      if params[:hints] == false
+        made_params[:hints] = false
+      end
+
+      if params[:filter]
+        #we'll make this more dynamic later
+        made_params[:filter] = params[:filter]
+      end
+
+      made_params
+    end
+
+    def mk_filter(params = {})
+      # this is just a string for now
+      filter = []
+
+      params.each do |key, value|
+
+      end
+
+      filter
+    end
+
+  end
+end

data/lib/flowthings/version.rb

@@ -0,0 +1,3 @@
+module Flowthings
+  VERSION = "0.1.1"
+end

data/lib/flowthings.rb

@@ -0,0 +1,7 @@
+require 'flowthings/version'
+require 'flowthings/configuration'
+require 'flowthings/client'
+
+module Flowthings
+  extend Configuration
+end

data/spec/client_configuration_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Flowthings::Client do
+  before do
+    @keys = Flowthings::Configuration::VALID_CONFIG_KEYS
+  end
+
+  describe 'configuration' do
+
+    describe 'with module configuration' do
+      before do
+        Flowthings.configure do |config|
+          @keys.each do |key|
+            config.send("#{key}=", key)
+          end
+        end
+      end
+
+      after do
+        Flowthings.reset
+      end
+
+      it 'should inherit module configuration' do
+        api = Flowthings::Client.new
+
+        @keys.each do |key|
+          expect(api.send(key)).to eq(key)
+        end
+      end
+    end
+
+    describe 'with class configuration' do
+      before do
+        @config = {
+          account_name: 'aa',
+          account_token: 'bb',
+          endpoint: 'dd',
+          user_agent: 'ee',
+          secure: 'ff',
+          platform_version: 'gg',
+        }
+      end
+
+      it 'should override module configuration' do
+        api = Flowthings::Client.new(@config)
+
+        @keys.each do |key|
+          expect(api.send(key)).to eq(@config[key])
+        end
+      end
+
+      it 'should override module configuration after' do
+        api = Flowthings::Client.new
+
+        @config.each do |key, value|
+          api.send("#{key}=", value)
+        end
+
+        @keys.each do |key|
+          expect(api.send("#{key}")).to eq(@config[key])
+        end
+      end
+
+    end
+  end
+
+end

data/spec/client_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'active_support/inflector'
+
+describe Flowthings::Client do
+  services = ["api_task", "drop", "flow", "group", "identity", "mqtt", "share", "token", "track"]
+
+  describe 'interfaces' do
+    before do
+      @api = Flowthings::Client.new
+    end
+
+    services.each do |service|
+      service_class = "flowthings/" + service
+      service_class = service_class.camelize.constantize
+
+      describe ".#{service}" do
+        it "the method should exist" do
+          expect(@api.respond_to? "#{service}").to be true
+        end
+
+        it "the method should construct the proper class" do
+          if service == 'drop'
+            initialized_service = @api.send("#{service}", "d")
+            expect(initialized_service.class).to eq(service_class)
+          else
+            initialized_service = @api.send("#{service}")
+            expect(initialized_service.class).to eq(service_class)
+          end
+        end
+
+        if service == 'drop'
+          it "should throw an error if it is called without an argument" do
+            expect { @api.send("#{service}") }.to raise_error
+          end
+
+          it "should raise an argument error" do
+            expect { @api.send("#{service}") }.to raise_error(ArgumentError)
+          end
+
+          it "should not throw an error if it is called with an argument" do
+            expect { @api.send("#{service}", "d") }.not_to raise_error
+          end
+        end
+
+      end # describe block
+
+    end # services loop
+
+  end #interfaces
+
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe 'configuration' do
+
+  Flowthings::Configuration::VALID_CONFIG_KEYS.each do |key|
+    describe ".#{key}" do
+      it 'should return the default value' do
+        expect(Flowthings.send(key)).to eq(Flowthings::Configuration.const_get("DEFAULT_#{key.upcase}"))
+      end
+    end
+  end
+
+  after do
+    Flowthings.reset
+  end
+
+  describe '.configure' do
+    Flowthings::Configuration::VALID_CONFIG_KEYS.each do |key|
+      it "should set the #{key}" do
+        Flowthings.configure do |config|
+          config.send("#{key}=", key)
+          expect(Flowthings.send(key)).to eq(key)
+        end
+      end
+    end
+  end
+
+end