glg-databasedotcom 1.3.2.1

data/lib/databasedotcom/chatter/feed_item.rb

@@ -0,0 +1,40 @@
+require 'databasedotcom/chatter/record'
+
+module Databasedotcom
+  module Chatter
+
+    # An item in a Feed.
+    class FeedItem < Record
+
+      # Returns a Collection of comments that were posted on this FeedItem instance.
+      def comments
+        collection = Databasedotcom::Collection.new(self.client, self.raw_hash["comments"]["total"], self.raw_hash["comments"]["nextPageUrl"], nil, self.raw_hash["comments"]["currentPageUrl"])
+        collection.concat(self.raw_hash["comments"]["comments"])
+      end
+
+      # Returns a Collection of likes for this FeedItem instance.
+      def likes
+        collection = Databasedotcom::Collection.new(self.client, self.raw_hash["likes"]["total"], self.raw_hash["likes"]["nextPageUrl"], self.raw_hash["likes"]["previousPageUrl"], self.raw_hash["likes"]["currentPageUrl"])
+        collection.concat(self.raw_hash["likes"]["likes"])
+      end
+
+      # Like this FeedItem.
+      def like
+        result = self.client.http_post("/services/data/v#{self.client.version}/chatter/feed-items/#{self.id}/likes")
+        Like.new(self.client, result.body)
+      end
+
+      # Post a Comment on this FeedItem with content _text_.
+      def comment(text)
+        result = self.client.http_post("/services/data/v#{self.client.version}/chatter/feed-items/#{self.id}/comments", nil, :text => text)
+        Comment.new(self.client, result.body)
+      end
+
+      protected
+
+      def self.collection_from_response(response)
+        response["items"]
+      end
+    end
+  end
+end

data/lib/databasedotcom/chatter/feeds.rb

@@ -0,0 +1,5 @@
+require 'databasedotcom/chatter/feed'
+
+Databasedotcom::Chatter::FEED_TYPES.each do |feed_type|
+  Databasedotcom::Chatter.const_set("#{feed_type}Feed", Class.new(Databasedotcom::Chatter::Feed))
+end

data/lib/databasedotcom/chatter/filter_feed.rb

@@ -0,0 +1,14 @@
+module Databasedotcom
+  module Chatter
+    # Filter feeds contain items pertaining to both a user and another specified resource.
+    class FilterFeed < Feed
+
+      # Lists all FilterFeeds for the user with id _user_id_.
+      def self.feeds(client, user_id="me")
+        url = "/services/data/v#{client.version}/chatter/feeds/filter/#{user_id}"
+        result = client.http_get(url)
+        JSON.parse(result.body)
+      end
+    end
+  end
+end

data/lib/databasedotcom/chatter/group.rb

@@ -0,0 +1,45 @@
+require 'databasedotcom/chatter/record'
+require 'databasedotcom/chatter/photo_methods'
+
+module Databasedotcom
+  module Chatter
+    # A group of Users
+    class Group < Record
+      include PhotoMethods
+
+      # Returns a Collection of GroupMembership instances for the Group identified by _group_id_.
+      def self.members(client, group_id)
+        url = "/services/data/v#{client.version}/chatter/groups/#{group_id}/members"
+        result = client.http_get(url)
+        response = JSON.parse(result.body)
+        collection = Databasedotcom::Collection.new(client, response["totalMemberCount"], response["nextPageUrl"], response["previousPageUrl"], response["currentPageUrl"])
+        response["members"].each do |member|
+          collection << GroupMembership.new(client, member)
+        end
+        collection
+      end
+
+      # Join the group identified by _group_id_ as the user identified by _user_id_.
+      def self.join(client, group_id, user_id="me")
+        url = "/services/data/v#{client.version}/chatter/groups/#{group_id}/members"
+        response = client.http_post(url, nil, :userId => user_id)
+        GroupMembership.new(client, response.body)
+      end
+
+      # Get a Collection of GroupMembership objects for this Group. Always makes a call to the server.
+      def members!
+        self.class.members(self.client, self.id)
+      end
+
+      # Get a Collection of GroupMembership objects for this Group. Returns cached data if it has been called before.
+      def members
+        @members ||= members!
+      end
+
+      # Join this Group as the user identified by _user_id_.
+      def join(user_id="me")
+        self.class.join(self.client, self.id, user_id)
+      end
+    end
+  end
+end

data/lib/databasedotcom/chatter/group_membership.rb

@@ -0,0 +1,9 @@
+require 'databasedotcom/chatter/record'
+
+module Databasedotcom
+  module Chatter
+    # A GroupMembership represents the membership of a certain User in a certain Group.
+    class GroupMembership < Record
+    end
+  end
+end

