podio 0.4.1 → 0.5.0

data/lib/podio/models/by_line.rb

@@ -0,0 +1,11 @@
+# Wraps common byline hashes. See https://hoist.podio.com/api/item/56084
+class Podio::ByLine < ActivePodio::Base
+  property :type, :string
+  property :id, :integer
+  property :avatar_type, :string
+  property :avatar_id, :integer
+  property :image, :hash
+  property :name, :string
+  property :url, :string
+  property :avatar, :integer # Sometimes used by older operations
+end

data/lib/podio/models/category.rb

@@ -0,0 +1,49 @@
+class Podio::Category < ActivePodio::Base
+  property :category_id, :integer
+  property :type, :string
+  property :name, :string
+
+  alias_method :id, :category_id
+  
+  class << self
+    def create(attributes)
+      response = Podio.connection.post do |req|
+        req.url "/app_store/category/"
+        req.body = attributes
+      end
+    
+      response.status
+    end
+    
+    def update(id, attributes)
+      response = Podio.connection.put do |req|
+        req.url "/app_store/category/#{id}"
+        req.body = attributes
+      end
+    
+      response.status
+    end
+    
+    def delete(id)
+      Podio.connection.delete("/app_store/category/#{id}").status
+    end
+    
+    def find(id)
+      member Podio.connection.get("/app_store/category/#{id}").body
+    end
+    
+    def find_all
+      collection Podio.connection.get("/app_store/category/").body
+    end
+
+    private
+
+      def collection(response)
+        return Struct.new(:functional, :vertical).new([], []) if response.blank?
+        functionals = response['functional'].map! { |cat| member(cat) }
+        verticals   = response['vertical'].map! { |cat| member(cat) }
+        Struct.new(:functional, :vertical).new(functionals, verticals)
+      end
+
+  end
+end

data/lib/podio/models/comment.rb

@@ -0,0 +1,63 @@
+class Podio::Comment < ActivePodio::Base
+  property :comment_id, :integer
+  property :value, :string
+  property :external_id, :integer
+  property :space_id, :integer
+  property :created_on, :datetime
+  property :files, :array # when outputting comments
+  property :file_ids, :array # when inputting comments
+  property :embed_id, :integer #optional, when inputting comments
+  property :embed_file_id, :integer #optional, when inputting comments
+
+  has_one :embed, :class => 'Embed'
+  has_one :embed_file, :class => 'FileAttachment'
+
+  has_one :created_by, :class => 'ByLine'
+  has_one :created_via, :class => 'Via'
+  has_many :files, :class => 'FileAttachment'
+
+  alias_method :id, :comment_id
+  attr_accessor :commentable_type, :commentable_id
+
+  def create
+    self.comment_id = Comment.create(commentable_type, commentable_id, attributes)
+  end
+  
+  class << self
+    def create(commentable_type, commentable_id, attributes)
+      response = Podio.connection.post do |req|
+        req.url "/comment/#{commentable_type}/#{commentable_id}"
+        req.body = attributes
+      end
+
+      response.body['comment_id']
+    end
+
+    def update(id, attributes)
+      response = Podio.connection.put do |req|
+        req.url "/comment/#{id}"
+        req.body = attributes
+      end
+
+      response.status
+    end
+
+    def delete(id)
+      Podio.connection.delete("/comment/#{id}").status
+    end
+
+    def find(id)
+      member Podio.connection.get("/comment/#{id}").body
+    end
+
+    def find_all_for(commentable_type, commentable_id)
+      list Podio.connection.get("/comment/#{commentable_type}/#{commentable_id}").body
+    end
+
+    def find_recent_for_share
+      #Internal
+      list Podio.connection.get("/comment/share/").body
+    end
+    
+  end
+end

data/lib/podio/{areas → models}/connection.rb

@@ -1,8 +1,23 @@
-module Podio
-  module Connection
-    include Podio::ResponseWrapper
-    extend self
+class Podio::Connection < ActivePodio::Base
+  property :connection_id, :integer
+  property :type, :string
+  property :name, :string
+  property :last_load_on, :datetime
+  property :created_on, :datetime
 
+  property :contact_count, :integer
+
+  alias_method :id, :connection_id
+
+  def reload
+    Connection.reload(id)
+  end
+
+  def destroy
+    Connection.delete(id)
+  end
+  
+  class << self
     def create(attributes)
       response = Podio.connection.post do |req|
         req.url '/connection/'
