function importdata()
{
var cradle = require("cradle"),
sys = require("sys"),
fs = require("fs");
var connection = new (cradle.Connection)("localhost",5984);
var db = connection.database('geoexample');
data = fs.readFileSync("./datos/data.json","utf-8");
flickr = JSON.parse(data);
for(p in flickr.photos.photo)
{
photo = flickr.photos.photo[p];
photo.geometry = {"type":"Point", "coordinates" : [photo.longitude, photo.latitude] };
// save url to flickr image
photo.image_url_small = "http://farm"+photo.farm+".static.flickr.com/"+photo.server+"/"+photo.id+"_"+photo.secret+"_s.jpg";
db.save(photo.id,photo,function(er,ok)
{
if (er) {sys.puts("error: " + er); return; }
});
}
}
jf.readFile('server/config/casa-design.json', function(err, designFile) {
if(err){
console.log('could not read view json file, ', err);
} else {
var c = new(cradle.Connection)(couch.host, couch.port, {
cache: true,
raw: false,
forceSave: true
});
var db = c.database(config.couch.db_name);
var updateDesign = function(design){
db.save(design._id, design);
}
db.exists(function (err, exists) {
if (err) {
console.log('could not determine if database: ' + config.couch.db_name + ' exists, ', err);
} else if (exists) {
console.log('database: ' + config.couch.db_name + ' already exists');
updateDesign(designFile);
} else {
console.log('database does not exists.');
db.create(function(err){
// do something if there's an error
if(!err){
updateDesign(designFile);
console.log('database' + config.couch.db_name + ' created successfully');
// populate design documents
} else {
console.log('Error creating database: ' + config.couch.db_name + '...', err);
}
});
}
});
}
});
connect: function (callback) {
var self = this;
var options = this.options;
var client = new (cradle.Connection)(options.host, options.port, options.options);
var db = client.database(options.dbName);
db.exists(function (err, exists) {
function finish() {
self.client = client;
self.db = db;
db.get('_design/sessions', function (err, obj) {
var view = {
views: {
findAll: {
map: function (doc) {
emit(doc.collectionName, doc);
}
}
}
};
if (err && err.error === 'not_found') {
db.save('_design/sessions', view, function (err) {
if (!err) {
self.emit('connect');
}
if (callback) callback(err, self);
});
return;
}
if (!err) {
self.emit('connect');
}
if (callback) callback(err, self);
});
}
if (err) {
if (callback) callback(err);
return;
}
if (!exists) {
db.create(function (err) {
if (err) {
if (callback) callback(err);
return;
}
finish();
});
return;
}
finish();
});
},
module.exports = function couchAttachmentProvider(options) {
var database = options.database;
var prefix = options.prefix;
var cradleOptions = options.connectionOptions || {}
var connection = new cradle.Connection(cradleOptions);
var db = connection.database('votes');
return function(req, res, next) {
var path = parseUrl(req.url).pathname;
// Match the prefix
if (path.indexOf(prefix) !== -1) {
var components = path.substring(prefix.length + 1, path.length).split('/');
var attachment = components.pop();
var request = db.getAttachment(components.pop(), 'photo.jpg');
request.on('response', function(response) {
if (response.statusCode == 200) {
// Respond with the same headers that Couch sent
res.writeHead(response.statusCode, response.headers);
response.on('data', function(chunk) {
res.write(chunk);
});
response.on('end', function() {
res.end();
});
}
else {
next();
}
});
}
else {
next();
}
}
}
/*-------------------------------------------
function usp()
DESCRIPTION: Update SearchPhrase -- Function that
retreives twitter searchphrase from couchDB
created: 12.4.12
---------------------------------------------*/
function usp(){
var conn = new(cradle.Connection)('CONNECTION', 443,{
cache: true,
raw: false,
auth: {
username:"******", //cloudant generated key
password:"******" //cloudant generated password
}
});
var db = conn.database('DBNAME');
//retrieve passphrase from database
db.get('passphrase', function (err, doc) {
console.log(doc);
if (err) {
console.log('cradle db error' + err);
} else {
if(doc)
searchPhrase = doc.phrase;
}
});
}
module.exports = function (couch, cb) {
var host = couch.host
var protocol = couch.protocol
var fullHost = protocol + '://'+host
var port = couch.port
var databaseName = couch.database
var opts = {
cache: false,
raw: false
}
var username = couch.username
var password = couch.password
if (username) {
opts.auth = {
username: username,
password: password
}
}
var c = new(cradle.Connection)(fullHost, port, opts)
var db = c.database(databaseName)
var createData = {
db: db,
databaseName: databaseName
}
createIfNeeded(createData, cb)
}
function getDBConnectionFromConfig(dbConf, callback){
var connection = new(cradle.Connection)(dbConf.host,dbConf.port, dbConf.options);
connection.info(function (err, json) {
if (err === null){
console.log("Couchdb ("+json.version+") at "+dbConf.host+" connected.", json);
var forenDb = connection.database(dbConf.dbname);
// Create the db if it doesn't exist.
forenDb.exists(function (error, exists) {
if (!exists) {
forenDb.create(
function(error, res){
if(error === null){
callback(null, forenDb, connection);
}else{
callback(error, null,null);
}
});
}else callback(null, forenDb, connection);
});
}
else{
err.host = dbConf.host;
callback(err, null);
//console.log("info() failed to connect to couchdb : ", err);
}
});
}
exports.publish = function (design, to, next) {
var couch = app.get('config').couch,
connection = new cradle.Connection(couch.url, couch.port, { cache: false, auth: couch.admin }),
db = connection.database(to);
db.save(design, function (e) {
var connect;
if (e && e.error === 'conflict') {
// update
db.get(design._id, function (e, design) {
if (e) return app.log.error('[Design] could not get: ' + design._id), next(e);
connect = require('connect');
db.save(connect.utils.merge(design, design), function (e, design) {
if (e) return app.log.error('[Design] could not save: ' + design._id), next(e);
app.log.info('[Design] updated: ' + design._id + ' to: ' + to + ' rev: ' + design._rev);
next();
});
});
} else if (e) {
return app.log.error('[Design] could not save: ' + design._id + ' to: ' + to), next(e);
} else {
app.log.info('[Design] saved: ' + design._id + ' to: ' + to);
next();
}
});
};
function install() {
var couch = new (cradle.Connection)();
var moddb = module.exports.moddb = couch.database('spanner-mods');
var userdb = module.exports.userdb = couch.database('spanner-users');
var logdb = module.exports.logdb = couch.database('spanner-log');
[moddb, userdb].forEach(function(db) {
db.exists(function(err, exists) {
if (!exists) {
db.create()
}
})
});
logdb.exists(function(err, exists) {
if (!exists) {
logdb.create(function() {
// TODO: dunno what this is gonna do....
logdb.save('_design/log', {
bydate: {
map: function (doc) {
emit(doc.ts, doc);
}
}
});
});
}
});
}
;(function(){
"use strict";
var cradle = require('cradle'),
when = require('when');
// config
var config = require('cat-settings').loadSync(__dirname + '/config.json');
// connect to db
var connection = new cradle.Connection(config.db.host, config.db.port),
db = connection.database(config.db.database);
// lazy-create db
createDb(db)
.then(createView);
// helpers
function createDb (db) {
var deferred = when.defer();
db.exists(function (err, exists) {
if (err) {
throw new Error (err);
}
if (!exists) {
db.create();
console.log('db created!');
deferred.resolve(db);
} else {
console.log('db already exists!');
deferred.resolve(db); // db.reject()
}
});
return deferred.promise;
}
function createView (db) {
db.save('_design/runs', {
views: {
list: {
map: 'function (doc){ emit(doc._id, {mean: doc.mean, stddev: doc.stddev, count: doc.count}) }'
}
}
});
console.log('view created!');
}
})();
it('is available', function (done) {
var c = new(cradle.Connection)();
c.database('_users').get('', function (err, doc) {
assert.equal('_users', doc.db_name);
assert(!err);
done();
});
});
getDatabase:function(){
var c = new(cradle.Connection)(couch.host, couch.port, {
cache: true,
raw: false,
forceSave: true
});
return c.database(couch.db_name);
}
beforeEach(function() {
var browser = new zombie.Browser({debug: true});
browser.runScripts = false;
var fetch_done = false;
// initialize Base/CouchDB
var connection = new cradle.Connection();
db = connection.database("cardscience-test");
var created = false;
db.destroy(function() {
db.create(function() {
base.init(db);
base.Base.updateAllDesignDocuments(function() {
created = true;
});
});
});
waitsFor(function() { return created; }, "Couldn't create CouchDB test database?", 10000);
runs(function() {
// initialize scraper:
s = new scraper.Scraper();
var pages_to_fetch = [33, 38];
var grabAndSubmitPages = function(done) {
var current_page = pages_to_fetch.pop();
var p = path.join(__dirname, "fixtures", current_page + ".html");
browser.visit( url.format({protocol: "file", pathname: "//" + p}), function(err, _browser, status) {
expect(err).toBeNull();
z = _browser;
s.scrapePage(z.document, "classic", function(need_to_do_more) {
if(pages_to_fetch.length < 1) {
console.log("Done fetching and loading fixtures.");
done();
} else {
grabAndSubmitPages(done);
}
});
});
};
grabAndSubmitPages(function() { fetch_done = true;} );
});
waitsFor(function() {
return fetch_done;
}, "Zombie never finished loading our fixtures...?", 100000);
runs(function() {
console.log("Fixture loaded, ready to continue!");
});
});
(function() {
"use-strict";
var cradle = require('cradle')
, fs = require('fs')
, cradle = new (cradle.Connection)
, dbName = 'devfeed'
, db
, view
;
view = {
/*
latestConfig: {
map: function(doc) {
if(doc.type === 'config') {
emit(doc.timestamp, doc);
}
}
,
internal: {
map: function(doc) {
if (doc.type === 'internal') {
emit(doc.timestamp, doc);
}
}
}
*/
messages: {
map: function(doc) {
if(doc.type === 'message') {
emit(doc.timestamp, doc);
}
}
}
};
db = cradle.database(dbName);
db.create(function (createErr) {
if (createErr) {
console.log("Error creating db:\n" + createErr.reason);
if (createErr.error != "file_exists")
return;
}
console.log("Database created, or already existed!");
db.save("_design/feed", view, function(err, res) {
if (err) {
console.log("Error encountered while saving document:");
console.log(JSON.stringify(err, null, ' '));
return;
}
console.log("Response: "+ res);
console.log("(that means it probably worked)");
});
});
}());
exports.init = function(config) {
c = new(cradle.Connection)('http://' + config.TOKENS.couchHost, config.TOKENS.couchPort, {
cache: true,
raw: false
});
db = c.database(config.TOKENS.dbName);
}
var MessageModel = module.exports = function MessageModel() {
var couchCon = new(cradle.Connection)(
"173.230.137.226", 5984,
{auth: { username: "******", password: process.env.COUCH_PWD}}
);
this._couchClient = couchCon.database("stackchat");
this._redisClient = redis.createClient(6379, "173.230.137.226");
this._redisClient.auth(process.env.REDIS_PWD, function() {});
};
var setup = exports.setup = function(opts,cb) {
cradle.setup({
host: opts.host || '127.0.0.1',
port: 5984,
options: opts.options
});
var conn = new (cradle.Connection)({auth:opts.auth}),
db = conn.database(opts.database || 'buck');
cb(null,db);
};
connect: function(options, callback) {
this.isConnected = false;
if (typeof options === 'function')
callback = options;
var defaults = {
host: 'http://localhost',
port: 5984,
dbName: 'i18next',
resCollectionName: 'resources'
};
options = mergeOptions(options, defaults);
var defaultOpt = {
cache: true,
raw: false//,
// secure: true,
// auth: { username: '******', password: '******' }
};
options.options = options.options || {};
options.options = mergeOptions(options.options, defaultOpt);
this.resCollectionName = options.resCollectionName;
var self = this;
var client = new(cradle.Connection)(options.host, options.port, options.options);
var db = client.database(options.dbName);
db.exists(function (err, exists) {
function finish() {
self.client = client;
self.db = db;
self.isConnected = true;
if (callback) { return callback(null, self); }
}
if (err) {
if (callback) { return callback(err); }
} else if (!exists) {
db.create(function(err) {
finish();
});
} else {
finish();
}
});
},
module.exports.changeUsersPassword = function changeUsersPassword(dbConnection, user, newpassword,
successcallback, errorcallback) {
var c = new cradle.Connection();
var usersdb = c.database('_users', function () {
debug(new Date() + ' In the callback of opening the users database.');
});
// Get the user's current details,
var userid = 'org.couchdb.user:'******'There was a problem opening the user ' + user.username + ' in the database, their password cannot be updated.', err);
err.status = err.status || 500;
debug(new Date() + ' Here are the errors ' + util.inspect(err) + ' \n Here is the doc we get back ' + util.inspect(doc));
if (typeof errorcallback === 'function') {
errorcallback(err);
}
return;
}
debug(new Date() + " These are the users's details before changing their password." + util.inspect(userold));
// Delete the user
usersdb.remove(userid, userold._rev, function (err, couchdbresponse) {
debug('removing a user ', err, couchdbresponse);
// Save the user with a new password
var userParamsForNewUser = {
name: user.username,
password: newpassword,
roles: userold.roles,
previous_rev: userold._rev,
type: 'user'
};
usersdb.save(userid, userParamsForNewUser, function (err, doc) {
if (doc === undefined) {
doc = {
error: err
};
}
if (err !== null || !doc.ok) {
err.status = err.status || 500;
debug(new Date() + ' Here are the errors ' + util.inspect(err) + ' \n Here is the doc we get back ' + util.inspect(doc));
if (typeof errorcallback === 'function') {
errorcallback(err);
}
} else {
debug(new Date() + " User's couchdb password changed old revision number: " + userold._rev);
if (typeof successcallback === 'function') {
successcallback(doc);
}
}
});
});
});
};
couch.get(id, function design(error, doc) {
if (error && error.error === 'not_found') return couch.save(id, setup, done);
if (error) return done(error);
//
// Check if the current design document is up to date.
//
delete doc._rev;
if (JSON.stringify(doc) !== JSON.stringify(setup)) {
return couch.save(id, setup, done);
}
done(error);
});
init: function(config) {
console.log(config);
var cradle = require("cradle");
cradle.setup(config);
var connection = new (cradle.Connection);
var db = connection.database(config.name);
console.log(String.format("CouchDB database '{0}' running on {1}:{2} - relax...", config.name, config.host, config.port));
this.instance = db;
return db;
},
var setup = exports.setup = function (options, callback) {
// Set connection configuration
cradle.setup({
host: options.host || '199.192.240.62',
port: 5984,
options: options.options
});
// Connect to cradle
var conn = new (cradle.Connection)({ auth: options.auth }),
db = conn.database(options.database || 'team-too');
callback(null, db);
}
VotesPlugin.prototype.attach = function(options) {
var app = options.app,
connection = new(cradle.Connection)('https://' + options.host, 443, {
cache: false,
raw: false,
auth: options.auth
}),
db = connection.database(options.database);
this.votes = {
// assign the couch providers to the api object.
db: db,
connection: connection,
// get by id.
get: function(id, callback) {
db.get(id, function(err, doc) {
if (err) {
logger.error("Database error: " + err);
callback(err, null);
return;
}
callback(null, doc);
});
},
all: function(callback) {
db.view('bbq-votes/_all_docs', callback);
// function (err, res) {
// res.forEach(function (row) {
// console.log("%s is on the %s side of the force.", row.name, row.force);
// });
// });
},
/** Use this to update seats sold. **/
update: function(id, fields, callback) {
db.get(id, function(err, doc) {
_.extend(fields || {}, { _rev: doc._rev });
db.merge(id, fields, callback);
});
}
};
};
var setup = exports.setup = function (options, callback)
{
// Connect to cradle
var conn = new (cradle.Connection)(DBHOST, DBPORT, { auth: options.auth });
var db = conn.database('bookmarks');
if (options.setup)
{
initViews(db, callback);
}
else
{
callback(null, db);
}
};
createUserDatabase: function(data, res, userData) {
var newDb = db.database(data.name);
newDb.exists(function(error, exists) {
if (error) {
user.deleteUser(userData);
res.json({
success: false,
message: 'There was an error creating user database.',
data: err
});
}
else if (exists) {
user.deleteUser(userData);
res.json({
success: false,
message: 'User database already exists.',
data: {}
});
}
else {
newDb.create();
//setTimeout(function() {
// user.setUserDatabaseSecurity(newDb, data, res, userData);
//}, 3000);
user.setUserDatabaseSecurity(newDb, data, res, userData);
}
});
},
//
function userSessionUpdate(req, res) {
console.log('OMG, a request!');
console.info('request made for: ' + logNewLineResultsIndent + req.url + logNewLineIndent + 'check to see if user exists: ' + logNewLineResultsIndent + base64.decode(req.body.email));
var db = conn.database('heard');
db.get(req.body.email, function(err, doc) {
console.log('DB responded!');
if (err) {
if (err.error === 'not_found') {
console.error('user doesn\'t seem to exist in the DB - that\'s odd (unless it\'s an fb user)');
res.json({ userSessionUpdateStatus: 'notFound' });
} else {
console.error('uh-oh, unknown ERROR: ' + logNewLineResultsIndent + err);
res.json(err);
}
} else {
console.info('updating user session');
var docPayload = {
session: sessionHash(),
services: doc.services
};
if (doc.password !== undefined) docPayload.services.do.fb = true;
db.merge(req.body.email, docPayload, function(err, result2) {
console.log('DB responded!');
if (err) {
console.error('uh-oh, unknown ERROR: ' + logNewLineResultsIndent + err);
res.json(err);
} else {
// ideal outcome
console.info('success! send sessionPayload');
res.json({ userSessionUpdateStatus: 'letsRock', session: req.body.email + '.' + docPayload.session });
}
});
}
});
}
exports.connect = function () {
var dbHost = nconf.get('db_host');
var dbUserName = nconf.get('db_username');
var dbPassword = nconf.get('db_password');
var dbName = nconf.get('db_name');
logger.log("Trying to connect to database host: " + dbHost);
var connection = new (cradle.Connection)(dbHost, {
auth: { username: dbUserName, password: dbPassword }
});
db = connection.database(dbName);
logger.log('Successfully connected to couchdb');
return db;
};
self.database.create = function(data, callback) {
var ret = {};
var db1 = client.database(data.content.name);
db1.create();
ret.url = '/';
ret.message = 'Database ' + db1.name + ' has created successfully!';
callback(ret);
}
/**
* List data from a view specified by name.
*
* @param {String} view Optional name of the view in CouchDB, defaults to ping.
* @param {Function} done Completion callback.
* @api private
*/
function list(view, done) {
if ('function' !== typeof done) {
done = view;
view = 'ping';
}
couch.list('results/byRegistry/' + view, done);
}
function getData(couchUrl, callback) {
var parts = url.parse(couchUrl);
var client = new cradle.Connection(parts.hostname, parts.port || 80);
var db = client.database(parts.pathname.replace(/^\//, ""));
db.all({include_docs: true}, function(err, res) {
if (err) {
console.log("error getting data from " + url + ": ");
console.log(err);
}
else {
var data = _(res.rows).pluck("doc");
callback(data);
}
});
}