var seedProfs = function(profData, job, next) {
sails.log.debug("seeding profs");
sails.log.debug("length", profData.length)
async.eachSeries(profData, function(entry, next){
var profCreated = {};
var prof = {};
prof.code = entry.code;
prof.name = entry.name;
if (entry.gender == "男") {
prof.gender = "男";
} else if (entry.gender == "女") {
prof.gender = "女";
}
prof.email = entry.email;
prof.phone = entry.phone;
if (entry.birth && !isNaN(parseFloat(entry.birth))
&& entry.brith > 1930 && entry.birth < 2010 ) {
prof.birth = entry.birth;
}
prof.hometown = entry.hometown;
if (entry.exp && !isNaN(parseFloat(entry.exp))) {
prof.exp = entry.exp;
}
prof.group = entry.group;
prof.motto = entry.motto;
prof.intro = entry.intro;
prof.education = entry.education;
prof.research = entry.research;
prof.achievement = entry.achievement;
prof.legacyCourses = entry.legacyCourses;
sails.log.info("seed prof " + prof.name);
Prof.create(prof)
.then(function(results){
profCreated = results;
return School.findOne({ where: {"name": SCHOOL_NAME}});
})
.then(function(school){
school.addProf(profCreated);
return Dept.findOne({where: {"longname": entry.dept}});
})
.then(function(dept){
if (dept) {
return dept.addProf(profCreated);
}
})
.then(()=>{
return Position.findOne({where: {"name": entry.position}});
})
.then((position)=>{
if (position){
return position.addProf(profCreated);
} else if (entry.position) {
sails.log.debug("unknown position", entry.position);
}
})
.then(()=>{
return Prof.count();
})
.then(function(countProf){
sails.log.info("seeded prof " + countProf + ": " + prof.name);
next();
})
.catch(function(err){
if (err) sails.log.error("error", err);
next();
});
}, function (err) {
if (err) sails.log.error("error", err);
sails.log.debug("seeded: profs");
job.progress(4, 10);
next();
});
};
raccoon.config.numOfRecsStore = 200;
var async = require('async');
function addLikes(user, likes, next) {
async.eachLimit(likes, 20, function(like, next) {
console.log(user + " liked "+like);
raccoon.liked(user, like, next);
}, function(err) {
console.log("Done "+user+": "+err);
next(err);
});
};
async.eachSeries([["bol", bol], ["ChristianB", ChristianB], ["malbery", malbery]],
function(userData, next) {
addLikes(userData[0], userData[1], next);
},
function(err) {
console.log("Overall: "+err);
async.eachSeries(["bol", "ChristianB", "malbery"], function(user, next) {
raccoon.recommendFor(user, 10, function(results){
console.log("Recommendations for "+user+":");
console.dir(results);
next();
});
}, function(err) {
console.log(err);
});
});
downloadArtifactGroup(group, cb) {
async.eachSeries(group, this.downloadArtifact.bind(this), cb)
}
.then(function(result) {
// debug('pollUpdates got ', result)
var updates = result.updates.filter(function(a) { return a.action !== 'created at' })
updates.sort(function(a,b) { return a.timestamp - b.timestamp }) // Ascending sort by timestamp
if (updates.length) {
debug('pollUpdates got ' + updates.length + ' tasks to check.')
}
var toGo = updates.length
async.eachSeries(updates, function(update, callback) {
if (update.action === 'deleted at') {
if (update.timestamp > 0) { setLastPollTs(update.timestamp) }
debug('(' + (toGo--) + ') Removing ' + update.definition + ' ' + update.id + ' @ ' + update.timestamp + (new Date(update.timestamp*1000)))
return removeFromCache(update.id, callback)
}
if (update.timestamp > 0) { setLastPollTs(update.timestamp) }
debug('(' + (toGo--) + ') Updating ' + update.definition + ' ' + update.id + ' @ ' + update.timestamp + ' ' + (new Date(update.timestamp*1000)))
entu.pollParents(update.id, APP_ENTU_OPTIONS)
.then(function(parents) {
var currentParents = parents.map(function(element) { return Number(element.id) })
var filteredCFE = cacheFromEntu.filter(function(n) {
return currentParents.indexOf(Number(n.parent)) !== -1
})
return filteredCFE
})
.catch(function(reason) {
debug('\n\n!!!\nFetching parents of ' + update.definition + ' ' + update.id + ' @ ' + update.timestamp, 'failed:', reason)
return callback(reason)
})
.then(function(parents) {
// debug('1. Filtered parents of ', update, ': ', parents)
entu.getEntity(update.id, APP_ENTU_OPTIONS)
.then(function(opEntity) {
if (opEntity.get(['properties', 'nopublish', 0, 'value']) === 'True') {
debug('Unpublishing ' + update.definition + ' ' + update.id + ' @ ' + update.timestamp)
setTimeout(function () {
return removeFromCache(update.id, callback)
}, 61)
}
else {
parents = parents.filter(function(element) {
return opEntity.get(['definition']) === element.definition
})
// debug('2. Filtered parents of ', update, ': ', parents)
async.each(parents, function(parent, callback) {
myProcessEntities(null, parent.class, parent.definition, [opEntity], callback)
}, function(err) {
if (err) { return callback(err) }
// debug('1.Entity: ' + JSON.stringify(opEntity.get(['definition']) + ' ' + opEntity.get(['id']), null, 4), 'Parents: ', parents)
// debug('SDC.set([\'lastPollTs\'], ' + update.timestamp)
SDC.set(['lastPollTs'], update.timestamp)
updated = true
debug('Setting updated = ', updated)
return callback(null)
})
}
})
.catch(function(reason) {
debug('1. Filtered parents of ', update, ': ', parents, 'failed:', reason)
return callback(reason)
})
})
.catch(function(reason) {
debug('\n\n!!!\nUpdating ' + update.definition + ' ' + update.id + ' @ ' + update.timestamp, 'failed:', reason)
return callback(reason)
})
}, function(err) {
if (err) {
var message = '*INFO*: Cache routine stumbled. Restart in ' + ENTU_POLL_SEC / 1e2
console.log(message, new Date(), err)
report(message, {
level: 'warning',
extra: { err: err }
})
setTimeout(function() { pollEntu(report, workerReloadCB) }, ENTU_POLL_SEC * 10)
}
else {
console.log('Cache routine finished', new Date())
setTimeout(function() { pollEntu(report, workerReloadCB) }, ENTU_POLL_SEC)
if (updated) {
debug('We have updated = ', updated)
updated = false
debug('Setting updated = ', updated)
saveCache(workerReloadCB)
}
}
})
})
me.getNote(noteId, function(note) {
if(!note) {
callback(false);
return;
}
// 新Id
delete note['_id'];
delete note['ServerNoteId'];
note.NoteId = Common.objectId(); // 新生成一个NoteId
note.ConflictNoteId = noteId; // 与noteId有冲突
note.ConflictTime = new Date(); // 发生冲突时间
note.ConflictFixed = false; // 冲突未解决
note.IsDirty = true;
note.LocalIsNew = true; // 新增加的
note.InitSync = false; // 都是本地的, 相当于新建的笔记
note.LocalIsDelete = false;
// 只复制有path的
var attachs = note.Attachs || [];
var newAttachs = [];
console.log('不会吧.............')
console.log(attachs);
async.eachSeries(attachs, function(attach, cb) {
if(!attach.Path) {
return cb();
}
// 新路径
var filePathAttr = Common.splitFile(attach.Path);
filePathAttr.nameNotExt += '_cp_' + attach.FileId; // 另一个
var newPath = filePathAttr.getFullPath();
console.log('复制文件');
console.log(attach);
// 复制之
// try {
Common.copyFile(attach.Path, newPath, function(ret) {
if(ret) {
attach.FileId = Common.objectId();
attach.IsDirty = true;
attach.Path = newPath;
delete attach['ServerFileId'];
newAttachs.push(attach);
}
cb();
});
/*
} catch(e) {
cb();
}
*/
}, function() {
note.Attachs = newAttachs;
console.log('conflict 复制后的');
console.log(note);
Notes.insert(note, function(err, newNote) {
if(err) {
callback(false);
} else {
callback(newNote);
// 重新统计笔记本的笔记数量
Notebook.reCountNotebookNumberNotes(newNote.NotebookId);
}
});
});
});
concatFile: function (filePath, callback) {
var self = this;
var enableSourceMap = false;
var flattenFiles = [];
if (!this.concatConfig.pkg[filePath]) {
this.concatConfig.pkg[filePath] = [filePath];
}
if (this.enableSourceMap && rJS.test(filePath)) {
if (this.concatConfig.pkg[filePath.replace(rJS, '.coffee')]){
filePath = filePath.replace(rJS, '.coffee');
enableSourceMap = true;
}
}
enableSourceMap = false;
async.eachSeries(this.concatConfig.pkg[filePath], function (file, c) {
if (file.indexOf('*') > -1) {
self.flattenFiles(file, function (err, files) {
files.forEach(function (f) {
if (flattenFiles.indexOf(f) === -1) {
flattenFiles.push(f);
}
});
c();
});
}
else {
flattenFiles.push(file);
c();
}
}, function () {
async.mapSeries(flattenFiles, function (file, c) {
var cw = function (err, data) {
c(null, {data: data, err: err});
};
var ext = self.concatConfig.ext && self.concatConfig.ext[file];
if (ext) {
if (self.repos[ext.repo]) {
self.getExternalFile(self.repos[ext.repo], ext.uri, cw);
}
else {
c(null, {data: self.wrapOrigin(file, ''), err: ext.repo + ' doesn\'t exits'});
}
}
else if (self.concatConfig.pkg[file] && file !== filePath) {
self.concatFile(file, cw);
}
else {
self.readFile(self.enableSourceMap && !enableSourceMap ? file.replace(rCoffee, '.js') : file, cw);
}
}, function (err, result) {
var wholeData = result.map(function (item) {return item.data;}).join('\n');
var wholeErr = result.filter(function (item) {return item.err;}).map(function (item) {return item.err;});
if (enableSourceMap) {
self.compileCoffee(wholeData, {
bare: false,
sourceMap: true,
sourceFiles: [path.basename(filePath)]
}, function (err, data) {
if (err) {
wholeErr.push(filePath + ' has coffee errors.');
}
else {
var sourceMapURL = filePath.replace(rCoffee, '.map');
wholeData = data.js;
wholeData = '//# sourceMappingURL=' + path.basename(sourceMapURL) + '\n' + wholeData;
fsp.writeFileSync(path.join(self.repoPath, '.gsproxy', sourceMapURL), data.v3SourceMap);
}
callback(wholeErr.join('\n'), wholeData);
});
}
else {
callback(wholeErr.join('\n'), wholeData);
}
});
});
},
it('can get the latest record', function (done) {
var indexes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
async.eachSeries(indexes, function (index, eachCallback) {
meshInstance.exchange.data.set('movie/family/' + index,
{name: 'the black stallion', genre: 'family'},
eachCallback);
}, function (e) {
if (e) return callback(e);
var options = {
sort: {"_meta.created": -1},
limit: 1
}
var criteria = {
"genre": "family"
}
var latestResult;
meshInstance.exchange.data.get('movie/*', {criteria: criteria, options: options},
function (e, result) {
if (e) return done(e);
result.length.should.eql(1);
latestResult = result[0];
expect(latestResult._meta.created).to.not.be(null);
expect(latestResult._meta.created).to.not.be(undefined);
meshInstance.exchange.data.get('movie/family/*',
function (e, result) {
if (e) return callback(e);
for (var resultItemIndex in result) {
var resultItem = result[resultItemIndex];
expect(resultItem._meta.created).to.not.be(null);
expect(resultItem._meta.created).to.not.be(undefined);
if ((resultItem._meta.path != latestResult._meta.path) && resultItem._meta.created > latestResult._meta.created)
return done(new Error('the latest result is not the latest result...'));
}
done();
});
});
});
});
this.checkBootstrapNode(model, function (err) {
if (err) {
core.emitter.emit('error', err);
return;
}
if (core.nodeInstance != undefined && core.nodeInstance != null) {
// given model is defined and not null
core.deployModel = core.cloner.clone(model, true);
core.deployModel.setRecursiveReadOnly();
var diffSeq = core.compare.diff(core.currentModel, core.deployModel);
var adaptations = core.nodeInstance.processTraces(diffSeq.traces, core.deployModel);
// list of adaptation commands retrieved
var cmdStack = [];
// executeCommand: function that save cmd to stack and executes it
var executeCommand = function executeCommand(cmd, iteratorCallback) {
// save the cmd to be processed in a stack using unshift
// in order to add the last processed cmd at the beginning of the array
// => cmdStack[0] = more recently executed cmd
cmdStack.unshift(cmd);
// execute cmd
cmd.execute(function (err) {
if (err) {
iteratorCallback(err);
return;
}
// adaptation succeed
iteratorCallback();
});
};
// rollbackCommand: function that calls undo() on cmds in the stack
var rollbackCommand = function rollbackCommand(cmd, iteratorCallback) {
cmd.undo(function (err) {
if (err) {
iteratorCallback(err);
return;
}
// undo succeed
iteratorCallback();
});
};
// execute each command synchronously
async.eachSeries(adaptations, executeCommand, function (err) {
if (err) {
// something went wrong while processing adaptations
core.log.error(err.message);
// rollback process
async.eachSeries(cmdStack, rollbackCommand, function (er) {
if (er) {
// something went wrong while rollbacking
core.log.error(er.message);
core.emitter.emit('error', new Error("Something went wrong while rollbacking..."));
return;
}
// rollback succeed
core.emitter.emit('rollback');
return;
});
core.emitter.emit('error', new Error("Something went wrong while processing adaptations. Rollback"));
return;
}
// adaptations succeed : woot
core.log.debug("Model deployed successfully.");
// save old model
pushInArray(core.models, core.currentModel);
// set new model to be the current deployed one
core.currentModel = model; // do not give core.deployModel here because it is a readOnly model
// reset deployModel
core.deployModel = null;
// all good :)
core.emitter.emit('deployed', core.currentModel);
return;
});
} else {
core.emitter.emit('error', new Error("There is no instance to bootstrap on"));
return;
}
});
Spider.prototype.crawler = function(){
var self = this;
var urlLevels = [];
console.log('程序执行中');
async.eachSeries(this.config.selector,function(item,callback){
var index = self.config.selector.indexOf(item);
//第一层获取链接
if(index === 0){
urlLevels[0] = [];
var i = self.config.from;
async.whilst(function(){
return i <= self.config.to;
},function(_callback){
//urlLevls.push(this.config)
self.request(self.rootUrl(i),function(status,$){
if(status){
var $$ = eval(item.$);
//console.log($$);
$$.each(function(){
var nextUrl = $(this).attr(item.attr);
//console.log(nextUrl);
if (!/^http:\/\//i.test(nextUrl)) {
nextUrl = self.rootsite + nextUrl;
if(self.config.isImagePage){
self.request(nextUrl,function(_status,_$){
var $$$ = _$;
var s_first = $$$('.page-show').children().eq(0);
var s_last = $$$('.page-show').children().last();
if(_status){
var first = s_first.hasClass('prev') ? s_first.next().text() : s_first.text();
var last = (s_last.hasClass('next') ? s_last.prev().text() : s_last.text()).replace('..','');
var s_from = first;
async.whilst(function(){
return s_from <= last;
},function(cb){
var s_url = url.resolve(self.rootsite, nextUrl.replace('.htm', '') + s_from + '.htm');
if(s_from <= 1){
//console.log(s_from);
s_url = url.resolve(self.rootsite, nextUrl);
}
//var s_url = nextUrl.replace('.htm','')+s_from+'.htm';
urlLevels[0].push(s_url);
//console.log('----------------------' + s_url);
++s_from;
cb();
})
}
})
}else{
urlLevels[0].push(nextUrl);
}
}
//console.log(urlLevels);
});
}
setTimeout(function () {
++i;
_callback(null);
}, parseInt(Math.random() * 5000));
});
}, function (err) {
if (err) {
console.log(err);
} else {
console.log('分页处理完成，共收集到了' + urlLevels[0].length);
}
console.log(urlLevels[0]);
//console.log(urlLevels);
callback(null);
})
}else if(index === self.config.selector.length - 1){//获取图片链接
//console.log(urlLevels[0]);
self.images(urlLevels[index-1]);
}
},function(err){
if(err){
}
})
}
var seedDislikedReviews = function(seedData, job, next) {
sails.log.debug("seeding associations: User:DislikedReviews:Review");
async.eachSeries(seedData.dislikedReview.results, function(entry, next){
var reviewLeanId = entry.relatedId;
var userLeanId = entry.owningId;
var username = null;
var reviewCourse = null;
var reviewProf = null;
var reviewAuthor = null;
var reviewFound = null;
var userFound = null;
seedData.user.results.forEach(function(item, index, arr){
if (item.objectId == userLeanId) {
username = item.username;
}
});
seedData.review.results.forEach(function(item, index, arr){
if (item.objectId == reviewLeanId) {
reviewCourse = item.courseName;
reviewProf = item.profName;
var authorLeanId = item.authorId.objectId;
seedData.user.results.forEach(function(item, index, arr){
if (item.objectId == authorLeanId) {
reviewAuthor = item.username;
}
});
}
});
Review.findOne({
include: [
{
model: User, as: 'Author',
where: {username: reviewAuthor}
}, {
model: Course, as: 'Course',
where: {name: reviewCourse}
}, {
model: Prof, as: 'Prof',
where: {name: reviewProf}
}
]
})
.then((results)=> {
reviewFound = results;
return User.findOne({where:{
username: username
}})
})
.then((results)=> {
userFound = results;
if (reviewFound && userFound) {
sails.log.info("seeded relation " + ": " + username
+ ": " + reviewCourse + ": " + reviewProf + ":" + reviewAuthor);
userFound.addDislikedReview(reviewFound);
}
next();
})
.catch(function(err){
if (err) {
sails.log.info("seeded relation " + ": " + username
+ ": " + reviewCourse + ": " + reviewProf + ":" + reviewAuthor);
sails.log.error("error", err);
}
next();
});
}, function (err) {
if (err) sails.log.error("error", err.errors);
sails.log.debug("seeded relation: User:DislikedReviews:Review");
job.progress(8, 10);
next();
});
};
connectionStore.query('SET NAMES utf8', function() {
var count = 0;
async.eachSeries(Ready, function(r, next) {
// ポイント加算処理・メール送信
if (r.customer_type == 0) { // store
connectionStore.query('SELECT name01, name02, email FROM dtb_customer WHERE customer_id = ?', [
r.customer_id
], function(error, results, fields) {
if (error) {
console.error(error);
console.error('Failed getting email address!');
process.exit(1);
} else {
// ポイント加算顧客情報
var name = results[0].name01 + ' ' + results[0].name02;
var email = results[0].email;
console.log('UPDATE (id = ' + r.id + ')');
connectionStore.query('UPDATE dtb_customer SET point = point + ? WHERE customer_id = ?', [
r.point_total, r.customer_id
], function(error, results, fields) {
if (error) {
console.error(error);
console.error('Failed updating point!');
process.exit(1);
} else {
console.log('Succeeded updating point!');
connection.query('UPDATE winners SET appended_at = NOW() WHERE appended_at IS NULL AND user_id = ?', [
r.user_id
], function(error, results, fields) {
if (error) {
console.error(error);
process.exit(1);
} else {
count++;
// メール送信
console.log(name);
console.log(email);
console.log(r.season);
console.log(r.events_name.join('-'));
console.log(r.point_total);
var command = '/usr/bin/php ' + __dirname + '/send-winners.php'
+ ' "' + email + '"'
+ ' "' + name + '"'
+ ' "' + r.season + '"'
+ ' "' + r.events_name.join('-') + '"'
+ ' ' + r.point_total;
exec(command, function(err, stdout, stderr) {
if (err) {
console.error(err);
} else {
//console.log(stdout);
console.error(stderr);
setTimeout(function() {
next();
}, 1000);
}
});
}
});
}
});
}
});
} else {
// triboxstickers
console.error('Not implemented yet! (triboxstickers)');
process.exit(1);
}
}, function(err) {
if (!err) {
console.log('Completed! (' + count + ' records)');
process.exit(0);
} else {
console.error(err);
}
});
});
var seedKelists = function(seedData, job, next) {
sails.log.debug("seeding Kelists");
async.eachSeries(seedData.likedCourse.results, function(entry, next){
var courseLeanId = entry.relatedId;
var userLeanId = entry.owningId;
var username = null;
var courseName = null;
var courseProf = null;
var courseFound = null;
var userFound = null;
seedData.user.results.forEach(function(item, index, arr){
if (item.objectId == userLeanId) {
username = item.username;
}
});
seedData.course.results.forEach(function(item, index, arr){
if (item.objectId == courseLeanId) {
courseName = SeedUtil.replaceRoman(item.name);
courseProf = item.prof;
}
});
Course.findOne({
where: {name: courseName},
include: [
{
model: Prof, as: 'Prof',
where: {name: courseProf}
}
]
})
.then((results)=> {
courseFound = results;
return User.findOne({where:{
username: username
}})
})
.then((results)=> {
userFound = results;
return userFound.getOwnsKelists({
where: {category: 'default_liked_courses'}
});
})
.then((results)=> {
sails.log.info("seeded kelist " + ": " + username
+ ": " + courseName + ": " + courseProf);
var kelist = results[0];
kelist.addCourse(courseFound);
next();
})
.catch(function(err){
if (err) {
sails.log.error("error", err);
}
next();
});
}, function (err) {
if (err) sails.log.error("error", err.errors);
sails.log.debug("seeded kelists");
job.progress(7, 10);
next();
});
};
var seedReviews = function(userData, reviewData, job, next) {
sails.log.debug("seeding review");
async.eachSeries(reviewData.results, function(entry, next){
var reviewCreated = null;
var courseFound = null;
var profFound = null
var review = {};
//must
review.text = entry.comment;
review.professional = entry.rating.rate1;
review.expressive = entry.rating.rate2;
review.kind = entry.rating.rate3;
//optional: exam data
review.hasExam = entry.exam.touched;
if (review.hasExam) {
review.examprep = entry.exam.examprep.checked;
review.openbook = entry.exam.openbook.checked;
review.oldquestion = entry.exam.oldquestion.checked;
review.easymark = entry.exam.easiness.checked;
}
//optional: secondary data
review.rateAttend = entry.attendance.value + 1;
review.rateBirdy = entry.bird.value + 1;
review.rateHomework = entry.homework.value + 1;
review.rateExam = 0;
if (entry.exam.difficulty && entry.exam.difficulty.value
&& entry.exam.difficulty.value > 0) {
review.rateExam = entry.exam.difficulty.value;
} else if (review.hasExam) {
review.rateExam = SeedUtil.getRateExam({
examprep: review.examprep,
openbook: review.openbook,
oldquestion: review.oldquestion,
easymark: review.easymark
})
}
//optional: upvote/downvote
review.downVote = entry.downVote;
review.upVote = entry.upVote;
//date
review.createdAt = entry.createdAt;
review.updatedAt = entry.updatedAt;
//additional parsing
entry.courseName = SeedUtil.replaceRoman(entry.courseName);
Review.create(review)
.then(function(newReview){
reviewCreated = newReview;
var authorLeancloudId = entry.authorId.objectId;
var authorName = null;
userData.results.forEach(function(item, index, arr){
if (item.objectId == authorLeancloudId) {
authorName = item.username;
}
});
return User.findOne({where: {"username": authorName}})
})
.then(function(userFound){
return userFound.addReview(reviewCreated);
})
.then(()=> {
return Prof.findOne({
where: {"name": entry.profName}
})
})
.then((results)=> {
profFound = results
return profFound.addReview(reviewCreated);
})
.then(function(){
return Course.findOne({
where: {"name": entry.courseName},
include: [{
model: Prof, as: 'Prof',
where: {
name: entry.profName
}
}]
});
})
.then(function(results){
courseFound = results;
if (!courseFound) {
sails.log.error("Found no course with same prof as review");
sails.log.error("course name", entry.courseName );
sails.log.error("review prof", entry.profName);
} else {
return courseFound.addReview(reviewCreated);
}
})
.then(() => {
return CourseStatService.updateStat(courseFound)
})
.then(() => {
return ProfStatService.updateStat(profFound)
})
.then(()=> {
var tagsArray = entry.tags;
return Promise.all(tagsArray).map((tag)=> {
tagName = tag.value;
var tagFound = null;
var tagFoundId = null;
var profFound = null;
return Tag
.findOne({where: {"name": tagName }})
.then((results)=> {
tagFound = results;
tagFoundId = tagFound.get('id');
return Prof.findOne({where: {name: entry.profName}});
})
.then((results)=> {
profFound = results;
return profFound.addTag(tagFound);
})
.then(()=> {
return profFound.getTags({where: {"id": tagFoundId}});
})
.then((profTags)=> {
return profTags[0].Join_Item_Tag.increment({'count': 1});
})
.then(()=> {
return reviewCreated.addTag(tagFound);
})
.then(()=> {
return courseFound.addTag(tagFound);
})
.then(()=> {
return courseFound.getTags({where: {"id": tagFoundId}});
})
.then((courseTags)=> {
return courseTags[0].Join_Item_Tag.increment({'count': 1});
})
.catch((err)=> {
if (err) {
sails.log.error("error", err.errors);
}
});
});
})
.then(()=> {
return Review.count();
})
.then((reviewCount)=> {
sails.log.info("seeded review " + reviewCount + ": " + entry.profName + ": " + entry.courseName);
next();
})
.catch((err)=> {
if (err) {
sails.log.error("course name", entry.courseName );
sails.log.error("prof name", entry.profName);
sails.log.error("review", review);
sails.log.error("error", err);
}
next();
});
}, (err)=> {
if (err) sails.log.error("error", err);
sails.log.debug("seeded table: reviews");
job.progress(6, 10);
next();
});
};
var seedCourses = function(courseData, job, next) {
sails.log.debug("seeding course");
async.eachSeries(courseData.results, function(entry, next){
var courseCreated = null;
var statCreated = null;
var course = {};
var stat = {};
// course core
course.name = SeedUtil.replaceRoman(entry.name);
course.isElective = (entry.isElective) ? entry.isElective : null;
course.audience = (entry.audience) ? entry.audience : null;
// stats core
stat.professional = entry.rate1;
stat.expressive = entry.rate2;
stat.kind = entry.rate3;
stat.scoreOverall = entry.rateOverall;
stat.countReview = entry.reviewCount;
stat.countGoodReview = entry.reviewGoodCount;
// stats secondary
stat.countHomework = entry.homeworkCount;
stat.rateHomework = entry.homeworkOverall;
stat.countAttend = entry.attendanceCount;
stat.rateAttend = entry.attendanceOverall;
stat.countExam = entry.examCount;
stat.rateExam = entry.examOverall;
stat.countBird = entry.birdCount;
stat.rateBird = entry.birdOverall;
stat.followerCount = 0;
Course.create(course)
.then(function(results){
courseCreated = results;
return School.findOne({ where: {"name": SCHOOL_NAME}});
})
.then(function(school){
school.addCourse(courseCreated);
return Dept.findOne({where: {"shortname": entry.dept}});
})
.then(function(dept){
if (dept) {
dept.addCourse(courseCreated);
}
return Prof.findOne({where: {"name": entry.prof}});
})
.then(function(prof){
if (prof) {
prof.addCourse(courseCreated);
} else {
//create prof if not found
Prof.create({name: entry.prof})
.then(function(newProf){
newProf.addCourse(courseCreated);
});
}
return CourseStat.create(stat);
})
.then(function(newStat){
statCreated = newStat;
courseCreated.setStat(statCreated);
return Course.count();
})
.then(function(countCourse){
sails.log.info("seed course " + countCourse + ": " + entry.prof + ": " + entry.name);
next();
})
.catch(function(err){
if (err) sails.log.error("error", err);
next();
});
}, function (err) {
if (err) sails.log.error("error", err);
sails.log.debug("seeded: courses");
job.progress(5, 10);
next();
});
};
}, function(err) {
if (err) return callback(err);
async.eachSeries(Object.getOwnPropertyNames(commitObjects),
async.seq(
function createTempFile(doubleHash, next) {
// make sure it exists
var hashes = doubleHash.split('-');
if ((hashes[0] == '0000000000000000000000000000000000000000') || (hashes[1] == '0000000000000000000000000000000000000000'))
return next(null, doubleHash, null);
var filename = path.basename(hashes[2]),
dirname = path.dirname(hashes[2]);
if (dirname == '.')
dirname = '';
else
dirname += '/';
var fileHash = fileInfo.treeInfos[dirname][filename].objectHash;
exec('git', ['unpack-file', fileHash], { cwd: workingDir },
function(err, stdout, stderr) {
if (err) return next(err);
var tempFile = stdout.trimRight();
commitObjects[doubleHash].tempFile = tempFile;
tempFiles.push(tempFile);
next(null, doubleHash, tempFile);
});
},
function patchTempFile(doubleHash, tempFile, next) {
var args = ['-u', '-F', '3'];
if (tempFile == null) {
var hash = doubleHash.split('-')[1];
if (hash == '0000000000000000000000000000000000000000')
return next(null, doubleHash, null);
tempFile = '.merge_file_' + hash.substr(0, 8);
tempFiles.push(tempFile);
args.push('-o');
}
args.push(tempFile);
var patch = spawn('patch', args, { cwd: workingDir }),
stdout = '',
stderr = '';
patch.stderr.on('data', function(buffer) {
stderr += buffer.toString();
});
patch.stdout.on('data', function(buffer) {
stdout += buffer.toString();
});
patch.on('close', function(code) {
if (code == 0)
next(null, doubleHash, tempFile);
else
next(new Error(stderr != '' ? stderr : stdout));
});
patch.stdin.end(commitObjects[doubleHash].diffs.join('\n') + '\n', 'binary'); // new line IMPORTANT for patch
},
function saveOrDeleteTempFile(doubleHash, tempFile, next) {
var newFilename = getNewFilename(commitObjects[doubleHash].diffs[0]);
if (newFilename == null && tempFile == null) { // DELETE
newFilename = getOldFilename(commitObjects[doubleHash].diffs[0]);
removeObjectFromTree(newFilename, fileInfo, next);
return;
}
createHashObjectFromFile(workingDir, tempFile, function(err, hash) {
if (err) return next(err);
commitObjects[doubleHash].fileHash = hash;
injectHashObjectIntoTree(newFilename, hash, fileInfo.treeInfos);
next(null);
});
}
), function(err) {
removeTempFiles(tempFiles, workingDir);
if (err) return callback(err);
async.waterfall([
createTrees.bind(null, workingDir, fileInfo),
createCommit.bind(null, workingDir, commitInfo, message),
], callback);
});
});
function walkTree (dir, tree, done) {
async.eachSeries(_.keys(tree), function (key, next) {
console.log('* ' + pt.relative(sourceDir, dir).replace(/\//g, '.'), key)
walkClass(dir, tree[key], key, next)
}, done)
}
this.GetOpeningTimes = function(callback) {
// check we've been configured correctly
if (!self.calendar_URL || !self.calendar_VStarget) return self.Error("Orlando Park ID calendar " + self.park_id + " not configured.", null, callback);
// get today's date in local time and the ending date for our schedule fetch
var today = moment().tz(self.park_timezone);
var endDay = moment().add(self.scheduleMaxDates, 'days').tz(self.park_timezone);
// So. Orlando's calendar page uses ASPX ViewStates etc, and seems to have an encrpyted view state.
// Rather than try to interfere with that, I'm just sending POST data directly and letting the server
// create us a Viewstate and generally side-stepping that pain.
// The POST data needs two keys to update the viewstate:
// __EVENTTARGET: "UniversalStudiosFloridaCalendar$ECalendar" (or similar)
// __EVENTARGUMENT: Z[number of days to start of the month from 2000-01-01]
var Y2K = moment("2000-01-01", "YYYY-MM-DD");
// get today's date and the current month
var requestStart = moment.range(Y2K, moment(today.format("YYYY-MM"), "YYYY-MM")).diff("days");
// get formatted end date for fetching
var requestEnd = moment.range(Y2K, moment(endDay.format("YYYY-MM"), "YYYY-MM")).diff("days");
// get list of month calendars to process (either just this month, or this month and next)
var todo = [requestStart];
if (requestEnd != requestStart) {
todo.push(requestEnd);
}
var schedule = [];
var startDateFound = false;
async.eachSeries(todo, function(calendarMonth, callback) {
var requestObj = {
url: self.calendar_URL,
headers: {
"User-Agent": self.useragent
},
method: "POST",
formData: {
__EVENTTARGET: self.calendar_VStarget,
__EVENTARGUMENT: "V" + calendarMonth,
}
};
self.Dbg("Fetching...", requestObj);
request(requestObj, function(err, resp, body) {
if (err) return self.Error("Error fetching calendar page", err, callback);
// parse returned HTML
self.ParseCalendar(body, function(err, data) {
if (err) return self.Error("Failed to parse calendar page HTML", err, callback);
// loop through returned dates
for (var i = 0, date; date = data[i++];) {
// don't start adding to return object until we find our start date value
if (!startDateFound && !schedule.length) {
if (!moment(date.date).isSameOrAfter(today, "day")) continue;
startDateFound = true;
}
// add to returned schedule
schedule.push(date);
if (moment(date.date).isSameOrAfter(endDay, "date")) {
// reached desired end date, return
return callback(null);
}
}
// not reached end date yet, return for next async series to process
return callback(null);
});
});
}, function(err) {
self.Dbg("FDSAfdsfds");
if (err) return self.Error("Failed to fetch calendar data", err, callback);
return callback(null, schedule);
});
};
function updateCache(match, cb)
{
if (enabled)
{
var players = match.players;
if (match.pgroup && players)
{
players.forEach(function(p)
{
//add account id to each player so we know what caches to update
p.account_id = match.pgroup[p.player_slot].account_id;
//add hero_id to each player so we update records with hero played
p.hero_id = match.pgroup[p.player_slot].hero_id;
});
}
async.eachSeries(players, function(player_match, cb)
{
if (player_match.account_id && player_match.account_id !== constants.anonymous_account_id)
{
readCache(player_match.account_id,
{}, function(err, cache)
{
if (err)
{
return cb(err);
}
//if player cache doesn't exist, skip
if (cache)
{
//join player with match to form player_match
for (var key in match)
{
player_match[key] = match[key];
}
computePlayerMatchData(player_match);
if (cEnabled)
{
writeCache(player_match.account_id,
{
raw: [player_match]
}, cb);
}
else
{
cache.aggData = aggregator([player_match], null, cache.aggData);
writeCache(player_match.account_id, cache, cb);
}
}
else
{
return cb();
}
});
}
else
{
return cb();
}
}, cb);
}
else
{
return cb();
}
}
var ARTICLE_PATH = './articles';
fs.readdirSync(ARTICLE_PATH).forEach(function (f) {
fs.unlinkSync(path.resolve(ARTICLE_PATH, f));
});
var renderArticle = tinyliquid.compile(fs.readFileSync('_article.html', 'utf8'));
async.eachSeries(list, function (item, next) {
var c = tinyliquid.newContext({locals: item});
renderArticle(c, function (err, html) {
if (err) return next(err);
fs.writeFileSync(path.resolve(ARTICLE_PATH, item.name + '.html'), html);
next();
});
}, function (err) {
if (err) throw err;
// 生成首页
var renderIndex = tinyliquid.compile(fs.readFileSync('_home.html', 'utf8'));
var c = tinyliquid.newContext();
c.setLocals('articles', list);
renderIndex(c, function (err, html) {
if (err) throw err;
fs.writeFileSync('index.html', html);
});
});
Species.find({where: filter}, function(err, all_species){
if (err) throw new Error(err);
var list_of_items = [];
async.eachSeries(all_species, function(species, callback1){
var identification_item = {};
identification_item.id = species.id;
identification_item["states"] = [];
async.forEachOfSeries(species, function(item, key, callback2){
if (species.hasOwnProperty(key) && species[key] && species[key].term != "pollenShape" && (species[key].class == "CategoricalDescriptor" || species[key].class == "NumericalDescriptor") && species[key].term != "espexi"){
//TODO: handle pollenShape and espexi
// we only want entries with classes CategoricalDescriptor or NumericalDescriptor
// we can have multiple states
var entry = {
language: species[key].language,
id: species[key].id,
order: species[key].order,
schema: species[key].schema,
class: species[key].class,
term: species[key].term,
category: species[key].category,
descriptor: species[key].field
};
if(species[key].states){
entry.states = [];
async.eachSeries(species[key].states, function(state, callback3){
var entry_state = {value:state.state, order:state.order, id:state.id};
entry.states.push(entry_state );
callback3();
}, function(err){
if (err) throw new Error(err);
identification_item["states"].push(entry);
callback2();
});
} else if (species[key].numerical){
entry.numerical = species[key].numerical;
identification_item["states"].push(entry);
callback2();
} else {
identification_item["states"].push(entry);
callback2();
}
} else callback2();
}, function(err){
if (err) throw new Error(err);
list_of_items.push(identification_item);
callback1();
});
}, function(err) {
if (err) throw new Error(err);
mongoDs.automigrate('Identification', function(err){
if (err) throw new Error(err);
Identification.upsert(list_of_items, function(err, results){
if (err) throw new Error(err);
callback(null, list_of_items.length);
});
});
});
});
function processCard(SET, card, callback) {
if (!allCardsWithExtras.hasOwnProperty(card.name)) {
allCardsWithExtras[card.name] = {};
}
if(!previousSeenSetCodes.hasOwnProperty(card.name))
previousSeenSetCodes[card.name] = {};
var checkTaint = function(fieldName, fieldValue) {
if (ignoredSets.indexOf(SET.code) >= 0)
// ignore un-sets.
return;
if (!fieldValue) {
if (card.hasOwnProperty(fieldName))
fieldValue = card[fieldName];
}
// Do nothing if we do not have a previous value.
if (!allCardsWithExtras[card.name].hasOwnProperty(fieldName))
return;
var previousValue = allCardsWithExtras[card.name][fieldName];
var taint = false;
var diff = null;
if (previousValue) {
if (!fieldValue) {
taint = true;
}
else {
try {
const a = readyToDiff(previousValue);
const b = readyToDiff(fieldValue);
diff = ansidiff.words(a, b);
} catch (e) {
console.error('error on ansidiff.words.');
console.error('parameters:');
console.error(previousValue);
console.error(fieldValue);
console.error(e);
}
}
if (diff) {
taint = true
}
}
if (taint) {
taintedCards.push({ card: card, fieldName: fieldName });
winston.info("Tainted field %s on card '%s' (%s)", fieldName, card.name, SET.code);
if (diff)
winston.info(diff);
}
};
async.eachSeries(
Object.keys(C.FIELD_TYPES),
function(fieldName, subcb) {
if (C.SET_SPECIFIC_FIELDS.includes(fieldName)) {
setImmediate(subcb);
return;
}
if (!previousSeenSetCodes[card.name].hasOwnProperty(fieldName))
previousSeenSetCodes[card.name][fieldName] = [];
var fieldValue = card[fieldName];
if (fieldName === "imageName") // Modify for AllCards.json the imageName field
fieldValue = card.name.toLowerCase().replace(new RegExp(":\"?", "g"), "").replace(new RegExp("/", "g"), " ").replace(new RegExp("^[0-9 \.]+|[0-9 \.]+$", "g"), "").replace(new RegExp(" token card", "g"), "");
if (C.ORACLE_FIELDS.includes(fieldName) && fieldName !== 'foreignNames') {
checkTaint(fieldName, fieldValue);
}
previousSeenSetCodes[card.name][fieldName].push(SET.code);
allCardsWithExtras[card.name][fieldName] = fieldValue;
setImmediate(subcb);
},
callback
);
}
function (currentMembers, next) {
async.eachSeries(currentMembers, function (member, next) {
groups.leave('cid:' + toCid + ':privileges:' + privilege, member, next);
}, next);
},
fixConflicts: function(noteSyncInfo, callback) {
var me = this;
var conflictNotes = noteSyncInfo.conflicts;
console.log('fix note conflicts');
console.log(conflictNotes);
// 这里为什么要同步? 因为fixConflicts后要进行send changes, 这些有冲突的不能发送changes
conflictNotes || (conflictNotes = []);
if(!Api) {
Api = require('api')
}
async.eachSeries(conflictNotes, function(serverAndLocalNote, cb) {
// var noteId = note.NoteId; // 本地noteId
// 复制一份, 本地的复制一份, 然后服务器上的替换本地的
// newNote其实是现有的复制一份得到的
// TODO, 这里, 如果内容是一样的, 则以服务器上的版为准
console.error('是否真的冲突');
var serverNote = serverAndLocalNote.server; // noteId没有转换的
var localNote = serverAndLocalNote.local; // 本地的note
Api.getNoteContent(serverNote.NoteId, function(noteContent) {
// 同步到本地
if(Common.isOk(noteContent)) {
var serverContent = me.fixNoteContent(noteContent.Content); // 图片, 附件的链接
// var serverContent = noteContent.Content; // 图片, 附件的链接
// console.error(serverContent);
// console.error(localNote.Content);
// 没有冲突, 好, 用服务器端的其它值
if(serverContent == localNote.Content) {
console.error(localNote.Title + ' 无冲突');
// console.log(serverNote);
delete serverNote['Content'];
delete serverNote['Abstract'];
delete serverNote['Desc'];
me.updateNoteForce(serverNote, function(updatedNote) {
// 作为更新
noteSyncInfo.updates.push(updatedNote);
cb();
}, false);
}
// 不行, 冲突了, 复制一份
// TODO 用新的Content, 不要再去取了
else {
me.copyNoteForConfict(localNote.NoteId, function(newNote) {
if(newNote) {
// 更新之前的
serverNote.ServerNoteId = serverNote.NoteId;
serverNote.NoteId = localNote.NoteId;
me.updateNoteForceForConflict(serverNote, function(note2) {
if(note2) {
// 前端来处理, 全量sync时不用前端一个个处理
Web.fixSyncConflictNote(note2, newNote);
}
cb();
});
} else {
cb();
}
});
}
}
});
}, function() {
// 最后调用
callback && callback();
// 因为在处理冲突的时候有些成为更新了, 所以必须在此之后调用
console.log('has updates...');
console.log(noteSyncInfo.updates);
// 处理更新的
Web.updateSyncNote(noteSyncInfo.updates);
});
// 发送改变的冲突
// 复制一份
// 发送改变的冲突, 有这种情况发生吗?
var changeConflicts = noteSyncInfo.changeConflicts;
console.log('changeConflicts');
console.log(changeConflicts);
for(var i in changeConflicts) {
(function(i) {
var note = changeConflicts[i]; // note是本地的note
// 复制一份
me.copyNoteForConfict(note.NoteId, function(newNote) {
if(newNote) {
// 更新之前的, 要先从服务器上得到服务版的
// 这里的note是本地的, 所以将服务器上的覆盖它
if(!Api) {
Api = require('api');
}
Api.getNote(note.ServerNoteId, function(serverNote) {
serverNote.ServerNoteId = serverNote.NoteId;
serverNote.NoteId = note.NoteId;
console.error("changeConflicts -> get note from server");
console.log(serverNote);
console.log(note);
me.updateNoteForceForConflict(serverNote, function(note2) {
if(!note2) {
// 前端来处理, 全量sync时不用前端一个个处理
Web.fixSyncConflict(note2, newNote);
}
});
});
} else {
}
});
})(i);
}
// 服务器没有, 但是是发送更新的, 所以需要作为添加以后再send changes
if(noteSyncInfo.changeNeedAdds) {
var needAddNotes = noteSyncInfo.changeNeedAdds;
for(var i in needAddNotes) {
console.log('need add ');
var note = needAddNotes[i];
me.setIsNew(note.NoteId);
}
}
// 处理添加的
var addNotes = noteSyncInfo.adds;
console.log('has add...');
console.log(addNotes);
Web.addSyncNote(addNotes);
// 处理删除的
Web.deleteSyncNote(noteSyncInfo.deletes);
// 为了博客
var changeAdds = noteSyncInfo.changeAdds || [];
var changeUpdates = noteSyncInfo.changeUpdates || [];
changeAdds = changeAdds.concat(changeUpdates);
Web.updateNoteCacheForServer(changeAdds);
},
$eachSeries: function(list, tasks, callback) {
tasks = this._createFunc(tasks);
callback = this._createCb(callback);
async.eachSeries(list, tasks, callback);
},
parser1.parseString(data, function (err, result) {
var arr = result.Places.Place;
var objArray = new Array();
for(var i=0; i<arr.length; i++) {
var obje = arr[i]['$'];
objArray.push(obje);
}
/* For each place read, create its reference to placetypes*/
async.eachSeries(objArray, placeInsert, function(err) {
async.waterfall([
function(callback) {
sys.log("started");
callback(null,'Initialized!');
},
/*Sporttypes inserted in an upsert manner.*/
function(arg1, callback) {
console.log(arg1);
var parser1 = new xml2js.Parser();
fs.readFile(__dirname + '/sporttypes.xml', function(err, data) {
parser1.parseString(data, function (err, result) {
var arr = result.SportTypes.SportType;
for(var i=0; i<arr.length; i++) {
var obje = arr[i]['$'];
SportType.update({
sportTypeId : obje.sportTypeId
},{
sportTypeId : obje.sportTypeId,
name: obje.name
},{
upsert: true
}, function(err, data) {
var parser1 = new xml2js.Parser();
fs.readFile(__dirname + '/organizations.xml', function(err, data) {
parser1.parseString(data, function (err, result) {
var arr = result.Organizations.Organization;
for(var i=0; i<arr.length; i++) {
var obje = arr[i]['$'];
Organization.update({
orgId : obje.orgId
},{
orgId : obje.orgId,
name: obje.name
},{
upsert: true
}, function(err, data) {});
}
});
});
});
}
});
});
callback(null,'SportTypes Inserted!');
},
function(arg1, callback) {
console.log(arg1);
var parser1 = new xml2js.Parser();
fs.readFile(__dirname + '/teams.xml', function(err, data) {
parser1.parseString(data, function (err, result) {
var arr = result.Teams.Team;
var objArray = new Array();
for(var i=0; i<arr.length; i++) {
var obje = arr[i]['$'];
objArray.push(obje);
}
async.eachSeries(objArray, teamInsert, function(err) {
var parser1 = new xml2js.Parser();
fs.readFile(__dirname + '/events.xml', function(err, data) {
parser1.parseString(data, function (err, result) {
var arr = result.Events.Event;
var objArray = new Array();
for(var i=0; i<arr.length; i++) {
var obje = arr[i]['$'];
objArray.push(obje);
}
async.eachSeries(objArray, eventInsert, function(err) {
if(err)
sys.log(err);
sys.log("Events finished");
res.send("Events finished");
});
});
});
//sys.log("team finished");
});
});
});
callback(null,'Teams Inserted!');
}
],
function (err, caption) {
console.log('Teams finished!!!!');
}
);
});
});
it('projects', function (done) {
var process = function (proj, done) {
var user = conf.users[proj.owner];
// sub-functions to create comments
var createComments = function (comments, parentId, done) {
var request = utils.init();
var processComment = function (comment, done) {
var user = conf.users[comment['user']];
utils.login(request , user.username, user.password, function (err) {
if (err) return done(err);
comment.projectId = proj.id;
if (parentId) {
comment.parentId = parentId;
}
utils.comment_create(request, comment, function (err, commentObj) {
if (err) return done(err);
comment.obj = commentObj;
comment.id = commentObj.id;
if (comment.children) {
createComments(comment.children, comment.id, function (err) {
done(err);
})
} else {
done();
}
});
});
};
async.eachSeries(comments, processComment, function (err) {
done(err);
});
};
var startCover = function (proj, done) {
var request = utils.init();
if (!proj.cover) return done();
utils.login(request, user.username, user.password, function (err) {
if (err) return done(err);
utils.file_create(request, proj.cover, false, function (err, fileObj) {
if (err) return done(err);
proj.coverId = fileObj.id;
utils.proj_put(request, proj, function (err, projObj) {
if (err) return done(err);
proj.obj = projObj;
done(err);
});
});
});
};
var startComments = function (proj, done) {
if (!proj.comments) return done();
createComments(proj.comments, null, done);
};
var startOwners = function (proj, done) {
var request = utils.init();
var createOwner = function (owner, done) {
var pOwner = {
projectId: proj.id,
userId: conf.users[owner].id
};
utils.projowner_create(request, pOwner, function (err, ownerObj) {
owner.obj = ownerObj;
owner.id = ownerObj.id;
done(err);
});
};
if (!proj.owners) return done();
utils.login(request, user.username, user.password, function (err) {
if (err) return done(err);
async.each(proj.owners, createOwner, done);
});
};
var startEvents = function (proj, done) {
var request = utils.init();
var now = new Date();
var createEvent = function (ev, done) {
ev.projectId = proj.id;
ev.start = new Date(now.valueOf());
ev.start.setDate(now.getDate() + Math.ceil(Math.random()*30));
ev.start.setMinutes(0);
ev.start.setSeconds(0);
ev.start.setMilliseconds(0);
ev.end = new Date(ev.start.getTime());
ev.end.setHours(ev.start.getHours() + 1);
ev.start = ev.start.toISOString();
ev.end = ev.end.toISOString();
utils.event_create(request, ev, function (err, eventObj) {
ev.obj = eventObj;
ev.id = eventObj.id;
done(err);
});
};
utils.login(request, user.username, user.password, function (err) {
if (err) return done(err);
async.each(proj.events, createEvent, done);
});
};
var startTasks = function (proj, done) {
var request = utils.init();
var createTask = function (task, done) {
task.projectId = proj.id;
utils.task_create(request, task, function (err, taskObj) {
task.obj = taskObj;
task.id = taskObj.id;
done(err);
});
}
utils.login(request, user.username, user.password, function (err) {
if (err) return done(err);
async.each(proj.tasks, createTask, done);
});
};
var startTags = function (tag, done) {
var request = utils.init();
var createTag = function (tag, done) {
var t = {
tagId: conf.tags[tag].id,
projectId: proj.id
};
utils.tag_create(request, t, function (err, tagObj) {
done(err);
});
};
utils.login(request, user.username, user.password, function (err) {
if (err) return done(err);
async.each(proj.tags, createTag, done);
});
};
var start = function (fn, done) {
fn(proj, done);
};
var order = [startCover, startOwners, startComments, startEvents, startTasks, startTags];
// start processing each project
utils.login(request, user.username, user.password, function (err) {
if (err) return done(err);
utils.proj_create(request, proj, function (err, projObj) {
proj.obj = projObj;
proj.id = projObj.id;
// Process each of the sub functions
async.eachSeries(order, start, function (err) {
done(err);
});
});
});
};
async.eachSeries(conf.projects, process, function (err) {
done(err);
});
});
Status.check = function () {
console.log('Running checks')
currentlyChecking = true
var currentCheckResults = []
async.eachSeries(checks, function (check, callback) {
Status.call(check.host, check.path, function (status, error) {
currentCheckResults.push({ 'server': check.server, 'section': check.section, 'version': check.version, 'status': (error == 'ETIMEDOUT' ? 'warning' : (status ? 'ok' : 'down')) })
callback()
})
}, function (err) {
if (err) {
console.log('Error when checking status: ')
return console.trace(err)
} else {
console.log('Checks successfully executed')
}
var totalErrors = 0
for (var i in currentCheckResults) {
var checkResult = currentCheckResults[i]
if (checkResult.status == 'down') {
totalErrors++
}
stats.servers[checkResult.server][checkResult.version][checkResult.section] = checkResult.status
}
var the_status = 'ok'
if (totalErrors > 3) {
downCount++
} else if (totalErrors > 0) {
the_status = 'warning'
} else {
downCount = 0
}
if (downCount > 4) {
the_status = 'down'
}
currentlyChecking = false
var doRefresh = false
if (stats.status !== 'down' && the_status === 'down') {
stats.status = the_status
Status.sendEmail('BukGet is down!', JSON.stringify(stats, null, 4))
doRefresh = true
} else if (stats.status === 'down' && the_status === 'ok') {
stats.status = the_status
Status.sendEmail('BukGet is back up!', JSON.stringify(stats, null, 4))
doRefresh = true
} else {
stats.status = the_status
}
if (!started) {
started = true
if (!doRefresh) {
console.log('Checking initial DNS consistency')
Status.checkDnsConsistency()
}
}
if (doRefresh) {
console.log('Refreshing DNS for state: %s', stats.status)
Status.dnsRefresh()
}
setTimeout(function () {
Status.check()
}, 1000 * 60)
})
}
function convertElements(elements, html, messages, callback) {
async.eachSeries(elements, function(element, callback) {
return elementToHtml(element, html, messages, callback);
}, callback);
}
fs.readFile('./data/parcels.geojson', 'utf-8', function(err2, contents) {
var data = JSON.parse(contents),
len = data.features.length;
//console.log(len);
for (var i = 0; i < len; i++) {
//console.log(data.features[i].properties.PIN);
queue.push(data.features[i]);
}
queue.push({
done: true
});
async.eachSeries(queue, function(data, callback) {
if (data.done) {
console.log('done');
setImmediate(function() {
callback();
});
} else {
//console.log(data.properties.PIN);
collection.findOne({
_id: data.properties.PIN
}, function(err, result) {
//console.log('result of find being processed');
if (err) {
console.log(err);
setImmediate(function() {
callback();
});
} else {
//console.log('result of find has no error');
if (data.geometry && data.properties.FULLADDR != '0' && data.properties.FULLADDR != null) {
// lets find out if the geometry is valid (ish)
var coords = data.geometry.coordinates,
coordlen = data.geometry.coordinates.length;
//console.log('First geom lats:',geom[0][0], geom[geomlen-1][0]);
//console.log('First geom lngs:',geom[0][1], geom[geomlen-1][1]);
for (var i = 0; i < coordlen; i++) {
var geom = coords[i],
geomlen = geom.length;
if (geom[0][0] != geom[geomlen - 1][0] || geom[0][1] != geom[geomlen - 1][1]) {
console.log('Start and end are not the same.');
data.geometry.coordinates[i].push(geom[0]);
}
}
/*if (coordlen > 1) {
console.log("found a ", "MultiPolygon", coordlen);
data.geometry.type = "MultiPolygon";
}*/
if (result != null) {
console.log('Updating existing property for ' + data.properties.PIN);
result.geometry = data.geometry;
result.properties.lot_area = data.properties.SHAPE_Area;
if (!test) {
collection.update({
_id: data.properties.PIN
}, result, function() {
setImmediate(function() {
callback();
});
});
} else {
setImmediate(function() {
callback();
});
}
} else {
if (result == null) {
console.log('No property exists yet, adding one for ' + data.properties.PIN);
var entry = {
_id: data.properties.PIN,
properties: {
block: data.properties.BLOCKNUM,
lot: data.properties.PARCELNUM,
property_address: data.properties.FULLADDR,
lot_area: data.properties.SHAPE_Area
},
geometry: data.geometry
};
if (!test) {
collection.insert(entry, {
w: 1
}, function(err, result2) {
if (err) {
console.log(err);
} else {
console.log(result2[0].block + ', ' + result2[0].lot);
}
setImmediate(function() {
callback();
});
});
} else {
setImmediate(function() {
callback();
});
}
} else {
console.log('Result is something else : ' + result);
setImmediate(function() {
callback();
});
}
}
}
}
});
}
});
});
const seedUsers = (userData, job, next) => {
sails.log.debug("seeding users")
async.eachSeries(userData.results, (entry, next) => {
let userCreated = null
let userLocalCreated = null
let kelistCreated = null
let user = {
username: entry.username,
email: entry.email,
firstYear: entry.year,
}
let userLocal = {
email: entry.email,
salt: entry.salt,
password: entry.password,
}
UserLocal.create(userLocal)
.then((created) => {
userLocalCreated = created
return User.create(user)
})
.then((created) => {
userCreated = created
userCreated.setUserLocal(userLocalCreated)
return School.findOne({ where: {"name": SCHOOL_NAME}})
})
.then(function(school){
return school.addUser(userCreated);
})
.then(function(){
return Dept.findOne({where: {"shortname": entry.dept}});
})
.then(function(dept){
if (!dept) {
Dept.findAll({})
.then(function(depts){
var deptFound = false;
depts.forEach(function(dept, index, arr){
deptData = dept.dataValues;
if (deptData.hasOwnProperty("alias") && deptData.alias ) {
deptData.alias.forEach(function(alias, index, arr) {
if (alias == entry.dept) {
dept.addUser(userCreated);
deptFound = true;
}
})
}
})
if (!deptFound) {
sails.log.error("seed user error, dept not exist: " + entry.username + " : " + entry.dept);
}
})
} else {
dept.addUser(userCreated);
}
})
.then(()=> {
if (user.email == "*****@*****.**") {
Role.findOne({where: {name: "admin"}})
.then((adminRole) => {
userCreated.addRole(adminRole)
})
}
})
.then(()=> {
return KelistService.createDefaultKelist()
})
.then((results)=> {
var kelistCreated = results;
return userCreated.addOwnsKelists(kelistCreated);
})
.then(()=> {
return User.count();
})
.then(function(countUser){
sails.log.info("seed user " + countUser + ": " + user.username);
next();
})
.catch(function(err){
sails.log.error("seeding failure: user");
sails.log.error("error", err);
next();
});
}, function (err) {
if (err) sails.log.error("error", err);
sails.log.debug("seeded: users");
job.progress(3, 10);
next();
});
};