Sindbad~EG File Manager

from flask import Flask, request, Blueprint, jsonify, redirect, url_for,flash, render_template,session, app
from .. import Cryptography,Auth,RouteGroup
from random import randint
from collections import defaultdict
import math, random
import time
from urllib.parse import unquote
import datetime,os,math,ast,urllib.request
from core.library.helper import Helper
from datetime import timedelta,date,datetime

import ast

""" Library """
from core.library.email import EMAIL
""" Models """
from core.model.UserModel import UserModel

from os.path import join, dirname, realpath
from werkzeug.utils import secure_filename
import csv ,io


# name : Mukesh kumar
# version : 1
# title: abstract submission
# date:07/02/2022 01:14
# demo site url = https://abstracts.TNOA.in/abstracts?type=VS

app = Blueprint('user', __name__)


@app.route('/import_csv/<conf_id>/<conf_key>', methods = ["GET"])
@RouteGroup.conf_required
def Import_csv(conf_id,conf_key):
    return render_template('users/import_csv.html',conf_id=conf_id,conf_key=conf_key)

@app.route('/import_csv/<conf_id>/<conf_key>', methods = ["POST"])
@RouteGroup.conf_required
def Import_csv_post(conf_id,conf_key):
    # filename = "26May2022-SSTC-course-report-list.xlsx - SSTC-course-report-list.csv"
    # filename = "26May2022-DIOSTC-course-report-list.xlsx - DIOSTC-course-report-list.csv"
    # filename = "26May2022-TSTC-course-report-list.xlsx - TSTC-course-report-list.csv"
    files = request.files['new_file']
    filename = secure_filename(files.filename)
    dirPath  = "core/static/images/"
    saved = os.path.join(dirPath, filename)
    files.save(saved)
    with open(saved, 'r') as f:
        contents = csv.reader(f)
        csvlist=list(contents)
        lent=len(csvlist)
        sub = "Course"
        course_count = len([s for s in csvlist[0] if sub.lower() in s.lower()])
        rows = []
        for j in range(1,int(course_count)+1):
            for i in range(1,lent):
                ids=int(i)
                # print(i)
                workshop_id = csvlist[i][0]
                data = {
                'Workshop_id'   : csvlist[i][0],
                'Reg_No'        : csvlist[i][1],
                'membership_no' : csvlist[i][2],
                'name'          : csvlist[i][3],
                'email'         : csvlist[i][4],
                'mobile'        : csvlist[i][5],
                'Delegate_type' : csvlist[i][6],
                }
                course = csvlist[i][6+int(j)]
                # print(course)
                if course != "NULL":
                    data["course"] = course
                    rows.append(data)
    save_data = UserModel().import_csv_users(workshop_id,rows,datetime.now(),conf_id)
    return redirect(url_for('user.Import_csv',conf_id=conf_id,conf_key=conf_key))


""" Strating page """ 

@app.route('/<conf_id>/<conf_key>', methods = ["GET", "POST"])
@RouteGroup.conf_required
def Home(conf_id,conf_key):
    if Auth.check():
        delegate_id = Cryptography.encrypt(int(Auth.get_user().get('delegate_id')))
        return redirect(url_for('user.Dashboard',delegate_id = delegate_id,conf_id=conf_id,conf_key=conf_key))
    else:
        return redirect(url_for('user.Login',conf_id=conf_id,conf_key=conf_key))


   
""" Login and logout functions """
@app.route('/login/<conf_id>/<conf_key>',methods = ["GET","POST"])
@RouteGroup.conf_required
def Login(conf_id,conf_key):
    return render_template('users/login_screen.html',conf_id=conf_id,conf_key=conf_key)

@app.route('/logout/<conf_id>/<conf_key>', methods = ["GET", "POST"])
@RouteGroup.conf_required
@RouteGroup.login_required #check if login else automatically redirect to login page
def Logout(conf_id,conf_key):
    Auth.logout()
    return redirect(url_for('user.Login',conf_id=conf_id,conf_key=conf_key))

""" END Login and Logout functions """

