sfdc 0.0.1 → 1.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MWE4YzU3MmM5ZTliOWY4YjI0OTY0ZWFlZmFhMjA2YWUzMTllNTViZQ==
+    MGU4YWYxYWM2Nzg5MmVlNWJlZGZmYTJkNDA1NWVjNDBhNGM1ODdjOQ==
   data.tar.gz: !binary |-
-    MTNkMmNlNjM0Y2YzMmVkMDcyOGFlOTQ4N2NiOWYyYWIyMmI3YzRlZA==
+    ZWY5NTg2NmZlMWVjNTNkMGFiNTMwNTg3ZjM3ZTkyZjUxYmNjNGI1Yw==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZGFhNDM4N2Y3MzRhNzRiNDgzYzYzNDMxNjJjMWU5NjA0YWViNmM3MmVjMTlk
-    ODZkNjcyMDJjNTQxNDU4ZTA4OWZhMjFmNDU1MTE4ZjM2YzM3ZWQ5M2E3Njg4
-    ZGI3ZjkxNjFhN2I0ZGRlMGJlZmI4NGI5YmI3NThjM2JiZjhhYWM=
+    NWFiYTBhMjhhYTU4YmY1ZDQ4MzIyYmY1NDEyZDM5ZmY3MThmOGZkZTlhYzNi
+    MGI1MjYxMGVkYTBmNGQzOWEyZTFlNzNmMTIyZjJkMDdkMWY1NjVhODMwM2Yz
+    YjIxNzM4MTE0NDExZjI5YmNmOTQyODBlMTYyMjA1NTE5N2I3YzA=
   data.tar.gz: !binary |-
-    NGNkNzA2ZTFlZGUzZDg3ZTI3ZWY4NzU5YWNjMjQxYzViNWU0MTIxODM1NGY0
-    YWVmZTA4OGRhMDNjZjg0MzNiNTc4OTljY2M1NzZlN2FlNjgyMDM0NDcyYWZh
-    ZWFlNDlkODA2ZTJkZGJkYTg0MTIxNmNjMDM5ZDA5ZThkMTgxMTI=
+    MGE3N2E4MDc5ODQyZGQ3NDg3ZDgwOGQxZjExNzUwMGQ3MDFhNzM5MDQ2MTUy
+    Y2RhZTUzYTkzNWJhZGJlNzQzNTg1ODhkYTRkZDQ3NGY1ZTVhZTgyYWQ2ZDll
+    MGNkMjIyMjZjMDk1OTFhMzNmMjk3NGNiMTZlY2E5MWZmMDdiNTY=

data/lib/sfdc.rb

@@ -1,5 +1,43 @@
 require "sfdc/version"
 
+require 'faraday'
+require 'faraday_middleware'
+require 'json'
+
+require 'sfdc/version'
+require 'sfdc/config'
+
 module Sfdc
-  # Your code goes here...
+  autoload :SignedRequest, 'sfdc/signed_request'
+  autoload :Collection,    'sfdc/collection'
+  autoload :Middleware,    'sfdc/middleware'
+  autoload :Attachment,    'sfdc/attachment'
+  autoload :UploadIO,      'sfdc/upload_io'
+  autoload :SObject,       'sfdc/sobject'
+  autoload :Client,        'sfdc/client'
+  autoload :Mash,          'sfdc/mash'
+
+  AuthenticationError = Class.new(StandardError)
+  UnauthorizedError   = Class.new(StandardError)
+
+  class << self
+    # Alias for Sfdc::Client.new
+    def new(options = {}, &block)
+      Sfdc::Client.new(options, &block)
+    end
+
+    # Helper for decoding signed requests.
+    def decode_signed_request(*args)
+      SignedRequest.decode(*args)
+    end
+  end
+
+  # Add .tap method in Ruby 1.8
+  module CoreExtensions
+    def tap
+      yield self
+      self
+    end
+  end
+  Object.send :include, Sfdc::CoreExtensions unless Object.respond_to? :tap
 end

data/lib/sfdc/attachment.rb

@@ -0,0 +1,23 @@
+module Sfdc
+  class Attachment < Sfdc::SObject
+
+    # Public: Returns the body of the attachment.
+    #
+    # Examples
+    #
+    #   attachment = client.query('select Id, Name, Body from Attachment').first
+    #   File.open(attachment.Name, 'wb') { |f| f.write(attachment.Body) }
+    def Body
+      ensure_id && ensure_body
+      @client.get(super).body
+    end
+
+  private
+
+    def ensure_body
+      return true if self.Body?
+      raise 'You need to query the Body for the record first.'
+    end
+
+  end
+end

