fn-salesforce 0.1.0.pre → 0.2.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56c8050e52f4dd1c6895fd3e89c12eeab60e8f19
-  data.tar.gz: 7ade6ae5a5a2fbaa5da19dd9d8de761b5e16e769
+  metadata.gz: 82f216e7b819a1f7b0a01c9d6c5e01ba488bae78
+  data.tar.gz: ab224735759865beefcb5a3ccd1d8fd5e59f6ecd
 SHA512:
-  metadata.gz: 94bde1299413a5afd4612cb0e632a54cc453a9fff90b0e2d493a71e1e4d19843cb495852a7694870f28839f421e83d8ced4196d4fba84d86fd56b6f1ef6a3ffe
-  data.tar.gz: c0a9885db5ac8165562a582854d252de327c23c7260cd11aa5c79f7597273335d928e383f0abe77177329ff4a7d5e99857ae3355a6783e8d4004ff23aded4505
+  metadata.gz: 8cf89d992698421808b9a31831e0d7cd949b8c201391bbdb6451c6645ec7413a8d9130f483743937d73a4ee2c17802e0b270ff66564b467051fdb0a80053d6b7
+  data.tar.gz: b51b76d9286030d2411c668d869f026b55dcf99299e71939b24c40c2b9039f9d25eb10dcd051ef77d9cedbe6b2433ca6d1386f844529ffd09e0dc795e0b4ef18

data/README.md

@@ -12,6 +12,10 @@ and external data. It supports nested JSON data, and can resolve
 basic dependency graphs while providing access to intermediary data
 formats.
 
+Install
+-------
+
+`$ gem install fn-salesforce --pre`
 
 Artifacts
 ---------
@@ -82,6 +86,34 @@ the value without talking to Salesforce first.
 
 The array of objects received are assumed to be in a reliable order.
 
+### Message types
+
+**create**
+
+```js
+{
+  "sObject": "my__ObjectName__c",
+  "properties": {
+    "Id": "12345"
+  }
+} 
+```
+
+**upsert**
+
+```js
+{
+  "sObject": "my__ObjectName__c",
+  "properties": {
+    "Foo": "Bar",
+    "External_Baz__c": "Catatafish"
+  },
+  "action": "upsert",
+  "externalID": "External_Baz__c"
+} 
+```
+
+
 ## describe
 
 Returns the object description from Salesforce.

data/lib/fn/salesforce.rb

@@ -2,7 +2,9 @@ require "json"
 require "fn/salesforce/version"
 require "fn/salesforce/environment"
 require "fn/salesforce/options"
-require "fn/salesforce/object"
+require "fn/salesforce/operation"
+require "fn/salesforce/rollback"
+require "fn/salesforce/transaction"
 require "fn/salesforce/object_factory"
 require "fn/salesforce/walker"
 require "restforce"
@@ -14,43 +16,20 @@ module Fn
     # Push
     # ----
     # Takes a prepared payload, and sends it to Salesforce.
-    def self.push(credentials, message)
+    def self.push(credentials, message, logger: Logger.new(STDOUT))
 
       client = Restforce.new(credentials)
-      message.
-        inject([]) { |plan,obj| 
-
-        begin
-          obj["properties"].merge! obj["properties"].
-            map { |k,v| 
-            if v.is_a?(Hash) && v["$ref"]
-              v = Hana::Pointer.new(v["$ref"]).eval(plan)
-            end
-            [k,v]
-          }.
-          map { |i| Hash[*i] }.inject(&:merge)
-
-          $stderr.puts "Creating #{obj["sObject"]}: #{ obj["properties"] }"
-          id = client.create!(obj["sObject"], obj["properties"])
-
-          obj["properties"]["Id"] = id
-          plan.push obj
-
-        rescue Exception => e
-          $stderr.puts e
-          if plan.any?
-            $stderr.puts "Rolling back previous objects"
-            plan.each { |obj| 
-              id = obj["properties"]["Id"]
-              object = obj["sObject"]
-              $stderr.puts "Deleting #{object}##{id}"
-              client.destroy(object, id) 
-            }
-          end
-          break
-        end
-
-      }
+      plan = Plan.new(message)
+
+      transaction = Transaction.new(client, plan, logger: logger)
+
+      transaction.execute
+
+      transaction.rollback! if transaction.failed
+
+      # Return true for success, false for failure.
+      !transaction.failed
+
     end
 
     # Prepare