data/lib/databasedotcom/chatter/like.rb

@@ -0,0 +1,9 @@
+require 'databasedotcom/chatter/record'
+
+module Databasedotcom
+  module Chatter
+    # A like on a FeedItem
+    class Like < Record
+    end
+  end
+end

data/lib/databasedotcom/chatter/message.rb

@@ -0,0 +1,29 @@
+require 'databasedotcom/chatter/record'
+
+module Databasedotcom
+  module Chatter
+    # A private message between two or more Users
+    class Message < Record
+
+      # Send a private message with the content _text_ to each user in the _recipients_ list.
+      def self.send_message(client, recipients, text)
+        url = "/services/data/v#{client.version}/chatter/users/me/messages"
+        recipients = recipients.is_a?(Array) ? recipients : [recipients]
+        response = client.http_post(url, nil, :text => text, :recipients => recipients.join(','))
+        Message.new(client, response.body)
+      end
+
+      # Send a reply to the message identified by _in_reply_to_message_id_ with content _text_.
+      def self.reply(client, in_reply_to_message_id, text)
+        url = "/services/data/v#{client.version}/chatter/users/me/messages"
+        response = client.http_post(url, nil, :text => text, :inReplyTo => in_reply_to_message_id)
+        Message.new(client, response.body)
+      end
+
+      # Send a reply to this Message with content _text_.
+      def reply(text)
+        self.class.reply(self.client, self.id, text)
+      end
+    end
+  end
+end

data/lib/databasedotcom/chatter/photo_methods.rb

@@ -0,0 +1,55 @@
+module Databasedotcom
+  module Chatter
+    # Defines methods for entities that can have photos i.e. Users, Groups.
+    module PhotoMethods
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # Defines class methods for resources that can have photos.
+      module ClassMethods
+        # Returns a Hash with urls for the small and large versions of the photo for a resource.
+        def photo(client, resource_id)
+          url = "/services/data/v#{client.version}/chatter/#{self.resource_name}/#{resource_id}/photo"
+          result = client.http_get(url)
+          JSON.parse(result.body)
+        end
+
+        # Uploads a photo for a resource with id _resource_id_.
+        #
+        #    User.upload_photo(@client, "me", File.open("SomePicture.png"), "image/png")
+        def upload_photo(client, resource_id, io, file_type)
+          url = "/services/data/v#{client.version}/chatter/#{self.resource_name}/#{resource_id}/photo"
+          result = client.http_multipart_post(url, {"fileUpload" => UploadIO.new(io, file_type)})
+          JSON.parse(result.body)
+        end
+
+        # Deletes the photo for the resource with id _resource_id_.
+        def delete_photo(client, resource_id)
+          client.http_delete "/services/data/v#{client.version}/chatter/#{self.resource_name}/#{resource_id}/photo"
+        end
+      end
+
+      # Returns a Hash with urls for the small and large versions of the photo for this resource.
+      #
+      #  User.find(@client, "me").photo  #=>  {"smallPhotoUrl"=>"/small/photo/url", "largePhotoUrl"=>"/large/photo/url"}
+      def photo
+        self.raw_hash["photo"]
+      end
+
+      # Uploads a photo for this resource.
+      #
+      #    me = User.find(@client)
+      #    me.upload_photo(File.open("SomePicture.png"), "image/png")
+      def upload_photo(io, file_type)
+        self.class.upload_photo(self.client, self.id, io, file_type)
+      end
+
+      # Deletes the photo for this resource.
+      def delete_photo
+        self.class.delete_photo(self.client, self.id)
+        photo
+      end
+    end
+  end
+end

data/lib/databasedotcom/chatter/record.rb

