nearmiss-ruby 1.0.0

data/lib/nearmiss-ruby/client/projects.rb

@@ -0,0 +1,76 @@
+module Nearmiss
+  class Client
+
+    # Methods for the Projects API
+    #
+    module Projects
+
+      # List projects
+      #
+      # @note Shows a list of projects for the users organization aka account
+      #
+      # @return [Array<Sawyer::Resource>] List of projects
+      def projects(options = {})
+        paginate "projects", options
+      end
+      alias :list_projects :projects
+
+      # Get a single project
+      #
+      # @param project [String] UUID of project to fetch
+      # @return [Sawyer::Resource] Project information
+      #
+      def project(project, options = {})
+        get "#{project_path(project)}", options
+      end
+
+      # Create a project
+      #
+      # @param options [Hash] Project information.
+      # @option options [String] :name e.g. Berkeley Art Museum
+      # @option options [String] :project_id e.g. 10611.70
+      # @return [Sawyer::Resource] Newly created project info
+      def create_project(options = {})
+        post 'projects', options
+      end
+
+      # Edit a project
+      #
+      # @param options [Hash] Project information.
+      # @option options [String] :name e.g. Berkeley Art Museum
+      # @option options [String] :project_id e.g. 10611.70
+      #
+      # @return
+      #   [Sawyer::Resource] Newly created project info
+      # @example Update a project
+      #   @client.edit_project('some_id', {
+      #     name: "New name of project",
+      #     project_id: "1043.32"
+      #   })
+      #
+      def edit_project(project, options = {})
+        patch "#{project_path(project)}", options
+      end
+
+      # Delete a project
+      #
+      # @param project [String] Project ID
+      # @return [Boolean] Indicating success of deletion
+      #
+      def delete_project(project, options = {})
+        boolean_from_response :delete, "projects/#{project}", options
+      end
+      alias :remove_project :delete_project
+
+      private
+
+      def project_path(id)
+        if uuid?(id)
+          "projects/#{id}"
+        else
+          "project/#{id}"
+        end
+      end
+    end
+  end
+end

data/lib/nearmiss-ruby/client/rate_limit.rb

@@ -0,0 +1,52 @@
+module Nearmiss
+  class Client
+
+    # Methods for API rate limiting info
+    #
+    # @see https://developer.github.com/v3/#rate-limiting
+    module RateLimit
+
+      # Get rate limit info from last response if available
+      # or make a new request to fetch rate limit
+      #
+      # @see https://developer.github.com/v3/rate_limit/#rate-limit
+      # @return [Nearmiss::RateLimit] Rate limit info
+      def rate_limit(options = {})
+        return rate_limit! if last_response.nil?
+
+        Nearmiss::RateLimit.from_response(last_response)
+      end
+      alias ratelimit rate_limit
+
+      # Get number of rate limted requests remaining
+      #
+      # @see https://developer.github.com/v3/rate_limit/#rate-limit
+      # @return [Fixnum] Number of requests remaining in this period
+      def rate_limit_remaining(options = {})
+        nearmiss_warn "Deprecated: Please use .rate_limit.remaining"
+        rate_limit.remaining
+      end
+      alias ratelimit_remaining rate_limit_remaining
+
+      # Refresh rate limit info by making a new request
+      #
+      # @return [Nearmiss::RateLimit] Rate limit info
+      def rate_limit!(options = {})
+        get "rate_limit"
+        Nearmiss::RateLimit.from_response(last_response)
+      end
+      alias ratelimit! rate_limit!
+
+      # Refresh rate limit info and get number of rate limted requests remaining
+      #
+      # @return [Fixnum] Number of requests remaining in this period
+      def rate_limit_remaining!(options = {})
+        nearmiss_warn "Deprecated: Please use .rate_limit!.remaining"
+        rate_limit!.remaining
+      end
+      alias ratelimit_remaining! rate_limit_remaining!
+
+    end
+  end
+end
+

