layer-api 0.3.1 → 0.4.0

data/layer-api.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'layer/api/version'
+require 'layer/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "layer-api"
@@ -10,8 +10,8 @@ Gem::Specification.new do |spec|
   spec.email         = ["jake.kelly10@gmail.com"]
   spec.license       = "MIT"
 
-  spec.summary       = "A ruby toolkit for Layer's Platform API (https://developer.layer.com/docs/platform)"
-  spec.description   = "Simple wrapper for the Layer Platform API"
+  spec.summary       = "A ruby toolkit for Layer's Web API's (https://developer.layer.com/docs)"
+  spec.description   = "Simple wrapper for the Layer's Web API's"
   spec.homepage      = "https://github.com/cakejelly/layer-api"
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }

data/lib/layer/api.rb

@@ -2,15 +2,21 @@ require 'faraday'
 require 'json'
 require 'jwt'
 
-require "layer/api/version"
-require "layer/api/configuration"
-require "layer/api/connection"
-require "layer/api/client"
-require "layer/api/error"
+require "layer/version"
+require "layer/http_client"
+require "layer/errors"
+require "layer/resource"
+require "layer/resource_proxy"
+require "layer/identity_token"
 
-require "layer/api/middleware/api_errors"
+# Platform
+require "layer/platform/client"
 
-module Layer
-  module Api
-  end
-end
+# Resources
+require "layer/resources/conversation"
+require "layer/resources/message"
+require "layer/resources/announcement"
+require "layer/resources/user"
+require "layer/resources/block"
+
+require "layer/middleware/api_errors"

data/lib/layer/errors.rb

@@ -0,0 +1,43 @@
+module Layer
+  class Error < StandardError
+    def self.from_response(response)
+      status = response[:status]
+
+      if klass = case status
+                 when 400 then Layer::Errors::BadRequest
+                 when 404 then Layer::Errors::NotFound
+                 when 409 then Layer::Errors::Conflict
+                 when 410 then Layer::Errors::ResourceDeleted
+                 when 500..599 then Layer::Errors::ServerError
+                 else self
+                 end
+        klass.new(response)
+      end
+    end
+
+    def initialize(response)
+      @response = response
+      super(build_error_message)
+    end
+
+    def response
+      @response
+    end
+
+    private
+
+    def build_error_message
+      message = "Layer responded with status "
+      message << "#{@response[:status]}: #{@response[:body]}"
+      message
+    end
+  end
+
+  module Errors
+    class BadRequest < Error; end
+    class NotFound < Error; end
+    class ServerError < Error; end
+    class ResourceDeleted < Error; end
+    class Conflict < Error; end
+  end
+end

data/lib/layer/http_client.rb

@@ -0,0 +1,70 @@
+require 'securerandom'
+
+module Layer
+  class HttpClient
+    DEFAULT_HOST = "https://api.layer.com"
+
+    attr_reader :app_id, :api_token
+
+    def initialize(app_id, api_token)
+      @app_id = app_id
+      @api_token = api_token
+    end
+
+    def connection
+      @connection ||= Faraday.new(url: base_url) do |faraday|
+        faraday.headers = default_layer_headers
+        faraday.request  :url_encoded
+        faraday.adapter  Faraday.default_adapter
+        faraday.use Middleware::ApiErrors
+      end
+    end
+
+    def get(url, options = {})
+      call(:get, url, options)
+    end
+
+    def post(url, options = {})
+      call(:post, url, options)
+    end
+
+    def patch(url, options = {})
+      call(:patch, url, options)
+    end
+
+    def delete(url)
+      call(:delete, url)
+    end
+
+    def call(method, url, options = {})
+      response = run_request(method, url, options)
+      response.body.empty? ? nil : JSON.parse(response.body)
+    end
+
+    def run_request(method, url, options = {})
+      connection.run_request(
+        method,
+        url,
+        options[:body],
+        options[:headers]
+      )
+    end
+
+    def default_layer_headers
+      {
+        'Accept' => 'application/vnd.layer+json; version=1.0',
+        'Authorization' => "Bearer #{api_token}",
+        'Content-Type' => 'application/json',
+        'If-None-Match' => SecureRandom.uuid
+      }
+    end
+
+    def layer_patch_header
+      { 'Content-Type' => 'application/vnd.layer-patch+json' }
+    end
+
+    def base_url
+      "#{DEFAULT_HOST}/apps/#{app_id}"
+    end
+  end
+end

data/lib/layer/identity_token.rb

@@ -0,0 +1,53 @@
+module Layer
+  class IdentityToken
+    attr_reader :user_id, :nonce, :expires_at
+
+    def initialize(options = {})
+      @user_id = options[:user_id]
+      @nonce = options[:nonce]
+      @expires_at = (options[:expires_at] || Time.now+(1209600))
+    end
+
+    def to_s
+      get_jwt
+    end
+
+    def layer_key_id
+      ENV['LAYER_KEY_ID']
+    end
+
+    def layer_provider_id
+      ENV['LAYER_PROVIDER_ID']
+    end
+
+    private
+
+    def get_jwt
+      JWT.encode(claim, private_key, 'RS256', headers)
+    end
+
+    def headers
+      {
+        typ: 'JWT',
+        cty: 'layer-eit;v=1',
+        kid: layer_key_id
+      }
+    end
+
+    def claim
+      {
+        iss: layer_provider_id,
+        prn: user_id.to_s,
+        iat: Time.now.to_i,
+        exp: expires_at.to_i,
+        nce: nonce
+      }
+    end
+
+    def private_key
+      # Cloud66 stores newlines as \n instead of \\n
+      key = ENV['LAYER_PRIVATE_KEY'].dup
+      OpenSSL::PKey::RSA.new(key.gsub!("\\n","\n"))
+    end
+  end
+end

