vworkapp_ruby 0.1.0 → 0.7.0

data/lib/vworkapp_ruby/{httparty_monkey_patch.rb → base/httparty_monkey_patch.rb}

@@ -3,10 +3,8 @@
 # Needed because the extra attributes on the below XML cause httparty to crash: 
 #   <jobs type="array" current_page="1" per_page="27" total_pages="1" total_entries="27">
 # 
-# We probably shouldn't have extra parameters here.
-# 
-#   && v.is_a?(Array)
-
+# We probably shouldn't have extra parameters here. Change was:
+#   && (v.is_a?(Array) || v.is_a?(Hash))
 module MultiXml
 
   def MultiXml.typecast_xml_value(value)

data/lib/vworkapp_ruby/base/resource.rb

@@ -0,0 +1,105 @@
+module VWorkApp
+  
+  class << self
+    @api_key = "YOU NEED TO SPECIFY YOUR API KEY!!"
+    def api_key=(key)
+      @api_key = key
+    end
+    def api_key
+      @api_key
+    end    
+  end
+
+  class Resource < Base
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+    include ActiveModel::Validations
+    include HTTParty
+
+    base_uri 'https://api.vworkapp.com/api/2.0'
+    # http_proxy 'localhost', 8888
+
+    headers({
+      "Content-Type" => "text/xml",
+      "User-Agent" => "Ruby.vWorkApp.API"
+    })
+
+    # ------------------
+    # Active Model
+    # ------------------
+    
+    def persisted?
+      false
+    end
+    
+    # ------------------
+    # Rest Methods
+    # ------------------
+    
+    def create
+      validate_and_raise
+      perform(:post, "/#{resource_name.pluralize}", {}, self.to_xml) do |res|
+        self.class.new(res[resource_name])
+      end
+    end
+
+    def update(options = {})
+      validate_and_raise
+      perform(:put, "/#{resource_name.pluralize}/#{id}.xml", options, self.to_xml)
+    end
+    
+    def delete(options = {})
+      perform(:delete, "/#{resource_name.pluralize}/#{id}.xml", options)
+    end
+    
+    def self.show(id, options = {})
+      perform(:get, "/#{resource_name.pluralize}/#{id}.xml", options) do |res|
+        self.new(res[resource_name])
+      end
+    end
+    
+    def self.find(options = {})
+      self.perform(:get, "/#{resource_name.pluralize}.xml", options) do |res|
+        res[resource_name.pluralize].map { |h| self.new(h) }
+      end
+    end
+        
+    # ------------------
+    # Misc Methods
+    # ------------------
+        
+    def self.resource_name
+      @resource_name ||= ActiveSupport::Inflector.demodulize(self).underscore
+    end
+    def resource_name
+      self.class.resource_name
+    end
+
+    def self.perform(action, url, query = {}, body = nil)
+      options = {}
+      options[:query] = { :api_key => VWorkApp.api_key }.merge(query)
+
+      options[:body] = body
+      
+      raw = self.send(action, url, options)
+
+      case raw.response
+      when Net::HTTPOK, Net::HTTPCreated
+        yield(raw) if block_given?
+      when Net::HTTPNotFound
+        nil
+      else
+        bad_response(raw)
+      end
+    end
+    def perform(action, url, query = {}, body = nil, &block)
+      self.class.perform(action, url, query, body, &block)
+    end
+
+    def self.bad_response(raw)
+      raise ResponseError.new(raw)
+    end
+    
+  end
+
+end

data/lib/vworkapp_ruby/base/response_error.rb

@@ -0,0 +1,26 @@
+module VWorkApp
+  
+  # Error raised on a bad response
+  class ResponseError < StandardError
+    attr_reader :response, :code, :errors
+    
+    def initialize(res)
+      @response = res.response
+      @code     = res.response.code
+      @errors   = extract_errors(res.parsed_response)
+    end
+    
+    def to_s
+      "#{code.to_s} - #{response.msg}:\n#{@errors && @errors.join("\n")}".strip
+    end
+    
+  private
+    
+    def extract_errors(body)
+      return if body.empty?
+      errors = Array.wrap(body["errors"]["error"])
+    end
+    
+  end
+  
+end

