podio 0.8.0 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ddca0ab27daadb721f418559e369f9df19ff079b
+  data.tar.gz: 62879f0a0051374d7edf58585fb23fcdc1b8a65f
+SHA512:
+  metadata.gz: 745846890f8a4a11a0ae2591db7d2921ab9fa33cb696b7573aedb7de87c46ddbf4966f16d97132e7da7e13756dff437eb48ae2dff15b34a6e7eed5509fd3550b
+  data.tar.gz: b1bd3c5b7177185fa91b198f88b05ebd51820c30a4fca4fb00f7f0feab151b2afa3ab2aa013f9881b623ba17eb5db3632be90a302585eeb9263c42a6f0c0297c

data/.gitignore

@@ -2,3 +2,6 @@ pkg/*
 *.gem
 .bundle
 .DS_Store
+Gemfile.lock
+script/config.rb
+*.swp

data/Gemfile

@@ -1,5 +1,12 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
-gem 'rake'
+platforms :jruby do
+  gem 'jruby-openssl', '~> 0.7'
+end
+
+platforms :rbx do
+  gem 'rubysl', '~> 2.0.15'
+  gem 'rubysl-test-unit', '~> 2.0.3'
+end
 
 gemspec

data/README.md

@@ -113,7 +113,7 @@ All unsuccessful responses returned by the API (everything that has a 4xx or 5xx
       puts exc.url                # uri of the API request
 
       # you normally want this one, a human readable error description
-      puts exc.response_body['error_description']
+      puts exc.message
     end
 
 On instance methods, however, exceptions are handled in a way similar to ActiveRecord. These methods returns a boolean indicating if the API request succeeded or not, and makes the code, description and parameters available when the request fails:
@@ -146,9 +146,6 @@ Full Example
       puts org.url
     end
 
-Note on Heroku Usage
---------------------
-If you plan on using podio-rb on Heroku please note that only the 1.9.2 stack has been tested. Specifically, bamboo-mri-1.9.2 is recommended, while 1.8.7 is still stock on Heroku. Refer to their documentation for information on how to migrate your dynos 
 
 Meta
 ----

data/examples/oauth_web_flow/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'sinatra', '~> 1.4.4'
+gem 'podio'

data/examples/{sinatra.rb → oauth_web_flow/sinatra.rb}

@@ -18,11 +18,12 @@ require 'sinatra'
 require 'podio'
 
 
-# CHANGE this this to make this example work
-Podio.setup(
-  :api_key    => 'YOUR_API_KEY',
-  :api_secret => 'YOUR_API_SECRET'
-)
+before do
+  Podio.setup(
+    :api_key    => 'YOUR_API_KEY',       # CHANGE this this to make this example work
+    :api_secret => 'YOUR_API_SECRET'     # CHANGE this this to make this example work
+  )
+end
 
 get '/' do
   %(<p>Update the <code>Podio.setup</code> call in the sinatra app and <a href="/auth/podio">try to authorize</a>.</p>)
@@ -50,6 +51,6 @@ end
 
 def redirect_uri(path='/auth/podio/callback')
   uri = URI.parse(request.url)
-  uri.path  = path
+  uri.path = path
   uri.to_s
 end

data/lib/podio.rb

@@ -2,8 +2,8 @@ require 'faraday'
 require 'active_support/core_ext'
 
 require 'podio/error'
+require 'podio/version'
 require 'podio/middleware/json_request'
-#require 'podio/middleware/date_conversion'
 require 'podio/middleware/logger'
 require 'podio/middleware/oauth2'
 require 'podio/middleware/json_response'
@@ -76,36 +76,48 @@ module Podio
   autoload :ApplicationField,         'podio/models/application_field'
   autoload :AccountProvider,          'podio/models/account_provider'
   autoload :Batch,                    'podio/models/batch'
-  autoload :Bulletin,                 'podio/models/bulletin'
   autoload :ByLine,                   'podio/models/by_line'
   autoload :CalendarEvent,            'podio/models/calendar_event'
   autoload :CalendarMute,             'podio/models/calendar_mute'
   autoload :Category,                 'podio/models/category'
   autoload :Comment,                  'podio/models/comment'
+  autoload :Condition,                'podio/models/condition'
+  autoload :ConditionSet,             'podio/models/condition_set'
   autoload :Connection,               'podio/models/connection'
   autoload :Contact,                  'podio/models/contact'
   autoload :Contract,                 'podio/models/contract'
   autoload :ContractAccounting,       'podio/models/contract_accounting'
+  autoload :ContractEvent,            'podio/models/contract_event'
   autoload :ContractPrice,            'podio/models/contract_price'
+  autoload :ContractPriceV2,          'podio/models/contract_price_v2'
+  autoload :ContractUser,             'podio/models/contract_user'
   autoload :Conversation,             'podio/models/conversation'
+  autoload :ConversationEvent,        'podio/models/conversation_event'
   autoload :ConversationMessage,      'podio/models/conversation_message'
   autoload :ConversationParticipant,  'podio/models/conversation_participant'
+  autoload :DateElection,             'podio/models/date_election'
   autoload :EmailSubscriptionSetting, 'podio/models/email_subscription_setting'
+  autoload :EmailContact,             'podio/models/email_contact'
   autoload :Embed,                    'podio/models/embed'
+  autoload :Experiment,               'podio/models/experiment'
   autoload :ExternalFile,             'podio/models/external_file'
   autoload :FileAttachment,           'podio/models/file_attachment'
   autoload :Filter,                   'podio/models/filter'
   autoload :Form,                     'podio/models/form'
+  autoload :Friend,                   'podio/models/friend'
+  autoload :Grant,                    'podio/models/grant'
   autoload :Hook,                     'podio/models/hook'
   autoload :Importer,                 'podio/models/importer'
   autoload :Integration,              'podio/models/integration'
+  autoload :Invoice,                  'podio/models/invoice'
   autoload :Item,                     'podio/models/item'
   autoload :ItemDiff,                 'podio/models/item_diff'
   autoload :ItemField,                'podio/models/item_field'
   autoload :ItemRevision,             'podio/models/item_revision'
   autoload :LinkedAccount,            'podio/models/linked_account'
   autoload :LinkedAccountData,        'podio/models/linked_account_data'
-  autoload :News,                     'podio/models/news'
+  autoload :Live,                     'podio/models/live'
+  autoload :NetPromoterScore,         'podio/models/net_promoter_score'
   autoload :Notification,             'podio/models/notification'
   autoload :NotificationGroup,        'podio/models/notification_group'
   autoload :OAuth,                    'podio/models/o_auth'
@@ -114,7 +126,9 @@ module Podio
   autoload :OrganizationContact,      'podio/models/organization_contact'
   autoload :OrganizationMember,       'podio/models/organization_member'
   autoload :OrganizationProfile,      'podio/models/organization_profile'
+  autoload :Pin,                      'podio/models/pin'
   autoload :Profile,                  'podio/models/profile'
+  autoload :Promotion,                'podio/models/promotion'
   autoload :Question,                 'podio/models/question'
   autoload :QuestionAnswer,           'podio/models/question_answer'
   autoload :QuestionOption,           'podio/models/question_option'
@@ -131,6 +145,7 @@ module Podio
   autoload :Status,                   'podio/models/status'
   autoload :StreamMute,               'podio/models/stream_mute'
   autoload :StreamObject,             'podio/models/stream_object'
+  autoload :StreamActivityGroup,      'podio/models/stream_activity_group'
   autoload :Subscription,             'podio/models/subscription'
   autoload :Tag,                      'podio/models/tag'
   autoload :TagSearch,                'podio/models/tag_search'

data/lib/podio/active_podio/base.rb

@@ -6,12 +6,15 @@ module ActivePodio
     extend ActiveModel::Naming, ActiveModel::Callbacks
     include ActiveModel::Conversion
 
-    class_attribute :valid_attributes, :_associations, :_properties, :json_attributes
-    attr_accessor :attributes, :error_code, :error_message, :error_parameters, :error_propagate
-    alias_method :propagate_error?, :error_propagate
+    class_attribute :valid_attributes, :json_attributes, :_associations
+
+    self.valid_attributes = []
+    self.json_attributes = []
+    self._associations = {}
+
+    attr_accessor :attributes
 
     def initialize(attributes = {}, options = {})
-      self.valid_attributes ||= []
       attributes = {} if attributes.blank?
       self.attributes = Hash[*self.valid_attributes.collect { |n| [n.to_sym, nil] }.flatten].merge(attributes.symbolize_keys)
 
@@ -28,11 +31,20 @@ module ActivePodio
         if self.respond_to?("#{key}=".to_sym)
           self.send("#{key}=".to_sym, value)
         else
-          is_association_hash = value.is_a?(Hash) && self._associations.present? && self._associations.has_key?(key.to_sym) && self._associations[key.to_sym] == :has_one && (self.send(key.to_sym).respond_to?(:attributes) || self.send(key.to_sym).nil?)
+          is_association_hash = value.is_a?(Hash) && self._associations.has_key?(key.to_sym) && self._associations[key.to_sym] == :has_one && (self.send(key.to_sym).respond_to?(:attributes) || self.send(key.to_sym).nil?)
           if valid_attributes.include?(key.to_sym) || is_association_hash
+
             # Initialize nested object to get correctly casted values set back, unless the given values are all blank
             if is_association_hash
-              self.send(:[]=, key.to_sym, value) if self.send(key.to_sym).nil? # If not set by constructor, set here to get typed values back
+              # Merge existing values with given values and do recursive initalize call to get values casted correctly
+              if self.send(key.to_sym).present?
+                existing_attributes = self.send(key.to_sym).try(:attributes) || {}
+                value.reverse_merge!(existing_attributes)
+                self.send(key.to_sym).initialize_attributes(value)
+              else
+                self.send(:[]=, key.to_sym, value)
+              end
+
               attributes = self.send(key.to_sym).try(:attributes)
               if attributes.present? && any_values_present_recursive?(attributes.values)
                 value = attributes
@@ -68,7 +80,7 @@ module ActivePodio
     def []=(attribute, value)
       @attributes ||= {}
       @attributes[attribute.to_sym] = value
-      if @belongs_to.present? && value.present?
+      if @belongs_to.present? && @belongs_to[:model].present? && @belongs_to[:as].present? && value.present?
         @belongs_to[:model][@belongs_to[:as]] ||= {}
         @belongs_to[:model][@belongs_to[:as]][attribute.to_sym] = value
       end
@@ -89,18 +101,27 @@ module ActivePodio
       result.merge!(:id => self.id) if self.respond_to?(:id)
 
       if options[:formatted]
-        (self.valid_attributes + (self.json_attributes || [])).uniq.each do |name|
+        (self.valid_attributes + self.json_attributes).uniq.each do |name|
           result[name] = json_friendly_value(self.send(name), options)
         end
 
         unless options[:nested] == false
-          if self._associations.respond_to?(:each)
-            self._associations.each do |name, type|
+          self._associations.each do |name, type|
+            nested_value = self.send(name)
+            unless nested_value.nil?
+              nested_options = options.except(:methods)
+              if options[:methods].present? && options[:methods].respond_to?(:find)
+                methods_hash = options[:methods].find { |method| method.is_a?(Hash) }
+                if methods_hash.present?
+                  nested_methods = methods_hash[name]
+                  nested_options.merge!(:methods => nested_methods) if nested_methods.present?
+                end
+              end
               case type
               when :has_one
-                result[name] = self.send(name).as_json(options.except(:methods))
+                result[name] = nested_value.as_json(nested_options)
               when :has_many
-                result[name] = self.send(name).collect { |assoc| assoc.as_json(options.except(:methods)) }
+                result[name] = nested_value.collect { |assoc| assoc.as_json(nested_options) }
               end
             end
           end
@@ -111,7 +132,7 @@ module ActivePodio
 
       if options[:methods]
         options[:methods].each do |name|
-          result[name] = json_friendly_value(self.send(name), options)
+          result[name] = json_friendly_value(self.send(name), options.except(:methods) ) unless name.is_a?(Hash)
         end
       end
 
@@ -120,17 +141,26 @@ module ActivePodio
 
     # Override this in models where the class name doesn't match the ref type
     def api_friendly_ref_type
-      self.class.name.downcase
+      self.class.name.demodulize.parameterize
+    end
+
+    def parent_model
+      @belongs_to[:model] if @belongs_to.present?
     end
 
     private
 
       def klass_for_association(options)
         klass_name = options[:class]
+
+        if !klass_name.present? && options[:class_map].present?
+          class_property = options[:class_property] || :type
+          class_property_value = self.send(class_property).try(:to_sym)
+          klass_name = options[:class_map][class_property_value]
+        end
+
         raise "Missing class name of associated model. Provide with :class => 'MyClass'." unless klass_name.present?
-        klass = klass_name.constantize rescue nil
-        klass = "Podio::#{klass_name}".constantize unless klass.respond_to?(:ancestors) && klass.ancestors.include?(ActivePodio::Base)
-        return klass
+        return self.class.klass_from_string(klass_name)
       end
 
       def any_values_present_recursive?(values)
@@ -145,7 +175,7 @@ module ActivePodio
 
       def json_friendly_value(ruby_value, options)
         if options[:formatted]
-          json_value = case ruby_value.class.name
+          case ruby_value.class.name
           when "DateTime", "Time"
             ruby_value.iso8601
           when "Array"
@@ -153,9 +183,11 @@ module ActivePodio
           when "Hash"
             ruby_value.each { |key, value| ruby_value[key] = json_friendly_value(value, options) }
             ruby_value
+          when "BigDecimal"
+            ruby_value.to_f # No Decimal in Javascript, Float is better than String
           else
             if ruby_value.kind_of?(ActivePodio::Base)
-              ruby_value.as_json(options)
+              ruby_value.as_json(options.except(:methods))
             else
               ruby_value
             end
@@ -163,6 +195,7 @@ module ActivePodio
         else
           ruby_value
         end
+
       end
 
     class << self
@@ -171,8 +204,7 @@ module ActivePodio
 
       # Defines the the supported attributes of the model
       def property(name, type = :string, options = {})
-        self.valid_attributes ||= []
-        self.valid_attributes << name
+        self.valid_attributes += [name]
 
         case type
         when :datetime
@@ -188,6 +220,10 @@ module ActivePodio
           define_boolean_accessors(name)
         when :array
           define_array_accessors(name)
+        when :float
+          define_float_accessor(name)
+        when :decimal
+          define_decimal_accessor(name)
         else
           define_generic_accessor(name)
         end
@@ -195,8 +231,7 @@ module ActivePodio
 
       # Wraps a single hash provided from the API in the given model
       def has_one(name, options = {})
-        self._associations ||= {}
-        self._associations[name] = :has_one
+        self._associations = self._associations.merge({name => :has_one})
 
         self.send(:define_method, name) do
           klass = klass_for_association(options)
@@ -220,8 +255,7 @@ module ActivePodio
 
       # Wraps a collection of hashes from the API to a collection of the given model
       def has_many(name, options = {})
-        self._associations ||= {}
-        self._associations[name] = :has_many
+        self._associations = self._associations.merge({name => :has_many})
 
         self.send(:define_method, name) do
           klass = klass_for_association(options)
@@ -229,7 +263,7 @@ module ActivePodio
           unless instances.present?
             property = options[:property] || name.to_sym
             if self[property].present? && self[property].respond_to?(:map)
-              instances = self[property].map { |attributes| klass.new(attributes) }
+              instances = self[property].map { |attributes| klass.new(attributes, :belongs_to => { :model => self }) }
               self.instance_variable_set("@#{name}_has_many_instances", instances)
             else
               instances = []
@@ -284,45 +318,16 @@ module ActivePodio
         end
       end
 
-      # Wraps the given methods in a begin/rescue block
-      # If no error occurs, the return value of the method, or true if nil is returned, is returned
-      # If a Podio::PodioError occurs, the method returns false and the error can be read from the error_message accessor
-      # If another error occurs, it is still raised
-      def handle_api_errors_for(*method_names)
-        method_names.each do |method_name|
-          self.send(:define_method, "#{method_name}_with_api_errors_handled") do |*args|
-            success, code, message, parameters, result = nil
-            begin
-              result = self.send("#{method_name}_without_api_errors_handled", *args)
-              success = true
-            rescue Podio::PodioError => ex
-              success = false
-              code        = ex.response_body["error"]
-              message     = ex.response_body["error_description"]
-              parameters  = ex.response_body["error_parameters"]
-              propagate  = ex.response_body["error_propagate"]
-            end
-
-            if success
-              return result || true
-            else
-              @error_code       = code
-              @error_message    = message
-              @error_parameters = parameters || {}
-              @error_propagate  = propagate
-              return false
-            end
-          end
-
-          alias_method_chain method_name, :api_errors_handled
-        end
-      end
-
       def output_attribute_as_json(*attributes)
-        self.json_attributes ||= []
         self.json_attributes += attributes
       end
 
+      def klass_from_string(klass_name)
+        klass = klass_name.constantize rescue nil
+        klass = "Podio::#{klass_name}".constantize unless klass.respond_to?(:ancestors) && klass.ancestors.include?(ActivePodio::Base)
+        return klass
+      end
+
       private
 
         def define_generic_accessor(name, options = {})
@@ -354,7 +359,11 @@ module ActivePodio
               value = if value.is_a?(DateTime)
                 Time.zone.local_to_utc(value)
               else
-                Time.zone.parse(value).try(:utc).try(:to_datetime)
+                begin
+                  Time.zone.parse(value).try(:utc).try(:to_datetime)
+                rescue TZInfo::AmbiguousTime
+                  nil
+                end
               end
             end
 
@@ -419,6 +428,42 @@ module ActivePodio
           end
         end
 
+        def define_float_accessor(name)
+          self.send(:define_method, name) do
+            if self[name.to_sym].present?
+              self[name.to_sym].to_f
+            else
+              nil
+            end
+          end
+
+          self.send(:define_method, "#{name}=") do |value|
+            if value.present?
+              self[name.to_sym] = value.to_f
+            else
+              self[name.to_sym] = nil
+            end
+          end
+        end
+
+        def define_decimal_accessor(name)
+          self.send(:define_method, name) do
+            if self[name.to_sym].present?
+              BigDecimal(self[name.to_sym], 2)
+            else
+              nil
+            end
+          end
+
+          self.send(:define_method, "#{name}=") do |value|
+            if value.present?
+              self[name.to_sym] = BigDecimal(value, 2)
+            else
+              self[name.to_sym] = nil
+            end
+          end
+        end
+
         def define_boolean_accessors(name)
           self.send(:define_method, "#{name}?") do
             if self[name.to_sym].present?