data/lib/layer/middleware/api_errors.rb

@@ -0,0 +1,13 @@
+module Layer
+  module Middleware
+    class ApiErrors < Faraday::Response::Middleware
+      ERROR_CODES = 400...600
+
+      def on_complete(response)
+        if ERROR_CODES.include?(response.status)
+          raise Layer::Error.from_response(response)
+        end
+      end
+    end
+  end
+end

data/lib/layer/platform/client.rb

@@ -0,0 +1,57 @@
+module Layer
+  module Platform
+    class Client
+      attr_accessor :api_token, :app_id
+
+      def initialize(options = {})
+        @api_token = options[:api_token] || ENV['LAYER_API_TOKEN']
+        @app_id = options[:app_id] || ENV['LAYER_APP_ID']
+        strip_layer_prefix(@app_id)
+      end
+
+      def client
+        @http_client ||= Layer::HttpClient.new(app_id, api_token)
+      end
+
+      def get(url, *args)
+        client.get(url, *args)
+      end
+
+      def post(url, *args)
+        client.post(url, *args)
+      end
+
+      def put(url, *args)
+        client.put(url, *args)
+      end
+
+      def patch(url, *args)
+        client.patch(url, *args)
+      end
+
+      def delete(url)
+        client.delete(url)
+      end
+
+      def strip_layer_prefix(string)
+        string.split("/").last if string
+      end
+
+      def announcements
+        Layer::ResourceProxy.new(nil, Layer::Resources::Announcement)
+      end
+
+      def conversations
+        Layer::ResourceProxy.new(nil, Layer::Resources::Conversation)
+      end
+
+      def users
+        Layer::ResourceProxy.new(nil, Layer::Resources::User)
+      end
+
+      def generate_identity_token(options = {})
+        Layer::IdentityToken.new(options)
+      end
+    end
+  end
+end

data/lib/layer/resource.rb

@@ -0,0 +1,80 @@
+module Layer
+  class Resource
+    attr_reader :attributes, :client
+
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def update(params)
+      client.patch(
+        url,
+        body: params.to_json,
+        headers: client.layer_patch_header
+      )
+    end
+
+    def destroy
+      client.delete(url)
+    end
+
+    def client
+      self.class.client
+    end
+
+    def method_missing(method, *args, &block)
+      method_key = method.to_s
+      attributes.has_key?(method_key) ? attributes[method_key] : super
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      method_key = method.to_s
+      attributes.has_key?(method_key) ? true : false
+    end
+
+    def uuid
+      attributes["id"].split("/").last if attributes["id"]
+    end
+
+    class << self
+      def class_name
+        name.split("::").last
+      end
+
+      def pluralized_name
+        "#{class_name}s"
+      end
+
+      def url
+        pluralized_name.downcase
+      end
+
+      def client
+        Layer::HttpClient.new(
+          ENV['LAYER_APP_ID'],
+          ENV['LAYER_API_TOKEN']
+        )
+      end
+
+      def create(url, params = {})
+        response = client.post(url, body: params.to_json)
+        new(response)
+      end
+
+      def find(url, id)
+        response = client.get("#{url}/#{id}")
+        new(response)
+      end
+
+      def list(url, params = {})
+        collection = client.get(url, body: params.to_json)
+
+        if collection.any?
+          collection.map{ |resource| new(resource) }
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/layer/resource_proxy.rb

@@ -0,0 +1,20 @@
+module Layer
+  class ResourceProxy
+    def initialize(base, resource)
+      @base = base
+      @resource = resource
+    end
+
+    def url
+      @base.nil? ? @resource.url : "#{@base.url}/#{@resource.url}"
+    end
+
+    def method_missing(method, *args, &block)
+      @resource.public_send(method, *([url] + args), &block)
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      @resource.respond_to?(method) || super
+    end
+  end
+end

data/lib/layer/resources/announcement.rb

@@ -0,0 +1,6 @@
+module Layer
+  module Resources
+    class Announcement < Layer::Resource
+    end
+  end
+end

data/lib/layer/resources/block.rb

@@ -0,0 +1,31 @@
+module Layer
+  module Resources
+    class Block < Layer::Resource
+      def self.find(url, user)
+        user_id = user.instance_of?(User) ? user.id : user
+        new_abstract_instance(url, user_id)
+      end
+
+      def self.list(url, params = {})
+        collection = client.get(url, body: params.to_json)
+
+        if collection.any?
+          collection.map{ |resource| new_abstract_instance(url, resource['user_id']) }
+        else
+          []
+        end
+      end
+
+      def self.create(url, params = {})
+        user_params = params.instance_of?(User) ? {user_id: params.id} : params
+
+        client.post(url, body: user_params.to_json)
+        new_abstract_instance(url, user_params[:user_id])
+      end
+
+      def self.new_abstract_instance(url, id)
+        new({"id" => id, "url" => "#{url}/#{id}"})
+      end
+    end
+  end
+end

data/lib/layer/resources/conversation.rb

@@ -0,0 +1,9 @@
+module Layer
+  module Resources
+    class Conversation < Layer::Resource
+      def messages
+        Layer::ResourceProxy.new(self, Message)
+      end
+    end
+  end
+end