@@ -27,5 +42,6 @@ module Podio
     def all(options={})
       list Podio.connection.get('/connection/').body
     end
+    
   end
 end

data/lib/podio/models/contact.rb

@@ -0,0 +1,10 @@
+class Podio::Contact < Podio::Profile
+  property :is_selected, :bool
+  property :user_id, :integer
+  property :organization, :string
+  property :role, :string # Only available when getting contacts for a space
+  property :type, :string # user, space, connection - blank probably means it's a real user / Podio member
+  property :link, :string
+
+  alias_method :id, :user_id
+end

data/lib/podio/models/conversation.rb

@@ -0,0 +1,72 @@
+class Podio::Conversation < ActivePodio::Base
+  property :conversation_id, :integer
+  property :subject, :string
+
+  # When inputting conversation
+  property :text, :string
+  property :participants, :array
+  property :file_ids, :array
+  property :embed_id, :integer
+  property :embed_file_id, :integer
+  
+  # When outputting conversation(s)
+  property :created_on, :datetime
+  has_one :created_by, :class => 'ByLine'
+  has_many :files, :class => 'FileAttachment'
+  has_many :messages, :class => 'ConversationMessage'
+  has_many :participants_full, :class => 'ConversationParticipant'
+  
+  alias_method :id, :conversation_id
+  alias_method :name, :subject # So tasks can refer to ref.name on all types of references
+
+  def save
+    self[:file_ids] ||= []
+    response = Conversation.create(self.attributes)
+    self.conversation_id = response['conversation_id']
+  end
+  
+  handle_api_errors_for :save # Call must be made after the methods to handle have been defined
+  
+  class << self
+    def find(conversation_id)
+      member Podio.connection.get("/conversation/#{conversation_id}").body
+    end
+
+    def find_all_for_reference(ref_type, ref_id)
+      list Podio.connection.get("/conversation/#{ref_type}/#{ref_id}/").body
+    end
+
+    def create(attributes)
+      response = Podio.connection.post do |req|
+        req.url '/conversation/'
+        req.body = attributes
+      end
+      response.body
+    end
+
+    def create_for_reference(ref_type, ref_id, attributes)
+      response = Podio.connection.post do |req|
+        req.url "/conversation/#{ref_type}/#{ref_id}/"
+        req.body = attributes
+      end
+      response.body
+    end
+    
+    def create_reply(conversation_id, text, file_ids = [])
+      response = Podio.connection.post do |req|
+        req.url "/conversation/#{conversation_id}/reply"
+        req.body = { :text => text, :file_ids => file_ids }
+      end
+      response.body['message_id']
+    end
+    
+    def add_participant(conversation_id, user_id)
+      response = Podio.connection.post do |req|
+        req.url "/conversation/#{conversation_id}/participant/"
+        req.body = { :user_id => user_id }
+      end
+      response.body
+    end
+    
+  end
+end

data/lib/podio/models/conversation_message.rb

@@ -0,0 +1,12 @@
+class Podio::ConversationMessage < ActivePodio::Base
+  property :message_id, :integer
+  property :embed_id, :integer
+  property :embed_file_id, :integer
+  property :text, :string
+  property :created_on, :datetime
+
+  has_one :created_by, :class => 'ByLine'
+  has_many :files, :class => 'FileAttachment'
+  
+  alias_method :id, :message_id
+end

data/lib/podio/models/conversation_participant.rb

@@ -0,0 +1,9 @@
+class Podio::ConversationParticipant < ActivePodio::Base
+  property :created_on, :datetime
+  
+  has_one :user, :class => 'User'
+  has_one :created_by, :class => 'ByLine'
+  has_one :created_via, :class => 'Via'
+
+  delegate :id, :name, :avatar, :link, :to => :user, :prefix => false
+end

data/lib/podio/models/email_subscription_setting.rb

@@ -0,0 +1,39 @@
+class Podio::EmailSubscriptionSetting < ActivePodio::Base
+  include ActivePodio::Updatable
+
+  property :digest, :boolean
+  property :bulletin, :boolean
+  property :reference, :boolean
+  property :message, :boolean
+  property :space, :boolean
+  property :subscription, :boolean
+
+  def self.find_for_current_user
+    self.get_groups
+  end
+  
+  def update
+    self.class.update_groups(self.attributes)
+  end
+  
+  class << self
+    def get_groups()
+      member Podio.connection.get { |req|
+        req.url("/email/group/", {})
+      }.body
+    end
+
+    def update_groups(options)
+      Podio.connection.put { |req|
+        req.url "/email/group/"
+        req.body = options
+      }.body
+    end
+
+    def unsubscribe(username)
+      Podio.connection.post("/email/unsubscribe/#{username}").status
+    end
+    
+  end
+
+end