data/lib/vworkapp_ruby/contact.rb

@@ -0,0 +1,11 @@
+module VWorkApp
+  class Contact < Base
+    hattr_accessor :first_name, :last_name, :phone, :mobile, :email, :location
+    self.include_root_in_json = false
+  
+    def ==(other)
+      attributes_eql?(other, :first_name, :last_name, :phone, :mobile, :email, :location)
+    end
+  
+  end
+end

data/lib/vworkapp_ruby/custom_field.rb

@@ -0,0 +1,11 @@
+module VWorkApp
+  class CustomField < Base
+    hattr_accessor :name, :value
+    self.include_root_in_json = false
+      
+    def ==(other)
+      attributes_eql?(other, :name, :value)
+    end
+
+  end
+end

data/lib/vworkapp_ruby/customer.rb

@@ -1,106 +1,18 @@
 module VWorkApp
-
-  class Customer < Base  
-    attr_accessor :id, :third_party_id, :name, :site_contact, :billing_contact
+  class Customer < Resource  
+    hattr_accessor :id, :third_party_id, :name, {:delivery_contact => VWorkApp::Contact}, {:billing_contact => VWorkApp::Contact}
   
-    #---------------
-    # Object Methods
-    #---------------
-
-    def initialize(name, id = nil, third_party_id = nil, site_contact = nil, billing_contact = nil)
-      @name = name
-      @id = id
-      @third_party_id = third_party_id
-      @site_contact = site_contact
-      @billing_contact = billing_contact
-    end
-    
-    def self.from_hash(attributes)
-      customer = Customer.new(attributes["name"], attributes["id"], attributes["third_party_id"])
-      customer.site_contact = Contact.from_hash(attributes["delivery_contact"])
-      customer.billing_contact = Contact.from_hash(attributes["billing_contact"])
-      customer
-    end
-
-    def to_hash
-      cust_hash = { :customer => { :name  => self.name } }
-      cust_hash[:customer][:third_party_id] = self.third_party_id if third_party_id
-      cust_hash[:customer][:delivery_contact] = self.site_contact.to_hash if site_contact
-      cust_hash[:customer][:billing_contact] = self.billing_contact.to_hash if billing_contact
-      cust_hash
-    end
-
     def ==(other)
-      attributes_eql?(other, [:id, :name, :third_party_id, :site_contact, :billing_contact])
-    end
-    
-    #---------------
-    # REST Methods
-    #---------------
-
-    def create
-      perform(:post, "/customers.xml", {}, self.to_hash) do |res|
-        Customer.from_hash(res["customer"])
-      end
-    end
-
-    def update(use_third_party_id = false)
-      perform(:put, "/customers/#{id}.xml", { :use_third_party_id => use_third_party_id }, self.to_hash)
-    end
-
-    def delete(use_third_party_id = false)
-      perform(:delete, "/customers/#{id}.xml", { :use_third_party_id => use_third_party_id })
-    end
-
-    def self.show(id, use_third_party_id = false)
-      perform(:get, "/customers/#{id}.xml", :use_third_party_id => use_third_party_id) do |res|
-        Customer.from_hash(res["customer"])
-      end
-    end    
-
-    def self.find      
-      self.perform(:get, "/customers.xml") do |res|
-        res["customers"].map { |h| Customer.from_hash(h) }
-      end
+      attributes_eql?(other, :id, :name, :third_party_id, :delivery_contact, :billing_contact)
     end
-      
-  end
-
-  class Contact < Base
-    include AttributeEquality
-    attr_accessor :first_name, :last_name, :phone, :mobile, :email, :location
     
