zater-verhoeff/src/CurrentAccount.js

Module for create account zater

class CurrentAccount {
	constructor(DigitalData, Verhoeff) {
		this.DigitalData = DigitalData;
		this.Verhoeff = Verhoeff;
	}

	generated() {
		const x =  Math.floor(1000 + Math.random() * 90000000);
		return ""+x.toString()+"";
	}

	findExist(numberAccount){
		const query = {where: {}};
		query.where.type = 'currentAccount';
		try {

			return Promise.resolve(this.DigitalData.find(query))
				.then(res => {
					if(res.length > 0) {
						const filterAccount = res.filter(item => item.data.numberAccount === numberAccount);
						if (filterAccount > 0)
							return true
					}
					return false;
				})
				.then(x => x)
				.catch(err => {throw err});
		} catch (e) {
			const err = new Error(e);
			err.statusCode = 500;
			err.code = 500;
			return Promise.reject(e)
		}
	}

	async create(user_id) {
		let numberAccount = 0;
		let numGen = true;

		try {

			let i = 0;
			while(numGen === true) {
				i++;
				numberAccount = this.generated();
				numGen = await this.findExist(numberAccount).then(res => res);
			};

			const verify = this.Verhoeff(numberAccount).generate();

			const digitalData = {};
			digitalData.type = 'currentAccount';
			digitalData.origin = 'btcBanco';
			digitalData.user_id = user_id;
			digitalData.data = {};
			digitalData.data.agency = '0001';
			digitalData.data.numberAccount = numberAccount;
			digitalData.data.verify = verify;
			digitalData.data.numberString = `${numberAccount}-${verify}`;


			return Promise.resolve(this.DigitalData.create(digitalData)).catch(err => {throw err});

		} catch (e) {
			const err = new Error(e);
			err.statusCode = 400;
			err.code = 400;
			return Promise.reject(err);
		}
	}

	validateCC(ccString) {
		if (ccString.length != 9) {
			const err = new Error('Número de conta inválido');
			err.code = 400;
			err.statusCode = 400;
			err.stack = "[zater-verhoeff] number invalid";
			return err;
		}
		if (!ccString.match(/[^$,.\d]/)) {
			const err = new Error('Dígito verificador é obrigatorio!');
			err.code = 400;
			err.statusCode = 400;
			err.stack = "[zater-verhoeff] verhoff invalid";
			return err;
		}
		const ccArray = ccString.split('-');

		if (isNaN(ccArray[1])) {
			const err = new Error('Dígito invalido!');
			err.code = 400;
			err.statusCode = 400;
			err.stack = "[zater-verhoeff] verhoff invalid";
			return err;
		}

		if (this.Verhoeff(ccArray[0]).generate() === ccArray[1]) {
			return true;
		} else {
			return false;
		}
	}

	getByuser(userId){
		const query = {where: {}};
		query.where.type = 'currentAccount';
		query.where.user_id = userId;
		try {
			const resolve = (res) => {
				if(!res || res.data === undefined)
					return ({numberAccount: "Não encontrada", numberString: "Não encontrada"});
				return res.data;
			};
			return Promise.resolve(this.DigitalData.findOne(query))
				.then(res => resolve(res))
				.catch(err => {throw err});
		} catch (e) {
			const err = new Error(e);
			err.statusCode = 500;
			err.code = 500;
			return Promise.reject(e)
		}
	}
}

export default (DigitalData, Verhoeff) => new CurrentAccount(DigitalData, Verhoeff);