populateTestData.js

var grunt = require('grunt');
var User = require('../models/user');
var MessageThread = require('../models/messageThread');
var config = require('config');
var Firebase = require('firebase');
var FirebaseAuthToken = process.env.FIREBASE_AUTH_TOKEN;
var firebaseService = require('../services/firebaseService');
var firebaseAuthService = require('../services/firebaseAuthService');
var Q = require('q');
var jsonfile = require('jsonfile');
var backupFileName = './backups/' + (new Date()).toString().split(' ').join('_') + "_backup.json";
var testUsers = require('./testData/testUsers').testUsers;
var liamTestUser = require('./testData/testUsers').liamTestUser;
LIAM_UID = "cece00ff-ef1c-49d4-b0c2-e2e182eadb7f";
var newUid;

function teardownAndCreateUserAccounts(){
  grunt.registerTask('teardownAndCreateUserAccounts', 'Clears Firebase Test Users and populates with test data',
    function() {
      var done = this.async();
      throwErrorIfNotDevEnvironment();
      grunt.log.writeln("pre-teardown");
      firebaseAuthService.authWithCustomToken(FirebaseAuthToken)
        .then(backUpData)
        .then(teardownUserAccounts)
        .then(createUserAccounts)
        .then(createMessageThreads)
        .then(function(){
          grunt.log.writeln("dunzo");
          done()
        }, function(err){
          grunt.log.error(err);
          done(false);
        });
    });
}

var populateTestData = {
  registerTask: {
    teardownAndCreateUserAccounts: teardownAndCreateUserAccounts
  }
};

function throwErrorIfNotDevEnvironment(){
  var devServerName = "glowing-inferno-8627";
  if (User.usersRef.ref().k.F.host.indexOf(devServerName) === -1) {
    grunt.fail.fatal("Not in dev server");
  } else {
    grunt.log.writeln("Running in dev √√√ ...");
  }
}

function teardownUserAccounts(){
  var deferred = Q.defer();

  User.usersRef.remove(function (error) {
    if (!error) {
      grunt.log.writeln("Successully removed test users");
      deferred.resolve();
    } else {
      grunt.log.error(error);
      deferred.reject();
    }
  });

  return deferred.promise;
}

function createUserAccounts(){
//  var deferred = Q.defer();
//  var u = new User();
//  u.set(testUsers[0], {silent: true}); //silent so that we can set key to uid after registration
//  u.createTestUser()
//    .then(function(userData){
//      var uid = userData.uid;
//      var registeredUser = new User(uid);
//      registeredUser.set(testUsers[0], {silent: false});
//      registeredUser.save();
//      deferred.resolve(userData);
//    }, function(err){
////      grunt.log.writeln(u.ref());
////      u.ref().remove();
//      deferred.reject(err);
//    });
//  return deferred.promise;
  grunt.log.writeln("creating user accts");
  var promises = [];
  testUsers.forEach(function(testUser){
    var createUserAccountPromise = createUserAccount(testUser);
    promises.push(createUserAccountPromise);
  });
  var liamUserCreationPromise = createUserAccount(liamTestUser, LIAM_UID);
  promises.push(liamUserCreationPromise);

  return Q.all(promises);
}

function createUserAccount(testUserData, existingUid){
  var deferred = Q.defer();
  var createUserPromise;
  if (existingUid){
    createUserPromise = Q.when({uid: existingUid});
  } else {
    var u = new User(); //u is unregistered user... probably a better way, but YOLO for scripts
    u.set(testUserData, {silent: true}); //silent so that we can set key to uid after registration
    createUserPromise = u.createTestUser()
  }
  createUserPromise
    .then(function(userAuthData){
      var uid = userAuthData.uid;
      if (!existingUid) newUid = uid; //only for testing MT creation... TODO: remove
      var registeredUser = new User(uid);
      registeredUser.set(testUserData, {silent: false});
//      registeredUser.save();
      deferred.resolve(userAuthData);
    }, function(err){
      deferred.reject(err);
    });
  return deferred.promise;
}

function createMessageThreads(){
  MessageThread.createThreadForUsers(LIAM_UID, newUid);
  return Q.when();
}

function backUpData(){
  var deferred = Q.defer();
  firebaseService.rootRef.once("value", function(bigData){
    jsonfile.writeFileSync(backupFileName, (bigData.exportVal()));
    deferred.resolve();
  });
  return deferred.promise;
}

module.exports = populateTestData;