-    def initialize(first_name = nil, last_name = nil, phone = nil, mobile = nil, email = nil, location = nil)
-      @first_name = first_name 
-      @last_name = last_name
-      @phone = phone
-      @mobile = mobile
-      @email = email
-      @location = location
-    end
-
-    def self.from_hash(attributes)
-      contact = Contact.new(attributes["first_name"], attributes["last_name"], attributes["phone"], attributes["mobile"], attributes["email"])
-      contact.location = Location.from_hash(attributes["location"])
-      contact
+    # XXX Work around for API bug that doesn't accept a nil contact detail. 
+    def to_xml(options = {})
+      except = options[:except] || [] 
+      except << "delivery_contact" unless delivery_contact 
+      except << "billing_contact" unless billing_contact 
+      super(:except => except)
     end
 
-    def to_hash
-      contact_hash = { 
-        :first_name  => self.first_name,
-        :last_name  => self.last_name,
-        :phone  => self.phone,
-        :mobile  => self.mobile,
-        :email => self.email
-      }
-      contact_hash[:location] = self.location.to_hash if location
-      contact_hash
-    end
-    
-    def ==(other)
-      attributes_eql?(other, [:first_name, :last_name, :phone, :mobile, :email, :location])
-    end
-    
   end
-
 end

data/lib/vworkapp_ruby/job.rb

@@ -1,168 +1,51 @@
 require 'gcoder'
 
 module VWorkApp
+  class Job < Resource
+    hattr_accessor :id, :customer_name, :template_name, :planned_duration, {:steps => Array(VWorkApp::Step)}, :published_at,
+                   {:custom_fields => Array(VWorkApp::CustomField)}, :third_party_id, :worker_id, :planned_start_at, :customer_id
 
-  class Job < Base
-    attr_accessor :id, :customer_name, :template_name, :planned_duration, :steps, :custom_fields, :third_party_id
-    attr_accessor :assigned_to_id, :planned_start_at, :progress_state
+    hattr_reader :actual_start_at, :actual_duration, :progress_state, :state
 
-    #---------------
-    # Object Methods
-    #---------------
-
-    def initialize(customer_name, template_name, planned_duration, steps, custom_fields = nil, id = nil, third_party_id = nil, assigned_to_id = nil, planned_start_at = nil)
-      @id = id
-      @customer_name = customer_name
-      @template_name = template_name
-      @planned_duration = planned_duration 
-      @steps = steps
-      @custom_fields = custom_fields 
-      @third_party_id = third_party_id
-      @assigned_to_id = assigned_to_id
-      @planned_start_at = planned_start_at
-    end
-            
-    def to_hash
-      job_hash = {
-        :job => {
-          :customer_name => self.customer_name,
-          :template_name  => self.template_name,
-          :planned_duration => self.planned_duration,
-          :steps =>  self.steps.map { |s| s.to_hash },
-        }
-      }
-      job_hash[:job][:third_party_id] = self.third_party_id if third_party_id
-      job_hash[:job][:custom_fields] = self.custom_fields.map { |s| s.to_hash } if custom_fields
-      job_hash
-    end
-
-    def self.from_hash(attributes)
-      job = Job.new(attributes["customer_name"], attributes["template_name"], attributes["planned_duration"], 
-                  attributes["steps"].map { |h| Step.from_hash(h) }, nil, attributes["id"], attributes["third_party_id"])      
-      job.custom_fields = attributes["custom_fields"].map { |h| CustomField.from_hash(h) } if attributes["custom_fields"]
-      
-      job.assigned_to_id = attributes["worker_id"]
-      job.planned_start_at = attributes["planned_start_at"]
-      job.progress_state = attributes["progress_state"]
-      
-      job
-    end
+    validates_presence_of :template_name, :planned_duration, :steps
+    validate :customer_validation
     
