require 'databasedotcom'

class Utils < Thor
  
  desc "query SOQL", "runs a soql query and displays the value of each record's 'name' field"
  method_option :config_file, :type => :string, :default => "databasedotcom.yml", 
    :aliases => "-c", :desc => "The name of the file containing the connection parameters."  
  def query(soql)
    client = authenticate(options[:config_file])
    # execute the soql and iterate over the results to output the name
    client.query("#{soql}").each do |r|
      puts r.Name
    end
  end
  
  desc "export SOQL FIELDS FILE", "runs a soql query and exports the specified 
    comma separated list of fields to a comma separated file"
  method_option :config_file, :type => :string, :default => "databasedotcom.yml", 
    :aliases => "-c", :desc => "The name of the file containing the connection parameters."
  def export(soql, fields, file)
    client = authenticate(options[:config_file])
    # query for records
    records = client.query("#{soql}")
    # open the file to write (probably local directory)
    File.open(file, 'w') do |f| 
      # interate over the records
      records.each do |r| 
        # create a single line with all field values specified
        line = ''
        fields.split(',').each do |field|
          line += "#{eval("r.#{field}")},"
        end 
        # write each line to the csv file       
        f.puts  "#{line}\n"
      end
    end 
  end
  
  desc "describe OBJECT", "displays the describe info for a particular object"
  method_option :config_file, :type => :string, :default => "databasedotcom.yml", 
    :aliases => "-c", :desc => "The name of the file containing the connection parameters."
  def describe(object)
    client = authenticate(options[:config_file])
    # call describe on the object by name
    sobject = client.describe_sobject(object)
    # output the results -- not very useful (frowny face)
    puts sobject
  end
  
  desc "get_token", "retreives an access token"
  method_option :config_file, :type => :string, :default => "databasedotcom.yml", 
    :aliases => "-c", :desc => "The name of the file containing the connection parameters."
  def get_token
    client = authenticate(options[:config_file]).oauth_token
    puts "Access token: #{client}"
  end

  desc "show_config", "display the salesforce connection properties"
  method_option :config_file, :type => :string, :default => "databasedotcom.yml", 
    :aliases => "-c", :desc => "The name of the file containing the connection parameters."
  def show_config
    config = YAML.load_file(options[:config_file])
    puts config
  end
  
  private 
  
    def authenticate(file_name)
      # load the configuration file with connection parameters
      config = YAML.load_file(file_name)
      # init the databasedotcom gem with the specified yml config file
      client = Databasedotcom::Client.new(file_name)    
      # pass the credentials to authenticate
      client.authenticate :username => config['username'], :password => config['password']
      return client
    end
  
end

client_id: YOUR-CLIENT-ID
client_secret: YOUR-CLIENT-SECRET
host: test.salesforce.com
debugging: false
username: YOUR-USERNAME
password: YOUR-PASSWORD

/**
 * Module dependencies.
 */
var express = require('express')
  , routes = require('./routes')
  , rest = require('./rest.js')
  , oauth = require('./oauth.js')
  , url = require('url');

/**
 * Setup some environment variables (heroku) with defaults if not present
 */
var port = process.env.PORT || 3001; // use heroku's dynamic port or 3001 if localhost
var cid = process.env.CLIENT_ID || "YOUR-REMOTE-ACCESS-CONSUMER-KEY";
var csecr = process.env.CLIENT_SECRET || "YOUR-REMOTE-ACCESS-CONSUMER-SECRET";
var lserv = process.env.LOGIN_SERVER || "https://login.salesforce.com";
var redir = process.env.REDIRECT_URI || "http://localhost:" + port + "/token";

/**
 * Middleware to call identity service and attach result to session
 */
function idcheck() {
  return function(req, res, next) {
    // Invoke identity service if we haven't got one or access token has 
    // changed since we got it
      if (!req.session || !req.session.identity || req.session.identity_check != req.oauth.access_token) {
        rest.api(req).identity(function(data) {
          console.log(data);
          req.session.identity = data;
          req.session.identity_check = req.oauth.access_token;
          next();
        });          
    } else {
      next();      
    }
  }
}

/**
 * Create the server
 */
var app = express.createServer(
    express.cookieParser(),
    express.session({ secret: csecr }),
    express.query(),
    oauth.oauth({
        clientId: cid,
        clientSecret: csecr,
        loginServer: lserv,
        redirectUri: redir,
    }),
  idcheck()
);

