code42 0.1.2

data/lib/code42/computer.rb

@@ -0,0 +1,15 @@
+module Code42
+  class Computer < Resource
+
+    attribute :id, :from => 'computerId'
+
+    def unblock
+      client.unblock_computer(id)
+    end
+
+    def block
+      client.block_computer(id)
+    end
+
+  end
+end

data/lib/code42/connection.rb

@@ -0,0 +1,124 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'logger'
+require 'code42/error'
+
+module Code42
+  class Connection
+    attr_accessor :host, :port, :scheme, :path_prefix, :username, :password, :adapter, :token, :verify_https, :logger
+    def initialize(options = {})
+      self.host         = options[:host]
+      self.port         = options[:port]
+      self.scheme       = options[:scheme]
+      self.path_prefix  = options[:path_prefix]
+      self.username     = options[:username]
+      self.password     = options[:password]
+      self.token        = options[:token] if options[:token]
+      self.verify_https = !options[:verify_https].nil? ? options[:verify_https] : true
+
+      adapter.host        = host
+      adapter.port        = port
+      adapter.scheme      = scheme
+      adapter.path_prefix = path_prefix
+      adapter.ssl[:verify] = verify_https
+    end
+
+    def logger
+      @logger ||= Logger.new(STDOUT)
+    end
+
+    def adapter
+      if !@adapter
+        @adapter = Faraday.new
+        @adapter.response :json
+      end
+      @adapter
+    end
+
+    def has_valid_credentials?
+      username && password
+    end
+
+    def token=(token)
+      @token = token
+      adapter.headers['Authorization-Challenge'] = "false"
+      adapter.headers['Authorization'] = "TOKEN #{token}"
+      @token
+    end
+
+    def username=(username)
+      @username = username
+      adapter.basic_auth(username, password) if has_valid_credentials?
+    end
+
+    def password=(password)
+      @password = password
+      adapter.basic_auth(username, password) if has_valid_credentials?
+    end
+
+    def make_request(method, *args)
+      begin
+        response = self.send(method, *args)
+      rescue Faraday::Error::ConnectionFailed
+        raise Code42::Error::ConnectionFailed
+      end
+      check_for_errors(response)
+      response.body
+    end
+
+    def get(path, data)
+      adapter.get(path, data)
+    end
+
+    def put(path, data)
+      adapter.headers['Content-Type'] = 'application/json'
+      adapter.put path, data.to_json
+    end
+
+    def post(path, data)
+      adapter.headers['Content-Type'] = 'application/json'
+      adapter.post path, data.to_json
+    end
+
+    def delete(path, data)
+      adapter.delete(path, data)
+    end
+
+    def respond_to?(method_name, include_private = false)
+      adapter.respond_to?(method_name, include_private) || super
+    end if RUBY_VERSION < "1.9"
+
+    def respond_to_missing?(method_name, include_private = false)
+      adapter.respond_to?(method_name, include_private) || super
+    end if RUBY_VERSION >= "1.9"
+
+    private
+
+    def check_for_errors(response)
+      if response.status == 401
+        raise Code42::Error::AuthenticationError.new(nil, response.status)
+      elsif response.status == 404
+        raise Code42::Error::ResourceNotFound.new(nil, response.status)
+      elsif response.status >= 400 && response.status < 600
+        body = response.body.is_a?(Array) ? response.body.first : response.body
+        raise exception_from_body(body, response.status)
+      end
+    end
+
+    def exception_from_body(body, status = nil)
+      return Code42::Error.new("Status: #{status}") if body.nil? || !body.has_key?('name')
+      exception_name = body['name'].downcase.camelize
+      if Code42::Error.const_defined?(exception_name)
+        klass = Code42::Error.const_get(exception_name)
+      else
+        klass = Code42::Error
+      end
+      klass.new(body['description'], status)
+    end
+
+    def method_missing(method_name, *args, &block)
+      return super unless adapter.respond_to?(method_name)
+      adapter.send(method_name, *args, &block)
+    end
+  end
+end

data/lib/code42/diagnostic.rb

@@ -0,0 +1,8 @@
+module Code42
+  class Diagnostic < Resource
+    attribute :timestamp, :from => 'diagnosticTimestamp', :as => DateTime
+    attribute :db_ok
+    attribute :volumes
+    attribute :system_alerts
+  end
+end

data/lib/code42/error.rb

