migration

#!/usr/bin/env node
'use strict';

var Steppy = require('twostep').Steppy,
	_= require('underscore'),
	db = require('../db'),
	mysql = require('mysql'),
	async = require('async'),
	config = require('../config')('development'),
	translit = require('transliteration'),
	generatePassword = require('password-generator'),
	helpers = require('../utils/helpers'),
	//rs = require('randomstring'),
	dict = require('../utils/helpers/resumeDictionaries'),
	striptags = require('striptags'),
	moment = require('moment');

var noVacancy = 0,
	yesVacancy = 0;

var conn = mysql.createConnection({
	host     : 'localhost',
	user     : 'root',
	password : 'root',
	database : 'skillbook'
});


var schedule = {
	'Полный рабочий день': 'fullday_work',
	'Сменный': 'shift_work',
	'Неполный рабочий день': 'not_fullday_work',
	'Свободный': 'free_work',
	'Скользящий': 'flexible_shedule',
	'Гибкий': 'flexible_shedule'
}

var employment = {
	'Постоянная': 'full_employment',
	'Разовая': 'one_time_employment',
	'Надомная': 'home_employment',
	'По совместительству': 'combine_employment',
	'Сезонная': 'temporary_job',
	'Временная': 'temporary_job',
	'Стажировки для студентов': 'traineeship'
}

var experience = {
	0 : 'null_experience',
	1 : '1to3years',
	2 : '3to5years',
	3 : 'over5years'
}

conn.connect();

function migrateVacancy(vacancy, organization, callback) {
	var newVacancy;
	Steppy(
		function() {

			var s = _(dict.schedule).filter(function(sch) {
				return sch.sysName === schedule[vacancy.schedule]
			});

			var e = _(dict.employment).filter(function(emp) {
				return emp.sysName === employment[vacancy.employment]
			});

			var edu = _(dict.education).filter(function(level) {
				return level.name === vacancy.edulevel;
			});

			var exp = _(dict.experience).filter(function(exp) {
				return exp.sysName === experience[vacancy.experience];
			});

			newVacancy = {
				name: vacancy.position,
				salary: vacancy.salary,
				placesCount: vacancy.vaccount? vacancy.vaccount: 1,
				duties: striptags(vacancy.mainduties),
				schedule: s.length? s[0] : {},
				employment: e.length? e[0] : {},
				education: edu.length? edu[0]: {},
				experience: exp.length? exp[0]: {},
				organization: _(organization).pick('_id', 'name'),
				createDate: moment(vacancy.pubdate).valueOf(),
				updateDate: moment(vacancy.pubdate).valueOf(),
				isPublished: true,
				isDraft: false
			}

			//console.log('vacancy.pubdate>>> ', vacancy.pubdate);
			var regex = new RegExp('.*' + vacancy.city + '.*');
			db.dictionaries.find({dictName: 'cities', fullName: regex}).toArray(this.slot());
		},
		function(err, cities) {
			//console.log('cities>>> ', cities);
			if (cities.length) {
				newVacancy.city = cities;
			}
			//console.log('newVacancy>>> ', newVacancy);
			db.vacancies.find({
				name: newVacancy.name,
				'organization._id': organization._id
			}).toArray(this.slot());
		},
		function(err, vacancies) {
			var slot = this.slot();

			if(!vacancies.length) {
				++noVacancy
				console.log("no vacancy", noVacancy);

				// console.log('insert new vacancy>>> ', newVacancy.name);
				db.vacancies.insertOne(newVacancy, slot)
			} else {
				// console.log('update vacancy>>> ', newVacancy.name);
				++yesVacancy
				console.log("yes vacancy", yesVacancy);
				db.vacancies.updateOne(
					{
						name: newVacancy.name,
						'organization._id': organization._id
					},
					{$set: newVacancy},
					slot
				)
			}
		},
		function(err, insertRes) {
			//console.log('insertRes>>> ', insertRes);
			callback(err, null);
		}
	)
}

function migrateVacancies(organization, callback) {
	console.log("organization", organization);
	Steppy(
		function() {

// Здесь вакансии фильтруются по организации и здесь косяк

			conn.query('select vac.position, vac.pubdate as pubdate, edu.name as edulevel, vac.salary as salary, vac.experience as experience,'
				' vac.number as vaccount, vac.mainduties, sh.name as schedule, cit.name as city,'+
				' emp.name as employer, empt.name as employment from modx_vacancies_vacancies as vac' +
				' join modx_vacancies_employers as emp on emp.id = vac.employer_id ' +				//  emp.name as employer если здесь 0 то теряем вакансию
				' join modx_vacancies_cities as cit on cit.id = vac.city_id ' +
				' join modx_vacancies_employments as empt on empt.id = vac.employment_id ' +        // 	empt.name as employment_id если здесь 0 то теряем вакансию
				' join modx_vacancies_educationlevels as edu on edu.id = vac.educationlevel_id ' +	//	edu.name as edulevel если здесь 0 то теряем вакансию
				'join modx_vacancies_scheduletypes as sh on sh.id = vac.scheduletype_id where vac.employer_id = ' + organization.oldId, this.slot());	// sh.name as schedule если здесь 0 то теряем вакансию
		},
		function(err, vacancies) {
			//console.log("query result", vacancies);
			console.log("wtf", vacancies.length);
			async.eachSeries(vacancies, function(vacancy, cb) {
				migrateVacancy(vacancy, organization, cb);
			}, this.slot())
		},
		function(err, res) {
			callback(err, res);
		}
	)
}


