Backend-POS/Controller/Authentication.js

const asyncHandler = require("../Middleware/async");
const jwt = require("jsonwebtoken")
const User = require("../Model/User");
const AppModel = require("../Model/AppModel");
const ErrorResponse = require("../utils/errorResponse");
const dbInfo = require("../Model/Database")
const StoreInfo = require("../Model/StoreModel")
const DataModel = require("../Model/TD_DATA");
const UserModel = require("../Model/User");
const sequelize = require("sequelize");
const { log } = require("winston");


// Get Connection 
exports.getconnection = asyncHandler(async (req, res, next) => {
    try {
        db.authenticate()
            .then(() => {
                res
                    .send({
                        success: "true",
                        description: "Connection established",
                    })
                    .status(200);
            })
            .catch((err) => {
                return next(new ErrorResponse("Connection Falied", 500));
            });
    } catch (ex) {
        return next(new ErrorResponse("Connection Falied", 500));
    }
})

// Login User 
exports.login = asyncHandler(async (req, res, next) => {
    const { username, password, DB_CODE, APP_CODE = 'POS', CUST_CODE } = req.body
    console.log("USERNAME ", username)
    console.log("PASSWORD ", password)
    console.log("DB CODE ", DB_CODE)
    try {
        if (!username || !password || !DB_CODE) {
            throw "Not enough information"
        }
        // static admin case 
        if (username.toLowerCase() == process.env.ADMIN_USERNAME) {
            if (password != process.env.ADMIN_PASS) {
                throw "Invalid username or password"
            }

            const token = jwt.sign({
                id: 1,
                dbCode: DB_CODE,
                appCode: APP_CODE,
                custCode: CUST_CODE
            }, process.env.JWT_SECRET, {
                expiresIn: process.env.JWT_EXPIRE
            })

            if (!token) {
                throw "Something when wrong"
            }

            return res.status(200).send({
                success: "true",
                token: token,
                userid: 1,
                typeof: "SELLER",
                typeid: "ADMIN",
                dbcode: "DB_CODE",
                firstName: "ADMIN",
                lastName: "BC",
                warehouse: "1-LOC-OFFICE",
                address: "Tonaire Digital",
                map: '11.58371006791093,104.89721512933093'
            })


        }
        // verify from Database
        var user = await User.findOne({
            where: {
                USER_NAME: username
            }
        });
        console.log("USER ", user)
        if (!user) {
            throw "Invalid username or password"
        }


        const validPass = await user.matchPassword(password)
        console.log("IS VALID PASS", validPass)
        if (validPass == false) {
            throw "Invalid Password. Try Again"
        }

        // check whether user authorize to use the app or not
        var app = await AppModel.findOne({
            where: {
                APP_CODE: process.env.APP_CODE,
                USER_ID: user.USER_ID,
                DB_CODE: DB_CODE
            },
            order: [['USER_ID']],
        })
        console.log(">>>>>>> APP : ", app)
        console.log(">>>>>>> APP : ", process.env.APP_CODE)
        console.log(">>>>>>> APP : ", user.USER_ID)
        console.log(">>>>>>> APP : ", DB_CODE)

        if (!app) {
            throw "You're not allowed to use this app"
        }
        // CHECK USER TYPE 
        console.log("USER TYPE ", user.USER_TYPE)
        if (user.USER_TYPE == "C") {
            token = await user.getSignedJwtToken(
                DB_CODE,
                APP_CODE,
                customer.ADD_CODE
            )
        } else {
            token = await user.getSignedJwtToken(
                DB_CODE,
                APP_CODE,
                CUST_CODE,
            )
        }

        var store = await StoreInfo.findOne({
            where: {
                DB_CODE: app.DB_CODE,
                DB_STAT: "A"
            },
            raw: true
        })
        console.log("STORE ", store)

        if (!store) {
            throw "Store not found or disabled"
        }

        if (!token) {
            throw "Something Went Wrong"
        }

        return res.status(200).send({
            message: "Login Successful",
            app: app,
            token: token
        })
    } catch (error) {
        next(new ErrorResponse(error, 400));
    }
})