data/lib/podio/models/embed.rb

@@ -0,0 +1,34 @@
+class Podio::Embed < ActivePodio::Base
+
+  property :embed_id, :integer
+  property :original_url, :string
+  property :resolved_url, :string
+  property :type, :string
+  property :title, :string
+  property :description, :string
+  property :created_on, :datetime
+  property :provider_name, :string
+  property :embed_html, :string
+  property :embed_height, :boolean
+  property :embed_width, :integer
+
+  has_many :files, :class => 'FileAttachment'
+
+  alias_method :id, :embed_id
+
+  class << self
+
+    def create(url)
+      response = Podio.connection.post do |req|
+        req.url '/embed/'
+        req.body = {:url => url }
+      end
+      member response.body
+    end
+
+    def find(id)
+      member Podio.connection.get("/embed/#{id}").body
+    end
+
+  end
+end

data/lib/podio/models/file_attachment.rb

@@ -0,0 +1,127 @@
+class Podio::FileAttachment < ActivePodio::Base
+  property :file_id, :integer
+  property :link, :string
+  property :name, :string
+  property :description, :string
+  property :mimetype, :string
+  property :size, :integer
+  property :created_on, :datetime
+  
+  has_one :created_by, :class => 'ByLine'
+  has_one :created_via, :class => 'Via'
+  has_many :replaces, :class => 'FileAttachment'
+  
+  alias_method :id, :file_id
+
+  def image?
+    ['image/png', 'image/jpeg', 'image/gif', 'image/tiff', 'image/bmp'].include?(self.mimetype)
+  end
+  
+  class << self
+
+    # Accepts an open file stream along with a content type and a file name and uploads the file to Podio
+    # Returns an instantiated FileAttachment model with id, link, name and mimetype set
+    # If you use Ruby on Rails 3 or higher you can also pass the file in params directly to +upload_from_rails_param+
+    def upload(file_stream, content_type, file_name)
+      response = Podio.client.raw_connection.post do |req|
+        req.url "/file/v2/"
+        req.body = {:source => Faraday::UploadIO.new(file_stream, content_type, file_name), :filename => file_name}
+      end
+      file_attributes = ActiveSupport::JSON.decode(response.body) # Using raw_connection means response is not automatically decoded to json
+      file_attributes.merge!(:name => file_name, :mimetype => content_type)
+      member file_attributes
+    end
+    
+    # Accepts a ActionDispatch::Http::UploadedFile or similar and uploads the file to Podio
+    # Optionally attaches the file to the given ref type and ref id
+    # Returns an instantiated FileAttachment model with id, link, name and mimetype set
+    def upload_from_rails_param(uploaded_file, ref_type = nil, ref_id = nil)
+      p uploaded_file
+      file_attachment = self.upload(uploaded_file.tempfile, uploaded_file.content_type, uploaded_file.original_filename)
+      if ref_type.present? && ref_id.present?
+        self.attach(file_attachment.id, ref_type, ref_id)
+      end
+      file_attachment
+    end
+    
+    # Attach a file to an existing reference
+    def attach(id, ref_type, ref_id)
+      Podio.connection.post do |req|
+        req.url "/file/#{id}/attach"
+        req.body = { :ref_type => ref_type, :ref_id => ref_id }
+      end
+    end
+
+    def copy(id)
+      Podio.connection.post("/file/#{id}/copy").body['file_id']
+    end
+    
+    def delete(id)
+      Podio.connection.delete("/file/#{id}")
+    end
+    
+    def find(id)
+      member Podio.connection.get("/file/#{id}").body
+    end
+
+    def find_for_app(app_id, options={})
+      collection Podio.connection.get { |req|
+        req.url("/file/app/#{app_id}/", options)
+      }.body
+    end
+
+    def find_for_space(space_id, options={})
+      collection Podio.connection.get { |req|
+        req.url("/file/space/#{space_id}/", options)
+      }.body
+    end
+
+    def find_latest_for_app(app_id, options={})
+      collection Podio.connection.get { |req|
+        req.url("/file/app/#{app_id}/latest/", options)
+      }.body
+    end
+
+    def find_latest_for_space(space_id, options={})
+      collection Podio.connection.get { |req|
+        req.url("/file/space/#{space_id}/latest/", options)
+      }.body
+    end
+    
+    def replace(old_file_id, new_file_id)
+      Podio.connection.post { |req|
+        req.url "/file/#{new_file_id}/replace"
+        req.body = { :old_file_id => old_file_id }
+      }.body
+    end
+
+    def update(id, description)
+      Podio.connection.put { |req|
+        req.url "/file/#{file_id}"
+        req.body = { :description => description }
+      }.body
+    end
+    
+    
+    #
+    # Obsolete way of uploading files, use upload method instead
+    #
+    
+    # Uploading a file is a two-step operation
+    # First, the file must be created to get a file id and the path to move it to
+    def create(name, content_type)
+      response = Podio.connection.post do |req|
+        req.url "/file/"
+        req.body = { :name => name, :mimetype => content_type }
+      end
+
+      response.body
+    end
+    
+    # Then, when the file has been moved, it must be marked as available
+    def set_available(id)
+      Podio.connection.post "/file/#{id}/available"
+    end
+    
+  end
+end

