teamsnap_rb 1.3.3 → 2.0.0.beta

data/lib/teamsnap/api.rb

@@ -0,0 +1,113 @@
+module TeamSnap
+  class Api
+
+    CRUD_METHODS = [:find, :create, :update, :delete]
+    CRUD_VIAS    = [:get,  :post,   :patch,  :delete]
+
+    def self.run(client, method, klass, args = {}, template_args = false)
+      klass = klass.class == Symbol ? get_class(klass) : klass
+      via = via(klass, method)
+      href = href(klass.href, method, args)
+      args = args(method, args)
+      client_send_args = template_args ? template_attributes(args) : args
+      resp = TeamSnap.client_send(client, via, href, client_send_args)
+      TeamSnap::Response.new(
+        :args => args,
+        :client => client,
+        :client_send_args => client_send_args,
+        :href => href,
+        :resp => resp,
+        :status => resp.status,
+        :via => via
+      )
+    end
+
+    def self.args(method, sent_args)
+      case method
+      when :update
+        sent_args.except(:id)
+      when :find, :delete
+        {}
+      else
+        sent_args
+      end
+    end
+
+    def self.get_class(sym)
+      "TeamSnap::#{sym.to_s.singularize.camelcase}".constantize
+    end
+
+    def self.href(base_href, method, args = {})
+      case method
+      when :find, :delete
+        if [Fixnum, String].include?(args.class)
+          base_href + "/#{args}"
+        elsif args.class == Hash
+          base_href + "/#{args.fetch(:id)}"
+        else
+          raise TeamSnap::Error.new("You must pass in the `id` of the object you would like to :find or :delete")
+        end
+      when :create
+        base_href
+      when :update
+        base_href + "/#{args.fetch(:id)}"
+      else
+        base_href + "/#{method}"
+      end
+    end
+
+    def self.via(klass, method)
+      queries = klass.query_names
+      commands = klass.command_names
+
+      method_map = CRUD_METHODS + queries + commands
+      via_map = CRUD_VIAS + ([:get] * queries.count) + ([:post] * commands.count)
+
+      # SET VIA
+      if method_index = method_map.index(method)
+        return via_map[method_index]
+      else
+        raise TeamSnap::Error.new("Method Missing: `#{method}` for Collection Class: `#{klass}`")
+      end
+    end
+
+    def self.parse_error(resp)
+      return "Object Not Found (404)" if resp.status == 404
+      begin
+        Oj.load(resp.body)
+          .fetch(:collection)
+          .fetch(:error)
+          .fetch(:message)
+      rescue KeyError
+        resp.body
+      end
+    end
+
+    def self.template_args?(method)
+      [:create, :update].include?(method)
+    end
+
+    def self.template_attributes(attributes)
+      request_attributes = {
+        :template => {
+          :data => []
+        }
+      }
+      attributes.each do |key, value|
+        request_attributes[:template][:data] << {
+          "name" => key,
+          "value" => value
+        }
+      end
+      return request_attributes
+    end
+
+    def self.untemplate_attributes(request_attributes)
+      attributes = {}
+      request_attributes.fetch(:template).fetch(:data).each do |datum|
+        attributes[datum.fetch(:name).to_sym] = datum.fetch(:value)
+      end
+      return attributes
+    end
+  end
+end

data/lib/teamsnap/auth_middleware.rb

@@ -0,0 +1,62 @@
+module TeamSnap
+  class AuthMiddleware < Faraday::Middleware
+    def initialize(app, options)
+      @options = options
+      super(app)
+    end
+
+    def call(env)
+      if token
+        env[:request_headers].merge!({"Authorization" => "Bearer #{token}"})
+      elsif client_id && client_secret
+        query_params = Hash[URI.decode_www_form(env.url.query || "")]
+          .merge({
+            hmac_client_id: client_id,
+            hmac_nonce: SecureRandom.uuid,
+            hmac_timestamp: Time.now.to_i
+          })
+        env.url.query = URI.encode_www_form(query_params)
+
+        env.request_headers["X-Teamsnap-Hmac"] = OpenSSL::HMAC.hexdigest(
+          digest, client_secret, message_hash(env)
+        )
+      end
+
+      @app.call(env)
+    end
+
+    def token
+      @token ||= @options[:token]
+    end
+
+    def client_id
+      @client_id ||= @options[:client_id]
+    end
+
+    def client_secret
+      @client_secret ||= @options[:client_secret]
+    end
+
+    def digest
+      OpenSSL::Digest.new("sha256")
+    end
+
+    def message_hash(env)
+      digest.hexdigest(
+        query_string(env) + message(env)
+      )
+    end
+
+    def query_string(env)
+      "/?" + env.url.query.to_s
+    end
+
+    def message(env)
+      env.body || ""
+    end
+  end
+end
+
+Faraday::Request.register_middleware(
+  :teamsnap_auth_middleware => -> { TeamSnap::AuthMiddleware }
+)

