vendor-management-api/engine.py

#----------Import neccessary packeges Starts-----------------#
from flask import Flask, request, jsonify, make_response, render_template
import pymongo
import json
from flask_cors import CORS
import gc
import os
from datetime import datetime
from flask import send_from_directory
import base64

#----------Import neccessary packeges Ends-----------------#

#----------Import Config File Starts-----------------#
from config import *
import requests
#----------Import neccessary  Ends-----------------#

#----------Import Service Func Starts------------ -----#
from service.vendor_service import *
from service.project_service import *
from service.fetch_master_service import *
from service.voucher_approval_service import *
from utils.FetchInterventions import getInterventionMaster
from service.voucher_list import *
from service.asset_service import *
from service.reports_service import *
from utils.DateOperation import *
from utils.FetchInterventions import getUserDetails
#----------Import Service Func Ends-----------------#

#----------Mongo Connection-----------#
mongoClient = pymongo.MongoClient(MONGO_URI)
mongo = mongoClient[MONGO_DBNAME]
#----------Mongo Connection End-------#
UPLOAD_FOLDER = 'uploads'
ALLOWED_EXTENSIONS = { '.pptx','.pdf', '.png', '.jpg', '.jpeg', '.gif','.xlsx','.xls'}


app = Flask(__name__)

app.config['JSON_SORT_KEYS'] = False
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.config['STATIC_IMG']='static_img'
app.config['PO_PDF']='po_pdf'
app.config['UPLOAD_EXTENSIONS']=ALLOWED_EXTENSIONS
app.config['SECRET_KEY'] = SECRET_KEY
app.config['TEMPLATES_AUTO_RELOAD'] = TEMPLATES_AUTO_RELOAD # Auto reload flak template
cors = CORS(app, resources={r"/*": {"origins": "*"}}) # Allow Cross origin request


@app.before_request
def before_request():
    gc.collect()

#------------------------------------------
#------------ Fetch Master Data------------
#------------------------------------------
@app.route('/validate_vendor_code', methods=['GET'])
def validate_vendor_code():
    try:
        queryResult=validateVendorCode(request.args.get('v_code'),mongo)
        return jsonify(queryResult)

    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify({'status': 'failure', 'message': 'Something went wrong!'})

@app.route('/validate_pan', methods=['GET'])
def validate_pan():
    try:
        queryResult=validatePANService(request.args.get('v_pan'),mongo)
        return jsonify(queryResult)

    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify({'status': 'failure', 'message': 'Something went wrong'})

