account.js

var async = require('async');
var jsonSql = require('json-sql')();
jsonSql.setDialect("sqlite")
var constants = require('../helpers/constants.js');
var slots = require('../helpers/slots.js');
var genesisBlock = null;

var privated = {};

// Constructor
function Account(scope, cb) {
	this.scope = scope;
	genesisBlock = this.scope.genesisblock.block;

	this.table = "mem_accounts";

	this.model = [
		{
			name: "username",
			type: "String",
			length: 20,
			filter: {
				type: "string",
				maxLength: 20,
				minLength: 1
			},
			conv: String,
			constante: true
		},
		{
			name: "isDelegate",
			type: "BigInt",
			filter: {
				type: "boolean"
			},
			conv: Boolean,
			default: 0
		},
		{
			name: "u_isDelegate",
			type: "BigInt",
			filter: {
				type: "boolean"
			},
			conv: Boolean,
			default: 0
		},
		{
			name: "secondSignature",
			type: "BigInt",
			filter: {
				type: "boolean"
			},
			conv: Boolean,
			default: 0
		},
		{
			name: "u_secondSignature",
			type: "BigInt",
			filter: {
				type: "boolean"
			},
			conv: Boolean,
			default: 0
		},
		{
			name: "u_username",
			type: "String",
			length: 20,
			filter: {
				type: "string",
				maxLength: 20
			},
			conv: String,
			constante: true
		},
		{
			name: "address",
			type: "String",
			length: 21,
			not_null: true,
			unique: true,
			primary_key: true,
			filter: {
				required: true,
				type: "string",
				minLength: 1,
				maxLength: 21
			},
			conv: String,
			constante: true
		},
		{
			name: "publicKey",
			type: "Binary",
			length: 32,
			filter: {
				type: "string",
				format: "publicKey"
			},
			conv: String,
			constante: true
		},
		{
			name: "secondPublicKey",
			type: "Binary",
			length: 32,
			filter: {
				type: "string",
				format: "publicKey"
			},
			conv: String,
			constante: true
		},
		{
			name: "balance",
			type: "BigInt",
			filter: {
				required: true,
				type: "integer",
				minimum: 0,
				maximum: constants.totalAmount
			},
			conv: Number,
			default: 0
		},
		{
			name: "u_balance",
			type: "BigInt",
			filter: {
				required: true,
				type: "integer",
				minimum: 0,
				maximum: constants.totalAMount
			},
			conv: Number,
			default: 0
		},
		{
			name: "vote",
			type: "BigInt",
			filter: {
				type: "integer"
			},
			conv: Number,
			default: 0
		},
		{
			name: "rate",
			type: "BigInt",
			filter: {
				type: "integer"
			},
			conv: Number,
			default: 0
		},
		{
			name: "delegates",
			type: "Text",
			filter: {
				type: "array",
				uniqueItems: true
			},
			conv: Array,
			expression: "(select GROUP_CONCAT(dependentId) from " + this.table + "2delegates where accountId = a.address)"
		},
		{
			name: "contacts",
			type: "Text",
			filter: {
				type: "array",
				uniqueItems: true
			},
			conv: Array,
			expression: "(select GROUP_CONCAT(dependentId) from " + this.table + "2contacts where accountId = a.address)"
		},
		{
			name: "followers",
			type: "Text",
			filter: {
				type: "array",
				uniqueItems: true
			},
			conv: Array,
			expression: "(select GROUP_CONCAT(accountId) from " + this.table + "2contacts where dependentId = a.address)",
			readonly: true
		},
		{
			name: "u_delegates",
			type: "Text",
			filter: {
				type: "array",
				uniqueItems: true
			},
			conv: Array,
			expression: "(select GROUP_CONCAT(dependentId) from " + this.table + "2u_delegates where accountId = a.address)"
		},
		{
			name: "u_contacts",
			type: "Text",
			filter: {
				type: "array",
				uniqueItems: true
			},
			conv: Array,
			expression: "(select GROUP_CONCAT(dependentId) from " + this.table + "2u_contacts where accountId = a.address)"
		},
		{
			name: "u_followers",
			type: "Text",
			filter: {
				type: "array",
				uniqueItems: true
			},
			conv: Array,
			expression: "(select GROUP_CONCAT(accountId) from " + this.table + "2u_contacts where dependentId = a.address)",
			readonly: true
		},
		{
			name: "multisignatures",
			type: "Text",
			filter: {
				type: "array",
				uniqueItems: true
			},
			conv: Array,
			expression: "(select GROUP_CONCAT(dependentId) from " + this.table + "2multisignatures where accountId = a.address)"
		},
		{
			name: "u_multisignatures",
			type: "Text",
			filter: {
				type: "array",
				uniqueItems: true
			},
			conv: Array,
			expression: "(select GROUP_CONCAT(dependentId) from " + this.table + "2u_multisignatures where accountId = a.address)"
		},
		{
			name: "multimin",
			type: "BigInt",
			filter: {
				type: "integer",
				minimum: 0,
				maximum: 17
			},
			conv: Number,
			default: 0
		},
		{
			name: "u_multimin",
			type: "BigInt",
			filter: {
				type: "integer",
				minimum: 0,
				maximum: 17
			},
			conv: Number,
			default: 0
		},
		{
			name: "multilifetime",
			type: "BigInt",
			filter: {
				type: "integer",
				minimum: 1,
				maximum: 72
			},
			conv: Number,
			default: 0
		},
		{
			name: "u_multilifetime",
			type: "BigInt",
			filter: {
				type: "integer",
				minimum: 1,
				maximum: 72
			},
			conv: Number,
			default: 0
		},
		{
			name: "blockId",
			type: "String",
			length: 20,
			filter: {
				type: "string",
				minLength: 1,
				maxLength: 20
			},
			conv: String,
			default: genesisBlock.id
		},
		{
			name: "nameexist",
			type: "Boolean",
			filter: {
				type: "boolean"
			},
			conv: Boolean,
			default: 0
		},
		{
			name: "u_nameexist",
			type: "Boolean",
			filter: {
				type: "boolean"
			},
			conv: Boolean,
			default: 0
		},
		{
			name: "producedblocks",
			type: "BigInt",
			filter: {
				type: "integer",
				minimum: -1,
				maximum: 1
			},
			conv: Number,
			default: 0
		},
		{
			name: "missedblocks",
			type: "BigInt",
			filter: {
				type: "integer",
				minimum: -1,
				maximum: 1
			},
			conv: Number,
			default: 0
		},
		{
			name: "virgin",
			type: "Boolean",
			filter: {
				type: "boolean"
			},
			conv: Boolean,
			expression: "0"
		},
		{
			name: "fees",
			type: "BigInt",
			filter: {
				type: "integer"
			},
			conv: Number,
			default: 0
		},
		{
			name: "rewards",
			type: "BigInt",
			filter: {
				type: "integer"
			},
			conv: Number,
			default: 0
		}
	];

	this.fields = this.model.map(function (field) {
		var _tmp = {};
		if (field.type == "Binary") {
			_tmp.expression = ['lower', 'hex'];
		}

		if (field.expression) {
			_tmp.expression = field.expression;
		} else {
			if (field.mod) {
				_tmp.expression = field.mod;
			}
			_tmp.field = field.name;
		}
		if (_tmp.expression || field.alias) {
			_tmp.alias = field.alias || field.name;
		}

		return _tmp;
	});

	this.binary = [];
	this.model.forEach(function (field) {
		if (field.type == "Binary") {
			this.binary.push(field.name);
		}
	}.bind(this));

	this.filter = {};
	this.model.forEach(function (field) {
		this.filter[field.name] = field.filter;
	}.bind(this));

	this.conv = {};
	this.model.forEach(function (field) {
		this.conv[field.name] = field.conv;
	}.bind(this));

	this.editable = [];
	this.model.forEach(function (field) {
		if (!field.constante && !field.readonly) {
			this.editable.push(field.name);
		}
	}.bind(this));

	setImmediate(cb, null, this);
}