data/lib/teamsnap/client.rb

@@ -0,0 +1,51 @@
+module TeamSnap
+  class Client
+
+    class << self
+      def set_faraday_client(url, token, client_id, client_secret)
+        Faraday.new(
+          :url => url,
+          :parallel_manager => Typhoeus::Hydra.new
+        ) do |c|
+          c.request :teamsnap_auth_middleware, {
+            :token => token,
+            :client_id => client_id,
+            :client_secret => client_secret
+          }
+          c.adapter :typhoeus
+        end
+      end
+    end
+
+    attr_accessor :faraday_client
+
+    def initialize(opts = {})
+      c_url = opts.fetch(:url) {}
+      c_token = opts.fetch(:token) {}
+      c_id = opts.fetch(:client_id) {}
+      c_secret = opts.fetch(:client_secret) {}
+
+      self.faraday_client = TeamSnap::Client.set_faraday_client(
+        c_url || TeamSnap.url,
+        c_token,
+        c_id || TeamSnap.client_id,
+        c_secret || TeamSnap.client_secret
+      )
+    end
+
+    def method_missing(method, *args, &block)
+      self.faraday_client.send(method, *args, &block)
+    end
+
+    def api(method, klass, sent_args = {})
+      TeamSnap::Api.run(
+        self,
+        method,
+        klass,
+        sent_args,
+        TeamSnap::Api.template_args?(method)
+      )
+    end
+
+  end
+end

data/lib/teamsnap/collection.rb

@@ -0,0 +1,125 @@
+module TeamSnap
+  module Collection
+
+    class << self
+
+      def apply_endpoints(obj, collection)
+        queries = collection.fetch(:queries) { [] }
+        commands = collection.fetch(:commands) { [] }
+
+        endpoint_creation_set(obj, queries, :get)
+        endpoint_creation_set(obj, commands, :post)
+      end
+
+      def endpoint_creation_set(obj, creation_set, via)
+        creation_set.each{ |endpoint| register_endpoint(obj, endpoint, :via => via) }
+      end
+
+      def register_endpoint(obj, endpoint, opts)
+        rel = endpoint.fetch(:rel)
+        href = endpoint.fetch(:href)
+        valid_args = endpoint.fetch(:data) { [] }
+          .map { |datum| datum.fetch(:name).to_sym }
+        via = opts.fetch(:via)
+
+        obj.define_singleton_method(rel) do |client, *args|
+          args = Hash[*args]
+
+          unless args.all? { |arg, _| valid_args.include?(arg) }
+            raise ArgumentError.new(
+              "Invalid argument(s). Valid argument(s) are #{valid_args.inspect}"
+            )
+          end
+
+          resp = TeamSnap.run(client, via, href, args)
+          TeamSnap::Item.load_items(client, resp)
+        end
+      end
+    end
+
+    def actions
+      actions = parsed_collection.fetch(:actions) {
+        %w(create read update delete search)
+      }
+      return actions.map(&:to_sym)
+    end
+
+    def queries
+      parsed_collection.fetch(:queries) { [] }
+    end
+
+    def query_names
+      queries.map{ |q| q[:rel].to_sym }
+    end
+
+    def commands
+      parsed_collection.fetch(:commands) { [] }
+    end
+
+    def command_names
+      commands.map{ |q| q[:rel].to_sym }
+    end
+
+    def create(client, attributes = {})
+      post_attributes = TeamSnap::Api.template_attributes(attributes)
+
+      create_resp = TeamSnap.run(client, :post, href, post_attributes)
+      TeamSnap::Item.load_items(client, create_resp).first
+    end
+
+    def update(client, id, attributes = {})
+      patch_attributes = TeamSnap::Api.template_attributes(attributes)
+
+      update_resp = TeamSnap.run(client, :patch, href+"/#{id}", patch_attributes)
+      TeamSnap::Item.load_items(client, update_resp).first
+    end
+
+    def delete(client, id)
+      TeamSnap.run(client, :delete, href+"/#{id}", {})
+    end
+
+    def template_attributes
+      template = parsed_collection.fetch(:template) {}
+      data = template.fetch(:data) { [] }
+      data
+        .reject{ |col| col.fetch(:name) == "type" }
+        .map{ |col| col.fetch(:name) }
+    end
+
+    def href
+      self.instance_variable_get(:@href)
+    end
+
+    def resp
+      self.instance_variable_get(:@resp)
+    end
+
+    def parsed_collection
+      self.instance_variable_get(:@parsed_collection)
+    end
+
+    def parse_collection
+      if resp
+        TeamSnap.response_check(resp, :get)
+        collection = Oj.load(resp.body).fetch(:collection) { [] }
+      elsif parsed_collection
+        collection = parsed_collection
+      end
+
+      TeamSnap::Collection.apply_endpoints(self, collection)
+      enable_find if respond_to?(:search)
+    end
+
+    private
+
+    def enable_find
+      define_singleton_method(:find) do |client, id|
+        search(client, :id => id).first.tap do |object|
+          raise TeamSnap::NotFound.new(
+            "Could not find a #{self} with an id of '#{id}'."
+          ) unless object
+        end
+      end
+    end
+  end
+end