exports.register = asyncHandler(async (req, res, next) => {
    try {

        var data = JSON.parse(req.body.data)
        console.log("DATA ", data)
        const photo = req.files.photo
        const { testing } = data
        console.log("TESTING ", testing);
        // const { username, password, email, phone, userType, appCode, dbCode, custCode } = req.body
        res.status(200).send({
            success: true,
            data: data,
        })
    }
    catch (e) {
        return new ErrorResponse(e, 400)
    }

})

exports.checkUsername = asyncHandler(async (req, res, next) => {
    const { username, APP_CODE } = req.query;
    console.log("USERNAME ", username)
    try {
        if (!username) {
            return res.status(400).send({
                message: "Invalid Username"
            })
        }
        var user = await User.findOne({
            where: {
                USER_NAME: username
            }
        });
        if (user) {
            if (user.APPROVED == 0) {
                return next(new ErrorResponse("Username is not yet approved", 403))
            }

            if (user.USER_STATUS == "0") {
                return next(new ErrorResponse("Username is disabled", 403))
            }
            user = JSON.parse(JSON.stringify(user))
            delete user.USER_PASS //remove password from user object when return to client 

            // chech whether user authorize to use the app or not
            const isAllowed = await AppModel.findAll({
                where: {
                    APP_CODE: APP_CODE,
                    USER_ID: user.USER_ID
                },
                // we need to specify this order because in APP_MODEL we don't have primary key
                // in default sequelize will order by primary key so it will turn into error
                order: [['DB_CODE']]
            })

            console.log("IS ALLOWED ", isAllowed)


            if (isAllowed.length == 0) {
                return next(new ErrorResponse("User is not allowed to use this app", 403))
            } else {
                // In this Block we want to return the USER Presets To Client 
                // Note : Presets is not a column in User Table

                user.PRESETS = {}

                // GET Store Name from SDSTINFO by using DB_CODe from APP_MODEL


                await Promise.all(isAllowed.map(async (app) => {
                    console.log((">>>>>>> APP DB CODE", app))

                    const { DB_NAME } = await StoreInfo.findOne({
                        where: {
                            DB_CODE: app.DB_CODE,
                            DB_STAT: "A"
                        },
                        raw: true
                    })

                    const DBName = app.DB_CODE + ' - ' + DB_NAME
                    if (!user.PRESETS[DBName]) {
                        user.PRESETS[DBName] = []
                    }

                    // // check user type 
                    if (user.USER_TYPE == "S" || user.USER_TYPE == "C" || user.USER_TYPE == "A") {
                        var userPresets = await DataModel.findAll({
                            where: {
                                DATA_CODE: app.PRESET,
                            },
                            order: [["DATA_DESC"]]
                        })
                        user.PRESETS[DBName].push(userPresets)
                    }
                }))
                user.profile_image = "uploads/store_image/" + user.USER_ID + ".jpg"

                res.status(200).send(
                    JSON.stringify(user)
                )
            }

        } else {
            return next(new ErrorResponse("Username is not available", 404))
        }
    } catch (e) {
        if (req.files && req.files.store_image) {
            const filePath = req.files.store_image[0].path;
            fs.unlink(filePath, err => {
                if (err) console.error("Error removing file", err);
            });
        }
        throw new ErrorResponse(e, 400)
    }
})

exports.checkExistingUsername = asyncHandler(async (req, res, next) => {
    const { username } = req.query
    try {
        const existingUsername = await UserModel.findOne({
            where: {
                USER_NAME: sequelize.where(
                    sequelize.fn("LOWER", sequelize.col("USER_NAME")),
                    " = ", username.toLowerCase()
                )
            },
            order: [["USER_ID"]]
        })

        if (existingUsername) {
            return res.status(200).send({
                success: true,
                data: true
            })
        }
        return res.status(200).send({
            success: true,
            data: false
        })
    } catch (err) {
        console.log("ERROR CHECK EXISTING USERNAME", err)
        return next(new ErrorResponse(err, 400));
    }
})