validic 0.3.3 → 0.4.1

data/lib/validic/organization.rb

@@ -1,17 +1,10 @@
-# encoding: utf-8
-
 module Validic
-  module Organization
-
-    ##
-    # Get Organization base on `access_token` and organization_id
-    # 
-    # @params :access_token
-    # @return [Hashie::Mash] with list of Organization
-    def get_organization(params={})
-      params = extract_params(params)
-      get("/#{Validic.api_version}/organizations/#{Validic.organization_id}.json", params)
+  class Organization
+    def initialize(attrs = {})
+      attrs.each do |k, v|
+        instance_variable_set("@#{k}", v)
+        self.class.send(:attr_reader, k)
+      end
     end
-
   end
 end

data/lib/validic/profile.rb

@@ -1,43 +1,8 @@
-# encoding: utf-8
-
 module Validic
-  module Profile
-
-    ##
-    # Get Profile base on `access_token`
-    #
-    # @params :access_token - override for default access_token
-    # @return [Hashie::Mash] with list of Profile
-    def get_profile(options={})
-      options = {
-        access_token: options[:access_token]
-      }
-      response = get("/#{Validic.api_version}/profile.json", options)
-      response if response
+  class Profile
+    include Validic::Utils
+    def initialize(attrs = {})
+      attributes_builder(attrs, self)
     end
-
-    ##
-    # Update Profile base on `access_token`
-    # 
-    # @return success
-    # def update_profile(options={})
-    #   options = {
-    #     profile: {
-    #       gender: options[:gender],
-    #       location: options[:location],
-    #       birth_year: options[:birth_year],
-    #       height: options[:height],
-    #       weight: options[:weight],
-    #       first_name: options[:first_name],
-    #       last_name: options[:last_name]
-    #     }
-    #   }
-
-    #   response = post("/#{Validic.api_version}/profile.json", options)
-    #   response if response
-    # end
-
   end
 end
-
-

data/lib/validic/response.rb

@@ -0,0 +1,15 @@
+module Validic
+  class Response
+    attr_reader :summary, :records, :attributes
+    def initialize(summary, response)
+      @summary = summary
+
+      case response
+      when Array
+        @records = response
+      when Hash
+        @attributes = response
+      end
+    end
+  end
+end

data/lib/validic/rest/apps.rb

@@ -0,0 +1,21 @@
+require 'validic/app'
+
+module Validic
+  module REST
+    module Apps
+
+      def get_org_apps
+        resp = get_request(:apps)
+        build_response_attr(resp)
+      end
+      alias :get_apps :get_org_apps
+
+      def get_user_synced_apps(options = {})
+        resp = get_request(:sync_apps,
+                           authentication_token: options[:authentication_token])
+        build_response_attr(resp)
+      end
+      alias :get_synced_apps :get_user_synced_apps
+    end
+  end
+end

data/lib/validic/rest/biometrics.rb

@@ -0,0 +1,39 @@
+require 'validic/biometrics'
+
+module Validic
+  module REST
+    module Biometrics
+
+      def get_biometrics(options = {})
+        resp = get_request(:biometrics, options)
+        build_response_attr(resp)
+      end
+
+      def create_biometrics(options = {})
+        user_id = options.delete(:user_id)
+        options = { user_id: user_id, biometrics: options }
+        response = post_request(:biometrics, options)
+        Validic::Biometrics.new(response['biometrics'])
+      end
+
+      def update_biometrics(options = {})
+        user_id, _id = options.delete(:user_id), options.delete(:_id)
+        options = { user_id: user_id, _id: _id, biometrics: options }
+        response = put_request(:biometrics, options)
+        Validic::Biometrics.new(response['biometrics'])
+      end
+
+      def delete_biometrics(options = {})
+        user_id, _id = options.delete(:user_id), options.delete(:_id)
+        options = { user_id: user_id, _id: _id }
+        delete_request(:biometrics, options)
+        true
+      end
+
+      def latest_biometrics(options = {})
+        resp = latest(:biometrics, options)
+        build_response_attr(resp)
+      end
+    end
+  end
+end

data/lib/validic/rest/diabetes.rb

