Auth.prototype.changePassword = function(db, data, params) {
var deferred = Q.defer();
var ret ={code:0, msg:'Auth.changePassword ', user:false};
db.user.findOne({ _id:MongoDBMod.makeIds({'id':data.user_id}) }, function(err, user) {
if(err) {
ret.msg +='Error: '+err;
deferred.reject(ret);
}
else if(!user) {
ret.msg +='No user - likely an invalid user_id';
deferred.reject(ret);
}
else {
var passFinal =createPassword(user.password_salt, data.new_password, {});
db.user.update({_id:user._id}, {$set: {'password':passFinal}}, function(err, valid) {
if(err) {
ret.msg +='Error: '+err;
deferred.reject(ret);
}
else if(!valid) {
ret.msg +='Not valid';
deferred.reject(ret);
}
else {
ret.user =user;
deferred.resolve(ret);
}
});
}
});
return deferred.promise;
};
db.user.findOne({email:data.email}, function(err, user) {
if(err) {
ret.msg +="db.user.findOne Error: "+err;
deferred.reject(ret);
}
else if(!user) {
ret.msg ="No user with email '"+data.email+"' exists";
deferred.reject(ret);
}
else {
var promiseLogin =loginActual(db, data, user, {});
promiseLogin.then(function(ret1) {
deferred.resolve(ret1);
}, function(err) {
deferred.reject(err);
});
//ensure user is no longer 'guest' status
var setObj ={
'status':'member'
};
db.user.update({_id: MongoDBMod.makeIds({'id':user._id})}, {$set: setObj}, function(err, valid) {
var dummy =1;
});
}
});
function(ret1)
{
ret.already_exists = ret1.already_exists;
ret.user = ret1.user;
if(ret.user.social === undefined)
{
ret.user.social = {};
}
var set_obj = {};
set_obj["social." + data.type] = data.socialData;
db.user.update({_id:MongoDBMod.makeIds({'id':ret1.user._id}) }, {$set: set_obj}, function(err, valid)
{
if(err)
{
ret.code = 1;
ret.msg +='Error: '+err;
deferred.reject(ret);
}
else if (!valid)
{
ret.code = 2;
ret.msg +='Not valid ';
deferred.reject(ret);
}
else
{
ret.code = 0;
ret.msg +='User updated';
ret.user.social[data.type] = data.socialData;
deferred.resolve(ret);
}
});
},
User.prototype.makeAdmin = function(db, data, params)
{
var deferred = Q.defer();
var ret ={code:0, msg:'User.makeAdmin '};
var admin_id = data.new_admin_id;
db.user.update({_id:MongoDBMod.makeIds({'id':admin_id}) }, {$set: {'admin': 1}}, function(err, valid)
{
if(err)
{
ret.code = 1;
ret.msg +='Error: '+err;
deferred.reject(ret);
}
else if (!valid)
{
ret.code = 1;
ret.msg +='Not valid ';
deferred.reject(ret);
}
else
{
ret.code = 0;
deferred.resolve(ret);
}
});
return deferred.promise;
};
User.prototype.update = function(db, data, params)
{
var AuthMod =require(pathParts.controllers+'auth/auth.js');
var deferred = Q.defer();
var ret ={code:0, msg:'User.update '};
var _id =data.user_id;
delete data.user_id;
data = AuthMod.formatAlternateContact(data, {});
ret.user = data;
delete data._id; //can't $set _id
data =self.fixPhoneFormat(db, data, params);
db.user.update({_id:MongoDBMod.makeIds({'id':_id}) }, {$set: data}, function(err, valid)
{
if(err) {
ret.msg +='Error: '+err;
deferred.reject(ret);
}
else if (!valid) {
ret.msg +='Not valid ';
deferred.reject(ret);
}
else {
ret.msg ='User updated';
deferred.resolve(ret);
}
});
return deferred.promise;
};
Crud.prototype.deleteSubArray =function(db, data, params, callback)
{
var ret ={'code':0, 'msg':'Crud.deleteSubArray '};
var mainId =MongoDBMod.makeIds({'id':data.main._id});
var subObjId;
if(params.subKeysNoObjectId ===undefined || !params.subKeysNoObjectId) {
subObjId =MongoDBMod.makeIds({'id':data.subObj._id});
}
else {
subObjId =data.subObj._id;
}
var pullObj ={};
pullObj[params.subKey] ={'_id':subObjId};
var query ={'_id':mainId};
if(data.secondary !==undefined)
{
for(var xx in data.secondary)
{
if(params.subKeysNoObjectId ===undefined || !params.subKeysNoObjectId) {
query[xx] =MongoDBMod.makeIds({'id':data.secondary[xx]});
}
else {
query[xx] =data.secondary[xx];
}
}
}
ret.msg +='params.collection: '+params.collection+' query: '+JSON.stringify(query)+' pullObj: '+JSON.stringify(pullObj)+' ';
db[params.collection].update(query, {'$pull':pullObj}, {'safe':true}, function(err, valid)
{
if(err)
{
ret.code =1;
ret.msg +="db."+params.collection+".update Error: "+err;
}
else if(!valid)
{
ret.code =2;
ret.msg +="db."+params.collection+".update Invalid";
}
callback(ret.code, ret);
});
};
Follow.prototype.searchFollowableUsers = function(db, data, params)
{
var deferred = Q.defer();
var ret ={code:0, msg:'Follow.searchFollowableUsers ', 'results': []};
var obj_id = MongoDBMod.makeIds({'id': data.user_id});
var ii;
db.user.findOne({'_id': obj_id }, function(err, user)
{
if(err)
{
ret.code = 1;
ret.msg += 'Error: '+err;
deferred.reject(ret);
}
else if(!user)
{
ret.code = 1;
ret.msg +='Invalid user ';
deferred.reject(ret);
}
else
{
if(data.skipIds === undefined)
{
data.skipIds = [];
}
if(user.follow !== undefined && user.follow.length > 0)
{
for(ii = 0; ii < user.follow.length; ii++)
{
data.skipIds.push(user.follow[ii].user_id);
}
}
data.skipIds.push(data.user_id);
var search_promise = UserMod.search(db, data, params);
search_promise.then(
function(ret1)
{
ret.code = 0;
ret.results = ret1.results;
deferred.resolve(ret);
},
function(ret1)
{
ret.code = 1;
deferred.reject(ret);
}
);
}
});
return deferred.promise;
};
Crud.prototype.delete1 =function(db, data, params, callback) {
var ret ={'code':0, 'msg':'Crud.delete1 '};
var query ={};
if(data._id !==undefined && data._id.toString().length >1) {
data._id =MongoDBMod.makeIds({'id':data._id});
db[params.collection].remove({_id:data._id}, function(err, numRemoved) {
if(err) {
ret.code =1;
ret.msg +="db."+params.collection+".remove Error: "+err;
}
else if(numRemoved <1) {
ret.code =2;
ret.msg +="db."+params.collection+".remove Num removed: "+numRemoved;
}
else {
ret.msg +="db."+params.collection+".remove Removed "+numRemoved;
}
callback(ret.code, ret);
});
}
else if(data._ids !==undefined) {
data._ids =MongoDBMod.makeIds({'ids':data._ids});
query._id ={$in:data._ids};
db[params.collection].remove({_id:{$in:data._ids}}, function(err, numRemoved) {
if(err) {
ret.code =1;
ret.msg +="db."+params.collection+".remove Error: "+err;
}
else if(numRemoved !=data._ids.length) {
ret.code =2;
ret.msg +="db."+params.collection+".remove Num removed "+numRemoved+" not equal to num ids "+data._ids.length;
}
else {
ret.msg +="db."+params.collection+".remove Removed "+numRemoved;
}
callback(ret.code, ret);
});
}
else {
ret.msg ='One of _id OR _ids must be supplied';
callback(true, ret);
}
};
Crud.prototype.save =function(db, data, params, callback)
{
var ret ={'code':0, 'msg':'Crud.save ', 'result':false};
if(data._id !==undefined) //update
{
var idSave =data._id;
delete data._id; //for $set update
db[params.collection].update({_id:MongoDBMod.makeIds({'id':idSave}) }, {$set:data}, {'safe':true}, function(err, result)
{
if(err)
{
ret.code =1;
ret.msg +="db."+params.collection+"update Error: "+err;
}
else if(!result)
{
ret.code =2;
ret.msg +="db."+params.collection+"update No result";
}
else
{
ret.msg = 4;
}
callback(ret.code, ret);
});
}
else //create
{
db[params.collection].insert(data, {safe: true}, function(err, record)
{
if(err)
{
ret.code =1;
ret.msg +="db."+params.collection+".insert Error: "+err;
}
else if(!record)
{
ret.code =2;
ret.msg +="db."+params.collection+".insert No record";
}
else
{
ret.result =record[0]; //insert returns an array of items, even if there's only 1
}
callback(ret.code, ret);
});
}
};
var updateUserLocal =function(paramsUser) {
db.user.update({_id:MongoDBMod.makeIds({'id':_id}) }, {$set: data.user}, function(err, valid)
{
if(err) {
ret.msg +='Error: '+err;
deferred.reject(ret);
}
else if (!valid) {
ret.msg +='Not valid ';
deferred.reject(ret);
}
else {
ret.msg ='User updated';
deferred.resolve(ret);
}
});
};
/**
@toc 6.5.
@method updateSession
@param {Object} user User looked up from db (matched to email or other field to identify this user)
@param {String} email Email of user to log in and update session
@return {Promise}
@param {Object} user User info now with active session id (and last_login is updated as well)
*/
function updateSession(db, user, params) {
var deferred =Q.defer();
var ret ={code:0, msg:'updateSession: ', user:false};
//update session info in database
var sessId =StringMod.random(16,{});
user.last_login =moment(new Date()).format('YYYY-MM-DD HH:mm:ss');
//may not have email so need to check by _id too
var valid =true;
var query ={};
if(user.email !==undefined) {
query.email =user.email;
}
else if(user._id !==undefined) {
query._id =MongoDBMod.makeIds({'id': user._id});
}
else {
valid =false;
ret.code =1;
ret.msg +='A valid user email or _id must be specified ';
deferred.reject(ret);
}
if(valid) {
db.user.update(query, {$set: {last_login:user.last_login}, $push:{sess_id: sessId } }, function(err, valid) {
if(err) {
ret.code =2;
ret.msg +='Error: '+err;
deferred.reject(ret);
}
else if(!valid) {
ret.code =3;
ret.msg +='Invalid query ';
deferred.reject(ret);
}
else {
user.sess_id =sessId; //set to string of CURRENT session rather than array of all sessions
ret.user =user;
deferred.resolve(ret);
}
});
}
return deferred.promise;
}
Auth.prototype.logout = function(db, data, params) {
var deferred = Q.defer();
var ret ={code:0, msg:'Auth.logout '};
db.user.update({_id: MongoDBMod.makeIds({'id': data.user_id}) }, {$set: {sess_id:''}}, function(err, user) {
if(err) {
ret.msg +='Error: '+err;
deferred.reject(ret);
}
else if(!user) {
ret.msg +='Invalid user ';
deferred.reject(ret);
}
else if(user) {
deferred.resolve(ret);
}
});
return deferred.promise;
};
Auth.prototype.checkLogin = function(db, data, params) {
var deferred = Q.defer();
var ret ={code:0, msg:'Auth.checkLogin ', user:false};
db.user.findOne({_id: MongoDBMod.makeIds({'id':data.user_id}), sess_id:data.sess_id}, function(err, user) {
if(err) {
ret.msg +='Error: '+err;
deferred.reject(ret);
}
else if(!user) {
ret.msg ="Invalid sess_id and user_id combination";
deferred.reject(ret);
}
else if(user) {
ret.user =user;
deferred.resolve(ret);
}
});
return deferred.promise;
};
Auth.prototype.checkLogin = function(db, data, params) {
var deferred = Q.defer();
var ret ={code:0, msg:'Auth.checkLogin ', user:false};
db.user.findOne({_id: MongoDBMod.makeIds({'id':data.user_id}), sess_id: {$in: [data.sess_id] } }, function(err, user) {
if(err) {
ret.code =1;
ret.msg +='Error: '+err;
deferred.reject(ret);
}
else if(!user) {
ret.code =2;
ret.msg ="Invalid sess_id and user_id combination";
deferred.reject(ret);
}
else if(user) {
user.sess_id =data.sess_id; //set to string of CURRENT session instead of array of all sessions
ret.user =user;
deferred.resolve(ret);
}
});
return deferred.promise;
};
function(ret1)
{
ret.already_exists = ret1.already_exists;
ret.user =ArrayMod.copy(ret1.user); //ensure no over-writing / funky behavior..
// ret.user = ret1.user; //breaks things since data.user then is equal to ret.user somehow..
if(ret.user.social === undefined)
{
ret.user.social = {};
}
var finishLocal =function(paramsFinish) {
//in case of update, need to re-read user to get all info (esp. sess_id)
// ret.user.social[data.type] = data.socialData;
UserMod.read(db, {_id: ret.user._id}, {})
.then(function(retUser) {
ret.user =retUser.result;
//also need to update session
var promiseSession =updateSession(db, ret.user, {});
promiseSession.then(function(ret1) {
ret.user =ret1.user;
deferred.resolve(ret);
}, function(err) {
deferred.reject(err);
});
}, function(retErr) {
deferred.reject(retErr);
});
};
var saveImageLocal =function(paramsImage) {
if(data.pic_directory ===undefined) {
data.pic_directory ='user';
}
var imgUrl =_imageUrl;
var imgUrlStripped =imgUrl;
//strip url params if they're there as this may mess up things (get an ESDIR or ENOENT error since the file extension isn't at the end) or get a small version of the image and we want the larger / default one
if(imgUrlStripped.indexOf('?') >-1) {
imgUrlStripped =imgUrlStripped.slice(0, imgUrlStripped.indexOf('?'));
}
//get the file extension
var posExt =imgUrlStripped.lastIndexOf('.');
var ext =imgUrlStripped.slice(posExt, imgUrlStripped.length);
var filename ='profile'+ext;
var imgSavePath =data.pic_directory +'/'+ret1.user._id;
var folderWritePath =path.normalize(__dirname +'../../../../' +imageInfo.imgPath +'/' +imgSavePath); //hardcoded - 4 '../' to get from this directory back to 'app/'. Very important to use path.normalize so it works on both windows and linux!!
//recursively create directories / folders in case they don't exist yet
fs.mkdirSync(folderWritePath, parseInt('777', 8), true); //0777 octal in strict mode is not allowed
var dbSavePath =imgSavePath +'/' +filename; //what will be stored in the database
var imgWritePath =folderWritePath +'/' +filename;
var picStream =fs.createWriteStream(imgWritePath);
picStream.on('close', function() {
if(data.user.image !==undefined) { //image key already exists
data.user['image.profile'] =dbSavePath; //have to do it this way for mongo db syntax and to avoid over-writing any other keys (other than 'profile') that may exist
}
else { //image key doesn't exist yet
data.user.image ={
profile: dbSavePath
};
}
//have to call the UserMod.update function to ensure the crop version of the image gets saved properly
UserMod.update(db, {user_id: ret1.user._id, user:data.user}, {})
.then(function(retUserUpdate) {
finishLocal({});
}, function(retErr) {
deferred.reject(retErr);
});
});
request(imgUrlStripped).pipe(picStream);
};
var set_obj = {};
set_obj["social." + data.type] = data.socialData;
//update other fields (i.e. name, email) too IF not already set. //@todo - extend existing fields and/or add to emails array with new ones?
var xx;
for(xx in data.user) {
if(ret.user[xx] ===undefined || !ret.user[xx]) {
set_obj[xx] =data.user[xx];
}
}
db.user.update({_id:MongoDBMod.makeIds({'id':ret1.user._id}) }, {$set: set_obj}, function(err, valid)
{
if(err)
{
ret.code = 1;
ret.msg +='Error: '+err;
deferred.reject(ret);
}
else if (!valid)
{
ret.code = 2;
ret.msg +='Not valid ';
deferred.reject(ret);
}
else
{
ret.code = 0;
ret.msg +='User updated';
//get image if it exists AND do not already have an image (don't overwrite if already do)
if(_imageUrl && (ret.user.image ===undefined || ret.user.image.profile ===undefined)) {
saveImageLocal({});
}
else {
finishLocal({});
}
}
});
},
Follow.prototype.unfollow = function(db, data, params)
{
var deferred = Q.defer();
var ret ={code:0, msg:'Follow.unfollow '};
var obj_id = MongoDBMod.makeIds({'id': data.user_id});
db.user.findOne({'_id': obj_id }, function(err, user)
{
if(err)
{
ret.msg += 'Error: '+err;
deferred.reject(ret);
}
else if(!user)
{
ret.msg +='Invalid user ';
deferred.reject(ret);
}
else if(user.follow === undefined || user.follow.length < 1) //Nothing to unfollow, we're done
{
ret.code = 0;
ret.msg += 'No users currently followed ';
deferred.resolve(ret);
}
else
{
//Remove from followed users array.
var ii;
for(ii = 0; ii < data.followed.length; ii++)
{
var jj;
for(jj = 0; jj < user.follow.length; jj++)
{
if(data.followed[ii]._id == user.follow[jj].user_id)
{
user.follow.splice(jj, 1);
jj = user.follow.length; //Stop looping
}
}
}
//Now user.follow is updated. Save it to the database.
db.user.update({'_id': obj_id }, {'$set': {'follow': user.follow} }, {'safe': true}, function(err2, user_new)
{
if(err)
{
ret.msg += 'Error: ' + err2;
ret.code = 1;
deferred.reject(ret);
}
else
{
ret.code = 0;
deferred.resolve(ret);
}
});
}
});
return deferred.promise;
};
Follow.prototype.follow = function(db, data, params)
{
var deferred = Q.defer();
var ret ={code:0, msg:'Follow.follow '};
var obj_id = MongoDBMod.makeIds({'id': data.user_id});
db.user.findOne({'_id': obj_id }, function(err, user)
{
if(err)
{
ret.msg += 'Error: '+err;
deferred.reject(ret);
}
else if(!user)
{
ret.msg +='Invalid user ';
deferred.reject(ret);
}
else
{
var timestamp = moment(new Date()).format('YYYY-MM-DD HH:mm:ss');
if(user.follow === undefined)
{
user.follow = [];
}
//Add to followed users array. Don't add an _id that's already there. Don't even assume that the given array has no duplicates.
//If the _id is already there, consider this an update for the timestamp.
var ii;
for(ii = 0; ii < data.followed.length; ii++)
{
var jj;
var found = false;
for(jj = 0; jj < user.follow.length; jj++)
{
if(data.followed[ii]._id == user.follow[jj].user_id)
{
found = true;
//Update timestamp
user.follow[jj].timestamp = timestamp;
jj = user.follow.length; //Stop looping
}
}
if(found === false)
{
user.follow.push({'user_id': data.followed[ii]._id, 'timestamp': timestamp});
}
}
//Now user.follow is updated. Save it to the database.
db.user.update({'_id': obj_id }, {'$set': {'follow': user.follow} }, {'safe': true}, function(err2, user_new)
{
if(err)
{
ret.msg += 'Error: ' + err2;
ret.code = 1;
deferred.reject(ret);
}
else
{
ret.code = 0;
deferred.resolve(ret);
}
});
}
});
return deferred.promise;
};
Follow.prototype.getFollowedUsers = function(db, data, params)
{
var deferred = Q.defer();
var ret ={code:0, msg:'Follow.getFollowedUsers ', 'follower': data.user_id, 'followed': []};
var ii;
var defaults =
{
'fields':{'_id':1}
};
var basic_only = false;
if(data.fields === undefined)
{
data.fields = defaults.fields;
basic_only = true; //Flags that we're only returning the _id's. This means we can skip a bunch of logic later.
}
db.user.findOne({_id:MongoDBMod.makeIds({'id':data.user_id}) }, function(err, user)
{
if(err)
{
ret.code = 1;
ret.msg += 'Error, could not find follower user';
deferred.reject(ret);
}
else if(user.follow === undefined || user.follow.length < 1) //If no followed users, we're done
{
deferred.resolve(ret);
}
else if(basic_only === true)
{
for(ii = 0; ii < user.follow.length; ii++)
{
ret.followed.push({'_id': user.follow[ii].user_id, 'timestamp': user.follow[ii].timestamp});
}
deferred.resolve(ret);
}
else
{
//Form array of followed user _ids
var followed_ids = [];
for(ii = 0; ii < user.follow.length; ii++)
{
followed_ids.push(user.follow[ii].user_id);
}
var read_data =
{
'_ids': followed_ids,
'fields': data.fields
};
var read_promise = UserMod.read(db, read_data, params);
read_promise.then(function(ret1)
{
ret.msg += ret1.msg;
ret.code = 0;
for(ii = 0; ii < ret1.results.length; ii++)
{
ret1.results[ii] = UserMod.readFilter(ret1.results[ii], {type:'full'}); //Cut out password fields if present
}
ret.followed = ret1.results;
deferred.resolve(ret);
}, function(err)
{
ret.msg += err.msg;
ret.code = 1;
deferred.reject(ret);
});
}
});
return deferred.promise;
};
Crud.prototype.read =function(db, data, params, callback) {
var retArray ={'code':0, 'msg':'Crud.read ', 'results':false};
//@todo - update / get new extend function that can not overwrite blank/empty (for data.fields)
// var fieldsSave =global.LArray.copyArray(data.fields, {});
// data =global.LArray.extend(params.defaults, data, {});
var fieldsSave =lodash.cloneDeep(data.fields);
data =lodash.extend({}, params.defaults, data);
//copy over data.fields that's passed in (if it is) - want to preserve empty array
if(fieldsSave !==undefined) {
data.fields =fieldsSave;
}
var query ={};
if(data.query) {
query =data.query;
}
if(data.fullQuery !==undefined) {
query =data.fullQuery;
db[params.collection].find(query, data.fields).toArray(function(err, records) {
if(err) {
retArray.code =1;
retArray.msg +="Error: "+err;
callback(retArray.code, retArray);
}
else if(!records) {
retArray.code =2;
retArray.msg +="fullQuery - No results. query was: "+JSON.stringify(query);
callback(retArray.code, retArray);
}
else {
retArray.results =records;
callback(false, retArray);
}
});
}
else if(data._id !==undefined)
{
data._id =MongoDBMod.makeIds({'id':data._id});
query._id =data._id;
db[params.collection].findOne(query, data.fields, function(err, record)
{
if(err)
{
retArray.code =1;
retArray.msg +="Error: "+err;
callback(retArray.code, retArray);
}
else if(!record)
{
retArray.code =2;
retArray.msg +="_id no result; invalid _id. query was: "+JSON.stringify(query);
callback(retArray.code, retArray);
}
else
{
retArray.result =record;
callback(false, retArray);
}
});
}
else if(data._ids !==undefined)
{
data._ids =MongoDBMod.makeIds({'ids':data._ids});
console.log(data._ids[0]);
query._id ={$in:data._ids};
db[params.collection].find(query, data.fields).toArray(function(err, records) {
if(err)
{
retArray.code =1;
retArray.msg +="Error: "+err;
callback(retArray.code, retArray);
}
else if(!records)
{
retArray.code =2;
retArray.msg +="_ids no results. Invalid _ids. query was: "+JSON.stringify(query);
callback(retArray.code, retArray);
}
else
{
retArray.results =records;
callback(false, retArray);
}
});
}
else
{
retArray.msg +='One of _id OR _ids OR fullQuery must be supplied';
callback(true, retArray);
}
};
Crud.prototype.saveSubArray =function(db, data, params, callback)
{
var thisObj =this;
var ret ={'code':0, 'msg':'Crud.saveSubArray '};
var mainId =MongoDBMod.makeIds({'id':data.main._id});
if(data.subObj._id ===undefined) //it's a create
{
thisObj.subArrayCreate(db, data, params, callback);
}
else //have to see if array item with this id already exists or not
{
var subObjId;
if(params.subKeysNoObjectId ===undefined || !params.subKeysNoObjectId) {
subObjId =MongoDBMod.makeIds({'id':data.subObj._id});
}
else {
subObjId =data.subObj._id;
}
var subKeyId =params.subKey+'._id';
subKeyId = subKeyId.replace('.$.', '.'); //Don't need positional operator for the query.
//Using ".findOne({'_id':mainId, subKeyId:subObjId}, ..." fails because it will try to find something with a property named subKeyId
//Must form the query separately
var query = {'_id':mainId};
query[subKeyId] = subObjId;
db[params.collection].findOne(query, function(err, record)
{
if(err)
{
ret.code =1;
ret.msg +="db."+params.collection+".findOne Error: "+err;
callback(ret.code, ret);
}
else if(!record) //create / $push new
{
ret.msg +="db."+params.collection+".findOne !record - creating new ";
thisObj.subArrayCreate(db, data, params, callback);
}
else //update existing
{
//ret.msg +='db[params.collection].findOne update existing ';
var setKey =params.subKey;
var subIdSave =data.subObj._id;
delete data.subObj._id;
var setQuery ={};
if(data.setObj !==undefined) {
setQuery =data.setObj;
}
var updateQuery ={};
if(data.updateQuery !==undefined) {
updateQuery =data.updateQuery;
}
//ret.msg +='data.subObj: '+JSON.stringify(data.subObj)+' ';
for(var xx in data.subObj)
{
var key1 =params.subKey+'.$.'+xx;
setQuery[key1] =data.subObj[xx];
}
//ret.msg +='query: '+JSON.stringify(query)+' setQuery: '+JSON.stringify(setQuery)+' ';
updateQuery.$set =setQuery;
// db[params.collection].update(query, {'$set':setQuery}, {'safe':true}, function(err, num_modified)
// console.log('collection: '+params.collection+' query: '+JSON.stringify(query)+' updateQuery: '+JSON.stringify(updateQuery));
db[params.collection].update(query, updateQuery, {'safe':true}, function(err, num_modified)
{
if(err)
{
ret.code =1;
ret.msg +="db."+params.collection+".update Error: "+err;
}
callback(ret.code, ret);
});
}
});
}
};
Crud.prototype.subArrayCreate =function(db, data, params, callback)
{
var ret ={'code':0, 'msg':'Crud.subArrayCreate ', 'result': false};
var mainId =MongoDBMod.makeIds({'id':data.main._id});
var subObjId;
if(data.subObj._id ===undefined)
{
subObjId =new mongodb.ObjectID();
}
else
{
if(params.subKeysNoObjectId ===undefined || !params.subKeysNoObjectId) {
subObjId =MongoDBMod.makeIds({'id':data.subObj._id});
}
else {
subObjId =data.subObj._id;
}
}
var pushItem = data.subObj;
pushItem._id = subObjId;
ret._id = subObjId;
ret.result = pushItem;
var pushObj ={};
pushObj[params.subKey] =pushItem;
var query ={'_id':mainId};
if(data.secondary !==undefined)
{
for(var xx in data.secondary)
{
if(params.subKeysNoObjectId ===undefined || !params.subKeysNoObjectId) {
query[xx] =MongoDBMod.makeIds({'id':data.secondary[xx]});
}
else {
query[xx] =data.secondary[xx];
}
}
}
var updateQuery ={};
if(data.updateQuery !==undefined) {
updateQuery =data.updateQuery;
}
if(data.setObj !==undefined) {
updateQuery.$set =data.setObj;
}
updateQuery.$push =pushObj;
// console.log('collection: '+params.collection+' query: '+JSON.stringify(query)+' updateQuery: '+JSON.stringify(updateQuery));
db[params.collection].update(query, updateQuery, {'safe':true}, function(err, valid)
{
if(err)
{
ret.code =1;
ret.msg +='db'+[params.collection]+'.update Error: '+err;
}
else if(!valid)
{
ret.code =2;
ret.msg +='db'+[params.collection]+'.update Invalid mainId: '+mainId+' query: '+JSON.stringify(query)+' pushObj: '+JSON.stringify(pushObj);
}
else {
ret.msg +='db'+[params.collection]+'.update VALID mainId: '+mainId+' query: '+JSON.stringify(query)+' pushObj: '+JSON.stringify(pushObj);
}
callback(ret.code, ret);
});
};
Lookup.prototype.search =function(db, collection, params, callback) {
var thisObj =this;
var retArray ={'code':0, 'valid':0, 'msg':'', 'results':false};
//defaults
var limit =20;
//end: defaults
/*
//apparently can't pass in an array []..
var fullQuery =[];
var queryIndex =0;
if(params.query !=undefined) {
fullQuery[queryIndex] =params.query;
}
if(params.skipIds !=undefined && params.skipIds.length >0) {
if(params.skipIdsNotObjectIds ==undefined || !params.skipIdsNotObjectIds) {
var ids =MongoDBMod.makeIds({'ids':params.skipIds});
fullQuery[queryIndex]['_id'] ={$nin:ids};
}
else {
fullQuery[queryIndex]['_id'] ={$nin:params.skipIds};
}
}
if(params.fields !=undefined) {
fullQuery.push(params.fields);
}
*/
var fullQuery ={'query':{}, 'fields':false};
if(params.query !==undefined) {
fullQuery.query =params.query;
}
if(params.skipIds !==undefined && params.skipIds.length >0) {
if(params.skipIdsNotObjectIds ===undefined || !params.skipIdsNotObjectIds) {
//if(0) {
var ids =MongoDBMod.makeIds({'ids':params.skipIds});
fullQuery.query._id ={$nin:ids};
}
else {
fullQuery.query._id ={$nin:params.skipIds};
}
}
if(params.fields !==undefined) {
fullQuery.fields =params.fields;
}
if(params.limit !==undefined) {
limit =params.limit;
}
retArray.fullQuery =fullQuery;
retArray.collection =collection;
//monogdb-native
var queryOpts ={
'limit':limit
};
retArray.msg +='limit ';
if(fullQuery.fields) {
queryOpts.fields =fullQuery.fields;
retArray.msg +='fields ';
}
if(params.skip !==undefined && params.skip >0) {
queryOpts.skip =params.skip;
retArray.msg +='skip ';
}
if(params.sort) {
queryOpts.sort =params.sort;
retArray.msg +='sort ';
}
db[collection].find(fullQuery.query, queryOpts).toArray(function(err, docs) {
thisObj.searchResults(err, docs, retArray, params, callback);
});
};