@app.route('/register_vendor', methods=['POST'])
def register_vendor():
    try:
        data=request.form.to_dict(flat=True)
        queryResult=addVendorService(request.files,data,app,mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify({'status': 'failure', 'data': 'Something went wrong!'})

@app.route('/get_vendors', methods=['GET'])
def get_vendor():
    try:
        queryResult=getVendorList(request.args.get('id'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_all_vendors',methods=['GET'])
def get_all_vendors():
    try:
        queryResult=getAllVendorList(mongo)
        return jsonify(queryResult)
    except Exception as err:
        print(err)

@app.route('/get_unregistered_vendors',methods=['GET'])
def get_unregistered_vendors():
    try:
        queryResult=getAllUnregisteredVendorList(mongo)
        return jsonify(queryResult)
    except Exception as err:
        print(err)

@app.route('/get_vendor_details',methods=['GET'])
def get_vendor_details():
    try:
        queryResult=getVendorDetails(request.args.get('id'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/update_vendor_status',methods=['POST'])
def update_vendor_status():
    try:
        if not request.json:
            return jsonify({'status': 'failure', 'data':'Something went wrong!'})
        else:
            queryResult=updateVendorStatus(request.json,mongo)
            return queryResult
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify({'status': 'failure', 'data': 'Something went wrong!'})

@app.route('/update_vendor_status_admin',methods=['POST'])
def update_vendor_status_admin():
    try:
        if not request.json:
            return jsonify({'status': 'failure', 'data':'Something went wrong!'})
        else:
            queryResult=updateVendorStatusAdmin(request.json,mongo)
            return queryResult
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify({'status': 'failure', 'data': 'Something went wrong!'})

@app.route('/update_rating',methods=['POST'])
def update_rating():
    try:
        if not request.json:
            return jsonify({'status': 'failure', 'data':'Something went wrong!'})
        else:
            queryResult=update_rating_service(request.json,mongo)
            return queryResult
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify({'status': 'failure', 'data': 'Something went wrong!'})

@app.route('/get_vendor_ratings',methods=['GET'])
def get_vendor_ratings():
    try:
        queryResult=getVendorRatingsService(request.args.get('id'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_intervention', methods=['GET'])
def get_intervention():
    try:
        queryResult=getInterventionMaster(mongo)
        return jsonify({'status': 'success', 'data': queryResult})
    except Exception as err:
        print(err)
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify({'status': 'failure', 'data': 'Something went wrong!'})

@app.route('/add_project',methods=['POST'])
def add_project():
    try:
        data=request.form.to_dict(flat=True)
        queryResult=addProjectService(request.files,data,app,mongo)
        return queryResult
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify({'status': 'failure', 'data': 'Something went wrong!'})

@app.route('/submit_project',methods=['POST'])
def submit_project():
    try:
        if not request.json:
            return jsonify({'status': 'failure', 'data':'Something went wrong!'})
        else:
            queryResult=submitProjectDetails(request.json,mongo)
            return queryResult
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify({'status': 'failure', 'data': 'Something went wrong!'})

@app.route('/get_projects', methods=['GET'])
def get_projects():
    try:
        queryResult=getProjectList(request.args.get('id'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_all_projects', methods=['GET'])
def get_all_projects():
    try:
        queryResult=getAllProjectList(mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_project_details',methods=['GET'])
def get_project_details():
    try:
        queryResult=getProjectDetails(request.args.get('id'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/create_po',methods=['POST'])
def create_po():
    try:
        data=request.form.to_dict(flat=True)
        queryResult=createPOService(data,app,mongo)
        return queryResult
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify({'status': 'failure', 'data': 'Something went wrong!'})

@app.route('/create_po_pdf',methods=['GET'])
def create_po_pdf():
    try:
        queryResult=createPoPdfService(request.args.get('id'),app,mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_po_pdf',methods=['GET'])
def get_po_pdf():
    try:
        return send_from_directory(app.config['PO_PDF'], request.args.get('id')+'.pdf')
        
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_po_approvals',methods=['GET'])
def get_po_approvals():
    try:
        queryResult=getPOPendingLisForApprovals(request.args.get('id'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_po_archive_approvals',methods=['GET'])
def get_po_archive_approvals():
    try:
        queryResult=getPOArchiveLisForApprovals(request.args.get('id'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])


@app.route('/get_voucher_approvals',methods=['GET'])
def get_voucher_approvals():
    try:
        queryResult=getVoucherPendingLisForApprovals(request.args.get('id'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_voucher_archive_approvals',methods=['GET'])
def get_voucher_archive_approvals():
    try:
        queryResult=getVoucherArchiveLisForApprovals(request.args.get('id'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/approveDeclinePO',methods=['POST'])
def approveDeclinePO():
    try:
        if not request.json:
            return jsonify({'status': 'failure', 'data':'Something went wrong!'})
        else:
            queryResult=approveDeclinePOService(request.json,mongo,app)
            return queryResult
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify({'status': 'failure', 'data': 'Something went wrong!'})

@app.route('/get_po_status_log',methods=['GET'])
def get_po_status_log():
    try:
        queryResult=getPOStatusLogs(request.args.get('id'),mongo,app)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_voucher_status_log',methods=['GET'])
def get_voucher_status_log():
    try:
        queryResult=getVoucherStatusLogsService(request.args.get('id'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/vendor_acceptance',methods=['POST'])
def vendor_acceptance():
    queryResult={}
    try:
        data=request.form.to_dict(flat=True)
        queryResult=vendorAcceptanceService(request.files,data,app,mongo)
        return queryResult
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify({'status': 'failure', 'data': 'Something went wrong!'})

@app.route('/get_vouchers', methods=['GET'])
def get_vouchers():
    try:
        queryResult=getVoucherList(request.args.get('id'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_all_vouchers', methods=['GET'])
def get_all_vouchers():
    try:
        queryResult=getAllVoucherListService(mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_all_po',methods=['GET'])
def get_all_po():
    try:
        queryResult=getAllPOListService(mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_voucher_type',methods=['GET'])
def get_voucher_type():
    try:
        queryResult=getAllVoucherTypeListService(mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_budget_head',methods=['GET'])
def get_budget_head():
    try:
        queryResult=getAllBudgetHeadListService(mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_tds_rate',methods=['GET'])
def get_tds_rate():
    try:
        queryResult=getTDSRateListService(mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/create_voucher',methods=['POST'])
def create_voucher():
    try:
        data=request.form.to_dict(flat=True)
        queryResult=createVoucherService(request.files,data,app,mongo)
        return queryResult
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/update_tds_rate',methods=['POST'])
def update_tds_rate():
    try:
        if not request.json:
            return jsonify({'status': 'failure', 'data':'Something went wrong!'})
        else:
            queryResult=updateVoucherTDSService(request.json,mongo)
            return queryResult
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify({'status': 'failure', 'data': 'Something went wrong!'})

@app.route('/get_voucher_details',methods=['GET'])
def get_voucher_details():
    try:
        queryResult=getVoucherDetails(request.args.get('id'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/voucher_print_count',methods=['GET'])
def voucher_print_count():
    try:
        queryResult=getVoucherDetailsPrintCount(request.args.get('id'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/fetch_voucher_analytics',methods=['GET'])
def fetch_voucher_analytics():
    try:
        queryResult=getVoucherAnalyticsDataService(request.args.get('fromDate'),request.args.get('toDate'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_senior_list',methods=['GET'])
def get_senior_list():
    try:
        queryResult=getVoucherApprovalUserReportService(mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_senior_details',methods=['GET'])
def get_senior_details():
    try:
        queryResult=getSeniorDetailsService(request.args.get('emp_key'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        return jsonify([])

@app.route('/upload_senior_details',methods=['POST'])
def upload_senior_details():
    try:
        if not request.json:
            return jsonify({'status': 'failure', 'data':'Something went wrong!'})
        else:
            queryResult=uploadSeniorDetailsService(request.json,mongo)
            return jsonify(queryResult)
    except Exception as err:
        return jsonify({'status': 'failure', 'data': 'Something went wrong!'})

@app.route('/approve_decline_voucher',methods=['POST'])
def approve_decline_voucher():
    try:
        if not request.json:
            return jsonify({'status': 'failure', 'data':'Something went wrong!'})
        else:
            queryResult=approveDeclineVoucherService(request.json,mongo,app)
            return queryResult
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify({'status': 'failure', 'data': 'Something went wrong!'})

@app.route('/update_voucher_date',methods=['POST'])
def update_voucher_date():
    try:
        if not request.json:
            return jsonify({'status': 'failure', 'data':'Something went wrong!'})
        else:
            queryResult=updateVoucherDateService(request.json,mongo)
            return queryResult
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify({'status': 'failure', 'data': 'Something went wrong!'})

@app.route('/submitted_voucher_copy',methods=['GET'])
def submitted_voucher_copy():
    try:
        queryResult=submittedVoucherCopyService(request.args.get('id'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        return jsonify({'status': 'failure', 'data': 'Something went wrong!'})

@app.route('/delete_voucher',methods=['GET'])
def delete_voucher():
    try:
        queryResult=deleteVoucherService(request.args.get('id'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        return jsonify({'status': 'failure', 'data': 'Something went wrong!'})

@app.route('/delete_voucher_file',methods=['POST'])
def delete_voucher_file():
    try:
        if not request.json:
            return jsonify({'status': 'failure', 'message':'Something went wrong!'})
        else:
            queryResult=delete_voucher_file_service(request.json,mongo)
            return queryResult
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify({'status': 'failure', 'message': 'Something went wrong!'})

@app.route('/genrate_asset_id',methods=['POST'])
def genrate_asset_id():
    try:
        if not request.json:
                return jsonify([])
        else:
            queryResult=genrateAssetCode(request.json,mongo)
            return jsonify([queryResult])
    except Exception as err:
        return jsonify([])

@app.route('/get_asset_category',methods=['GET'])
def get_asset_category():
    try:
        queryResult=getAssetCategoryList(mongo)
        return jsonify(queryResult)
    except Exception as err:
        return jsonify([])

@app.route('/getAllAssetsList',methods=['GET'])
def getAllAssetsList():
    try:
        queryResult=getAllAssetsListService(mongo)
        return jsonify(queryResult)
    except Exception as err:
        return jsonify([])

@app.route('/get_approved_voucher_report',methods=['GET'])
def get_approved_voucher_report():
    try:
        queryResult=getVoucherReportDataService(request.args.get('fromDate'),request.args.get('toDate'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_mis_report',methods=['GET'])
def get_mis_report():
    try:
        queryResult=getVoucherMISReportDataService(request.args.get('fromDate'),request.args.get('toDate'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_mou_report',methods=['GET'])
def get_mou_report():
    try:
        queryResult=getMouReportDataService(request.args.get('fromDate'),request.args.get('toDate'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_tds_report',methods=['GET'])
def get_tds_report():
    try:
        queryResult=getTdsReportDataService(request.args.get('fromDate'),request.args.get('toDate'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_tally_report',methods=['GET'])
def get_tally_report():
    try:
        queryResult=getTallyReportDataService(request.args.get('fromDate'),request.args.get('toDate'),mongo)
        return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/get_depriciation_report',methods=['POST'])
def get_depriciation_report():
    try:
        if not request.json:
                return jsonify([])
        else:
            queryResult=getDepriciationReportService(request.json,app,mongo)
            return jsonify([queryResult])
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify([])

@app.route('/update_report_asset_details',methods=['POST'])
def update_report_asset_details():
    try:
        if not request.json:
                return jsonify({'status':'failure','message':'Something went wrong!'})
        else:
            queryResult=updateAssetReportDetailsService(request.json,mongo)
            return jsonify(queryResult)
    except Exception as err:
        # insert_into_error_log({'timestamp':int(datetime.now().timestamp()*1000),'type':'api','err':str(err),'function':'login'},mongo)
        return jsonify({'status':'failure','message':'Something went wrong!'})

@app.route('/get_all_users',methods=['GET'])
def get_all_users():
    try:
        queryResult=getAllUserList(mongo)
        return jsonify(queryResult)
    except Exception as err:
        print(err)

@app.route('/d_l/<uid>',methods=['GET'])
def direct_login(uid):
    response={}
    try:
        user_lst=getUserDetails(uid,mongo)
        if len(user_lst)!=0:
            timestamp=int(datetime.now().timestamp()*1000)
            
            name=""
            approval_track_vms="no"
            onboard_id=user_lst[0]['key']
            token=""

            if 'first_name' in user_lst[0]:
                name=user_lst[0]['first_name']

            if "approval_track_vms" in user_lst[0]:
                approval_track_vms= user_lst[0]["approval_track_vms"]
            
            try:
                token_string = user_lst[0]['personal_email_id']+str(123456)+str(timestamp)
                token_string_bytes = token_string.encode("ascii")
                
                base64_bytes = base64.b64encode(token_string_bytes)
                token = base64_bytes.decode("ascii")
            except Exception as err:
                print('===',err)

            response={"status":"Ok","user_name":name,"approval_track_vms":approval_track_vms,"onboard_id":onboard_id,"token":token}
        else:
            response={"status":"Error"}
    except Exception as err:
        response={"status":"Error"}
        print(err)
    
    return jsonify(response)

# Fetch Uploaded files
@app.route('/uploads/<filename>')
def upload(filename):
    return send_from_directory(app.config['UPLOAD_FOLDER'], filename)



if __name__ == '__main__':
    app.run(host="0.0.0.0", port=PORT,debug=True)

# created_lst=list(mongo['expense_detail'].aggregate([
#     {"$group" : { "_id": "$created_on", "count": { "$sum": 1 } } },
#     {"$match": {"_id" :{ "$ne" : None } , "count" : {"$gt": 1} } }, 
#     {"$project": {"name" : "$_id", "_id" : 0} }
# ]))
# i=0
# print("started")
# for created_on in created_lst:
#     i+=1
#     docs=list(mongo['expense_detail'].find({'added_from':{'$exists':True},'is_deleted':False,'created_on':created_on['name']}))
#     doc_id=""
#     remark=""
#     amount=0
#     expense_date=0
#     for index,doc in enumerate(docs):
        
#         if index==0:
#             exp_lst=list(mongo['expense_request'].find({'expenseKey':doc['expenseKey'],'status':'PENDING'}))
#             if len(exp_lst)==0:
#                 break
#             doc_id=doc['expenseKey']
#             remark=doc['remark']
#             amount=doc['amount']
#             expense_date=doc['expense_date']
#         elif doc_id==doc['expenseKey'] and expense_date==doc['expense_date'] and remark==doc['remark'] and amount==doc['amount']:
#             print(doc['expenseKey'],created_on['name'])
#             mongo['expense_detail'].update_one({'_id':doc['_id']},{'$set':{'is_deleted':True,'created_on':(created_on['name']+index+1)}})
# print("completed")