data/lib/podio/models/form.rb

@@ -0,0 +1,25 @@
+class Podio::Form < ActivePodio::Base
+  property :form_id, :integer
+  property :app_id, :integer
+  property :settings, :hash
+  property :domains, :array
+  property :field_ids, :array
+  property :attachments, :boolean
+  
+  alias_method :id, :form_id
+  
+  class << self
+    def create(app_id, attributes)
+      response = Podio.connection.post do |req|
+        req.url "/form/app/#{app_id}/"
+        req.body = attributes
+      end
+
+      response.body['form_id']
+    end
+
+    def find(form_id)
+      member Podio.connection.get("/form/#{form_id}").body
+    end
+  end
+end

data/lib/podio/{areas → models}/hook.rb

@@ -1,8 +1,18 @@
-module Podio
-  module Hook
-    include Podio::ResponseWrapper
-    extend self
-    
+class Podio::Hook < ActivePodio::Base
+  property :hook_id, :integer
+  property :status, :string
+  property :type, :string
+  property :url, :string
+
+  alias_method :id, :hook_id
+
+  attr_accessor :hookable_type, :hookable_id
+
+  def create
+    self.hook_id = self.class.create(self.hookable_type, self.hookable_id, attributes)
+  end
+  
+  class << self
     def create(hookable_type, hookable_id, attributes)
       response = Podio.connection.post do |req|
         req.url "/hook/#{hookable_type}/#{hookable_id}/"

data/lib/podio/{areas → models}/importer.rb

@@ -1,8 +1,6 @@
-module Podio
-  module Importer
-    include Podio::ResponseWrapper
-    extend self
-
+class Podio::Importer < ActivePodio::Base
+  
+  class << self
     def process_file(file_id, app_id, mappings)
       response = Podio.connection.post do |req|
         req.url "/importer/#{file_id}/process"
@@ -20,4 +18,4 @@ module Podio
     end
     
   end
-end
+end

data/lib/podio/{areas → models}/integration.rb

@@ -1,8 +1,44 @@
-module Podio
-  module Integration
-    include Podio::ResponseWrapper
-    extend self
+class Podio::Integration < ActivePodio::Base
+  include ActivePodio::Updatable
 
+  property :integration_id, :integer
+  property :app_id, :integer
+  property :status, :string
+  property :type, :string
+  property :silent, :boolean
+  property :config, :hash
+  property :mapping, :hash
+  property :updating, :boolean
+  property :last_updated_on, :datetime
+  property :created_on, :datetime
+  
+  has_one :created_by, :class => 'ByLine'
+
+  alias_method :id, :integration_id
+
+  def create
+    self.integration_id = Integration.create(self.app_id, attributes)
+  end
+
+  def update
+    Integration.update(self.app_id, attributes)
+  end
+
+  def update_mapping
+    Integration.update_mapping(self.app_id, attributes)
+  end
+  
+  def destroy
+    Integration.delete(self.app_id)
+  end
+
+  def refresh
+    Integration.refresh(self.app_id)
+  end
+  
+  handle_api_errors_for :create, :update, :update_mapping
+  
+  class << self
     def create(app_id, attributes)
       response = Podio.connection.post do |req|
         req.url "/integration/#{app_id}"