-    def is_new?
-      self.id == nil
-    end
-
-    def assigned_to
-      return nil if @assigned_to_id.nil?
-      @assigned_to ||= Worker.show(self.assigned_to_id)
-    end
-
-    def ==(other)
-      attributes_eql?(other, [
-        :id, :third_party_id, :customer_name, :template_name, :planned_duration, :planned_start_at, 
-        :assigned_to_id, :steps, :custom_fields
-      ])
-    end
-
-    #---------------
-    # REST Methods
-    #---------------
-
-    def create
-      perform(:post, "/jobs.xml", {}, self.to_hash) do |res|
-        Job.from_hash(res["job"])
-      end
-
-      # res = self.class.post("/jobs", :body => self.to_hash, :query => { :api_key => VWorkApp.api_key })
-      # if res.success?
-      #   self.id = res["job"]["id"]
-      #   self 
-      # else
-      #   self.class.bad_response(res)
-      # end
-    end
-
-    def update(id, attributes)
-      res = self.class.post("/jobs", :body => { :job => self.to_hash }, :query => { :api_key => VWorkApp.api_key })
-      res.success? ? res : bad_response(res)
-    end
-
-    def delete(use_third_party_id = false)
-      perform(:delete, "/jobs/#{id}.xml", { :use_third_party_id => use_third_party_id })
-    end
-
-    def self.show(id, use_third_party_id = false)
-      perform(:get, "/jobs/#{id}.xml", :use_third_party_id => use_third_party_id) do |res|
-        Job.from_hash(res["job"])
-      end
-      # raw = get("/jobs/#{id}.xml", :query => { :api_key => VWorkApp.api_key, :use_third_party_id => use_third_party_id })
-      # case res
-      # when Net::HTTPOK
-      #   Job.from_hash(raw["job"])
-      # when Net::HTTPNotFound
-      #    nil
-      # else
-      #   bad_response(res)
-      # end
-    end
-
-    def self.find(options={})
-      third_party_id = options.delete(:third_party_id)
-      options[:search] = "@third_party_id=#{third_party_id.to_s}" if (third_party_id)
-      options[:api_key] = VWorkApp.api_key
-      
-      raw = get("/jobs.xml", :query => options)
-      raw["jobs"].map { |h| Job.from_hash(h) }
+    def customer_validation
+      return true if @customer_id || @customer_name
+      error_str = "- Either customer_name OR customer_id must be present"
+      self.errors.add :customer_name, error_str
+      self.errors.add :customer_id, error_str
     end
-            
-  end
-
-  class Step
-    include AttributeEquality
-    attr_accessor :name, :location
     
-    def initialize(name, location = nil)
-      @name = name
-      @location = location
+    def customer
+      return nil if @customer_id.nil?
+      @customer ||= Customer.show(@customer_id)
     end
 
-    def to_hash
-      h = { :name => name }
-      h.merge!({ :location => location.to_hash }) if location  
-      h
-    end
-    
-    def self.from_hash(attributes)
-      Step.new(attributes["name"], Location.from_hash(attributes["location"]))
+    def worker
+      return nil if @worker_id.nil?
+      @worker ||= Worker.show(@worker_id)
     end
 
-    def ==(other)
-      attributes_eql?(other, [:name, :location])
+    # XXX Published at also needs to be set. 
+    def planned_start_at=(datetime)
+      self.published_at = datetime
+      @planned_start_at = datetime
     end
-    
-  end
-
-  class CustomField
-    include AttributeEquality
-    attr_accessor :name, :value
 
-    def initialize(name, value)
-      @name = name
-      @value = value
-    end
+    # XXX Work around for API bug that doesn't accept a nil contact detail. 
+    def to_xml(options = {})
+      except = options[:except] || []
+      except << "custom_fields" unless custom_fields
+      except << "customer_id" unless customer_id && customer_name.nil?
 
-    def to_hash
-      { :name => name.to_s, :value => value.to_s }
-    end
-    
-    def self.from_hash(attributes)
-      CustomField.new(attributes["name"], attributes["value"])
+      super(:except => except)
     end
     
     def ==(other)
-      attributes_eql?(other, [:name, :value])
+      attributes_eql?(other, :id, :third_party_id, :customer_name, :template_name, :planned_duration, :planned_start_at, 
+        :worker_id, :steps, :custom_fields)
     end
 
   end
-
 end