@@ -0,0 +1,39 @@
+require 'validic/diabetes'
+
+module Validic
+  module REST
+    module Diabetes
+
+      def get_diabetes(options = {})
+        resp = get_request(:diabetes, options)
+        build_response_attr(resp)
+      end
+
+      def create_diabetes(options = {})
+        user_id = options.delete(:user_id)
+        options = { user_id: user_id, diabetes: options }
+        response = post_request(:diabetes, options)
+        Validic::Diabetes.new(response['diabetes'])
+      end
+
+      def update_diabetes(options = {})
+        user_id, _id = options.delete(:user_id), options.delete(:_id)
+        options = { user_id: user_id, _id: _id, diabetes: options }
+        response = put_request(:diabetes, options)
+        Validic::Diabetes.new(response['diabetes'])
+      end
+
+      def delete_diabetes(options = {})
+        user_id, _id = options.delete(:user_id), options.delete(:_id)
+        options = { user_id: user_id, _id: _id }
+        delete_request(:diabetes, options)
+        true
+      end
+
+      def latest_diabetes(options = {})
+        resp = latest(:diabetes, options)
+        build_response_attr(resp)
+      end
+    end
+  end
+end

data/lib/validic/rest/fitness.rb

@@ -0,0 +1,40 @@
+require 'validic/fitness'
+
+module Validic
+  module REST
+    module Fitness
+
+      def get_fitness(options = {})
+        resp = get_request(:fitness, options)
+        build_response_attr(resp)
+      end
+      alias :get_fitnesses :get_fitness
+
+      def create_fitness(options = {})
+        user_id = options.delete(:user_id)
+        options = { user_id: user_id, fitness: options }
+        response = post_request(:fitness, options)
+        Validic::Fitness.new(response['fitness'])
+      end
+
+      def update_fitness(options = {})
+        user_id, _id = options.delete(:user_id), options.delete(:_id)
+        options = { user_id: user_id, _id: _id, fitness: options }
+        response = put_request(:fitness, options)
+        Validic::Fitness.new(response['fitness'])
+      end
+
+      def delete_fitness(options = {})
+        user_id, _id = options.delete(:user_id), options.delete(:_id)
+        options = { user_id: user_id, _id: _id }
+        delete_request(:fitness, options)
+        true
+      end
+
+      def latest_fitness(options = {})
+        resp = latest(:fitness, options)
+        build_response_attr(resp)
+      end
+    end
+  end
+end

data/lib/validic/rest/nutrition.rb

@@ -0,0 +1,40 @@
+require 'validic/nutrition'
+
+module Validic
+  module REST
+    module Nutrition
+
+      def get_nutrition(options = {})
+        resp = get_request(:nutrition, options)
+        build_response_attr(resp)
+      end
+      alias :get_nutritions :get_nutrition
+
+      def create_nutrition(options = {})
+        user_id, _id = options.delete(:user_id), options.delete(:_id)
+        options = { user_id: user_id, nutrition: options }
+        response = post_request(:nutrition, options)
+        Validic::Nutrition.new(response['nutrition'])
+      end
+
+      def update_nutrition(options = {})
+        user_id, _id = options.delete(:user_id), options.delete(:_id)
+        options = { user_id: user_id, _id: _id, nutrition: options }
+        response = put_request(:nutrition, options)
+        Validic::Nutrition.new(response['nutrition'])
+      end
+
+      def delete_nutrition(options = {})
+        user_id, _id = options.delete(:user_id), options.delete(:_id)
+        options = { user_id: user_id, _id: _id }
+        delete_request(:nutrition, options)
+        true
+      end
+
+      def latest_nutrition(options = {})
+        resp = latest(:nutrition, options)
+        build_response_attr(resp)
+      end
+    end
+  end
+end

data/lib/validic/rest/organizations.rb

@@ -0,0 +1,12 @@
+require 'validic/organization'
+
+module Validic
+  module REST
+    module Organizations
+      def get_organization(params = {})
+        resp = get_request(:organizations, params)
+        build_response_attr(resp)
+      end
+    end
+  end
+end

data/lib/validic/rest/profile.rb

@@ -0,0 +1,18 @@
+require 'validic/profile'
+
+module Validic
+  module REST
+    module Profile
+      def get_profile(options = {})
+        resp = get_request(:profile, options)
+        Validic::Profile.new(resp)
+      end
+
+      def create_profile(options = {})
+        token = options.delete(:authentication_token)
+        resp = post_request(:profile, authentication_token: token, profile: options)
+        Validic::Profile.new(resp['profile'])
+      end
+    end
+  end
+end

data/lib/validic/rest/request.rb