data/lib/nearmiss-ruby/client/users.rb

@@ -0,0 +1,81 @@
+module Nearmiss
+  class Client
+
+    # Methods for the Users API
+    #
+    module Users
+
+      # List users
+      #
+      # @note Logged in user must be an admin to see all users
+      #
+      # @return [Array<Sawyer::Resource>] List of projects
+      def users(options = {})
+        paginate "users", options
+      end
+      alias :list_users :users
+
+      # Get a single user
+      #
+      # @param user [String] Nearmiss user email or id.
+      # @return [Sawyer::Resource]
+      # @example
+      #   Nearmiss.user("31817811-dce4-48c4-aa5f-f49603c5abee") or Nearmiss.user("m4rkuskk+a@gmail.com")
+      def user(user=nil, options = {})
+        if user.nil?
+          get "me", options
+        else
+          get "users/#{user}", options
+        end
+        # get User.path(user), options
+      end
+
+      # Edit a user
+      #
+      # @param options [Hash] User information.
+      # @option options [String] :email Email of user
+      # @option options [String] :name Name of user
+      # @option options [String] :nickname Nickname of user
+      # @option options [Integer] :role Set to admin or not
+      # @option options [String] :phone_number Phone number of user
+      # @option options [String] :image URL of image of user
+      # @option options [String] :language Code "en", "de", "es"
+      # @return
+      #   [Sawyer::Resource] Edited user info
+      # @example Update a user
+      #   @client.edit_user('some_id', {
+      #     email: "mklooth@webcor.com",
+      #     name: "Markus Klooth"
+      #   })
+      #
+      def edit_user(user, options = {})
+        patch "update_user/#{user}", options
+      end
+      alias :update_user :edit_user
+
+      def update_email(user, options = {})
+
+      end
+
+
+      def delete_user(user, options = {})
+        delete "users/#{user}", options
+      end
+
+      # Validate user username and password
+      #
+      # @param options [Hash] User credentials
+      # @option options [String] :email Nearmiss login email
+      # @option options [String] :password Nearmiss password
+      # @return [Boolean] True if credentials are valid
+      def validate_credentials(options = {})
+        !self.class.new(options).user.nil?
+      rescue Nearmiss::Unauthorized
+        false
+      end
+
+
+
+    end
+  end
+end

data/lib/nearmiss-ruby/client.rb