function insertOrUpdateEmployer(employer, callback) {
	var sysName,
		authUser,
		organization,
		account;

	Steppy(
		function() {
			sysName = employer.name;
			sysName = translit.transliterate(sysName.replace(/\s/g, '_'));
			sysName = sysName.replace(/[^a-zA-Z_]/g, '');
			sysName = sysName.toLowerCase();

			var newPassword = generatePassword(6, false);

			var md5 = helpers.makePassword(sysName);

			var sum = _.reduce(md5, function(a, b) {
				return ('' + a).charCodeAt(0) + ('' + b).charCodeAt(0);
			})

			var email = sysName.substr(sysName.length - 3) + md5.substr(md5.length - 6) + sum;

			email = email.toLowerCase() + '@' + (email[0] < 'n' ? 'mail.ru': 'yandex.ru');

			var newPasswordHash = helpers.makePassword(newPassword);

			authUser = {
				firstName: 'organizationFirst',
				lastName: 'organizationLast',
				middleName: 'organizationMiddle',
				fullName: sysName,
				email: email,
				passwordOpen: newPassword,
				password: newPasswordHash
			}
			organization = {
				name: employer.name,
				sysName: sysName,
				oldId: employer.id,
				approved: true
			}

			db.authUsers.find(
				{
					email: authUser.email,
					firstName: 'organizationFirst'
				}
			).toArray(this.slot())
		},
		function(err, authUsers) {
			var slot = this.slot();

			if(!authUsers.length) {
				//console.log('insert authUser; ', authUser.email,
					//authUser.passwordOpen, organization.name, organization.sysName);
				db.authUsers.insertOne(authUser, slot)
			} else {
				//console.log('update authUser; ', authUser.email,
					//authUser.passwordOpen, organization.name, organization.sysName);

				db.authUsers.updateOne(
					{email: authUser.email},
					{$set: authUser},
					slot
				)
			}
		},
		function(err, authUserRes) {
			db.organizations.find({sysName: organization.sysName}).toArray(this.slot());
		},
		function(err, organizations) {
			var slot = this.slot()
			if(!organizations.length) {
				//console.log('insert organization; ', organization.name, organization.sysName);
				db.organizations.insertOne(organization, slot)
			} else {
				//console.log('update organization; ', organization.name, organization.sysName);
				db.organizations.updateOne(
					{sysName: organization.sysName},
					{$set: organization},
					slot
				)
			}
		},
		function(err, upRes) {
			db.organizations.findOne({sysName: organization.sysName}, this.slot());
		},
		function(err, dborganization) {
			this.pass(dborganization);
			db.authUsers.findOne({email: authUser.email}, this.slot())
		},
		function(err, dborganization, authUser) {
			//console.log(dborganization);
			account = {
				role: 'employer',
				structures: {
					organization: _(dborganization).pick('_id', 'name'),
				},
				email: authUser.email,
				data: {},
				authUserId: authUser._id
			}
			db.accounts.find({authUserId: account.authUserId}).toArray(this.slot());
		},
		function(err, accounts) {
			var slot = this.slot();

			if(!accounts.length) {
				//console.log('insert account>>> ', account.email);
				db.accounts.insertOne(account, slot)
			} else {
				//console.log('update account>>> ', account.email);
				db.accounts.updateOne(
					{authUserId: account.authUserId},
					{$set: account},
					slot
				)
			}
		},
		function(err, accRes) {

			db.organizations.findOne({sysName: organization.sysName}, this.slot());
		},
		function(err, dborganization) {
			migrateVacancies(dborganization, this.slot());
		},
		function(err, res) {
			callback(err, res);
		}
	)
}

Steppy(
	function() {
		db.init({config: config.mongodb}, this.slot());
	},
	function(err, connRes) {
		conn.query('select* from modx_vacancies_employers', this.slot());
	},
	function(err, employers) {
		console.log("first mysql query", employers.length);

		async.eachSeries(employers, function(employer, cb) {
			insertOrUpdateEmployer(employer, cb);
		}, this.slot())
	},
	function(err, res) {
		if(err) {
			throw err;
		}
		process.exit();
	}
)