/**
 * Configuration the server
 */
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(){
  app.use(express.errorHandler({ dumpExceptions: true, showStack: true }));
});

app.configure('production', function(){
  app.use(express.errorHandler());
});

/**
 * Routes
 */

 // 'home' page
app.get('/', routes.index);

// list of accounts - see routes/index.js for more info
app.get('/accounts', routes.accounts);

// form to create a new account
app.get('/accounts/new', function(req, res) {
  // call describe to dynamically generate the form fields
  rest.api(req).describe('Account', function(data) {
    res.render('new', { title: 'New Account', data: data })
  });
});

// create the account in salesforce
app.post('/accounts/create', function(req, res) {
  rest.api(req).create("Account", req.body.account, function(results) {
    if (results.success == true) {
      res.redirect('/accounts/'+results.id);
      res.end();
    }
  });
});

// display the account
app.get('/accounts/:id', function(req, res) {
  rest.api(req).retrieve('Account', req.params.id, null, function(data) {
    res.render('show', { title: 'Account Details', data: data });
  });
});

// form to update an existing account
app.get('/accounts/:id/edit', function(req, res) {
  rest.api(req).retrieve('Account', req.params.id, null, function(data) {
    res.render('edit', { title: 'Edit Account', data: data });
  });
});

// update the account in salesforce
app.post('/accounts/:id/update', function(req, res) {
  rest.api(req).update("Account", req.params.id, req.body.account, function(results) {
    res.redirect('/accounts/'+req.params.id);
    res.end();
  });  
});

app.listen(port, function(){
  console.log("Express server listening on port %d in %s mode", 
    app.address().port, app.settings.env);
});

// only needed if calling the rest api from this file (accounts route)
var rest = rest = require('./../rest.js');

/*
 * GET home page.
 */
exports.index = function(req, res){
  res.render('index', { title: 'Salesforce.com Node.js REST Demo' })
};

/*
 * GET list of accounts - for larger apps, you may want to separate
 * code into different routes for ease of maintenance and logic. 
 * Prevents app.js from becoming huge!
 */
exports.accounts = function(req, res){
  rest.api(req).query("select id, name from account limit 10", function(data) {
    res.render("accounts", { title: 'Accounts', data: data, user: req.session.identity } );
  });
};

trigger AccountRegionTrigger on Account_Region__c (after delete, after insert, after update) {
      
  // fires after both insert and update
  if((Trigger.isInsert || Trigger.isUpdate) && Trigger.isAfter){
    
    // find the ids of all accounts that were affected
    Set<Id> accountIds = new Set<Id>();
    for (Account_Region__c ar : [select Id, Account__c from Account_Region__c 
      where Id IN :Trigger.newMap.keySet()])
      accountIds.add(ar.Account__c);
        
    // process the accounts  
    AccountRegionTriggerHandler.ProcessRegionsAsync(accountIds);
    

  // fires when records are deleted. may want to do undelete also?
  } else if(Trigger.isDelete && Trigger.isAfter){
    
    // find the ids of all accounts that were affected
    Set<Id> accountIds = new Set<Id>();
    for (ID id : Trigger.oldMap.keySet())
      accountIds.add(Trigger.oldMap.get(id).Account__c);
    
    // process the accounts
    AccountRegionTriggerHandler.ProcessRegionsAsync(accountIds);

  }

}

public with sharing class AccountRegionTriggerHandler {
  
  @future 
  public static void ProcessRegionsAsync(Set<ID> accountIds){
    
    // holds a map of the account id and comma separated regions to build
    Map<Id, String> accountRegionMap = new Map<Id, String>();
      
    // get ALL of the regions for all affected accounts so we can build
    List<Account_Region__c> accountRegions = [select id, Account__c, 
      Region__r.Name from Account_Region__c 
      where Account__c IN :accountIds order by Region__r.Name];
      
    for (Account_Region__c ar : accountRegions) {
      if (!accountRegionMap.containsKey(ar.Account__c)) {
        // if the key (account) doesn't exist, add it with region name
        accountRegionMap.put(ar.Account__c,ar.Region__r.Name);
      } else {
        // if the key (account) already exist, add ", region-name"
        accountRegionMap.put(ar.Account__c,accountRegionMap.get(ar.Account__c) + 
          ', ' + ar.Region__r.Name);
      }
    }
    
    // get the account that were affected
    List<Account> accounts = [select id from Account where Id IN :accountIds];
    
    // add the comma separated list of regions
    for (Account a : accounts)
      a.Regions__c = accountRegionMap.get(a.id);
    
    // update the accounts
    update accounts;
    
  }  
  
}