data/lib/sfdc/chatter/comment.rb

@@ -0,0 +1,10 @@
+require 'sfdc/chatter/record'
+
+module Sfdc
+  module Chatter
+
+    # A comment posted on a FeedItem.
+    class Comment < Record
+    end
+  end
+end

data/lib/sfdc/chatter/conversation.rb

@@ -0,0 +1,100 @@
+require 'sfdc/chatter/record'
+
+module Sfdc
+  module Chatter
+    # A thread of private messages. When calling +Conversation.find+ or +Conversation.all+, you must pass +:user_id => <my_user_id>+ in the _parameters_
+    #
+    #    Conversation.all(@client, :user_id => "me")
+    #    Conversation.find(@client, "conversationId", :user_id => "f80ad89f9d98d89dfd89")
+    class Conversation < Record
+
+      # Creates a new Conversation and sets its +id+ and +url+ to values obtained from the server response.
+      def initialize(client, response)
+        super
+        @id ||= @raw_hash["conversationId"]
+        @url ||= @raw_hash["conversationUrl"]
+      end
+
+      # Find the Conversation identified by _cid_ and archive it. Returns the updated Conversation.
+      #
+      #    Conversation.archive(@client, "fakeid")
+      def self.archive(client, cid)
+        url = "/services/data/v#{client.version}/chatter/users/me/conversations/#{cid}"
+        response = client.http_patch(url, nil, :archived => "true")
+        Conversation.new(client, response.body)
+      end
+
+      # Find the Conversation identified by _cid_ and unarchive it. Returns the updated Conversation.
+      #
+      #    Conversation.unarchive(@client, "fakeid")
+      def self.unarchive(client, cid)
+        url = "/services/data/v#{client.version}/chatter/users/me/conversations/#{cid}"
+        response = client.http_patch(url, nil, :archived => "false")
+        Conversation.new(client, response.body)
+      end
+
+      # Find the Conversation identified by _cid_ and mark it as read. Returns the updated Conversation.
+      #
+      #    Conversation.mark_read(@client, "fakeid")
+      def self.mark_read(client, cid)
+        url = "/services/data/v#{client.version}/chatter/users/me/conversations/#{cid}"
+        response = client.http_patch(url, nil, :read => "true")
+        Conversation.new(client, response.body)
+      end
+
+      # Find the Conversation identified by _cid_ and mark it as unread. Returns the updated Conversation.
+      #
+      #    Conversation.mark_unread(@client, "fakeid")
+      def self.mark_unread(client, cid)
+        url = "/services/data/v#{client.version}/chatter/users/me/conversations/#{cid}"
+        response = client.http_patch(url, nil, :read => "false")
+        Conversation.new(client, response.body)
+      end
+
+      # Gets all messages for the Conversation specified by _cid_ and the User specified by _uid_. Returns a Collection of Message objects.
+      def self.messages(client, uid, cid)
+        conversation = self.find(client, cid, :user_id => uid)
+        collection = Sfdc::Collection.new(client, nil, conversation.raw_hash["messages"]["nextPageUrl"], conversation.raw_hash["messages"]["previousPageUrl"], conversation.raw_hash["messages"]["currentPageUrl"])
+        conversation.raw_hash["messages"]["messages"].each do |item|
+          collection << Message.new(client, item)
+        end
+        collection
+      end
+
+      # Archive this Conversation.
+      def archive
+        self.class.archive(self.client, self.id)
+      end
+
+      # Unarchive this Conversation.
+      def unarchive
+        self.class.unarchive(self.client, self.id)
+      end
+
+      # Mark this Conversation as read.
+      def mark_read
+        self.class.mark_read(self.client, self.id)
+      end
+
+      # Mark this Conversation as unread.
+      def mark_unread
+        self.class.mark_unread(self.client, self.id)
+      end
+
+      # Return a Collection of messages from this Conversation.
+      def messages
+        collection = Sfdc::Collection.new(client, nil, self.raw_hash["messages"]["nextPageUrl"], self.raw_hash["messages"]["previousPageUrl"], self.raw_hash["messages"]["currentPageUrl"])
+        self.raw_hash["messages"]["messages"].each do |item|
+          collection << Message.new(client, item)
+        end
+        collection
+      end
+
+      protected
+
+      def self.search_parameter_name
+        :Q
+      end
+    end
+  end
+end

data/lib/sfdc/chatter/feed.rb