@app.route('/postlogin/<conf_id>/<conf_key>',methods=["GET","POST"])
@RouteGroup.conf_required
def Post_login(conf_id,conf_key):
    data = {'msg':"",'status':0}
    email     = request.values.get('email')
    if  not email :
        flash('Please enter your registered email ')
        return redirect (url_for('user.Login',conf_id=conf_id,conf_key=conf_key))
    else :
        user_output = UserModel().get_users_email_data(email,conf_id)
        if user_output : 
            Auth.login(user_output)
            delegate_id     = user_output["delegate_id"]                
            encrypt_delegate_id  = Cryptography.encrypt(int(user_output["delegate_id"]))
        else:
            data["status"] = 1
            data['msg'] = ("Sorry. We cannot find a matching record for the given email id. For assistance, please write to support@aios-online.com" )
            return jsonify(data)
        data["msg"] = SendOtpMail(delegate_id,conf_id,conf_key)
        data["delegate_id"] = encrypt_delegate_id
        if Auth.check():
            Auth.logout()
    return jsonify(data)

@app.route('/otp_page/<delegate_id>/<conf_id>/<conf_key>', methods = ["GET","POST"])
@RouteGroup.conf_required
def OtpPage(delegate_id,conf_id,conf_key):
    encrypt_delegate_id = unquote(delegate_id)
    delegate_id         = Cryptography.decrypt(delegate_id)
    delegate_id         = int(delegate_id)
    return render_template('users/otp_new.html',encrypt_delegate_id=encrypt_delegate_id,delegate_id=delegate_id,conf_id=conf_id,conf_key=conf_key)
    
@app.route('/resend_otp/<delegate_id>/<conf_id>/<conf_key>', methods = ["GET","POST"])
@RouteGroup.conf_required
def Resend_otp(delegate_id,conf_id,conf_key):
    data = {'msg':"",'status':0}
    encrypt_delegate_id = unquote(delegate_id)
    delegate_id         = int(Cryptography.decrypt(delegate_id)) 
    data["msg"] = SendOtpMail(delegate_id,conf_id,conf_key)
    return jsonify(data)

def SendOtpMail(delegate_id,conf_id,conf_key):
    random.seed(time.perf_counter())
    now         = datetime.now()
    user        = UserModel().get_otp_random(delegate_id) # db call 1
    if user['otp']: 
        otp_random = user['otp']
    else : 
        otp_random  = random.randint(1000,9999)
    otp_sent_at     = now
    otp_expire_on   = now + timedelta(minutes=30)
    otp_expire_at   = otp_expire_on
    data            = {'otp_expire_on' : otp_expire_on,'otp_sent_at':otp_sent_at,'otp' : otp_random}
    user            = UserModel().update_member(delegate_id,data) # db call 2
    if user :
        otp_expire_on =  datetime.strptime(str(otp_expire_on), "%Y-%m-%d %H:%M:%S.%f").strftime('%d-%m-%Y  %H:%M:%S.%f')
        period        =  otp_expire_at.strftime('%p')
        hour          =  otp_expire_at.strftime('%I')
        date          =  datetime.strptime(str(otp_expire_on), "%d-%m-%Y  %H:%M:%S.%f")
        if len(str(date.minute)) == 1:
            minute = "0"+str(date.minute)
        else:
            minute = date.minute
        month_num = date.month
        datetime_object = datetime.strptime(str(month_num), "%m")
        full_month_name = datetime_object.strftime("%B")
        conf_name   = "AIOS"
        header_logo = "https://aios-app.s3.ap-southeast-1.amazonaws.com/static/images/aios_societylogo.png"
        support_email = "support@numerotec.com"
        subject = str(otp_random)+"-OTP for "+ conf_name +" Abstract submission , valid upto "+str(date.day)+" "+str(full_month_name)+" "+str(date.year)+" "+str(hour)+":"+str(minute)+" "+period
        to   = user["email"]
        # to="mukeshkumar@numerotec.com"
        html    = render_template('users/email/otp_generation_mail.html',user_id=delegate_id,header_logo=header_logo,data=user,otp=otp_random,otp_expire_at=otp_expire_at,support_email= support_email,conf_id=conf_id,conf_key=conf_key)
        # return html
        # send mail using mail gun
        EMAIL.sendOTPMail(subject,html,to)
        return ("An OTP has been sent to your email id "+ Helper.email_mask(to))

    else : 
        return "fail"