@@ -0,0 +1,122 @@
+require 'json'
+
+module Databasedotcom
+  module Chatter
+    # Superclasses all Chatter resources except feeds. Some methods may not be supported by the Force.com API for certain subclasses.
+    class Record
+      attr_reader :raw_hash, :name, :id, :url, :type, :client
+
+      # Create a new record from the returned JSON response of an API request. Sets the client, name, id, url, and type attributes. Saves the raw response as +raw_hash+.
+      def initialize(client, response)
+        @client = client
+        @raw_hash = response.is_a?(Hash) ? response : JSON.parse(response)
+        @name = @raw_hash["name"]
+        @id = @raw_hash["id"]
+        @url = @raw_hash["url"]
+        @type = @raw_hash["type"]
+      end
+
+      # Find a single Record or a Collection of records by id. _resource_id_ can be a single id or a list of ids.
+      def self.find(client, resource_id, parameters={})
+        if resource_id.is_a?(Array)
+          resource_ids = resource_id.join(',')
+          url = "/services/data/v#{client.version}/chatter/#{self.resource_name}/batch/#{resource_ids}"
+          response = JSON.parse(client.http_get(url, parameters).body)
+          good_results = response["results"].select { |r| r["statusCode"] == 200 }
+          collection = Databasedotcom::Collection.new(client, good_results.length)
+          good_results.each do |result|
+            collection << self.new(client, result["result"])
+          end
+          collection
+        else
+          path_components = ["/services/data/v#{client.version}/chatter"]
+          if parameters.has_key?(:user_id)
+            path_components << "users/#{parameters[:user_id]}"
+            parameters.delete(:user_id)
+          end
+          path_components << "#{self.resource_name}/#{resource_id}"
+          url = path_components.join('/')
+          response = JSON.parse(client.http_get(url, parameters).body)
+          self.new(client, response)
+        end
+      end
+
+      # Return a Collection of records that match the _query_.
+      def self.search(client, query, parameters={})
+        self.all(client, parameters.merge(self.search_parameter_name => query))
+      end
+
+      # Return a Collection of all records.
+      def self.all(client, parameters={})
+        path_components = ["/services/data/v#{client.version}/chatter"]
+        if parameters.has_key?(:user_id)
+          path_components << "users/#{parameters[:user_id]}"
+          parameters.delete(:user_id)
+        end
+        path_components << self.resource_name
+        url = path_components.join('/')
+        result = client.http_get(url, parameters)
+        response = JSON.parse(result.body)
+        collection = Databasedotcom::Collection.new(client, self.total_size_of_collection(response), response["nextPageUrl"], response["previousPageUrl"], response["currentPageUrl"])
+        self.collection_from_response(response).each do |resource|
+          collection << self.new(client, resource)
+        end
+        collection
+      end
+
+      # Delete the Record identified by _resource_id_.
+      def self.delete(client, resource_id, parameters={})
+        path_components = ["/services/data/v#{client.version}/chatter"]
+        if parameters.has_key?(:user_id)
+          path_components << "users/#{parameters[:user_id]}"
+          parameters.delete(:user_id)
+        end
+        path_components << self.resource_name
+        path_components << resource_id
+        path = path_components.join('/')
+        client.http_delete(path, parameters)
+      end
+
+      # A Hash representation of the User that created this Record.
+      def user
+        self.raw_hash["user"]
+      end
+
+      # A Hash representation of the entity that is the parent of this Record.
+      def parent
+        self.raw_hash["parent"]
+      end
+
+      # Delete this record.
+      def delete(parameters={})
+        self.class.delete(self.client, self.id, parameters)
+      end
+
+      # Reload this record.
+      def reload
+        self.class.find(self.client, self.id)
+      end
+
+      # The REST resource name of this Record.
+      #
+      #    GroupMembership.resource_name  #=>  group-memberships
+      def self.resource_name
+        (self.name.split('::').last).resourcerize + "s"
+      end
+
+      protected
+
+      def self.total_size_of_collection(response)
+        response["total"] || response["totalMemberCount"]
+      end
+
+      def self.collection_from_response(response)
+        response[self.resource_name]
+      end
+
+      def self.search_parameter_name
+        :q
+      end
+    end
+  end
+end

data/lib/databasedotcom/chatter/subscription.rb

@@ -0,0 +1,9 @@
+require 'databasedotcom/chatter/record'
+
+module Databasedotcom
+  module Chatter
+    # A representation of a user "following" some other entity.
+    class Subscription < Record
+    end
+  end
+end

data/lib/databasedotcom/chatter/user.rb

