Hello, I am creating an application and when the user registration is done, the data does not reach the database.
How and where should I do the console.log or debugger to see the errors?
I know that doing console.log or debugger could see the errors, but I do not know how to do it, in which part do the console.log.
I did it from the server in the post post, but the console only returns me: "[Function]"
From here the data is sent: <form class="signup-form" action="/signup" method="POST">
I show the code of the server.js and the connection to the database that I have in another module.
I do not know if I should show more code to give me an idea to find why the data does not reach the DB.
// SERVER.JS
let express = require('express');
let aws = require('aws-sdk');
let multer = require('multer');
let multerS3 = require('multer-s3');
let ext = require('file-extension');
let cookieParser = require('cookie-parser');
let bodyParser = require('body-parser');
let expressSession = require('express-session');
let passport = require('passport');
let michaelgram = require('michaelgram-client')
let config = require('./config');
let port = process.env.PORT || 3000;
let client = michaelgram.createClient(config.client);
let s3 = new aws.S3({
accessKeyId: config.aws.accessKey,
secretAccessKey: config.aws.secretKey
});
let storage = multerS3({
s3: s3,
bucket: 'michaelgram',
acl: 'public-read',
metadata: function (req, file, cb) {
cb(null, { fieldName: file.fieldname })
},
key: function (req, file, cb) {
cb(null, +Date.now() + '.' + ext(file.originalname))
}
});
let upload = multer({ storage: storage }).single('picture');
let app = express();
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(expressSession({
secret: config.secret,
resave: false,
saveUninitialized: false
}))
app.use(passport.initialize())
app.use(passport.session())
app.set('view engine', 'pug');
app.use(express.static('public'));
app.get('/', function (req, res) {
res.render('index', { title: 'Michaelgram' });
})
app.get('/signup', function (req, res) {
res.render('index', { title: 'Michaelgram - Signup' });
})
app.post('/signup', function (req, res) {
let user = req.body;
client.saveUser(user, function (err, usr) {
if (err) return res.status(500).send(err.message)
console.log(app.post)
res.redirect('/signin');
});
});
app.get('/signin', function (req, res) {
res.render('index', { title: 'Michaelgram - Signin' });
})
app.get('/api/pictures', function (req, res, next) {
let pictures = []
setTimeout(function () {
res.send(pictures);
}, 2000)
});
app.post('/api/pictures', function (req, res) {
upload(req, res, function (err) {
if (err) {
return res.send(500, "Error uploading file");
}
res.send('File uploaded');
})
})
app.get('/api/user/:username', (req, res) => {
const user = {
username: 'miguelito',
}
res.send(user);
})
app.get('/:username', function (req, res) {
res.render('index', { title: 'Michaelgram - ${req.params.username}' });
})
app.get('/:username/:id', function (req, res) {
res.render('index', { title: 'Michaelgram - ${req.params.username}' });
})
app.listen(3000, function (err) {
if (err) return console.log('Hubo un error'), process.exit(1);
console.log('Michaelgram escuchando en el puerto 3000');
})
// CONEXION A LA DB
const co = require('co')
const r = require('rethinkdb')
const Promise = require('bluebird')
const uuid = require('uuid-base62')
const utils = require('./utils')
const defaults = {
host: 'localhost',
port: 28015,
db: 'michaelgram'
}
class Db {
constructor (options) {
options = options || {}
this.host = options.host || defaults.host
this.port = options.port || defaults.port
this.db = options.db || defaults.db
this.setup = options.setup || false
}
connect (callback) {
this.connection = r.connect({
host: this.host,
port: this.port
})
this.connected = true
let db = this.db
let connection = this.connection
if (!this.setup) {
return Promise.resolve(connection).asCallback(callback)
}
let setup = co.wrap(function * () {
let conn = yield connection
let dbList = yield r.dbList().run(conn)
if (dbList.indexOf(db) === -1) {
yield r.dbCreate(db).run(conn)
}
let dbTables = yield r.db(db).tableList().run(conn)
if (dbTables.indexOf('images') === -1) {
yield r.db(db).tableCreate('images').run(conn)
yield r.db(db).table('images').indexCreate('createdAt').run(conn)
yield r.db(db).table('images').indexCreate('userId', { multi: true }).run(conn)
}
if (dbTables.indexOf('users') === -1) {
yield r.db(db).tableCreate('users').run(conn)
yield r.db(db).table('users').indexCreate('username').run(conn)
}
return conn
})
return Promise.resolve(setup()).asCallback(callback)
}
disconnect (callback) {
if (!this.connected) {
return Promise.reject(new Error('not connected')).asCallback(callback)
}
this.connected = false
return Promise.resolve(this.connection)
.then((conn) => conn.close())
}
saveImage (image, callback) {
if (!this.connect) {
return Promise.reject(new Error('not connected')).asCallback(callback)
}
let connection = this.connection
let db = this.db
let tasks = co.wrap(function * () {
let conn = yield connection
image.createdAt = new Date()
image.tags = utils.extractTags(image.description)
let result = yield r.db(db).table('images').insert(image).run(conn)
if (result.errors > 0) {
return Promise.reject(new Error(result.first_error))
}
image.id = result.generated_keys[0]
yield r.db(db).table('images').get(image.id).update({
publicId: uuid.encode(image.id)
}).run(conn)
let created = yield r.db(db).table('images').get(image.id).run(conn)
return Promise.resolve(created)
})
return Promise.resolve(tasks()).asCallback(callback)
}
likeImage (id, callback) {
if (!this.connect) {
return Promise.reject(new Error('not connected')).Callback(callback)
}
let connection = this.connection
let db = this.db
let getImage = this.getImage.bind(this)
let tasks = co.wrap(function * () {
let conn = yield connection
let image = yield getImage(id)
yield r.db(db).table('images').get(image.id).update({
liked: true,
likes: image.likes + 1
}).run(conn)
let created = yield getImage(id)
return Promise.resolve(created)
})
return Promise.resolve(tasks()).asCallback(callback)
}
getImage (id, callback) {
if (!this.connect) {
return Promise.reject(new Error('not connected')).Callback(callback)
}
let connection = this.connection
let db = this.db
let imageId = uuid.decode(id)
let tasks = co.wrap(function * () {
let conn = yield connection
let image = yield r.db(db).table('images').get(imageId).run(conn)
if (!image) {
return Promise.reject(new Error('image ${imageId} not found'))
}
return Promise.resolve(image)
})
return Promise.resolve(tasks()).asCallback(callback)
}
getImages (callback) {
if (!this.connected) {
return Promise.reject(new Error('not connected')).Callback(callback)
}
let connection = this.connection
let db = this.db
let tasks = co.wrap(function * () {
let conn = yield connection
let images = yield r.db(db).table('images').orderBy({
index: r.desc('createdAt')
}).run(conn)
let result = yield images.toArray()
return Promise.resolve(result)
})
return Promise.resolve(tasks()).asCallback(callback)
}
saveUser (user, callback) {
if (!this.connected) {
return Promise.reject(new Error('not connected')).Callback(callback)
}
let connection = this.connection
let db = this.db
let tasks = co.wrap(function * () {
let conn = yield connection
user.password = utils.encrypt(user.password)
user.createdAt = new Date()
let result = yield r.db(db).table('users').insert(user).run(conn)
if (result.errors > 0) {
return Promise.reject(new Error(result.first_error))
}
user.id = result.generated_keys[0]
let created = yield r.db(db).table('users').get(user.id).run(conn)
return Promise.resolve(created)
})
return Promise.resolve(tasks()).asCallback(callback)
}
getUser (username, callback) {
if (!this.connected) {
return Promise.reject(new Error('not connected')).Callback(callback)
}
let connection = this.connection
let db = this.db
let tasks = co.wrap(function * () {
let conn = yield connection
yield r.db(db).table('users').indexWait().run(conn)
let users = yield r.db(db).table('users').getAll(username, {
index: 'username'
}).run(conn)
let result = null
try {
result = yield users.next()
} catch (e) {
return Promise.reject(new Error('user ${username} not found'))
}
return Promise.resolve(result)
})
return Promise.resolve(tasks()).asCallback(callback)
}
authenticate (username, password, callback) {
if (!this.connected) {
return Promise.reject(new Error('not connected')).Callback(callback)
}
let getUser = this.getUser.bind(this)
let tasks = co.wrap(function * () {
let user = null
try {
user = yield getUser(username)
} catch (e) {
return Promise.resolve(false)
}
if (user.password === utils.encrypt(password)) {
return Promise.resolve(true)
}
return Promise.resolve(false)
})
return Promise.resolve(tasks()).asCallback(callback)
}
getImagesByUser (userId, password, callback) {
if (!this.connected) {
return Promise.reject(new Error('not connected')).Callback(callback)
}
let connection = this.connection
let db = this.db
let tasks = co.wrap(function * () {
let conn = yield connection
yield r.db(db).table('images').indexWait().run(conn)
let images = yield r.db(db).table('images').getAll(userId, {
index: 'userId'
}).orderBy(r.desc('createdAt')).run(conn)
let result = yield images.toArray()
return Promise.resolve(result)
})
return Promise.resolve(tasks()).asCallback(callback)
}
getImagesByTag (tag, callback) {
if (!this.connected) {
return Promise.reject(new Error('not connected')).Callback(callback)
}
let connection = this.connection
let db = this.db
tag = utils.normalize(tag)
let tasks = co.wrap(function * () {
let conn = yield connection
yield r.db(db).table('images').indexWait().run(conn)
let images = yield r.db(db).table('images').filter((img) => {
return img('tags').contains(tag)
}).orderBy(r.desc('createdAt')).run(conn)
let result = yield images.toArray()
return Promise.resolve(result)
})
return Promise.resolve(tasks()).asCallback(callback)
}
}
module.exports = Db
//ENVIO DESDE EL MODULO API
const env = process.env.NODE_ENV || 'production'
let db = new Db(config.db)
if (env === 'test') {
db = new DbStub()
}
const hash = HttpHash()
hash.set('POST /', async function saveUser (req, res, params) {
let user = await json(req)
await db.connect()
let created = await db.saveUser(user)
await db.disconnect()
delete created.password
delete created.email
send(res, 201, created)
})
hash.set('GET /:username', async function getUser (req, res, params) {
let username = params.username
await db.connect()
let user = await db.getUser(username)
await db.disconnect()
delete user.password
delete user.email
send(res, 200, user)
})
export default async function main (req, res) {
let { method, url } = req
let match = hash.get('${method.toUpperCase()} ${url}')
if (match.handler) {
try {
await match.handler(req, res, match.params)
} catch (e) {
send(res, 500, { error: e.message })
}
} else {
send(res, 404, { error: 'route not found' })
}
}Thank you.