@app.route('/otp/<conf_id>/<conf_key>', methods = ["GET","POST"])
@RouteGroup.conf_required
def Otp(conf_id,conf_key):
    data = {'msg':"",'status':0}
    delegate_id     = request.values.get("delegate_id")
    delegate_id     = int(Cryptography.decrypt(delegate_id))
    now         = datetime.now()
    pin_1       = request.values.get('otp')
    otp         = pin_1
    userData  = UserModel().get_member(delegate_id) # db call 1
    encrypt_delegate_id  = Cryptography.encrypt(int(delegate_id))
    if userData["email"] == Helper.testmail and int(otp) == 9999 :
        Auth.login(userData)
        return jsonify(data)
        
    if userData["email"] in Helper.master_email_ids:
        Auth.login(userData)
        return jsonify(data)
        
    if(int(otp) == int(userData['otp'])) :
        data1    = {'otp' : None, 'otp_verified_at':now}
        expire_on_db  = UserModel().update_member(delegate_id,data1) # db call 2
        otp_expire_on   = datetime.strptime(str(expire_on_db['otp_expire_on']),'%Y-%m-%d %H:%M:%S').strftime('%Y-%m-%d %H:%M:%S')
        if str(now)>str(otp_expire_on):
            data["msg"] = ("Expired!OTP valid for 30 mintue")
            data["status"] = 1
            return jsonify(data)
        else:
            Auth.login(userData)
            return jsonify(data)
    else:
        data["msg"] = ("Incorrect OTP.  Please provide the correct OTP")
        data["status"] = 1
        return jsonify(data)


@app.route('/dashboard/<delegate_id>/<conf_id>/<conf_key>', methods = ["GET", "POST"])
@RouteGroup.conf_required
@RouteGroup.login_required 
def Dashboard(delegate_id,conf_id,conf_key):
    delegate_id     = int(Cryptography.decrypt(delegate_id))
    workshop_data   = UserModel().get_user_workshop_data(delegate_id)
    course_list = UserModel().get_user_course_data(delegate_id)
    course_data =  defaultdict(list) # sub list with key
    if course_list:
        for r in course_list:
            course_data[r["WorkshopId"]].append(r)
        print(workshop_data)
    return render_template('users/dashboard.html',workshop_data=workshop_data,delegate_id=delegate_id,course_data=course_data,conf_id=conf_id,conf_key=conf_key)


@app.route('/courseslot/<delegate_id>/<workshop_id>/<conf_id>/<conf_key>', methods = ["GET", "POST"])
@RouteGroup.conf_required
@RouteGroup.login_required 
def Course_Sloting(delegate_id,workshop_id,conf_id,conf_key):
    course_list = UserModel().get_user_course_data(delegate_id,workshop_id)
    workshop_data = UserModel().get_workshop_data(workshop_id)
    return render_template('users/course_slot.html',delegate_id=delegate_id,workshop_id=workshop_id,course_list=course_list,workshop_data=workshop_data,conf_id=conf_id,conf_key=conf_key)


@app.route('/courseslotlist/<course_id>/<conf_id>/<conf_key>', methods = ["GET", "POST"])
@RouteGroup.conf_required
@RouteGroup.login_required 
def Course_Sloting_list(course_id,conf_id,conf_key):
    delegate_no = Auth.get_user().get('delegate_no')
    slot_list = UserModel().get_slot_list(course_id,delegate_no)
    return render_template('users/course_slot_list.html',slot_data=slot_list,conf_id=conf_id,conf_key=conf_key)

@app.route('/slot_delegate/<conf_id>/<conf_key>', methods = ["GET", "POST"])
@RouteGroup.conf_required
@RouteGroup.login_required 
def Slot_delegate(conf_id,conf_key):
    course_id   = request.values.get('course_id')
    delegate_no = request.values.get('delegate_no')
    slot_id     = request.values.get('slot_id')
    insert_slot = UserModel().insert_delegate_Slot(slot_id,delegate_no,course_id)
    slot_list   = UserModel().get_slot_list(course_id,delegate_no)
    data = insert_slot
    data["html"] = render_template('users/course_slot_list.html',slot_data=slot_list,conf_id=conf_id,conf_key=conf_key)
    return jsonify(data)