Account.prototype.createTables = function (cb) {
	var scope = this.scope;
	var sqles = [];

	var sql = jsonSql.build({
		type: 'create',
		table: this.table,
		tableFields: this.model
	});
	sqles.push(sql.query);

	var sql = jsonSql.build({
		type: 'create',
		table: "mem_round",
		tableFields: [
			{
				"name": "address",
				"type": "String",
				"length": 21
			},
			{
				"name": "amount",
				"type": "BigInt"
			},
			{
				"name": "delegate",
				"type": "String",
				"length": 64
			},
			{
				"name": "blockId",
				"type": "String",
				"length": 20
			},
			{
				"name": "round",
				"type": "BigInt"
			}
		]
	});
	sqles.push(sql.query);

	var sql = jsonSql.build({
		type: 'create',
		table: this.table + "2delegates",
		tableFields: [
			{
				name: "accountId",
				type: "String",
				length: 21,
				not_null: true
			}, {
				name: "dependentId",
				type: "String",
				length: 21,
				not_null: true
			}
		],
		foreignKeys: [
			{
				field: "accountId",
				table: this.table,
				table_field: "address",
				on_delete: "cascade"
			}
		]
	});
	sqles.push(sql.query);

	var sql = jsonSql.build({
		type: 'create',
		table: this.table + "2contacts",
		tableFields: [
			{
				name: "accountId",
				type: "String",
				length: 21,
				not_null: true
			}, {
				name: "dependentId",
				type: "String",
				length: 21,
				not_null: true
			}
		],
		foreignKeys: [
			{
				field: "accountId",
				table: this.table,
				table_field: "address",
				on_delete: "cascade"
			}
		]
	});
	sqles.push(sql.query);

	var sql = jsonSql.build({
		type: 'create',
		table: this.table + "2u_delegates",
		tableFields: [
			{
				name: "accountId",
				type: "String",
				length: 21,
				not_null: true
			}, {
				name: "dependentId",
				type: "String",
				length: 21,
				not_null: true
			}
		],
		foreignKeys: [
			{
				field: "accountId",
				table: this.table,
				table_field: "address",
				on_delete: "cascade"
			}
		]
	});
	sqles.push(sql.query);

	var sql = jsonSql.build({
		type: 'create',
		table: this.table + "2u_contacts",
		tableFields: [
			{
				name: "accountId",
				type: "String",
				length: 21,
				not_null: true
			}, {
				name: "dependentId",
				type: "String",
				length: 21,
				not_null: true
			}
		],
		foreignKeys: [
			{
				field: "accountId",
				table: this.table,
				table_field: "address",
				on_delete: "cascade"
			}
		]
	});
	sqles.push(sql.query);

	var sql = jsonSql.build({
		type: 'create',
		table: this.table + "2multisignatures",
		tableFields: [
			{
				name: "accountId",
				type: "String",
				length: 21,
				not_null: true
			}, {
				name: "dependentId",
				type: "String",
				length: 21,
				not_null: true
			}
		],
		foreignKeys: [
			{
				field: "accountId",
				table: this.table,
				table_field: "address",
				on_delete: "cascade"
			}
		]
	});
	sqles.push(sql.query);

	var sql = jsonSql.build({
		type: 'create',
		table: this.table + "2u_multisignatures",
		tableFields: [
			{
				name: "accountId",
				type: "String",
				length: 21,
				not_null: true
			}, {
				name: "dependentId",
				type: "String",
				length: 21,
				not_null: true
			}
		],
		foreignKeys: [
			{
				field: "accountId",
				table: this.table,
				table_field: "address",
				on_delete: "cascade"
			}
		]
	});
	sqles.push(sql.query);

	sqles.push("delete from mem_accounts2u_contacts;");
	sqles.push("delete from mem_accounts2u_delegates;");
	// sqles.push("delete from mem_accounts2u_multisignatures;");
	sqles.push("INSERT INTO mem_accounts2u_contacts SELECT * FROM mem_accounts2contacts;");
	sqles.push("INSERT INTO mem_accounts2u_delegates SELECT * FROM mem_accounts2delegates;");
	// sqles.push("INSERT INTO mem_accounts2u_multisignatures SELECT * FROM mem_accounts2multisignatures;");

	async.eachSeries(sqles, function (command, cb) {
		scope.dbLite.query(command, function (err, data) {
			cb(err, data);
		});
	}.bind(this), function (err) {
		setImmediate(cb, err, this);
	}.bind(this));
}