data/lib/teamsnap/item.rb

@@ -0,0 +1,100 @@
+module TeamSnap
+  module Item
+
+    class << self
+      def load_items(client, collection)
+        collection
+          .fetch(:items) { [] }
+          .map { |item|
+            data = parse_data(item).merge(:href => item[:href])
+            type = type_of(item)
+            cls = load_class(type, data)
+
+            cls.new(data).tap { |obj|
+              obj.send(:load_links, client, item.fetch(:links) { [] })
+            }
+          }
+      end
+
+      def parse_data(item)
+        data = item
+          .fetch(:data)
+          .map { |datum|
+            name = datum.fetch(:name)
+            value = datum.fetch(:value)
+            type = datum.fetch(:type) { :default }
+
+            value = DateTime.parse(value) if value && type == "DateTime"
+
+            [name, value]
+          }
+        hashify(data)
+      end
+
+      def type_of(item)
+        item
+          .fetch(:data)
+          .find { |datum| datum.fetch(:name) == "type" }
+          .fetch(:value)
+      end
+
+      def load_class(type, data)
+        TeamSnap.const_get(Inflecto.camelize(type), false).tap { |cls|
+          unless cls.include?(Virtus::Model::Core)
+            cls.class_eval do
+              include Virtus.value_object
+
+              values do
+                attribute :href, String
+                data.each { |name, value| attribute name, value.class }
+              end
+            end
+          end
+        }
+      end
+
+      def hashify(arr)
+        Hash[*arr.flatten]
+      rescue NoMethodError
+        arr.inject({}) { |hash, (key, value)| hash[key] = value; hash }
+      end
+
+    end
+
+    private
+
+    def load_links(client, links)
+      links.each do |link|
+        next if EXCLUDED_RELS.include?(link.fetch(:rel))
+
+        rel = link.fetch(:rel)
+        href = link.fetch(:href)
+        is_singular = rel == Inflecto.singularize(rel)
+
+        define_singleton_method(rel) {
+          instance_variable_get("@#{rel}") || instance_variable_set(
+            "@#{rel}", -> {
+              coll = TeamSnap::Item.load_items(
+                client,
+                TeamSnap.run(client, :get, href)
+              )
+              is_singular ? coll.first : coll
+            }.call
+          )
+        }
+      end
+
+      define_singleton_method(:update) { |attributes|
+        patch_attributes = TeamSnap::Api.template_attributes(attributes)
+
+        response = TeamSnap.run(client, :patch, instance_variable_get("@href"), patch_attributes)
+        TeamSnap::Item.load_items(client, response).first
+      }
+
+      define_singleton_method(:delete) {
+        response = TeamSnap.run(client, :delete, instance_variable_get("@href"), {})
+        TeamSnap::Item.load_items(client, response).first
+      }
+    end
+  end
+end