data/lib/fn/salesforce/object_factory.rb

@@ -18,19 +18,44 @@ class Fn::Salesforce::ObjectFactory
   end
 
   def create(key, properties, parent=nil)
-    sobject = sobject_for(key) || key
-    properties.merge! Hash[foreign_key_for(key), {"$ref" => "/#{parent}/properties/Id"}] if parent
-
-    {
-      "sObject" => sobject,
-      "properties" => properties
-    }
+   
+    [
+      ->(obj) {
+        { "properties" => properties }
+      },
+      ->(obj) {
+        { "action" => "create" }
+      },
+      ->(obj) {
+        { "sObject" => sobject_for(key) || key }
+      },
+      ->(obj) {
+        return {} unless parent
+        {
+          "properties" => obj["properties"].merge(
+            Hash[ foreign_key_for(key), {"$ref" => "/#{parent}/Id"} ]
+          )
+        }
+      },
+      ->(obj) { 
+        return {} unless lookup_key = lookup_key_for(key)
+        {
+          "action" => "update",
+          "lookupWith" => Hash[lookup_key, obj["properties"][lookup_key]],
+          "properties" => obj["properties"].select { |k| k != lookup_key } 
+        }
+      }
+    ].reduce({}) { |memo,op| memo.merge op[memo] }
   end
 
   def sobject_for(key)
     JsonPath.on(schema,"..properties.#{key}.sObject").first
   end
 
+  def lookup_key_for(key)
+    JsonPath.on(schema,"..properties.#{key}.lookupKey").first
+  end
+
   def foreign_key_for(relationship_key)
     JsonPath.on(schema,"..properties.#{relationship_key}.foreignKey").first
   end

data/lib/fn/salesforce/operation.rb

@@ -0,0 +1,51 @@
+require 'delegate'
+
+module Fn
+  module Salesforce
+
+    class Operation < Hashie::Mash
+
+      def action
+        (super || :create ).to_sym
+      end
+
+      def s_object
+        sObject
+      end
+
+      def lookup_with
+        lookupWith
+      end
+
+      def previous_properties
+        previousProperties
+      end
+
+      def references
+        properties.select { |k,v| 
+          v.is_a? Hash
+        }.select { |k,v|
+          v.keys.any? { |key| key == "$ref" }
+        }
+      end
+
+      def replace_refs(data)
+        properties.merge! properties.
+            map { |k,v| 
+            if v.is_a?(Hash) && v["$ref"]
+              v = Hana::Pointer.new(v["$ref"]).eval(data)
+            end
+            [k,v]
+          }.
+          map { |i| Hash[*i] }.inject(&:merge)
+      end
+    end
+
+    class Plan < SimpleDelegator
+      def initialize(operations)
+        super(operations.map { |op| Operation.new(op) })
+      end
+    end
+
+  end
+end

data/lib/fn/salesforce/options.rb

@@ -10,16 +10,20 @@ class Fn::Salesforce::Options
   def credentials
     return @credentials if @credentials
 
-    credentials = JSON.parse(File.read(@attributes[:credentials]))
+    if @attributes[:credentials].is_a? String
+      attributes = JSON.parse(File.read(@attributes[:credentials]))
+    else 
+      attributes = @attributes[:credentials]
+    end
+
     @credentials = Hashie::Mash.new( {
-      username:       credentials["username"],
-      password:       credentials["password"],
-      security_token: credentials["token"],
-      client_id:      credentials["key"],
-      client_secret:  credentials["secret"],
-      host:           credentials["host"]
+      username:       attributes["username"],
+      password:       attributes["password"],
+      security_token: attributes["token"],
+      client_id:      attributes["key"],
+      client_secret:  attributes["secret"],
+      host:           attributes["host"]
     } ).to_hash(symbolize_keys: true)
-
   end
 
   def schema

data/lib/fn/salesforce/rollback.rb