@@ -0,0 +1,307 @@
+# require "set"
+require_relative "authentication"
+require_relative "configurable"
+require_relative "arguments"
+require_relative "util"
+require_relative 'rate_limit'
+
+require_relative 'client/account'
+require_relative 'client/bookmarks'
+require_relative 'client/categories'
+require_relative 'client/incidents'
+require_relative 'client/notifications'
+require_relative 'client/projects'
+require_relative 'client/rate_limit'
+require_relative 'client/users'
+
+module Nearmiss
+
+  class Client
+    include Nearmiss::Util
+    include Nearmiss::Authentication
+    include Nearmiss::Configurable
+
+    include Nearmiss::Client::Account
+    include Nearmiss::Client::Bookmarks
+    include Nearmiss::Client::Categories
+    include Nearmiss::Client::Incidents
+    include Nearmiss::Client::Notifications
+    include Nearmiss::Client::Projects
+    include Nearmiss::Client::RateLimit
+    include Nearmiss::Client::Users
+
+    # include Nearmiss::Client::Users
+    # include Nearmiss::Client::ProjectLibrary
+    # include Nearmiss::Client::Projects
+    # include Nearmiss::Client::Templates
+    # include Nearmiss::Client::Checklists
+    # include Nearmiss::Client::Tasks
+    # include Nearmiss::Client::Issues
+    # include Nearmiss::Client::Utils
+
+    attr_accessor :access_token, :client_id, :uid, :expiry, :me
+
+    CONVENIENCE_HEADERS = Set.new([:accept, :content_type])
+
+
+    def initialize(options = {})
+
+      # Use options passed in, but fall back to module defaults
+      Nearmiss::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", options[key] || Nearmiss.instance_variable_get(:"@#{key}"))
+      end
+
+      sign_in if basic_authenticated?
+    end
+
+    # Compares client options to a Hash of requested options
+    #
+    # @param opts [Hash] Options to compare with current client options
+    # @return [Boolean]
+    def same_options?(opts)
+      opts.hash == options.hash
+    end
+
+
+    def inspect # :nodoc:
+
+      inspected = super
+
+      # mask password
+      inspected = inspected.gsub! @password, "*******" if @password
+      # Only show last 4 of token, secret
+      if @access_token
+        inspected = inspected.gsub! @access_token, "#{'*'*36}#{@access_token[36..-1]}"
+      end
+      # if @client_secret
+      #   inspected = inspected.gsub! @client_secret, "#{'*'*36}#{@client_secret[36..-1]}"
+      # end
+
+      inspected
+    end
+
+    # Hypermedia agent for the BIM360-Field API
+    #
+    # @return [Sawyer::Agent]
+    def agent
+      @agent ||= Sawyer::Agent.new(api_endpoint, sawyer_options) do |http|
+        # http.headers[:accept] = "image/jpg"
+        http.headers[:content_type]         = "application/json"
+        http.headers[:user_agent]           = user_agent
+        http.headers[:accept]               = "application/json"
+        http.headers[:api_key]              = api_key
+        http.headers[:'x-client-platform']  = "api"
+
+        if @access_token
+          http.headers.merge!({
+            :'access-token'   => @access_token,
+            :client           => @client_id,
+            :expiry           => @expiry,
+            :'token-type'     => "Bearer",
+            :uid              => @uid
+          })
+        end
+
+        # if
+        # if basic_authenticated?
+          # http.basic_auth(@login, @password)
+        # elsif token_authenticated?
+        #   http.authorization 'token', @access_token
+        # end
+      end
+    end
+
+
+    # Set username for authentication
+    #
+    # @param value [String] Nearmiss-field username
+    def email=(value)
+      reset_agent
+      @email = value
+    end
+
+    # Set password for authentication
+    #
+    # @param value [String] Nearmiss-field password
+    def password=(value)
+      reset_agent
+      @password = value
+    end
+
+    # Set OAuth access token for authentication
+    #
+    # @param value [String] 40 character Nearmiss-field API OAuth access token
+    # def access_token=(value)
+    #   reset_agent
+    #   @access_token = value
+    # end
+
+
+
+
+
+    # Make a HTTP GET request
+    #
+    # @param url [String] The path, relative to {#api_endpoint}
+    # @param options [Hash] Query and header params for request
+    # @return [Sawyer::Resource]
+    def get(url, options = {})
+      request :get, url, options
+    end
+
+    def post(url, options = {})
+      request :post, url, options
+    end
+
+    def put(url, options = {})
+      request :put, url, options
+    end
+
+    def patch(url, options = {})
+      request :patch, url, options
+    end
+
+    def delete(url, options = {})
+      request :delete, url, options
+    end
+
+    # Response for last HTTP request
+    #
+    # @return [Sawyer::Response]
+    def last_response
+      @last_response if defined? @last_response
+    end
+
+
+    # Make one or more HTTP GET requests, optionally fetching
+    # the next page of results from URL in Link response header based
+    # on value in {#auto_paginate}.
+    #
+    # @param url [String] The path, relative to {#api_endpoint}
+    # @param options [Hash] Query and header params for request
+    # @param block [Block] Block to perform the data concatination of the
+    #   multiple requests. The block is called with two parameters, the first
+    #   contains the contents of the requests so far and the second parameter
+    #   contains the latest response.
+    # @return [Sawyer::Resource]
+    def paginate(url, options = {}, &block)
+      opts = parse_query_and_convenience_headers(options.dup)
+      if @auto_paginate || @per_page
+        opts[:query][:per_page] ||=  @per_page || (@auto_paginate ? 100 : nil)
+      end
+
+      data = request(:get, url, opts)
+
+      if @auto_paginate
+        while @last_response.rels[:next] #&& rate_limit.remaining > 0
+          @last_response = @last_response.rels[:next].get
+          if block_given?
+            yield(data, @last_response)
+          else
+            data.concat(@last_response.data) if @last_response.data.is_a?(Array)
+          end
+        end
+
+      end
+
+      data
+    end
+
+
+    # Wrapper around Kernel#warn to print warnings unless
+    # OCTOKIT_SILENT is set to true.
+    #
+    # @return [nil]
+    def nearmiss_warn(*message)
+      unless ENV['NEARMISS_SILENT']
+        warn message
+      end
+    end
+
+
+
+    private
+
+    def reset_agent
+      @agent = nil
+    end
+
+    # Make a HTTP Request
+    #
+    # @param method [Symbol] Http method
+    # @param path [String] path relative to {#api_endpoint}
+    # @param options [Hash] Query and header params for request
+    # @return [Sawyer::Resource]
+
+    def request(method, path, data, options = {})
+      if data.is_a?(Hash)
+        options[:query]   = data.delete(:query) || {}
+        options[:headers] = data.delete(:headers) || {}
+        if accept = data.delete(:accept)
+          options[:headers][:accept] = accept
+        end
+      end
+
+      if @access_token
+        options[:headers].merge!({
+          "access-token"  => @access_token,
+          "client"        => @client_id,
+          "expiry"        => @expiry,
+          "token-type"    => "Bearer",
+          "uid"           => @uid
+        })
+      end
+
+
+      @last_response = response = agent.call(method, URI::Parser.new.escape(path.to_s), data, options)
+
+      update_headers(response.headers)
+
+      response.data
+
+    end
+
+
+    def sawyer_options
+      opts = {
+        :links_parser => Sawyer::LinkParsers::Simple.new
+      }
+      conn_opts           = @connection_options
+      conn_opts[:builder] = @middleware if @middleware
+      conn_opts[:proxy]   = @proxy if @proxy
+      opts[:faraday]      = Faraday.new(conn_opts)
+
+      opts
+    end
+
+    # Executes the request, checking if it was successful
+    #
+    # @return [Boolean] True on success, false otherwise
+    def boolean_from_response(method, path, options = {})
+      request(method, path, options)
+      @last_response.status == 204
+    rescue Nearmiss::NotFound
+      false
+    end
+
+
+    def parse_query_and_convenience_headers(options)
+      headers = options.fetch(:headers, {})
+      CONVENIENCE_HEADERS.each do |h|
+        if header = options.delete(h)
+          headers[h] = header
+        end
+      end
+      query = options.delete(:query)
+      opts = {:query => options}
+      opts[:query].merge!(query) if query && query.is_a?(Hash)
+      opts[:headers] = headers unless headers.empty?
+
+      opts
+    end
+
+
+  end
+
+
+end