@@ -0,0 +1,64 @@
+require 'json'
+
+module Sfdc
+  module Chatter
+    # Parent class of all feeds and inherits from Collection. This class is not intended to be instantiated. Methods should be called on subclasses, which are all are dynamically defined (except for FilterFeed). Defined feeds are *NewsFeed*, *UserProfileFeed*, *RecordFeed*, *ToFeed*, *PeopleFeed*, *GroupsFeed*, *FilesFeed*, *CompanyFeed*, and *FilterFeed*.
+    class Feed < Collection
+
+      # Returns an enumerable Feed of FeedItem objects that make up the feed with the specified _id_. Should not be called as a class method on Feed, but as a method on subclasses.
+      #
+      #    NewsFeed.find(@client)                   #=>   [#<FeedItem ...>, #<FeedItem ...>, ...]
+      #    PeopleFeed.find(@client, "userid")       #=>   [#<FeedItem ...>, #<FeedItem ...>, ...]
+      #    FilterFeed.find(@client, "me", "000")    #=>   [#<FeedItem ...>, #<FeedItem ...>, ...]
+      #
+      # _id_prefix_ is only applicable for FilterFeed.
+      def self.find(client, id="me", id_prefix=nil)
+        path_components = %w(services data)
+        path_components << "v#{client.version}"
+        path_components.concat(%w(chatter feeds))
+        path_components << feed_type
+        path_components << id unless feed_type == "company"
+        path_components << id_prefix
+        path_components << "feed-items"
+        path = "/" + path_components.compact.join('/')
+        result = client.http_get(path)
+        response = JSON.parse(result.body)
+        collection = self.new(client, nil, response["nextPageUrl"], response["previousPageUrl"], response["currentPageUrl"])
+        response["items"].each do |item|
+          collection << FeedItem.new(client, item)
+        end
+        collection
+      end
+
+      # Posts a FeedItem to a Feed specified by _user_id_. Should not be called as a class method on Feed, but as a method on subclasses.
+      #
+      #    UserProfileFeed.post(@client, "me", :text => "This is a status update about Salesforce.", :url => "http://www.salesforce.com")
+      #
+      # Returns the newly created FeedItem.
+      def self.post(client, user_id, parameters)
+        url = "/services/data/v#{client.version}/chatter/feeds/#{feed_type}/#{user_id}/feed-items"
+        response = client.http_post(url, nil, parameters)
+        Sfdc::Chatter::FeedItem.new(client, response.body)
+      end
+
+      # Posts a file to a Feed specified by _user_id_. Should not be called as a class method on Feed, but as a method on subclasses.
+      #
+      #    UserProfileFeed.post_file(@client, "me", File.open("MyFile"), "text/plain", "MyFile", :desc => "This is an uploaded text file.")
+      #
+      # Returns the newly created FeedItem.
+      def self.post_file(client, user_id, io, file_type, file_name, parameters={})
+        url = "/services/data/v#{client.version}/chatter/feeds/#{feed_type}/#{user_id}/feed-items"
+        response = client.http_multipart_post(url, {"feedItemFileUpload" => UploadIO.new(io, file_type, file_name), "fileName" => file_name}, parameters)
+        Sfdc::Chatter::FeedItem.new(client, response.body)
+      end
+
+      private
+
+      def self.feed_type
+        self.name.match(/.+::(.+)Feed$/)[1].resourcerize
+      end
+    end
+
+    FEED_TYPES = %w(News UserProfile Record To People Groups Files Company)
+  end
+end

data/lib/sfdc/chatter/feed_item.rb

@@ -0,0 +1,40 @@
+require 'Sfdc/chatter/record'
+
+module Sfdc
+  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 = Sfdc::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 = Sfdc::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/sfdc/chatter/feeds.rb

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

data/lib/sfdc/chatter/filter_feed.rb

@@ -0,0 +1,14 @@
+module Sfdc
+  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/sfdc/chatter/group.rb

@@ -0,0 +1,45 @@
+require 'Sfdc/chatter/record'
+require 'Sfdc/chatter/photo_methods'
+
+module Sfdc
+  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 = Sfdc::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/sfdc/chatter/group_membership.rb

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

data/lib/sfdc/chatter/like.rb

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

data/lib/sfdc/chatter/message.rb

@@ -0,0 +1,29 @@
+require 'Sfdc/chatter/record'
+
+module Sfdc
+  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/sfdc/chatter/photo_methods.rb

@@ -0,0 +1,55 @@
+module Sfdc
+  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