@isTest
private class Test_AccountRegionTriggerHandler {
  
  static List<Region__c> regions = new List<Region__c>();
  
  static {
  
    // insert some regions
    Region__c r1 = new Region__c(name='Region 1');
    Region__c r2 = new Region__c(name='Region 2');
    Region__c r3 = new Region__c(name='Region 3');
    Region__c r4 = new Region__c(name='Region 4');
    regions.add(r1);
    regions.add(r2);
    regions.add(r3);
    regions.add(r4);
    insert regions;
    
  }
  
  private static void testInsertRecords() {
    
    List<Account> accounts = new List<Account>();
    List<Account_Region__c> accountRegions = new List<Account_Region__c>();
    
    // insert some accounts
    Account a1 = new Account(name='Account 1');
    Account a2 = new Account(name='Account 2');
    accounts.add(a1);
    accounts.add(a2);
    insert accounts;
    
    Test.startTest();
    
      accountRegions.add(new Account_Region__c(Account__c=a1.Id, Region__c=regions.get(0).Id));
      accountRegions.add(new Account_Region__c(Account__c=a1.Id, Region__c=regions.get(1).Id));
      accountRegions.add(new Account_Region__c(Account__c=a2.Id, Region__c=regions.get(2).Id));
      accountRegions.add(new Account_Region__c(Account__c=a2.Id, Region__c=regions.get(3).Id));
      
      insert accountRegions;
    
    Test.stopTest();
    
    // since async, check for the accounts AFTER tests stop
    List<Account> updatedAccounts = [select id, name, regions__c from account where id IN :accounts];
    System.assertEquals('Region 1, Region 3',updatedAccounts.get(0).Regions__c);
    System.assertEquals('Region 2, Region 4',updatedAccounts.get(1).Regions__c);
    
  }
  
  private static void testDeleteRecords() {
    
    List<Account> accounts = new List<Account>();
    List<Account_Region__c> accountRegions = new List<Account_Region__c>();
    
    // insert an account
    Account a1 = new Account(name='Account 1');
    accounts.add(a1);
    insert accounts;
    
    Test.startTest();
    
      accountRegions.add(new Account_Region__c(Account__c=a1.Id, Region__c=regions.get(0).Id)); 
      accountRegions.add(new Account_Region__c(Account__c=a1.Id, Region__c=regions.get(1).Id));
      accountRegions.add(new Account_Region__c(Account__c=a1.Id, Region__c=regions.get(2).Id));
      accountRegions.add(new Account_Region__c(Account__c=a1.Id, Region__c=regions.get(3).Id));
      
      insert accountRegions;
    
      // now delete a record
      delete accountRegions.get(3);
    
    Test.stopTest();
    
    List<Account> updatedAccounts = [select id, name, regions__c from account where id IN :accounts];
    System.assertEquals('Region 1, Region 2, Region 3',updatedAccounts.get(0).Regions__c);
    
  }
  
}

if(process.env.VCAP_SERVICES){
  var env = JSON.parse(process.env.VCAP_SERVICES);
  var mongo = env['mongodb-1.8'][0]['credentials'];
}
else{
  var mongo = {
    "hostname":"localhost",
    "port":27017,
    "username":"",
    "password":"",
    "name":"",
    "db":"db"
  }
}

var generate_mongo_url = function(obj){
  obj.hostname = (obj.hostname || 'localhost');
  obj.port = (obj.port || 27017);
  obj.db = (obj.db || 'test');

  if(obj.username && obj.password){
    return "mongodb://" + obj.username + ":" + obj.password + "@" + obj.hostname + ":" + obj.port + "/" + obj.db;
  }
  else{
    return "mongodb://" + obj.hostname + ":" + obj.port + "/" + obj.db;
  }
}

var mongourl = generate_mongo_url(mongo);

// creates a location in the 'locations' collection
app.post('/v.1/locations', function(req, res){
  require('mongodb').connect(mongourl, function(err, conn){
    conn.collection('locations', function(err, coll){
      coll.insert( req.body, {safe:true}, function(err){
      res.writeHead(200, {
        "Content-Type": "application/json",
        "Access-Control-Allow-Origin": "*"
      });
      res.end(JSON.stringify(req.body));
      });
    });
  });
 });