Account.prototype.removeTables = function (cb) {
	var scope = this.scope;
	var sqles = [];

	var sql = jsonSql.build({
		type: 'remove',
		table: this.table
	});
	sqles.push(sql.query);

	async.eachSeries(sqles, function (command, cb) {
		scope.dbLite.query(command, function (err, data) {
			cb(err, data);
		});
	}.bind(this), function (err) {
		setImmediate(cb, err, this);
	}.bind(this));
}

Account.prototype.objectNormalize = function (account) {
	var report = this.scope.scheme.validate(account, {
		object: true,
		properties: this.filter
	});

	if (!report) {
		throw Error(this.scope.scheme.getLastError());
	}

	return account;
}

Account.prototype.toDB = function (raw) {
	this.binary.forEach(function (field) {
		if (raw[field]) {
			raw[field] = new Buffer(raw[field], "hex");
		}
	});

	return raw;
}

Account.prototype.get = function (filter, fields, cb) {
	if (typeof(fields) == 'function') {
		cb = fields;
		fields = this.fields.map(function (field) {
			return field.alias || field.field;
		});
	}

	this.getAll(filter, fields, function (err, data) {
		cb(err, data && data.length ? data[0] : null)
	})
}

Account.prototype.getAll = function (filter, fields, cb) {
	if (typeof(fields) == 'function') {
		cb = fields;
		fields = this.fields.map(function (field) {
			return field.alias || field.field;
		});
	}

	var realFields = this.fields.filter(function (field) {
		return fields.indexOf(field.alias || field.field) != -1;
	});

	var realConv = {};
	Object.keys(this.conv).forEach(function (key) {
		if (fields.indexOf(key) != -1) {
			realConv[key] = this.conv[key];
		}
	}.bind(this));

	var limit, offset, sort;

	if (filter.limit > 0) {
		limit = filter.limit;
	}
	delete filter.limit;
	if (filter.offset > 0) {
		offset = filter.offset;
	}
	delete filter.offset;
	if (filter.sort) {
		sort = filter.sort;
	}
	delete filter.sort;

	var sql = jsonSql.build({
		type: 'select',
		table: this.table,
		limit: limit,
		offset: offset,
		sort: sort,
		alias: 'a',
		condition: filter,
		fields: realFields
	});

	this.scope.dbLite.query(sql.query, sql.values, realConv, function (err, data) {
		if (err) {
			return cb(err);
		}

		cb(null, data || []);
	}.bind(this));
}