@@ -0,0 +1,21 @@
+module Code42
+  class Error < StandardError;
+    attr_reader :status
+    def initialize(message = nil, status = nil)
+      super(message)
+      @status = status
+    end
+  end
+
+  class Error::AuthenticationError < Error; end
+  class Error::UsernameNotEmail < Error; end
+  class Error::EmailInvalid < Error; end
+  class Error::InvalidUsername < Error; end
+  class Error::OrgNameMissing < Error; end
+  class Error::OrgDuplicate < Error; end
+  class Error::ParentOrgBlocked < Error; end
+  class Error::ParentOrgNotActive < Error; end
+  class Error::OrgNameTooShort < Error; end
+  class Error::ConnectionFailed < Error; end
+  class Error::ResourceNotFound < Error; end
+end

data/lib/code42/org.rb

@@ -0,0 +1,38 @@
+require 'date'
+module Code42
+  class Org < Resource
+
+    attribute :id, :from => 'orgId'
+    attribute :uid, :from => 'orgUid'
+    attribute :name, :from => 'orgName'
+    attribute :parent_id, :from => 'parentOrgId'
+    attribute :created_at, :from => 'creationDate', :as => DateTime
+    attribute :updated_at, :from => 'modificationDate', :as => DateTime
+    attribute :customer_id
+
+    def self.create(attrs = {})
+      client.create_org(attrs)
+    end
+
+    def self.find_by_name(name)
+      client.find_org_by_name(name)
+    end
+
+    def users
+      client.users(org_id: id)
+    end
+
+    def update(attrs = {})
+      client.update_org(id, attrs)
+    end
+
+    def delete
+      client.delete_org(id)
+    end
+
+    def create_user(attrs = {})
+      attrs.merge!(org_id: id)
+      client.create_user(attrs)
+    end
+  end
+end

data/lib/code42/ping.rb

@@ -0,0 +1,14 @@
+module Code42
+  class Ping < Resource
+
+    attribute :success
+
+    def to_s
+      success?
+    end
+
+  	def success?
+  		self.success
+  	end
+  end
+end

data/lib/code42/resource.rb

@@ -0,0 +1,58 @@
+module Code42
+  class Resource
+    alias_method :inspect, :to_s
+
+    class << self
+      def from_response(response, client = nil)
+        deserialize_and_initialize(response, client)
+      end
+
+      def deserialize_and_initialize(data, client = nil)
+        new deserialize(data), client
+      end
+
+      def serialize(data)
+        data.inject({}) { |o, ary| o.merge! serializer.serialize(*ary) }
+      end
+
+      def deserialize(data)
+        data.inject({}) { |o, ary| o.merge! serializer.deserialize(*ary) }
+      end
+
+      def serializer
+        @serializer ||= Code42::AttributeSerializer.new
+      end
+
+      def attribute(*args)
+        options = args.extract_options!
+        args.each do |name|
+          serializer << Attribute.new(name, options)
+        end
+      end
+
+      def collection_from_response(array)
+        array.map { |element| self.deserialize_and_initialize(element, self) }
+      end
+    end
+    attr_accessor :client, :attributes
+
+    def initialize(data = {}, client = nil)
+      self.client = client || Code42.client
+      self.attributes = {}
+      data.each do |key, value|
+        unless self.respond_to?("#{key}=".to_sym)
+          self.class.instance_eval { attr_writer key.to_sym }
+        end
+        unless self.respond_to?("#{key}".to_sym)
+          self.class.instance_eval { attr_reader key.to_sym }
+        end
+        self.send("#{key}=", value)
+        attributes[key.to_sym] = send(key.to_sym)
+      end
+    end
+
+    def serialize
+      self.class.serialize attributes
+    end
+  end
+end

data/lib/code42/role.rb

@@ -0,0 +1,26 @@
+module Code42
+  class Role < Resource
+
+    # @!attribute [rw] id
+    #   @return [Fixnum] The id of the role
+    # @!attribute [rw] name
+    #   @return [String] The name of the role
+    # @!attribute [rw] permissions
+    #   @return [Array] A list of permissions for this role
+    # @!attribute [rw] created_at
+    #   @return [DateTime] The timestamp for the time the role was assigned
+    # @!attribute [rw] updated_at
+    #   @return [DateTime] The timestamp for the time the role was updated
+
+    attribute :user_id
+    attribute :id, :from => :roleId
+    attribute :name, :from => :roleName
+    attribute :created_at, :from => :creationDate, :as => DateTime
+    attribute :updated_at, :from => :modificationDate, :as => DateTime
+    attribute :permissions
+
+    def permissions=(permissions = [])
+      @permissions = permissions.map { |p| p['permission'] }
+    end
+  end
+end