// returns list of locations
app.get('/v.1/locations', function(req, res){

  require('mongodb').connect(mongourl, function(err, conn){
    conn.collection('locations', function(err, coll){
      coll.find(function(err, cursor) {
      cursor.toArray(function(err, items) {
        res.writeHead(200, {
          "Content-Type": "application/json",
          "Access-Control-Allow-Origin": "*"
        });
        res.end(JSON.stringify(items));
      });
      });
    });
  });

});

// returns a specific location by id
app.get('/v.1/locations/:location_id', function(req, res){

  var ObjectID = require('mongodb').ObjectID;
  
  require('mongodb').connect(mongourl, function(err, conn){
    conn.collection('locations', function(err, coll){
      coll.findOne({'_id':new ObjectID(req.params.location_id)}, function(err, document) {
      res.writeHead(200, {
        "Content-Type": "application/json",
        "Access-Control-Allow-Origin": "*"
      });
      res.end(JSON.stringify(document));
      });
    });
  });
  
});

// creates a new facility for a location
app.post('/v.1/locations/:location_id/facilities', function(req, res){
  
  // add the location id to the json
  var facility = req.body;
  facility['location'] = req.params.location_id;

  require('mongodb').connect(mongourl, function(err, conn){
    conn.collection('facilities', function(err, coll){
      coll.insert( facility, {safe:true}, function(err){
      res.writeHead(200, {
        "Content-Type": "application/json",
        "Access-Control-Allow-Origin": "*"
      });
      res.end(JSON.stringify(facility));
      });
    });
  });

});

// updates a facility
app.put('/v.1/locations/:location_id/facilities/:facility_id', function(req, res){

  var ObjectID = require('mongodb').ObjectID;
  
  require('mongodb').connect(mongourl, function(err, conn){
    conn.collection('facilities', function(err, coll){
      coll.findAndModify({'_id':new ObjectID(req.params.facility_id)}, [['name','asc']], { $set: req.body }, {}, function(err, document) {
      res.writeHead(200, {
        "Content-Type": "application/json",
        "Access-Control-Allow-Origin": "*"
      });
      res.end(JSON.stringify(document));
      });
    });
  });

});

@RestResource(urlMapping='/v.9/member/*/results/*') 
global with sharing class MemberRestSvc {
 
  @HttpGet 
  global static ReturnClass doGet() {
  
    String[] uriKeys = RestContext.request.requestURI.split('/');
    // get the member name from the uri
    String memberName = uriKeys.get(uriKeys.size()-3);

    // do awesome programming stuff here & catch any exceptions
    try {
  
      List<Contact> contacts = [Select Id From Contact where member_name__c = :memberName];
      return new ReturnClass('true', 'Query executed successfully.', contacts);
    
    } catch (Exception e) {
      return new ReturnClass('false', e.getMessage(), null);
    }

  }

  global class ReturnClass {
    
    global String success;
    global String message;
    global List<Contact> records;
    
    global ReturnClass(String success, String message, List<Contact> records) {
      this.success = success;
      this.message = message;
      this.records = records;
    }
    
  }
    
}

@isTest
private class Test_MemberRestSvc {

  static {
    // setup test data	
  }

  static testMethod void testDoGet() {
  	    
    RestRequest req = new RestRequest(); 
    RestResponse res = new RestResponse();

    // pass the req and resp objects to the method		 
    req.requestURI = 'https://cs9.salesforce.com/services/apexrest/v.9/member/me/results/today';  
    req.httpMethod = 'GET';

    MemberRestSvc.ReturnClass results = MemberRestSvc.doGet(req,res);
    
    System.assertEquals('true', results.success);
    System.assertEquals(10, results.records.size());
    System.assertEquals('Query executed successfully.', results.message);
 
  }
  
}

@isTest
private class Test_MemberRestSvc {

  static {
    // setup test data	
  }

  static testMethod void testDoGet() {
  	    
    RestRequest req = new RestRequest(); 
    RestResponse res = new RestResponse();

    req.requestURI = 'https://cs9.salesforce.com/services/apexrest/v.9/member/me/results/today';  
    req.httpMethod = 'GET';
    RestContext.request = req;
    RestContext.response = res;

    MemberRestSvc.ReturnClass results = MemberRestSvc.doGet();
    
    System.assertEquals('true', results.success);
    System.assertEquals(10, results.records.size());
    System.assertEquals('Query executed successfully.', results.message);
 
  }
  
}