exports.updateMember = function(memberId) {
var org = nforce.createConnection({
clientId: process.env.DATABASEDOTCOM_CLIENT_ID,
clientSecret: process.env.DATABASEDOTCOM_CLIENT_SECRET,
redirectUri: process.env.CONFIG_URL_BASE + '/oauth/_callback',
apiVersion: 'v24.0', // optional, defaults to v24.0
environment: process.env.DATABASEDOTCOM_ENVIRONMENT // optional, sandbox or production, production default
});
org.authenticate({ username: process.env.SFDC_USERNAME, password: process.env.SFDC_PASSWORD }, function(err, resp){
if(err) {
console.log('Error for '+memberId+': ' + err.message);
} else {
oauth = resp;
console.log('Updating memberId: '+memberId);
org.query('select id, name from member__c where id = \''+memberId+'\'', oauth, function(err, resp){
var member = resp.records[0];
member.Paperwork_Received__c = 'Paper Work Received';
member.Paperwork_Year__c = new Date().getFullYear();
org.update(member, oauth, function(err, resp){
if(!err) console.log('Member successfully updated');
});
});
}
});
}
function authenticate(callback) {
var org = nforce.createConnection({
clientId: salesforceConfig.clientId,
clientSecret: salesforceConfig.clientSecret,
redirectUri: salesforceConfig.redirectUri,
mode: 'single',
apiVersion: 'v37.0',
autoRefresh: true,
});
org.authenticate({
username: salesforceConfig.username,
password: salesforceConfig.password,
securityToken: salesforceConfig.securityToken,
}, function(err, resp) {
if (err) {
callback(err);
} else {
callback(err, org);
}
})
}
function Streaming(config) {
RED.nodes.createNode(this,config);
this.connection = RED.nodes.getNode(config.connection);
var node = this;
// create connection object
var org = nforce.createConnection({
clientId: this.connection.consumerKey,
clientSecret: this.connection.consumerSecret,
redirectUri: this.connection.callbackUrl,
environment: this.connection.environment,
mode: 'single'
});
org.authenticate({ username: this.connection.username, password: this.connection.password }, function(err, oauth) {
if(err) node.err(err);
var client = org.createStreamClient();
var stream = client.subscribe({ topic: config.pushTopic });
node.log("Subscribing to topic: " + config.pushTopic );
stream.on('error', function(err) {
node.log('Subscription error!!!');
node.log(err);
client.disconnect();
});
stream.on('data', function(data) {
node.send({
payload: data
});
});
});
}
var app = module.exports = express.createServer();
// attach socket.io and listen
var io = require('socket.io').listen(app);
// get a reference to the socket once a client connects
var socket = io.sockets.on('connection', function(socket) {
});
// Bayeux server - mounted at /cometd
var fayeServer = new faye.NodeAdapter({mount: '/cometd', timeout: 60});
fayeServer.attach(app);
var sfdc = nforce.createConnection({
clientId: config.CLIENT_ID,
clientSecret: config.CLIENT_SECRET,
redirectUri: config.CALLBACK_URL + '/oauth/_callback',
apiVersion: 'v24.0', // optional, defaults to v24.0
environment: config.ENVIRONMENT // optional, sandbox or production, production default
});
// Configuration
app.configure(function() {
app.set('views', __dirname + '/views');
app.set('view engine', 'jade');
app.use(express.bodyParser());
app.use(express.methodOverride());
app.use(app.router);
app.use(express.static(__dirname + '/public'));
});
app.configure('development', function() {
var nforce = require('nforce');
var _ = require('lodash');
var util = require('util');
var archiver = require('archiver');
require('../')(nforce);
var org = nforce.createConnection({
clientId: '3MVG9rFJvQRVOvk5nd6A4swCyck.4BFLnjFuASqNZmmxzpQSFWSTe6lWQxtF3L5soyVLfjV3yBKkjcePAsPzi',
clientSecret: '9154137956044345875',
redirectUri: 'http://localhost:3000/oauth/_callback',
mode: 'single',
username: process.env.SFUSER,
password: process.env.SFPASS,
plugins: ['meta'],
debug: true
});
org.authenticate().then(function(){
var archive = archiver('zip');
var promise = org.meta.deploy({ zipFile: archive });
archive.directory('examples/src', 'src').finalize();
return promise;
}).then(function(resp) {
console.log(resp);
}).error(function(err) {
console.error(err);
var express = require('express');
var nforce = require('nforce');
var app = module.exports = express();
var org = nforce.createConnection({
clientId: '3MVG9rFJvQRVOvk5nd6A4swCyck.4BFLnjFuASqNZmmxzpQSFWSTe6lWQxtF3L5soyVLfjV3yBKkjcePAsPzi',
clientSecret: '9154137956044345875',
redirectUri: 'http://localhost:3000/oauth/_callback'
});
// Configuration
app.configure(function(){
app.set('views', __dirname + '/views');
app.set('view engine', 'jade');
app.use(express.json());
app.use(express.urlencoded());
app.use(express.methodOverride());
app.use(express.cookieParser());
app.use(express.session({ secret: 'nforce testing baby' }));
app.use(org.expressOAuth({onSuccess: '/test/query', onError: '/oauth/error'}));
app.use(app.router);
app.use(express.static(__dirname + '/public'));
});
app.configure('development', function(){
app.use(express.errorHandler({ dumpExceptions: true, showStack: true }));
});
app.configure('production', function(){
app.use(express.errorHandler());
/***********************************************
/ End - Setup and inclusion of libs
***********************************************/
/***********************************************
/ Connection to SFDC via REST Setup - used to understand
what accounts have upcoming events or have recently
been viewed - helping to ensure only relevant information
is brought into S1 Intake
***********************************************/
// use the nforce package to create a connection to salesforce.com
var org = nforce.createConnection({
clientId: process.env.CLIENT_ID,
clientSecret: process.env.CLIENT_SECRET,
redirectUri: 'http://localhost:' + port + '/oauth/_callback',
apiVersion: 'v29.0'
});
// authenticate using username-password oauth flow
org.authenticate({ username: process.env.USERNAME, password: process.env.PASSWORD }, function(err, resp){
if(err) {
console.log('Error: ' + err.message);
} else {
console.log('Access Token: ' + resp.access_token);
oauth = resp;
}
});
/***********************************************
var db = require('./pghelper'),
config = require('./config'),
nforce = require('nforce'),
userName = config.api.userName,
password = config.api.password;
org = nforce.createConnection({
clientId: config.api.clientId,
clientSecret: config.api.clientSecret,
redirectUri: config.api.redirectUri,
apiVersion: config.api.apiVersion, // optional, defaults to current salesforce API version
environment: 'production', // optional, salesforce 'sandbox' or 'production', production default
mode: 'single' // optional, 'single' or 'multi' user mode, multi default
});
org.authenticate({ username: userName, password: password}, function(err, resp) {
if(!err) {
console.log('nforce connection succeeded');
} else {
console.log('nforce connection failed: ' + err.message);
}
});
function createClaims(req, res, next) {
db.query('SELECT sfid FROM salesforce.contact WHERE id=$1',[req.userId], true)
var nforce = require("nforce"),
Q = require("q"),
request = require('request'),
config = require("../config.js").config;
var org = nforce.createConnection({
clientId: config.sfdc.client_id,
clientSecret: config.sfdc.client_secret,
redirectUri: 'http://localhost:3000/oauth/_callback',
environment: config.sfdc.environment,
mode: 'multi'
});
// authenticate to force.com and returns connection object
function login() {
var deferred = Q.defer();
org.authenticate({ username: config.sfdc.username, password: config.sfdc.password}, function(err, resp){
if(!err) {
console.log('Access Token: ' + resp.access_token);
deferred.resolve(resp);
} else {
console.log('Error connecting to Salesforce: ' + err.message);
deferred.reject(err);
}
});
return deferred.promise;
}
// qeuries for 5 records by the specified sObject
function query(sobject) {
"use strict";
var nforce = require('nforce');
var connection = {};
var org = nforce.createConnection({
clientId: '3MVG9xOCXq4ID1uENR_n0vamNcV9ttUyOINbn6coRAQ4rj4QrMvdOoUozVXyqlXIZXQ0Yp1kgmpGRGXX0j1cB',
clientSecret: '5893789878304722858',
redirectUri: 'https://oauthss.herokuapp.com/oauthcallback',
apiVersion: 'v38.0', // optional, defaults to current salesforce API version
environment: 'production', // optional, salesforce 'sandbox' or 'production', production default
mode: 'multi', // optional, 'single' or 'multi' user mode, multi default
});
//the above equals to the following
connection.getOrg = function(){
return org;
};
module.exports = connection;
var nforce = require('nforce');
var org = nforce.createConnection({
clientId: '3MVG98RqVesxRgQ6abeUDaL8txdCbQdaASc1jZlMVZuZoBl864fJw9VRj.HavfpYOpQKASbWAFKbm0nM61x8n',
clientSecret: '3967975534978011198',
redirectUri: 'http://localhost:3000/oauth/_callback',
apiVersion: 'v27.0', // optional, defaults to current salesforce API version
environment: 'todddev', // optional, salesforce 'sandbox' or 'production', production default
mode: 'single' // optional, 'single' or 'multi' user mode, multi default
});
// single-user mode
org.authenticate({ username: '******', password: '******'}, function(err, resp){
// the oauth object was stored in the connection object
if(!err) console.log('Cached Token: ' + org.oauth.access_token)
});
"use strict";
//remove this code as it's handled in `slack-salesforce-auth.js`
let nforce = require('nforce'),
SF_CLIENT_ID = process.env.SF_CLIENT_ID,
SF_CLIENT_SECRET = process.env.SF_CLIENT_SECRET,
SF_USER_NAME = process.env.SF_USER_NAME,
SF_PASSWORD = process.env.SF_PASSWORD,
org = nforce.createConnection({
clientId: SF_CLIENT_ID,
clientSecret: SF_CLIENT_SECRET,
redirectUri: 'http://localhost:3000/oauth/_callback',
mode: 'single',
autoRefresh: true
});
let login = () => {
org.authenticate({username: SF_USER_NAME, password: SF_PASSWORD}, err => {
if (err) {
console.error("Authentication error");
console.error(err);
} else {
console.log("Authentication successful");
}
});
};
var nforce = require('nforce');
var connection = nforce.createConnection({
clientId : process.env.SF_API_CLIENT,
clientSecret : process.env.SF_API_SECRET,
redirectUri : '',
environment : 'production',
mode : 'single' // optional, 'single' or 'multi' user mode, multi default
});
var Promise = global.Promise;
var connected = false;
function connect() {
if (connected) {
return Promise().resolve(connection);
} else {
return connection
.authenticate({
username : process.env.SF_API_USER,
password : process.env.SF_API_PASS
})
.then(() => {
return connection;
});
}
}
module.exports = {
connection : connection,
connect : connect
};
'use strict'
console.log('connection.js--> start');
var nforce = require('nforce');
var org = nforce.createConnection({
clientId: process.env.CLIENT_ID,
clientSecret: process.env.CLIENT_SECRET,
redirectUri: 'http://localhost:3000/oauth/_callback',
environment: 'production',
mode: 'single'
});
org.authenticate({ username: process.env.USERNAME, password: process.env.PASSWORD}, function(err, resp){
// the oauth object was stored in the connection object
if(!err) console.log('Successfully connected to Salesforce. Cached token: ' + org.oauth.access_token);
if(err) console.log('Cannot connect to Salesforce: ' + err);
});
module.exports = org;
console.log('connection.js--> end');
exports.updateMember = function(memberId, memberTabs) {
var org = nforce.createConnection({
clientId: process.env.DATABASEDOTCOM_CLIENT_ID,
clientSecret: process.env.DATABASEDOTCOM_CLIENT_SECRET,
redirectUri: process.env.CONFIG_URL_BASE + '/oauth/_callback',
apiVersion: 'v24.0', // optional, defaults to v24.0
environment: process.env.DATABASEDOTCOM_ENVIRONMENT // optional, sandbox or production, production default
});
org.authenticate({ username: process.env.SFDC_USERNAME, password: process.env.SFDC_PASSWORD }, function(err, resp){
if(err) {
console.log('Error for '+memberId+': ' + err.message);
} else {
oauth = resp;
console.log('Updating memberId: '+memberId);
var query = 'select id, name from member__c where id = \''+memberId+'\'';
org.query(query, oauth, function(err, resp){
console.log(resp);
var member = resp.records[0];
member.Paperwork_Received__c = 'Paper Work Received';
member.Paperwork_Year__c = new Date().getFullYear();
member.Country__c = 'United States';
// challenge 2026
// update member info here
var memberTextTabs = memberTabs.textTabs;
//console.log(memberTabs.textTabs);
// loop through text tabs and set member's fields
for(var i = 0; i < memberTextTabs.length; i++) {
var thisName = memberTextTabs[i].name;
var thisLabel = memberTextTabs[i].tabLabel;
var thisValue = memberTextTabs[i].value;
console.log(thisName + ' -> ' + thisLabel + ' -> ' + thisValue);
if(thisLabel == 'Name') {
var chunks = thisValue.split(' ');
member.First_Name__c = chunks[0].trim();
member.Last_Name__c = '';
for(var j = 1; j < chunks.length; j++) {
member.Last_Name__c += ' '+ chunks[j].trim();
}
member.Last_Name__c = member.Last_Name__c.trim();
} else if (thisLabel == 'Address') {
member.Address_Line1__c = thisValue;
} else if (thisLabel == 'City') {
member.City__c = thisValue.trim();
} else if (thisLabel == 'State') {
member.State__c = thisValue.trim();
} else if (thisLabel == 'Zip') {
member.Zip__c = thisValue.trim();
} else if (thisLabel == 'Country') {
member.Country__c = thisValue.trim();
}
}
console.log(member);
org.update(member, oauth, function(err, resp){
if(!err) console.log('Member successfully updated');
});
});
}
});
}
var express = require('express');
var bodyParser = require('body-parser');
var nforce = require('nforce');
var config = require('./config.js');
var sfdc = require('./sfdc.js');
var app = express();
app.use(bodyParser.json());
var org = nforce.createConnection({
clientId: config.CLIENT_ID,
clientSecret: config.CLIENT_SECRET,
redirectUri: config.CALLBACK_URL + '/oauth/_callback',
apiVersion: 'v32.0',
mode: 'single'
});
var accs = null;
app.get('/', function (req, res) {
res.send('Hello World!');
});
app.post('/Subscribe',function(req,res){
if(accs!=null){
accs.client.disconnect(); //disconnect existing connection
}
if(req.body.Name != '' && req.body.fields != null){
console.log("Subscribing to push topic : "+ req.body.Name);
// See FORCE_README.md
var nforce = require('nforce'),
config = require('./config');
var org = null;
var needs_login = true;
if (config.salesforce) {
var org = nforce.createConnection({
clientId: config.salesforce.clientId,
clientSecret: config.salesforce.clientSecret,
redirectUri: config.salesforce.redirectUri,
environment: config.salesforce.environment, // optional, salesforce 'sandbox' or 'production', production default
mode: 'single' // optional, 'single' or 'multi' user mode, multi default
});
login();
}
function login() {
if (!org.oauth) {
console.log("Connecting to force.com...")
org.authenticate({
username: config.salesforce.username,
password: config.salesforce.password + config.salesforce.token
}, function(err, resp) {
// the oauth object was stored in the connection object
if (err) {
config.error("Force.com connection error: ", err);
} else {
config.info('Connected to force.com: ' + org.oauth.id);
this.on('input', function(msg) {
// show initial status of progress
node.status({fill:"green",shape:"ring",text:"connecting...."});
// check for overriding message properties
if (msg.hasOwnProperty("action") && config.action === '') {
config.action = msg.action;
}
if (msg.hasOwnProperty("object") && config.object === '') {
config.object = msg.object;
}
// create connection object
var org = nforce.createConnection({
clientId: this.connection.consumerKey,
clientSecret: this.connection.consumerSecret,
redirectUri: this.connection.callbackUrl,
environment: this.connection.environment,
mode: 'single'
});
// auth and run query
org.authenticate({ username: this.connection.username, password: this.connection.password }).then(function(){
var obj = nforce.createSObject(config.object, msg.payload);
if (config.action === 'insert') {
return org.insert({ sobject: obj });
} else if (config.action === 'update') {
return org.update({ sobject: obj });
} else if (config.action === 'upsert') {
// check for a field specified for external id
if (msg.hasOwnProperty("externalId")) {
obj.setExternalId(msg.externalId.field, msg.externalId.value);
}
return org.upsert({ sobject: obj });
} else {
return org.delete({ sobject: obj })
}
}).then(function(results) {
// cteate a default payload to populate
msg.payload = {
success: true,
object: config.object.toLowerCase()
}
if (config.action === 'insert') {
_.extend(msg.payload, {id: results.id, 'action': 'insert'});
} else if (config.action === 'update') {
_.extend(msg.payload, {id: msg.payload.id, 'action': 'update'});
} else if (config.action === 'upsert') {
if (results.id != null) {
_.extend(msg.payload, {id: results.id, 'action': 'insert'});
} else {
_.extend(msg.payload, {id: msg.externalId, 'action': 'update'});
}
} else {
_.extend(msg.payload, {id: msg.payload.id, 'action': 'delete'});
}
node.send(msg);
node.status({});
}).error(function(err) {
node.status({fill:"red",shape:"dot",text:"Error!"});
node.error(err);
});
});
var nforce = require("nforce");
var tooling = require('../')(nforce);
var should = require("should");
var config = require("./config");
var oauth;
var org = nforce.createConnection({
clientId: config.connection.clientId,
clientSecret: config.connection.clientSecret,
redirectUri: config.connection.redirectUri,
mode: 'single',
plugins: ['tooling']
});
describe('plugin', function() {
describe('#insert()', function(){
it('should create a new MetadataContainer record successfully', function(done){
org.tooling.insert({type: 'MetadataContainer', object: {name: 'TestInsertContainer'}}, function(err, resp) {
if (config.debug) console.log(resp);
resp.success.should.eql(true);
// delete the record we just inserted
org.tooling.delete({type: 'MetadataContainer', id: resp.id}, function(err, resp) {
if (err) console.log('Could not delete MetadataContainer ' + resp.id + ': ' + err.message);
done();
});
});
})
})
const nforce = require('nforce')
require('dotenv').config()
/**
* Initialise connection parameters for Salesforce Connected App
*/
const org = nforce.createConnection({
clientId: process.env.CONSUMER_KEY,
clientSecret: process.env.CONSUMER_SECRET,
redirectUri: 'https://localhost:3000/oauth/_callback',
environment: 'production',
mode: 'multi'
})
/**
* Authenticate to login a user in the org
* @param {string} username - e.g. john@example.com
* @param {string} password
* @param {string} securityToken - Your user's security token.
* This can be reset in the org if needed.
*/
const authenticate = (username, password, securityToken) =>
new Promise((resolve, reject) => {
// Authenticate using multi user mode
org.authenticate(
{
username: username,
password: password,
securityToken: securityToken
},
(error, response) => {
* Module dependencies.
*/
var express = require('express')
, routes = require('./routes')
, util = require('util')
. async = require('async')
, nforce = require('nforce');
var port = process.env.PORT || 3001; // use heroku's dynamic port or 3001 if localhost
var oauth;
var org = nforce.createConnection({
clientId: process.env.CLIENT_ID,
clientSecret: process.env.CLIENT_SECRET,
redirectUri: 'http://localhost:' + port + '/oauth/_callback',
apiVersion: 'v24.0', // optional, defaults to v24.0
environment: 'production' // optional, sandbox or production, production default
});
org.authenticate({ username: process.env.USERNAME, password: process.env.PASSWORD }, function(err, resp){
if(err) {
console.log('Error: ' + err.message);
} else {
console.log('Access Token: ' + resp.access_token);
oauth = resp;
}
});
var app = module.exports = express.createServer();
var routes = require('./routes/index');
var app = express();
var server = require('http').Server(app);
// attach socket.io and listen
var io = require('socket.io')(server);
// get a reference to the socket once a client connects
var socket = io.sockets.on('connection', function (socket) { });
// --------- Connection to app to SalesForce
var org = nforce.createConnection({
clientId: config.CLIENT_ID,
clientSecret: config.CLIENT_SECRET,
redirectUri: config.CALLBACK_URL + '/oauth/_callback',
mode: 'multi',
environment: config.ENVIRONMENT // optional, sandbox or production, production default
});
org.authenticate({ username: config.USERNAME, password: config.PASSWORD }, function(err, oauth) {
if(err) return console.log(err);
if(!err) {
console.log('*** Successfully connected to Salesforce ***');
// add any logic to perform after login
}
// subscribe to a pushtopic
var str = org.stream({ topic: config.PUSH_TOPIC, oauth: oauth });