antaeus-sdk 0.2.3

data/lib/antaeus-sdk/resource_collection.rb

@@ -0,0 +1,198 @@
+module Antaeus
+  # The ResourceCollection class
+  # Should not allow or use mixed types
+  class ResourceCollection
+    include Enumerable
+    include Comparable
+
+    # @return [Class] this is a collection of this {Resource} subclass
+    attr_reader :type
+
+    def initialize(list, options = {})
+      raise Exceptions::InvalidOptions unless options.is_a?(Hash)
+      raise Exceptions::MissingAPIClient unless options[:client]
+      raise Exceptions::InvalidAPIClient unless options[:client].is_a?(APIClient)
+      raise Exceptions::InvalidInput if list.empty? and options[:type].nil?
+      @client = options[:client]
+      @list = list
+      if options[:type]
+        @type = options[:type]
+      else
+        @type = list.first.class
+      end
+    end
+
+    def each(&block)
+      @list.each(&block)
+    end
+
+    # Does the collection contain anything?
+    # @return [Boolean]
+    def empty?
+      @list.empty?
+    end
+
+    def first(n = nil)
+      if n
+        self.class.new(@list.first(n), type: @type, client: @client)
+      else
+        @list.first
+      end
+    end
+
+    def last(n = nil)
+      if n
+        self.class.new(@list.last(n), type: @type, client: @client)
+      else
+        @list.last
+      end
+    end
+
+    # Merge two collections
+    # @return [ResourceCollection]
+    def merge(other)
+      if other.is_a?(self.class)
+        new_list = @list.dup
+        self + (other - self)
+      else
+        fail Exceptions::InvalidInput
+      end
+    end
+
+    # Makes #model compatible with the server-side
+    def model
+      type
+    end
+
+    # Hacked together #or() method in the same spirit as #where().
+    # This method can be chained for multiple / more specific queries.
+    #
+    # @param attribute [Symbol] the attribute to query
+    # @param value [Object] the value to compare against
+    # @param comparison_method [String,Symbol] the method to use for comparison
+    #   - allowed options are "'==', '!=', '>', '>=', '<', '<=', and 'match'"
+    # @raise [Exceptions::InvalidWhereQuery] if not the right kind of comparison
+    # @return [ResourceCollection]
+    def or(attribute, value, options = {})
+      options[:comparison] ||= '=='
+      if empty?
+        @type.where(attribute, value, comparison: options[:comparison], client: @client)
+      else
+        merge first.class.where(
+          attribute, value,
+          comparison: options[:comparison],
+          client: @client
+        )
+      end
+    end
+
+    # Pass pagination through to the Array (which passes to will_paginate)
+    def paginate(*args)
+      @list.paginate(*args)
+    end
+
+    # Returns the number of Resource instances in the collection
+    # @return [Fixnum]
+    def size
+      @list.size
+    end
+
+    # Allow complex sorting like an Array
+    # @return [ResourceCollection] sorted collection
+    def sort(&block)
+      self.class.new(super(&block), type: @type, client: @client)
+    end
+
+    # Horribly inefficient way to allow querying Resources by their attributes.
+    # This method can be chained for multiple / more specific queries.
+    #
+    # @param attribute [Symbol] the attribute to query
+    # @param value [Object] the value to compare against
+    # @param comparison_method [String,Symbol] the method to use for comparison
+    #   - allowed options are "'==', '!=', '>', '>=', '<', '<=', and 'match'"
+    # @raise [Exceptions::InvalidWhereQuery] if not the right kind of comparison
+    # @return [ResourceCollection]
+    def where(attribute, value, options = {})
+      valid_comparisons = [:'==', :'!=', :>, :'>=', :<, :'<=', :match]
+      options[:comparison] ||= '=='
+      unless valid_comparisons.include?(options[:comparison].to_sym)
+        fail Exceptions::InvalidWhereQuery
+      end
+      self.class.new(
+        @list.collect do |item|
+          if item.send(attribute).nil?
+            nil
+          else
+            item if item.send(attribute).send(options[:comparison].to_sym, value)
+          end
+        end.compact,
+        type: @type,
+        client: @client
+      )
+    end
+
+    alias_method :and, :where
+
+    # Return the collection item at the specified index
+    # @return [Resource,ResourceCollection] the item at the requested index
+    def [](index)
+      if index.is_a?(Range)
+        self.class.new(@list[index], type: @type, client: @client)
+      else
+        @list[index]
+      end
+    end
+
+    # Return a collection after subtracting from the original
+    # @return [ResourceCollection]
+    def -(other)
+      new_list = @list.dup
+      if other.respond_to?(:to_a)
+        other.to_a.each do |item|
+          new_list.delete_if { |res| res.id == item.id }
+        end
+      elsif other.is_a?(Resource)
+        new_list.delete_if { |res| res.id == other.id }
+      else
+        raise Exceptions::InvalidInput
+      end
+      self.class.new(new_list, type: @type, client: @client)
+    end
+
+    # Return a collection after adding to the original
+    #   Warning: this may cause duplicates or mixed type joins! For safety,
+    #   use #merge
+    # @return [ResourceCollection]
+    def +(other)
+      if other.is_a?(self.class)
+        self.class.new(@list + other.to_a, type: @type, client: @client)
+      elsif other.is_a?(@type)
+        self.class.new(@list + [other], type: @type, client: @client)
+      else
+        fail Exceptions::InvalidInput
+      end
+    end
+
+    def <<(other)
+      if other.class == @type
+        @list << other
+      else
+        fail Exceptions::InvalidInput
+      end
+    end
+
+    def <=>(other)
+      collect(&:id).sort <=> other.collect(&:id).sort
+    end
+
+    # Allow comparison of collection
+    # @return [Boolean] do the collections contain the same resource ids?
+    def ==(other)
+      if other.is_a? self.class
+        collect(&:id).sort == other.collect(&:id).sort
+      else
+        false
+      end
+    end
+  end
+end

