beforeEach(function () {
mongoose.set('debug', true);
console.log('############');
});
import '../config';
import mongoose from 'mongoose';
mongoose.Promise = global.Promise;
// Setup logging stuff
import chalk from 'chalk';
const log = console.log;
// Set DB uri (production DB will be in .env)
const uri = (process.env.NODE_ENV === 'production')
? process.env.MONGO_URI
: 'localhost:27017/portfolio-test-db';
// Connect to the database
mongoose.connect(uri, {
useNewUrlParser: true
}).then(
() => { // Connected
log(chalk.green("### ") + chalk.italic("Connected to database"));
},
err => { // Error connecting
log(chalk.white.bgRed.bold("### Error connecting to database:"));
log(err);
}
);
// Set mongoose options
mongoose.set('useFindAndModify', false);
mongoose.set('useCreateIndex', true);
export default mongoose.connection;
}, routes.index);
/**
* launch server
*/
server.listen(app.get('port'), function(){
console.log('Express server listening on port ' + app.get('port'));
});
/**
* connec to mongoDB
*/
mongoose.set('dbname', 'speakusdb');
mongoose.connect('mongodb://localhost/'+mongoose.get('dbname'));
var db = mongoose.connection;
db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', function callback () {
console.log("you're well connected ! Yay !")
});
var user = new User( {name : "roger"} );
user.save();
User.find(function (err, users) {
if (err) console.log(err);
console.log(users)
/*
get: Accepts query options for courses, returns results of db query to
callback.
Examples:
{genEdFocus:['WI', 'OC']} -> find all courses that are WI _and_ OC
{course:'ICS'} -> find all 'ICS' courses
{days: 'T', 'R'} -> find all courses that are on Tuesday _or_ Thursday
{credits: 3}
{seatsAvail: true}
@param searchOpts query options to pass to mongodb
@param callback a callback
*/
function get(searchOpts, useTestDb, callback) {
/*var validProps = [
"course",
"credits",
"crn",
"genEdFocus",
"instructor",
"mtgTime",
"dates",
"days",
"loc",
"start",
"end",
"seatsAvail",
"waitListed",
"waitAvail",
"sectionNum",
"title"
];*/
if (searchOpts == null || searchOpts.length < 1) {
callback({message:'noCriteriaGiven'});
}
var username = (useTestDb)? cfg.testdb.username : cfg.db.username
, password = (useTestDb)? cfg.testdb.password : cfg.db.password
, databaseName = (useTestDb)? 'uhfind-test' : 'uhfind';
//if (useTestDb) {
mongoose.set('debug', true);
//}
mongoose.connect('mongodb://' + cfg.hostname + '/' + databaseName, {
user: username,
pass: password
});
var db = mongoose.connection;
db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', function() {
// Query builder.
var query = { $and: [] };
for (var key in searchOpts) {
var value = searchOpts[key];
console.log(key);
if (key == 'campus') {
query.$and.push({'campus': value});
}
//console.log(key);
if (key == 'genEdFocus') {
// little bit of data structure manipulation
for (var focus in value) {
if (value[focus] != 'Any' && value[focus] != '--') {
query.$and.push({
'genEdFocus': value[focus]
});
}
}
}
if (key == 'days') {
query.$and.push({
"mtgTime.days": value
});
}
if (key == 'course') {
query.$and.push({
"course": { '$regex': value }
});
}
if (key == 'credits') {
// can only match credit counts with regex because some
// of the data contains values like '1-5'.
query.$and.push({
"credits": { '$regex': value }
});
}
if (key == 'seatsAvail') {
if (value == true) {
query.$and.push({
"seatsAvail": { '$gt': 0 }
});
}
}
if (key == 'start' ) {
// Example valid mtgTime.start: '0900'.
query.$and.push({
"mtgTime.start" : {'$regex': value}
})
}
if (key == 'end') {
// Example valid mtgTime.end: '0900a'.
query.$and.push({
"mtgTime.end": {'$regex': value}
});
}
if (key == 'instructor') {
// Example valid mtgTime.end: '0900a'.
query.$and.push({
"instructor": {'$regex': value, '$options': 'i'}
});
}
} // end for
// disallow empty queries or those that enumerate an entire campus
if (query.$and.length == 0 ||
(query.$and.length == 1 && query.$and[0].campus)) {
mongoose.disconnect();
callback({message:'noCriteriaGiven'});
}
Course.find(query).sort({'course': 1}).select().exec(function(err, docs) {
mongoose.disconnect();
if (err) {
callback(err);
} else {
callback(null, docs);
}
});
});
}
exports.debug = function(debug) {
// コンソールにMongoDBへのクエリが表示されるようになる
mongoose.set('debug', debug);
};
var path = require('path');
var swig = require('swig');
var port = config.port || process.env.PORT || 3000;
app.set('port', port);
app.use(cors());
app.use(morgan(process.env.NODE_ENV=='production'?'[:date[clf]] ":method :remote-addr :url HTTP/:http-version" :status :res[content-length] :req[Authorization] :response-time':'dev')); // log every request to the console
app.use(compress()); // log every request to the console
app.use(cookiePraser(config.cookieSecret)); // read cookies
app.use(bodyParser()); // get req.body from normal html form
// app.use(multer({dest: "./uploads"})); // get req.files for miltipart/form-data
app.use(methodOverride());
var mongoose = require('mongoose');
mongoose.set('Promise', require('bluebird'));
var connectDB = function() {
mongoose.connect(config.db.url);
};
mongoose.connection.on('error',function() {
console.log('← MongoDB Connection Error →');
console.log('reconnedtin in 1 seccond');
setTimeout(connectDB, 1000);
});
connectDB();
if (config.runJava) {
var runner = require('java-code-runner');
runner.server.recompile(function () {
runner.watchServer(function(p) {
console.log('started java server at http://localhost:' + p);
var mongoose = require("mongoose");
// 核心代码，是否开启测试
mongoose.set('debug', false);
var db = mongoose.connect("mongodb://127.0.0.1:27017/db_helloworld");
db.connection.on("error", function (error) {
console.log("数据库连接失败：" + error);
});
db.connection.on("open", function () {
console.log("数据库连接成功");
mongoose.connection.db.dropDatabase();
});
, dateUtils = require('date-utils')
, colors = require('colors')
, Item = require('./models/item.js')
, Stat = require('./models/stat.js')
, normal_smtp_server = new require("simplesmtp").createServer(config.normal_smtp_opts)
normal_port = config.normal_smtp_port
, secure_smtp_server = new require("simplesmtp").createServer(config.secure_smtp_opts)
, secure_port = config.secure_smtp_port
, D = function(){return new Date().toFormat('YYYY-MM-DD HH24:MI:SS')};
console.log( D(), 'Starting SMTP server'.bold.blue);
mongoose.set('debug', config.mongo_debug);
mongoose.model('Item', Item.Item);
mongoose.model('Stat', Stat.Stat);
mongoose.connect(config.Mongo.url);
var MailServer;
var MongoConnection = mongoose.connection;
MongoConnection.on('error', function(e) {
console.log( D(), 'Mongo connection error'.red.bold,
JSON.stringify(e).red);
setTimeout(function(){
MongoConnection = mongoose.connect(config.Mongo.url);
// set up ======================================================================
var express = require('express');
var app = express(); // create our app w/ express
var mongoose = require('mongoose');
mongoose.set('debug', true) // mongoose for mongodb
var port = process.env.PORT || 8080; // set the port
var database = require('./config/database'); // load the database config
// configuration ===============================================================
mongoose.connect(database.url); // connect to mongoDB database on modulus.io
app.configure(function() {
app.use(express.static(__dirname + '/public')); // set the static files location /public/img will be /img for users
app.use(express.logger('dev')); // log every request to the console
app.use(express.bodyParser()); // pull information from html in POST
app.use(express.methodOverride()); // simulate DELETE and PUT
});
// routes ======================================================================
require('./app/routes.js')(app);
//Want to create predeftodos and save them in database if they do not exist
//Want to update each todolist with predeftodos once a week
/*var CronJob = require('cron').CronJob;
var job = new CronJob(new Date(), function() {
/* runs once at the specified date. */
/*}, function () {
/* This function is executed when the job stops */
var bodyParser = require('body-parser');
var mongoose = require('mongoose');
var port = process.env.PORT || 3000;
var app = express(); //启动一个 web 服务器
var cookieSession = require('cookie-session');
var logger = require('morgan');
var fs = require('fs');
mongoose.connect('mongodb://localhost/imooc');
app.set('views', './app/views/pages'); //设置视图根目录
app.set('view engine', 'jade'); //设置模板引擎
app.use(express.static(path.join(__dirname, 'public')));
app.use(bodyParser.urlencoded({extended:true}));
app.use(cookieSession({
secret: 'imooc'
}));
app.locals.moment = require('moment');
if('development' === app.get('env')){
app.set('showStackError', true);
app.locals.pretty = true;
app.use(logger('tiny'));
mongoose.set('dev', true);
}
require('./config/routes')(app);
app.listen(port);
console.log('imooc started on port ' + port);
, moment = require('moment')
, Event = require('../../models/event')
, Observation = require('../../models/observation');
// setup mongoose to talk to mongodb
var mongodbConfig = config.mongodb;
mongoose.connect(mongodbConfig.url, {server: {poolSize: mongodbConfig.poolSize}}, function(err) {
if (err) {
log.error('Error connecting to mongo database, please make sure mongodbConfig is running...');
throw err;
}
});
var mongooseLogger = log.loggers.get('mongoose');
mongoose.set('debug', function(collection, method, query, doc, options) {
mongooseLogger.log('mongoose', "%s.%s(%j, %j, %j)", collection, method, query, doc, options);
});
var attachmentBase = environment.attachmentBaseDirectory;
var timeout = config.esri.attachments.interval * 1000;
var url = [url.host, url.site, url.restServices, url.folder, url.serviceName, url.serviceType, url.layerId].join("/");
var events;
function getEvents(done) {
Event.getEvents(function(err, allEvents) {
events = allEvents;
done(err);
});
}
function createEsriAttachment(esriId, attachment, callback) {
function MongoDB(db_config) {
var mongoose = require('mongoose');
mongoose.set('debug', false);
var mongoose_obj = {};
function ConnectToDB() {
if (db_config == undefined) {
console.log('Mongo connect');
//mongoose_obj = mongoose.createConnection('mongodb://127.0.0.1/node-queue');
mongoose_obj = mongoose.createConnection('mongodb://*****:*****@' + db_config.host + ':' + db_config.port + '/' + db_config.db_name);
}
}
ConnectToDB();
/* JOBS Schema */
var Schema = mongoose.Schema
, ObjectId = Schema.ObjectId;
var JobSchema = new Schema({
CLASS_NAME: {type: String}
, STATUS: {type: String}
, QUEUE: {type: String}
, PARAMS: {type: Schema.Types.Mixed}
, HANDLE_BY: {type: Number}
, ERROR: {type: Schema.Types.Mixed}
, TIMESTAMP: {type: Number}
, SUT: {type: Number}
});
mongoose_obj.model('Jobs', JobSchema);
var Job = mongoose_obj.models.Jobs;
Job.enqueueJob = function (queue_name, job, params, callback) {
var job_obj = new Job();
job_obj.CLASS_NAME = job;
job_obj.QUEUE = queue_name;
job_obj.PARAMS = params;
job_obj.STATUS = 'Q';
job_obj.HANDLE_BY = 0;
job_obj.TIMESTAMP = (new Date().getTime());
// console.log('Job etails : ' + JSON.stringify(job_obj));
job_obj.save(function (err, res) {
callback(err, res);
});
};
Job.getNextJobsToDo = function (queue, pid, jobcallback) {
// console.log('priorityQueueNames : ' + priorityQueueNames);
// If priority is not set then process queue in FIFO mechanism
if (!priorityQueueNames.length) {
findJob(queue, pid, function (err, job) {
jobcallback(err, job);
});
} else {
//(E.g priorityQueue =["Queue1:153","Queue3:67","Queue2:0"])
//(E.g priorityQueueNames : ["Queue1","Queue3","Queue2"])
// Find highest priority queue job and process, if job not found then check for second highest priority queue job and so on
async.forEachLimit(priorityQueueNames, 1, function (queueName, callback) {
Job.find({$and: [{STATUS: 'Q'}, {QUEUE: queueName}]}).count(function (err, count) {
// if any priority job of queue found the pass queue name to process
if (count > 0) {
return callback({queue: queueName});
}
callback();
});
}, function (result) {
if (result) {
// Process priority queue
findJob(result.queue, pid, function (err, job) {
jobcallback(err, job);
});
} else {
console.log('No job to process');
jobcallback(null, false);
}
})
}
};
function findJob(queue, pid, callback) {
var condition;
// If queue=* then process job in FIFO mechanism
if (queue == "*") {
condition = {STATUS: 'Q'};
}
else {
// condition = {$and:[{STATUS:'Q'}, {QUEUE:queue}]};
// condition = {$and: [{STATUS: 'Q'}, {QUEUE: {$in: queue.split(',')}}]};
// If priority is not set then find job from given queue
if (!priorityQueueNames.length) {
condition = {$and: [{STATUS: 'Q'}, {QUEUE: {$in: queue.split(',')}}]};
} else {
// find job of priority queue
condition = {$and: [{STATUS: 'Q'}, {QUEUE: queue}]};
}
}
// console.log('Processing Queue ........Condition : ' + JSON.stringify(condition));
Job.findOneAndUpdate(condition, {
$set: {
STATUS: 'P',
HANDLE_BY: pid,
SUT: Math.round(new Date().getTime() / 1000)
}
}, {sort: "TIMESTAMP"}, function (err, job) {
if (err)
callback(err);
else if (job != null)
callback(null, job);
else
callback(null, false);
});
}
Job.retry = function (job_id, callback) {
var ObjectId = mongoose.Types.ObjectId(job_id);
Job.update({
"_id": ObjectId
}, {$set: {STATUS: 'Q', SUT: null}}, function (err, resp) {
callback(err, resp);
});
};
Job.removeJob = function (job_id, callback) {
var ObjectId = mongoose.Types.ObjectId(job_id);
Job.remove({
"_id": ObjectId
}, function (err, resp) {
callback(err, resp);
});
};
Job.getStuckedJobs = function (JOB_TIMEOUT, callback) {
var currTimeStamp = Math.round(new Date().getTime() / 1000 - (JOB_TIMEOUT / 1000), 0);
Job.find({STATUS: 'P', SUT: {$lte: currTimeStamp}}, callback);
};
this.Job = Job;
/* WORKERS SCHEMA */
var WorkerSchema = new Schema({
PID: {type: String}
, STATUS: {type: String}
, QUEUE: {type: String}
, PRIORITY: {type: Number}
});
mongoose_obj.model('Worker', WorkerSchema);
var Worker = mongoose_obj.models.Worker;
Worker.addNewWorker = function (pid, status, queue) {
var worker = new Worker();
worker.PID = pid;
worker.STATUS = 'F';
worker.QUEUE = queue;
//worker.PRIORITY = priority;
worker.save(function (err, result) {
});
};
Worker.getFreeWorker = function (queue, callback) {
if (queue != "*")
condition = {$and: {STATUS: 'F', QUEUE: queue}};
else
condition = {STATUS: 'F'};
Worker.find(condition, function (err, data) {
if (err) {
callback(err);
return;
}
callback(null, data);
});
};
Worker.MarkBusy = function (pid, callback) {
Worker.update({PID: pid}, {$set: {STATUS: 'B'}}, callback);
};
Worker.MarkFree = function (pid, callback) {
Worker.update({PID: pid}, {$set: {STATUS: 'F'}}, callback);
};
Worker.ReplaceWorker = function (pid, new_pid, callback) {
Job.update({$and: [{HANDLE_BY: pid}, {STATUS: 'P'}]}, {$set: {STATUS: 'Q', HANDLE_BY: 0}}, function (err, res) {
});
Worker.update({PID: pid}, {$set: {PID: new_pid, STATUS: 'F'}}, callback);
};
Worker.RemoveWorker = function (queue) {
Worker.remove({QUEUE: queue}, function (err, result) {
});
};
Worker.RemoveWorkerByPID = function (PID, callback) {
Worker.remove({PID: PID}, function (err, result) {
callback();
});
};
Worker.RemoveWorkerById = function (worker_id, callback) {
Worker.remove({PID: worker_id}, function (err, result) {
Job.update({$and: [{HANDLE_BY: worker_id}, {STATUS: 'P'}]}, {
$set: {
STATUS: 'Q',
HANDLE_BY: 0
}
}, function (err, res) {
callback(err, result);
});
});
};
this.Worker = Worker;
}
function connect() {
mongoose.set('debug', true);
return mongoose.connect(mongoUri);
}
Object.keys(mongo.options).forEach((key) => {
mongoose.set(key, mongo.options[key]);
});
debug: function (v) {
if (!arguments.length) v = true;
mongoose.set('debug', v);
},
return mongoose.connect(config.mongodb.uri).then((res) => {
consoleSuccess(`Connected to MongoDB at ${config.mongodb.uri}`);
if(process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
mongoose.set('debug', true);
}
}).catch((err) => {
app.use(session({
secret:"imooc",
store:new mongoStore({
url:dbUrl,
collection:"sessions"
})
}))
app.use(express.static(path.join(__dirname,"public")));
app.set("views","./app/views/pages");
app.set("view engine","jade");
if("development"==app.get("env")){
app.set("showStackError",true);
app.use(logger(":method :url :status"));
app.locals.pretty=true; //这是文本为非格式化文本
mongoose.set("debug",true); //设置mongoose调试打开
}
app.listen(port);
console.log("imooc started on port"+port);
mongoose.connect(dbUrl)
require("./config/routes")(app);
//app.get("/jquery-1.8.3",function(req,res){
// res.render("jquery-1.8.3",{
// title:"imooc 管理页"
// })
//})
'use strict';
/**
* Module dependencies.
*/
var config = require('./index'),
log = require('./logger'),
path = require('path'),
glob = require('glob'),
mongoose = require('mongoose');
mongoose.connection.on('error', log.error.bind(log, 'connection error:'));
mongoose.set('debug', function (collectionName, method, query, doc, options ) {
log.debug('mongo collection: %s method: %s', collectionName, method);
});
/**
* @deprecated
*/
module.exports.loadModels = function () {
glob("**/*Schema.js", function (err, modelPath) {
modelPath.forEach(function (model) {
log.debug("Loading model: " + model)
require(path.resolve(model));
})
});
};
/**
* @callback CallBack
"use strict";
process.env.NODE_ENV = process.env.NODE_ENV || "test";
Error.stackTraceLimit = Infinity;
const debug = require("debug");
debug.enable("controller:*");
debug.enable("model:*");
debug.enable("test:*");
debug.enable("log:*");
// const bluebird = require("bluebird");
// bluebird.longStackTraces();
const q = require("q");
q.longStackSupport = true;
const mongoose = require("mongoose");
mongoose.set("debug", false);
process.on("uncaughtException", (exception) => {
debug("log:mocha")(exception);
});
before(async () => {
mongoose.set('useCreateIndex', true);
await mongoose.connect(config.mongoUrl, {useNewUrlParser: true});
await mongoose.connection.db.dropDatabase();
await gtfs.import(config);
});
app.use(h5bp.crossDomainRules());
app.use(h5bp.suppressWww(true));
app.use(h5bp.removeEtag());
});
app.configure('development', function () {
app.use(express.errorHandler());
});
i18n.registerAppHelper(app);
// mongoose
var mongoose = require('mongoose');
mongoose.set('debug', config.verbose);
mongoose.connect(process.env.MONGOHQ_URL || config.database.uri);
mongoose.connection.on('error', function (err) {
console.error('MongoDB error: ' + err.message);
console.error('Make sure a mongoDB server is running and accessible by this application');
});
// passport
var
LocalStrategy = require('passport-local').Strategy,
User = require('./models/user');
passport.serializeUser(function (user, done) {
(function(module, require, logger){
'use strict';
const fs = require('fs'),
path = require('path'),
assert = require('assert'),
csvparse = require('csv-parse'),
parser = csvparse({delimiter: ';', columns: true, rtrim: true}),
mongoose = require('mongoose'),
Q = require('q'),
config = require('./config.json'),
models = require('./api/models');
const registros = [];
mongoose.set('debug', false);
mongoose.Promise = require('q').Promise;
mongoose.connect(config.mongodb.connectionString);
models.init(mongoose);
function checkRegistroNumerico(registro, campo){
/* excepcion */
if (campo === 'ancestrodirecto' && registro.id == '1'){
return true;
}
return registro[campo] && parseInt(registro[campo], 10) == registro[campo];
}
function checkRegistroString(registro, campo){
return registro[campo] && registro[campo] !== '';
}
function runTests(idsjerarquias){
assert( registros.length > 0, 'Debe cargar algún registro.');
registros.forEach(function(registro, i){
assert( checkRegistroNumerico(registro, 'id'), 'El campo id debe existir y ser numérico. Línea:' + (i + 1) + ' ' + JSON.stringify(registro));
assert( checkRegistroNumerico(registro, 'ancestrodirecto'), 'El campo ancestrodirecto debe existir y ser numérico. Línea:' + (i + 1) + ' ' + JSON.stringify(registro));
assert( checkRegistroString(registro, 'nombre'), 'El campo nombre debe existir y ser texto. Línea:' + (i + 1) + ' ' + JSON.stringify(registro));
assert( checkRegistroString(registro, 'nombrelargo'), 'El campo nombre largo debe existir y ser texto. Línea:' + (i + 1) + ' ' + JSON.stringify(registro));
assert( checkRegistroString(registro, 'inicialestipo'), 'El campo inicialestipo debe existir y ser texto. Línea:' + (i + 1) + ' ' + JSON.stringify(registro));
assert( checkRegistroString(registro, 'tipo'), 'El campo tipo debe existir y ser texto. Línea:' + (i + 1) + ' ' + JSON.stringify(registro));
});
const registrosXId = registros.reduce(function(prev, registro){
prev[registro.id] = registro;
return prev;
}, {});
registros.forEach(function(registro, i){
const ancestrodirecto = registro.ancestrodirecto;
if (ancestrodirecto){
assert(typeof registrosXId[ancestrodirecto] === 'object', 'El campo ancestrodirecto debe existir entre los importados. Línea:' + (i + 1));
}
});
for (let i = 0, j = idsjerarquias; i < j; i += 1){
const jerarquiausadaEnProcedimiento = idsjerarquias[i];
assert(typeof registrosXId[jerarquiausadaEnProcedimiento] === 'object', 'La jerarquia con id: ' + jerarquiausadaEnProcedimiento + ' no existe y es necesaria');
}
logger.log('Tests OK');
return true;
}
function transformar(){
for (let i = 0, j = registros.length; i < j; i += 1){
registros[i].id = parseInt(registros[i].id, 10);
registros[i].ancestrodirecto = registros[i].ancestrodirecto ? parseInt(registros[i].ancestrodirecto, 10) : null;
registros[i].numprocedimientos = 0;
registros[i].descendientes = [];
registros[i].ancestros = [];
Reflect.deleteProperty(registros[i], 'nivelsici');
}
}
function volcarJSON(){
fs.writeFile(path.join(__dirname, 'data', 'output.json'), JSON.stringify(registros), function(){
logger.log('Fichero volcado con éxito en: ' + path.join(__dirname, 'data', 'output.json'));
logger.log('Pasos:');
logger.log("\tmongodump -h mongosvr --db sici -c jerarquia");
logger.log("\tmongoimport --host mongosvr --db sici --collection jerarquia --file data/output.json --jsonArray --drop");
logger.log("\tmongo mongosvr/sici --eval 'db.jerarquia.update({id:1}, {$set: {ancestrodirecto : null}});'");
logger.log('En caso de crisis:');
logger.log("\tmongorestore --db sici -c jerarquia -h mongosvr --drop dump/sici/jerarquia.bson");
});
}
parser.on('readable', function(){
const record = parser.read();
if (record){
registros.push(record);
}
});
parser.on('error', function(err){
logger.error(err);
});
parser.on('finish', function(){
logger.log(registros.length + ' elementos leídos en el fichero origen de datos');
const procedimientomodel = models.procedimiento();
const entidadobjetomodel = models.entidadobjeto();
Q.all([procedimientomodel.distinct('idjerarquia'), entidadobjetomodel.distinct('idjerarquia')]).then(function(arrIdsjerarquias){
const idsjerarquias = require('uniq')(arrIdsjerarquias.reduce(function(p, c){ return p.concat(c); }, []));
logger.log(idsjerarquias.length + ' jerarquias usadas en procedimientos y cartas');
mongoose.disconnect();
logger.log('Running tests');
try {
runTests(idsjerarquias);
transformar();
volcarJSON();
} catch (excepcion) {
logger.error(excepcion);
}
}, function(err){
logger.error('Error al conectarse con la base de datos', err);
mongoose.disconnect();
});
});
const input = fs.createReadStream(path.join(__dirname, 'data', 'organica.csv'));
input.pipe(parser);
})(module, require, console);
// make bluebird default Promise
Promise = require('bluebird'); // eslint-disable-line no-global-assign
// plugin bluebird promise in mongoose
mongoose.Promise = Promise;
// connect to mongo db
const mongoUri = config.mongo.host;
mongoose.connect(mongoUri, { server: { socketOptions: { keepAlive: 1 } } });
mongoose.connection.on('error', () => {
throw new Error(`unable to connect to database: ${mongoUri}`);
});
// print mongoose logs in dev env
if (config.mongooseDebug) {
mongoose.set('debug', (collectionName, method, query, doc) => {
debug(`${collectionName}.${method}`, util.inspect(query, false, 20), doc);
});
}
// module.parent check is required to support mocha watch
// src: https://github.com/mochajs/mocha/issues/1912
if (!module.parent) {
// listen on port config.port
app.listen(config.port, () => {
console.info(`server started on port ${config.port} (${config.env})`); // eslint-disable-line no-console
});
}
module.exports = app;
const mongoose = require( 'mongoose' );
const dbURI = process.env.MONGODB_URI || 'mongodb://localhost:27017/eleicoes-brasil';
mongoose.Promise = global.Promise;
mongoose.connect(dbURI);
mongoose.set('debug', process.env.NODE_ENV !== 'production')
mongoose.connection.on('connected', () => {
console.log(`Mongoose default connection open to ${dbURI}`);
});
mongoose.connection.on('error', err => {
console.log(`Mongoose default connection error: ${err}`);
});
mongoose.connection.on('disconnected', () => {
console.log('Mongoose default connection disconnected');
});
mongoose.connection.once('open', () => {
console.log('Mongoose default connection is open')
});
process.on('SIGINT', () => {
mongoose.connection.close(() => {
console.log('Mongoose default connection disconnected through app termination');
process.exit(0);
});
// ports and URI //
const port = process.env.PORT || 8888;
const mongoURI = 'mongodb://localhost:27017/recruiterBot';
// app pre-processors //
app.use( urlencoded( { extended: true } ) ); //
app.use( json() );
app.use( express.static( `${ __dirname }/public`) );// public contains static assets and these are getting served up to express middleware
// use Master Routes //
MR( app );
Sophie( Botkit, app, mongoURI );
// mongoose connection //
mongoose.set( `debug`, true );
mongoose.connect( mongoURI ); // currently only sending to local storage
mongoose.connection.once( `open`, () => {
console.log( `connected to Mongo DB at ${ mongoURI }` );
} );
// express conneciton //
app.listen( port, function(){
console.log( `Express listening to port ${ port }` );
} )
//Dependencias:
const request = require("request");
const LineByLineReader = require('line-by-line');
const mongoose = require('mongoose');
mongoose.set('useCreateIndex', true)
const str = require('querystring');
let House = require('./models/houses');
// Variables globales:
let places = [];
let peticion = 0;
// conexión con DB
mongoose.connect('mongodb://astoriadb:27017/houses', { useMongoClient: true });
mongoose.Promise = global.Promise;
// Realiza petición HTTP
const doRequest = async (url) => {
return new Promise(function (resolve, reject) {
peticion = peticion + 1 ;
console.log("Peticion numero : " + peticion)
request({
url: url,
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:24.0) Gecko/20100101 Firefox/24.0'
},
port: 80,
json: true
}, function (error, res, body) {
var mongoose = require('mongoose');
var config = require('../config').mongo;
mongoose.set('debug', true);
//连接格式mongodb://主机/数据库名
//config.db--'mongodb://123.56.230.118:27017/cms'
mongoose.connect(config.db, {
server: {poolSize: 20}
}, function (err) {
if (err) {
console.error('connect to %s error: ', config.db, err.message);
process.exit(1);
}
console.log('数据库连接成功...')
});
//引入数据库表
require('./model');
exports.UserModel = mongoose.model('User');
exports.ClassModel = mongoose.model('Class');
exports.NewsModel = mongoose.model('News');
exports.NotificationModel = mongoose.model('Notification');
exports.JobModel = mongoose.model('Job');
exports.ResourceModel = mongoose.model('Resource');
exports.NoteModel = mongoose.model('Note');
before(function(){
mongoose.set('debug', config.mongodb.debug);
mongoose.connect(config.mongodb.connectionString);
models.init(mongoose);
});
var mongoose = require("mongoose");
mongoose.connect(process.env.MONGOLAB_URI || "mongodb://localhost/d3-map-example");
mongoose.set("debug", true);
module.exports.User = require("./user");
*/
var mongoose = require('mongoose')
, config = require('../config').mongodb;
/**
* Expose mongoose.
*/
exports.mongoose = mongoose;
/**
* Set debug flag.
*/
mongoose.set('debug', 'production' !== process.env.NODE_ENV);
/**
* Expose mongoose connection.
*/
var db = exports.db = process.env.MONGOLAB_URI
? mongoose.createConnection(process.env.MONGOLAB_URI)
: mongoose.createConnection(config.host, config.database);
/**
* Expose models.
*/
exports.Project = db.model('Project', require('./project'));
exports.Tag = db.model('Tag', require('./tag'));