data/lib/nearmiss-ruby/configurable.rb

@@ -0,0 +1,53 @@
+module Nearmiss
+  module Configurable
+    
+    attr_accessor :middleware, :proxy, :user_agent, :connection_options, :api_key, :auto_paginate, :per_page
+    attr_writer :password, :api_endpoint, :email
+
+    # Define static methods
+    class << self
+      
+      def keys
+        @keys ||= [
+          :middleware,
+          :proxy,
+          :user_agent,
+          :connection_options,
+          :password,
+          :api_endpoint,
+          :api_key,
+          :email,
+          :auto_paginate,
+          :per_page
+        ]
+      end
+    end
+
+    # Set configuration options using a block
+    def configure
+      yield self
+    end
+
+    # Reset configuration options to default values
+    def reset!
+      Nearmiss::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", Nearmiss::Default.options[key])
+      end
+      self
+    end
+    alias setup reset!
+
+    def api_endpoint
+      File.join(@api_endpoint, "")
+    end
+
+    def options
+      Hash[Nearmiss::Configurable.keys.map{|key| [key, instance_variable_get(:"@#{key}")]}]
+    end
+
+  private
+
+
+  
+  end  
+end

data/lib/nearmiss-ruby/default.rb

@@ -0,0 +1,137 @@
+# require "bim360/version" unless defined?(Nearmiss::VERSION)
+# require 'bim360/response/raise_error'
+
+module Nearmiss
+
+
+  # Default configuration options for {Client}
+  module Default
+
+    # config = YAML.load_file(File.join(Rails.root, 'secrets/secrets.yml'))['nearmiss']
+
+    # Default API endpoint
+    API_ENDPOINT  = "http://nearmissapp.com".freeze
+
+    # Default User Agent header string
+    USER_AGENT    = "Nearmiss Ruby Gem #{Nearmiss::VERSION}".freeze
+
+    API_KEY       = "WEBCOR".freeze
+
+    # Default Faraday middleware stack
+    # MIDDLEWARE =
+
+
+    class << self
+
+      # Configuration options
+      # @return [Hash]
+      def options
+        Hash[Nearmiss::Configurable.keys.map{|key| [key, send(key)]}]
+      end
+
+      # Default access token from ENV
+      # @return [String]
+      def access_token
+        ENV['NEARMISS_ACCESS_TOKEN']
+      end
+
+      def client_id
+
+      end
+
+      def uid
+
+      end
+
+      def expiry
+
+      end
+
+      def user
+
+      end
+
+
+      def config
+        @config ||= {}
+      end
+
+      # Default API endpoint from ENV or {API_ENDPOINT}
+      # @return [String]
+      def api_endpoint
+        ENV['NEARMISS_API_ENDPOINT'] || API_ENDPOINT
+      end
+
+      # Default BIM360-Field username for Basic Auth from ENV
+      # @return [String]
+      def email
+        ENV['NEARMISS_EMAIL'] || config['email']
+      end
+
+      # Default BIM360-Field password for Basic Auth from ENV
+      # @return [String]
+      def password
+        ENV['NEARMISS_PASSWORD'] || config['password']
+      end
+
+      # def ticket
+      #   ENV['NEARMISS_TICKET']
+      # end
+
+      # Default proxy server URI for Faraday connection from ENV
+      # @return [String]
+      def proxy
+        ENV['NEARMISS_PROXY']
+      end
+
+      # Default options for Faraday::Connection
+      # @return [Hash]
+      def connection_options
+        {
+          :headers => {
+            # :accept => default_media_type,
+            :user_agent => user_agent
+          }
+        }
+      end
+
+
+      # Default middleware stack for Faraday::Connection
+      # from {MIDDLEWARE}
+      # @return [String]
+      def middleware
+        Faraday::RackBuilder.new do |builder|
+          builder.use Nearmiss::Response::RaiseError
+          builder.adapter Faraday.default_adapter
+        end
+      end
+
+      # Default pagination preference from ENV
+      # @return [String]
+      def auto_paginate
+        ENV['NEARMISS_AUTO_PAGINATE'] || true
+      end
+
+      # Default pagination page size from ENV
+      # @return [Fixnum] Page size
+      def per_page
+        page_size = ENV['NEARMISS_PER_PAGE']
+
+        page_size.to_i if page_size
+      end
+
+
+      # Default User-Agent header string from ENV or {USER_AGENT}
+      # @return [String]
+      def user_agent
+        ENV['NEARMISS_USER_AGENT'] || USER_AGENT
+      end
+
+      def api_key
+        ENV['NEARMISS_API_KEY'] || API_KEY
+      end
+
+    end
+
+  end
+end