data/lib/antaeus-sdk/resources/appointment.rb

@@ -0,0 +1,166 @@
+module Antaeus
+  module Resources
+    class Appointment < Resource
+      property :arrival,    type: :time
+      property :comment
+      property :contact
+      property :departure,  type: :time
+      property :location_id
+      property :guest_id
+      property :created_at, read_only: true, type: :time
+      property :created_by, read_only: true
+      property :arrived?,   read_only: true
+      property :approved?,  read_only: true
+      property :departed?,  read_only: true
+      property :checkin_time, read_only: true, type: :time
+      property :checkout_time, read_only: true, type: :time
+
+      path :all, '/appointments'
+
+      # A collection of all upcoming appointments
+      def self.upcoming(options = {})
+        validate_options(options)
+        ResourceCollection.new(
+          options[:client].get("#{path_for(:all)}/upcoming")['appointments'].collect do |record|
+            self.new(
+              entity: record,
+              lazy: true,
+              tainted: false,
+              client: options[:client]
+            )
+          end,
+          type: self,
+          client: options[:client]
+        )
+      end
+
+      # Generate a report of appointments based on some criteria
+      def self.report(options = {})
+        validate_options(options)
+        ResourceCollection.new(
+          options[:client].post("/reports/generate", q: options[:criteria])['appointments'].collect do |record|
+            self.new(
+              entity: record,
+              lazy: false,
+              tainted: false,
+              client: options[:client]
+            )
+          end,
+          type: self,
+          client: options[:client]
+        )
+      end
+
+      # Approve an Appointment
+      def approve
+        if @client.patch("#{path_for(:all)}/#{id}/approve", approve: true)
+          true
+        else
+          fail Exceptions::ApprovalChangeFailed
+        end
+        reload
+        return true
+      end
+
+      # Checkin a Guest
+      def checkin
+        if @client.patch("#{path_for(:all)}/#{id}/checkin", email: guest.email)
+          true
+        else
+          raise Exceptions::CheckinChangeFailed
+        end
+        reload
+        return true
+      end
+
+      # Checkout a Guest
+      def checkout
+        if @client.patch("#{path_for(:all)}/#{id}/checkout", email: guest.email)
+          true
+        else
+          raise Exceptions::CheckoutChangeFailed
+        end
+        reload
+        return true
+      end
+
+      # Hidden property used to lookup related resource
+      def guest
+        Guest.get(@entity['guest_id'], client: @client)
+      end
+
+      # Set the guest associated with this appointment
+      def guest=(guest_or_guest_id)
+        @entity['guest_id'] = if guest_or_guest_id.is_a?(Guest)
+          guest_or_guest_id.id
+        else
+          guest_or_guest_id
+        end
+        @tainted = true
+      end
+
+      # Hidden property used to lookup related resource
+      def location
+        Location.get(@entity['location_id'], client: @client)
+      end
+
+      # Set the location associated with this appointment
+      def location=(location_or_location_id)
+        @entity['location_id'] = if location_or_location_id.is_a?(Location)
+          location_or_location_id.id
+        else
+          location_or_location_id
+        end
+        @tainted = true
+      end
+
+      # Unapprove an Appointment
+      def unapprove
+        if @client.patch("#{path_for(:all)}/#{id}/approve", approve: false)
+          true
+        else
+          fail Exceptions::ApprovalChangeFailed
+        end
+        reload
+        return true
+      end
+
+      # Checkin a Guest
+      def undo_checkin
+        if @client.delete("#{path_for(:all)}/#{id}/checkin")
+          true
+        else
+          raise Exceptions::CheckinChangeFailed
+        end
+        reload
+        return true
+      end
+
+      # Checkout a Guest
+      def undo_checkout
+        if @client.delete("#{path_for(:all)}/#{id}/checkout")
+          true
+        else
+          raise Exceptions::CheckoutChangeFailed
+        end
+        reload
+        return true
+      end
+
+      # User related to an appointment
+      def user
+        User.get(contact, client: @client)
+      end
+
+      # Set the user related to an appointment
+      def user=(username)
+        contact = if username.is_a?(User)
+          username.id
+        else
+          username
+        end
+        @tainted = true
+      end
+    end
+  end
+end