data/lib/code42/role_collection.rb

@@ -0,0 +1,35 @@
+module Code42
+  class RoleCollection
+    include Enumerable
+
+    def initialize(roles = [])
+      @roles = roles
+    end
+
+    def each(&block)
+      @roles.each do |role|
+        if block_given?
+          block.call role
+        else
+          yield role
+        end
+      end
+    end
+
+    def attributes
+      map(&:attributes)
+    end
+
+    def serialize
+      map(&:serialize)
+    end
+
+    def includes_id?(id)
+      map(&:id).include? id
+    end
+
+    def includes_name?(name)
+      map(&:name).include? name
+    end
+  end
+end

data/lib/code42/settings.rb

@@ -0,0 +1,42 @@
+module Code42
+  class Settings
+    attr_accessor :host, :port, :https, :api_root, :username, :password, :token, :verify_https, :debug
+
+    def initialize(options = {})
+      options.symbolize_keys!
+      self.host     = options[:host]
+      self.port     = options[:port]
+      self.https    = !options[:https].nil? ? options[:https] : true
+      self.verify_https = !options[:verify_https].nil? ? options[:verify_https] : true
+      self.api_root = options[:api_root] || '/api'
+      self.username = options[:username]
+      self.password = options[:password]
+      self.token    = options[:token]
+      self.debug    = options[:debug]
+    end
+
+    def all
+      settings = {}
+      settings[:host]     = host
+      settings[:port]     = port
+      settings[:https]    = https
+      settings[:api_root] = api_root
+      settings[:username] = username
+      settings[:password] = password
+      settings
+    end
+
+    def scheme
+      https ? 'https' : 'http'
+    end
+
+    def base_url
+      raise Error unless valid?
+      "#{scheme}://#{host}:#{port}#{api_root}"
+    end
+
+    def valid?
+      host && port && api_root
+    end
+  end
+end

data/lib/code42/token.rb

@@ -0,0 +1,31 @@
+require 'code42/resource'
+
+module Code42
+  class Token < Resource
+
+    class << self
+      def from_string(token_string)
+        tokens = token_string.split('-')
+        new(cookie_token: tokens[0],
+            url_token: tokens[1])
+      end
+
+      def deserialize(data)
+        result = {}
+        result[:cookie_token] = data[0]
+        result[:url_token]    = data[1]
+        result
+      end
+    end
+
+    alias inspect to_s
+
+    def to_s
+      token_string
+    end
+
+    def token_string
+      [cookie_token, url_token].join('-')
+    end
+  end
+end

data/lib/code42/token_validation.rb

@@ -0,0 +1,10 @@
+module Code42
+  class TokenValidation < Resource
+
+    attribute :valid, :username
+
+    def valid?
+      valid
+    end
+  end
+end

data/lib/code42/user.rb

@@ -0,0 +1,40 @@
+require 'date'
+
+module Code42
+  class User < Resource
+
+    attribute :id, :from => 'userId'
+    attribute :uid, :from => 'userUid'
+    attribute :org_id
+    attribute :updated_at, :from => 'modificationDate', :as => DateTime
+    attribute :created_at, :from => 'creationDate', :as => DateTime
+    attribute :status, :username, :email, :first_name, :last_name, :quota_in_bytes, :org_id, :org_uid, :org_name, :active, :blocked, :email_promo, :invited, :org_type, :username_is_an_email, :customer_id
+
+    def self.create(attributes)
+      client.create_user(attributes)
+    end
+
+    def delete
+      client.delete_user(id)
+    end
+
+    # Returns the org associated with this user
+    # @return [Code42::User]
+    def org
+      client.org(org_id)
+    end
+
+    # Returns the roles associated with this user
+    # @return [Code42::RoleCollection]
+    def roles
+      client.user_roles(id)
+    end
+
+    # Assigns a role to this user
+    # @return [Code42::Role]
+    def assign_role(attrs = {})
+      attrs.merge!(user_id: id)
+      client.assign_role(attrs)
+    end
+  end
+end