@@ -0,0 +1,29 @@
+module Fn
+  module Salesforce
+    class Rollback < SimpleDelegator
+
+      def initialize(plan)
+        super(
+          plan.map { |operation|
+            operation.dup
+          }.map { |operation| UndoFactory.coerce(operation) }
+        )
+      end
+
+    end
+
+    class UndoFactory
+      def self.coerce(operation)
+        case operation.action
+        when :create
+          operation["action"] = "delete"  
+        when :update
+          operation["properties"] = operation.previous_properties
+        end
+
+        operation
+      end
+    end
+
+  end
+end

data/lib/fn/salesforce/transaction.rb

@@ -0,0 +1,89 @@
+module Fn
+  module Salesforce
+
+    class Transaction
+
+      attr_reader :client, :plan, :failed, :result
+      attr_accessor :logger
+
+      def initialize(client, plan, logger: Logger.new(STDOUT))
+        @logger = logger
+        @client = client
+        @plan = plan
+        @result = []
+        @failed = false
+      end
+
+      def execute
+        @result = plan.inject([]) { |results, operation|
+          begin
+            operation.replace_refs(results)
+            results << perform(operation)
+          rescue Exception => e
+            logger.error "Transaction failed at ##{plan.index(operation)}"
+            logger.error "Error message: #{e.message}"
+            @failed = true
+            break results
+          end
+          results
+        }
+      end
+
+
+      def rollback!
+        Rollback.new(result).each { |operation| perform(operation) }
+      end
+
+      private
+
+      def perform(operation)
+        case operation.action
+
+        when :create
+          logger.info "Creating #{operation.s_object}: #{ operation.properties.to_hash }"
+          id = client.create!( operation.s_object, operation.properties.dup )
+          operation.merge!( {"Id" => id} )
+        when :update
+          logger.info "Finding #{operation.s_object}: #{ operation.lookup_with.to_hash }"
+          object = client.find(
+            operation.s_object,
+            *operation.lookup_with.invert.to_a.flatten
+          ) 
+
+          logger.info "Found #{operation.s_object}(#{object.Id})"
+          # Keep the Id we get back from the find operation, we
+          # use this for updating the object, and for rolling back if needed.
+          operation.merge!( {"Id" => object.Id} )
+
+          # Slice off the fields we are about to change, and put them on
+          # 'previousProperties'.
+          operation.previousProperties = object.select { |key, value|
+            operation.properties.keys.include?(key)
+          }
+          logger.info "Updating #{operation.s_object}: #{ operation.properties.to_hash }"
+
+          client.update!(
+            operation.s_object,
+            Hash["Id", operation["Id"]].merge( operation.properties )
+          )
+
+        when :delete
+          logger.info "Deleting #{operation.s_object}(#{operation.Id})"
+          client.destroy!(operation.sObject, operation.Id)
+
+        when :upsert
+          logger.info "Upserting #{operation.s_object}(#{operation.externalID})"
+          client.upsert!(operation.sObject, operation.externalID, operation.properties)
+        else
+          logger.warn "Warning: No action found for #{operation.inspect}. Skipping."
+        end
+
+        operation
+      end
+
+    end
+
+  end
+
+
+end

data/lib/fn/salesforce/version.rb

@@ -1,5 +1,5 @@
 module Fn
   module Salesforce
-    VERSION = "0.1.0.pre"
+    VERSION = "0.2.0.pre"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fn-salesforce
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre
+  version: 0.2.0.pre
 platform: ruby
 authors:
 - Stuart Corbishley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-14 00:00:00.000000000 Z
+date: 2015-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -187,7 +187,10 @@ files:
 - lib/fn/salesforce/environment.rb
 - lib/fn/salesforce/object.rb
 - lib/fn/salesforce/object_factory.rb
+- lib/fn/salesforce/operation.rb
 - lib/fn/salesforce/options.rb
+- lib/fn/salesforce/rollback.rb
+- lib/fn/salesforce/transaction.rb
 - lib/fn/salesforce/version.rb
 - lib/fn/salesforce/walker.rb
 homepage: https://github.com/stuartc/fn-salesforce