data/lib/antaeus-sdk/resources/group.rb

@@ -0,0 +1,27 @@
+module Antaeus
+  module Resources
+    class Group < Resource
+      delayed_property { Antaeus.config.group_name_attribute || :cn }
+
+      path      :all, '/groups'
+      immutable true
+
+      def members
+        ResourceCollection.new(
+          @client.get("#{path_for(:all)}/#{id}/members")['users'].collect do |record|
+            User.new(
+              entity: record,
+              lazy: true,
+              tainted: false,
+              client: @client
+            )
+          end,
+          type: Antaeus::Resources::User,
+          client: @client
+        )
+      end
+
+      alias_method :users, :members
+    end
+  end
+end

data/lib/antaeus-sdk/resources/guest.rb

@@ -0,0 +1,41 @@
+module Antaeus
+  module Resources
+    class Guest < Resource
+      property :email
+      property :full_name
+      property :phone
+      property :citizenship
+      property :need_nda
+      property :signed_nda
+      property :need_tcpa
+      property :signed_tcpa
+      property :pin
+      property :created_at, read_only: true, type: :time
+
+      path :all, '/guests'
+
+      def appointments
+        ResourceCollection.new(
+          @client.get("#{path_for(:all)}/#{id}/appointments")['appointments'].collect do |record|
+            Appointment.new(
+              entity: record,
+              lazy: true,
+              tainted: false,
+              client: @client
+            )
+          end,
+          type: Antaeus::Resources::Appointment,
+          client: @client
+        )
+      end
+
+      def available_appointments(location)
+        upcoming_appointments.where(location: location)
+      end
+
+      def upcoming_appointments
+        Appointment.upcoming(client: client).where(:guest_id, id)
+      end
+    end
+  end
+end

data/lib/antaeus-sdk/resources/hook.rb

@@ -0,0 +1,17 @@
+module Antaeus
+  module Resources
+    class Hook < Resource
+      property :name
+      property :plugins
+      property :configurations
+      property :created_at, read_only: true, type: :time
+
+      path :all, '/hooks'
+
+      def self.all_available(options = {})
+        validate_options(options)
+        options[:client].get("#{path_for(:all)}/available")['available_hooks']
+      end
+    end
+  end
+end