Account.prototype.set = function (address, fields, cb) {
	var self = this;

	if (fields.publicKey !== undefined && !fields.publicKey){
		console.log("!!!!!!!!!!!!!!!!!!!!!!!", address, diff)
	}

	fields.address = address;
	var account = fields;
	var sqles = []

	var sql = jsonSql.build({
		type: 'insert',
		or: "ignore",
		table: this.table,
		values: this.toDB(account)
	});

	sqles.push(sql);

	var sql = jsonSql.build({
		type: 'update',
		table: this.table,
		modifier: this.toDB(account),
		condition: {
			address: address
		}
	});

	sqles.push(sql);

	async.eachSeries(sqles, function (sql, cb) {
		self.scope.dbLite.query(sql.query, sql.values, function (err, data) {
			cb(err, data);
		});
	}, cb);
}

Account.prototype.merge = function (address, diff, cb) {
	var update = {}, remove = {}, insert = {}, insert_object = {}, remove_object = {}, round = [];

	var self = this;

	if (diff.publicKey !== undefined && !diff.publicKey){
		console.log("!!!!!!!!!!!!!!!!!!!!!!!", address, diff)
	}

	this.editable.forEach(function (value) {
		if (diff[value]) {
			var trueValue = diff[value];
			switch (self.conv[value]) {
				case String:
					update[value] = trueValue;
					break;
				case Number:
					if (Math.abs(trueValue) === trueValue && trueValue !== 0) {
						update.$inc = update.$inc || {};
						update.$inc[value] = trueValue;
						if (value == "balance") {
							round.push({
								query: "insert into mem_round (address, amount, delegate, blockId, round) select $address, $amount, dependentId, $blockId, $round from mem_accounts2delegates where accountId = $address",
								values: {
									address: address,
									amount: trueValue,
									blockId: diff.blockId,
									round: diff.round
								}
							});
						}
					}
					else if (trueValue < 0) {
						update.$dec = update.$dec || {};
						update.$dec[value] = Math.abs(trueValue);
						if (value == "balance") {
							round.push({
								query: "insert into mem_round (address, amount, delegate, blockId, round) select $address, $amount, dependentId, $blockId, $round from mem_accounts2delegates where accountId = $address",
								values: {
									address: address,
									amount: trueValue,
									blockId: diff.blockId,
									round: diff.round
								}
							});
						}
					}
					break;
				case Array:
					if (Object.prototype.toString.call(trueValue[0]) == "[object Object]") {
						for (var i = 0; i < trueValue.length; i++) {
							var val = trueValue[i];
							if (val.action == "-") {
								delete val.action;
								remove_object[value] = remove_object[value] || [];
								remove_object[value].push(val);
							} else if (val.action == "+") {
								delete val.action;
								insert_object[value] = insert_object[value] || [];
								insert_object[value].push(val)
							} else {
								delete val.action;
								insert_object[value] = insert_object[value] || [];
								insert_object[value].push(val)
							}
						}
					} else {
						for (var i = 0; i < trueValue.length; i++) {
							var math = trueValue[i][0];
							var val = null;
							if (math == "-") {
								val = trueValue[i].slice(1);
								remove[value] = remove[value] || [];
								remove[value].push(val);
								if (value == "delegates") {
									round.push({
										query: "insert into mem_round (address, amount, delegate, blockId, round) select $address, -balance, $delegate, $blockId, $round from mem_accounts where address = $address",
										values: {
											address: address,
											delegate: val,
											blockId: diff.blockId,
											round: diff.round
										}
									});
								}
							} else if (math == "+") {
								val = trueValue[i].slice(1);
								insert[value] = insert[value] || [];
								insert[value].push(val)
								if (value == "delegates") {
									round.push({
										query: "insert into mem_round (address, amount, delegate, blockId, round) select $address, balance, $delegate, $blockId, $round from mem_accounts where address = $address",
										values: {
											address: address,
											delegate: val,
											blockId: diff.blockId,
											round: diff.round
										}
									});
								}
							} else {
								val = trueValue[i];
								insert[value] = insert[value] || [];
								insert[value].push(val)
								if (value == "delegates") {
									round.push({
										query: "insert into mem_round (address, amount, delegate, blockId, round) select $address, balance, $delegate, $blockId, $round from mem_accounts where address = $address",
										values: {
											address: address,
											delegate: val,
											blockId: diff.blockId,
											round: diff.round
										}
									});
								}
							}
						}
					}
					break;
			}
		}
	});

	var sqles = [];

	if (Object.keys(remove).length) {
		Object.keys(remove).forEach(function (el) {
			var sql = jsonSql.build({
				type: 'remove',
				table: self.table + "2" + el,
				condition: {
					dependentId: {$in: remove[el]},
					accountId: address
				}
			});
			sqles.push(sql);
		});
	}

	if (Object.keys(insert).length) {
		Object.keys(insert).forEach(function (el) {
			for (var i = 0; i < insert[el].length; i++) {
				var sql = jsonSql.build({
					type: 'insert',
					table: self.table + "2" + el,
					values: {
						accountId: address,
						dependentId: insert[el][i]
					}
				});
				sqles.push(sql);
			}
		});
	}

	if (Object.keys(remove_object).length) {
		Object.keys(remove_object).forEach(function (el) {
			remove_object[el].accountId = address;
			var sql = jsonSql.build({
				type: 'remove',
				table: self.table + "2" + el,
				condition: remove_object[el]
			});
			sqles.push(sql);
		});
	}

	if (Object.keys(insert_object).length) {
		Object.keys(insert_object).forEach(function (el) {
			insert_object[el].accountId = address;
			for (var i = 0; i < insert_object[el].length; i++) {
				var sql = jsonSql.build({
					type: 'insert',
					table: self.table + "2" + el,
					values: insert_object[el]
				});
				sqles.push(sql);
			}
		});
	}

	if (Object.keys(update).length) {
		var sql = jsonSql.build({
			type: 'update',
			table: this.table,
			modifier: update,
			condition: {
				address: address
			}
		});
		sqles.push(sql);
	}

	function done(err) {
		if (cb.length != 2) {
			return cb(err);
		} else {
			if (err) {
				return cb(err);
			}
			self.get({address: address}, cb);
		}
	}

	async.series([
		function (cb) {
			if (sqles.length > 1) {
				self.scope.dbLite.query('BEGIN TRANSACTION;');
			}

			async.eachSeries(sqles, function (sql, cb) {
				self.scope.dbLite.query(sql.query, sql.values, function (err, data) {
					cb(err, data);
				});
			}, function (err) {
				if (err) {
					if (sqles.length > 1) {
						self.scope.dbLite.query('ROLLBACK;', function (rollbackErr) {
							cb(rollbackErr || err);
						});
					} else {
						cb(err);
					}
					return;
				}
				if (sqles.length > 1) {
					self.scope.dbLite.query('COMMIT;', cb);
				} else {
					cb();
				}
			});
		},
		function (cb) {
			if (round.length > 1) {
				self.scope.dbLite.query('BEGIN TRANSACTION;');
			}

			async.eachSeries(round, function (sql, cb) {
				self.scope.dbLite.query(sql.query, sql.values, function (err, data) {
					cb(err, data);
				});
			}, function (err) {
				if (err) {
					if (round.length > 1) {
						self.scope.dbLite.query('ROLLBACK;', function (rollbackErr) {
							cb(rollbackErr || err);
						});
					} else {
						cb(err);
					}
					return;
				}
				if (round.length > 1) {
					self.scope.dbLite.query('COMMIT;', cb);
				} else {
					cb();
				}
			});
		}
	], done);
}

Account.prototype.remove = function (address, cb) {
	var sql = jsonSql.build({
		type: 'remove',
		table: this.table,
		condition: {
			address: address
		}
	});
	this.scope.dbLite.query(sql.query, sql.values, function (err, data) {
		cb(err, address);
	});
}

// Export
module.exports = Account;