@@ -0,0 +1,95 @@
+require 'multi_json'
+require 'validic/error'
+
+module Validic
+  module REST
+    module Request
+      def latest(type, options = {})
+        organization_id = options[:organization_id] || Validic.organization_id
+        user_id = options.delete(:user_id)
+        if user_id
+          path = "/#{Validic.api_version}/organizations/#{organization_id}/users/#{user_id}/#{type.to_s}/latest.json"
+        else
+          path = "/#{Validic.api_version}/organizations/#{organization_id}/#{type.to_s}/latest.json"
+        end
+        get(path, options)
+      end
+
+      private
+
+      def get_request(type, options = {})
+        path = construct_path(type, options)
+        get(path, options)
+      end
+
+      def post_request(type, options = {})
+        path = construct_path(type, options)
+        post(path, options)
+      end
+
+      def put_request(type, options = {})
+        path = construct_path(type, options)
+        put(path, options)
+      end
+
+      def delete_request(type, options = {})
+        path = construct_path(type, options)
+        delete(path, options)
+      end
+
+      def construct_path(type, options)
+        organization_id = options.delete(:organization_id) || Validic.organization_id
+        user_id = options.delete(:user_id)
+        activity_id = options.delete(:_id)
+        if activity_id
+          path = "/#{Validic.api_version}/organizations/#{organization_id}/users/#{user_id}/#{type.to_s}/#{activity_id}.json"
+        elsif user_id && type == :users
+          path = "/#{Validic.api_version}/organizations/#{organization_id}/users/#{user_id}.json"
+        elsif user_id
+          path = "/#{Validic.api_version}/organizations/#{organization_id}/users/#{user_id}/#{type.to_s}.json"
+        elsif type == :me
+          path = "/#{Validic.api_version}/me.json"
+        elsif type == :profile
+          path = "/#{Validic.api_version}/profile.json"
+        elsif type == :organizations
+          path = "/#{Validic.api_version}/organizations/#{organization_id}.json"
+        else
+          path = "/#{Validic.api_version}/organizations/#{organization_id}/#{type.to_s}.json"
+        end
+        path
+      end
+
+      def get(path, options)
+        request(:get, path, options)
+      end
+
+      def post(path, options)
+        request(:post, path, options)
+      end
+
+      def put(path, options)
+        request(:put, path, options)
+      end
+
+      def delete(path, options)
+        request(:delete, path, options)
+      end
+
+      def request(method, path, options)
+        options[:access_token] = options[:access_token].nil? ? Validic.access_token : options[:access_token]
+        response = connection.send(method) do |request|
+          case method
+          when :get
+            request.url(path, options)
+          when :post, :put, :delete
+            request.path = path
+            request.body = MultiJson.encode(options) unless options.empty?
+          end
+        end
+        error = Validic::Error::ERRORS[response.status]
+        raise error.from_response(response.body) if error
+        response.body
+      end
+    end
+  end
+end

data/lib/validic/rest/routine.rb

@@ -0,0 +1,40 @@
+require 'validic/routine'
+
+module Validic
+  module REST
+    module Routine
+
+      def get_routine(params = {})
+        resp = get_request(:routine, params)
+        build_response_attr(resp)
+      end
+      alias :get_routines :get_routine
+
+      def create_routine(options = {})
+        user_id = options.delete(:user_id)
+        options = { user_id: user_id, routine: options }
+        response = post_request(:routine, options)
+        Validic::Routine.new(response['routine'])
+      end
+
+      def update_routine(options = {})
+        user_id, _id = options.delete(:user_id), options.delete(:_id)
+        options = { user_id: user_id, _id: _id, routine: options }
+        response = put_request(:routine, options)
+        Validic::Routine.new(response['routine'])
+      end
+
+      def delete_routine(options = {})
+        user_id, _id = options.delete(:user_id), options.delete(:_id)
+        options = { user_id: user_id, _id: _id }
+        delete_request(:routine, options)
+        true
+      end
+
+      def latest_routine(options = {})
+        resp = latest(:routine, options)
+        build_response_attr(resp)
+      end
+    end
+  end
+end

data/lib/validic/rest/sleep.rb

@@ -0,0 +1,41 @@
+require 'validic/sleep'
+
+module Validic
+  module REST
+    module Sleep
+
+      def get_sleep(options = {})
+        resp = get_request(:sleep, options)
+        build_response_attr(resp)
+      end
+      alias :get_sleeps :get_sleep
+
+      def create_sleep(options = {})
+        user_id = options.delete(:user_id)
+        options = { user_id: user_id, sleep: options }
+        response = post_request(:sleep, options)
+        Validic::Sleep.new(response['sleep'])
+      end
+
+      def update_sleep(options = {})
+        user_id, _id = options.delete(:user_id), options.delete(:_id)
+        options = { user_id: user_id, _id: _id, sleep: options }
+        response = put_request(:sleep, options)
+        Validic::Sleep.new(response['sleep'])
+      end
+
+      def latest_sleep(options = {})
+        resp = latest(:sleep, options)
+        build_response_attr(resp)
+      end
+
+      def delete_sleep(options = {})
+        user_id, _id = options.delete(:user_id), options.delete(:_id)
+        options = { user_id: user_id, _id: _id }
+        delete_request(:sleep, options)
+        true
+      end
+
+    end
+  end
+end