@@ -0,0 +1,153 @@
+require 'databasedotcom/chatter/record'
+require 'databasedotcom/chatter/photo_methods'
+
+module Databasedotcom
+  module Chatter
+    # Defines a User in your org.
+    class User < Record
+      include PhotoMethods
+
+      # Returns a Collection of Subscription objects that represents all followers of the User identified by _subject_id_.
+      def self.followers(client, subject_id="me")
+        url = "/services/data/v#{client.version}/chatter/users/#{subject_id}/followers"
+        result = client.http_get(url)
+        response = JSON.parse(result.body)
+        collection = Databasedotcom::Collection.new(client, response["total"], response["nextPageUrl"], response["previousPageUrl"], response["currentPageUrl"])
+        response["followers"].each do |subscription|
+          collection << Subscription.new(client, subscription)
+        end
+        collection
+      end
+
+      # Returns a Collection of Subscription objects that represent all entities that the User identified by _subject_id_ is following.
+      def self.following(client, subject_id="me")
+        url = "/services/data/v#{client.version}/chatter/users/#{subject_id}/following"
+        result = client.http_get(url)
+        response = JSON.parse(result.body)
+        collection = Databasedotcom::Collection.new(client, response["total"], response["nextPageUrl"], response["previousPageUrl"], response["currentPageUrl"])
+        response["following"].each do |subscription|
+          collection << Subscription.new(client, subscription)
+        end
+        collection
+      end
+
+      # Returns a Collection of Group objects that represent all the groups that the User identified by _subject_id_ is a part of.
+      def self.groups(client, subject_id="me")
+        url = "/services/data/v#{client.version}/chatter/users/#{subject_id}/groups"
+        result = client.http_get(url)
+        response = JSON.parse(result.body)
+        collection = Databasedotcom::Collection.new(client, response["total"], response["nextPageUrl"], response["previousPageUrl"], response["currentPageUrl"])
+        response["groups"].each do |group|
+          collection << Group.new(client, group)
+        end
+        collection
+      end
+
+      # Returns the current status of the User identified by _subject_id_.
+      def self.status(client, subject_id="me")
+        url = "/services/data/v#{client.version}/chatter/users/#{subject_id}/status"
+        result = client.http_get(url)
+        JSON.parse(result.body)
+      end
+
+      # Posts a status update as the User identified by _subject_id_ with content _text_.
+      def self.post_status(client, subject_id, text)
+        url = "/services/data/v#{client.version}/chatter/users/#{subject_id}/status"
+        result = client.http_post(url, nil, :text => text)
+        JSON.parse(result.body)
+      end
+
+      # Deletes the status of User identified by _subject_id_.
+      def self.delete_status(client, subject_id="me")
+        client.http_delete "/services/data/v#{client.version}/chatter/users/#{subject_id}/status"
+      end
+
+      # Creates and returns a new Subscription object that represents the User identified by _subject_id_ following the resource identified by _resource_id_.
+      def self.follow(client, subject_id, resource_id)
+        response = client.http_post("/services/data/v#{client.version}/chatter/users/#{subject_id}/following", nil, :subjectId => resource_id)
+        Subscription.new(client, response.body)
+      end
+
+      # Returns a Collection of conversations that belong to the User identified by _subject_id_.
+      def self.conversations(client, subject_id)
+        Conversation.all(client, :user_id => subject_id)
+      end
+
+      # Returns a Collection of private messages that belong to the User identified by _subject_id_.
+      def self.messages(client, subject_id)
+        Message.all(client, :user_id => subject_id)
+      end
+
+      # Get a Collection of Subscription objects for this User. Always makes a call to the server.
+      def followers!
+        self.class.followers(self.client, self.id)
+      end
+
+      # Get a Collection of Subscription objects for this User. Returns cached data if it has been called before.
+      def followers
+        @followers ||= followers!
+      end
+
+      # Get a Collection of Subscription objects that represents all resources that this User is following. Always makes a call to the server.
+      def following!
+        self.class.following(self.client, self.id)
+      end
+
+      # Get a Collection of Subscription objects that represents all resources that this User is following. Returns cached data if it has been called before.
+      def following
+        @following ||= following!
+      end
+
+      # Returns this current status of this User.
+      def status
+        self.raw_hash["currentStatus"]
+      end
+
+      # Posts a new status with content _text_ for this User.
+      def post_status(text)
+        self.class.post_status(self.client, self.id, text)
+      end
+
+      # Deletes the current status of this User. Returns the deleted status.
+      def delete_status
+        self.class.delete_status(self.client, self.id)
+        status
+      end
+
+      # Get a Collection of Group objects that represents all groups that this User is in. Always makes a call to the server.
+      def groups!
+        self.class.groups(self.client, self.id)
+      end
+
+      # Get a Collection of Group objects that represents all groups that this User is in. Returns cached data if it has been called before.
+      def groups
+        @groups ||= groups!
+      end
+
+      # Creates a new Subscription that represents this User following the resource with id _record_id_.
+      def follow(record_id)
+        self.class.follow(self.client, self.id, record_id)
+      end
+
+      # Get a Collection of Conversation objects that represents the conversations for this User. Always makes a call to the server.
+      def conversations!
+        self.class.conversations(self.client, self.id)
+      end
+
+      # Get a Collection of Conversation objects that represents the conversations for this User. Returns cached data if it has been called before.
+      def conversations
+        @conversations ||= conversations!
+      end
+
+      # Get a Collection of Message objects that represents the messages for this User. Always makes a call to the server.
+      def messages!
+        self.class.messages(self.client, self.id)
+      end
+
+      # Get a Collection of Message objects that represents the messages for this User. Returns cached data if it has been called before.
+      def messages
+        @messages ||= messages!
+      end
+    end
+  end
+end