gigaaa-chatbot-auth-extended/GigaaaAuthService.js

Gigaaa chatbots auth

var SQLDB = require('./mySQL-DB')
var gigaaaApi = require('./GigaaaApi');
var passwordGenerator = require('generate-password');

module.exports = {
    getUserToken: getUserTokenFromDb,
    checkIfUserExistInGigaaaSystem: checkIfUserExistInGigaaaSystem,
    authExistinGigaaaUser: authExistinGigaaaUser,
    authNewGigaaaUser: authNewGigaaaUser,
    deleteBotUserToken: deleteBotUserToken,
    initDB: SQLDB.initDb,
    loginUserOnGigaaaSystem: loginUserOnGigaaaSystem,
}

/**
 *
 *
 * @param {string} email
 * @param {string} password
 * @param {string} botId
 * @param {string} botType
 * @returns {string}
 */
async function authExistinGigaaaUser(email, password, botId, botType) {
    var loggedUser = await loginUserOnGigaaaSystem(email, password);
    await saveUserTokenToDb(botId, botType, loggedUser.id, loggedUser.api_token);
    return loggedUser.api_token;
}

/**
 *
 *
 * @param {string} email
 * @param {string} botId
 * @param {string} botType
 * @returns {token, password}
 */
async function authNewGigaaaUser(email, botId, botType) {
    var userPassword = await registerUserOnGigaaaSystem(email);
    var token = await authExistinGigaaaUser(email, userPassword, botId, botType);
    return {
        token: token,
        password: userPassword
    }
}

/**
 *
 *
 * @param {string} userId
 * @param {string} botType
 * @returns {string}
 */
async function getUserTokenFromDb(botUserId, botType) {
    let user = await SQLDB.getUser(botUserId, botType);
    if (user && user.gigaaaToken) {
        return user.gigaaaToken
    }
    return null;
}

/**
 *
 *
 * @param {string} email
 * @returns {boolean}
 */
async function checkIfUserExistInGigaaaSystem(email) {
    return gigaaaApi.registerUser(email)
        .catch((err) => {
            if (err.error.errors.email && err.error.errors.email[0] == 'The email has already been taken.') {
                return true;
            }
            return false;
        });
}

/**
 *
 *
 * @param {string} email
 * @param {string} password
 * @param {string} confirmPassword
 * @param {string} username
 * @returns {boolean}
 */
async function registerUserOnGigaaaSystem(email) {
    var randomlyGeneratedPassword = passwordGenerator.generate({
        length: 10,
        numbers: true
    });
    await gigaaaApi.registerUser(email, randomlyGeneratedPassword, randomlyGeneratedPassword, email);
    var loggedUser = await loginUserOnGigaaaSystem(email, randomlyGeneratedPassword);
    //set user language EN
    await gigaaaApi.updateUser(loggedUser.id, loggedUser.api_token, { language_code: "en" });
    return randomlyGeneratedPassword;
}

/**
 *
 *
 * @param {string} email
 * @param {string} password
 * @returns {user object}
 */
async function loginUserOnGigaaaSystem(email, password) {
    var response = await gigaaaApi.loginUser(email, password);
    var user = await gigaaaApi.currentUser(response.access_token);
    user.api_token = response.access_token;
    return user;
}

/**
 *
 *
 * @param {string} userId
 * @param {string} botType
 * @param {string} gigaaaUserId
 * @param {string} token
 * @returns {boolean}
 */
async function saveUserTokenToDb(botUserId, botType, gigaaaUserId, token) {
    try {
        let user = await SQLDB.getUser(gigaaaUserId, 'gigaaa');
        let lists = null;
        if (user) {
            lists = createListOfPropsAndValues(botUserId, botType, null, token);
            await SQLDB.updateUser(gigaaaUserId, 'gigaaa', lists.props, lists.values)
        } else {
            lists = createListOfPropsAndValues(botUserId, botType, gigaaaUserId, token);
            await SQLDB.createUser(lists.props, lists.values)
        }
        return true;
    } catch (error) {
        return false;
    }
}

/**
 *
 *
 * @param {string} botUserId
 * @param {string} botType
 * @returns {boolean} 
 */
async function deleteBotUserToken(botUserId, botType) {
    try {
        let user = await SQLDB.getUser(botUserId, botType);
        if (user) {
            await SQLDB.updateUser(botUserId, botType, [`${botType}ID`], [null])
        }
        return true;
    } catch (error) {
        return false;
    }
}

function createListOfPropsAndValues(botUserId, botType, gigaaaUserId, token) {
    let lists = {
        props: [],
        values: []
    }
    if (botUserId) {
        lists.props.push(`${botType}ID`);
        lists.values.push(botUserId);
    }
    if (gigaaaUserId) {
        lists.props.push('gigaaaID');
        lists.values.push(gigaaaUserId);
    }
    if (token) {
        lists.props.push('gigaaaToken');
        lists.values.push(token);
    }
    return lists;
}