Sindbad~EG File Manager

from flask import Flask, request, Blueprint, jsonify, redirect, url_for,flash, render_template,session, app, json
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
from core.library.helper import Helper
from datetime import timedelta,date,datetime
from dateutil.rrule import rrule, DAILY
import ast
import requests
""" Library """
from core.library.email import EMAIL
""" Models """
from core.model.UserModel import UserModel

import boto3, botocore
from botocore.exceptions import ClientError
import logging
# from os import listdir
# from os.path import join, dirname, realpath
import os
# from os import path
from werkzeug.utils import secure_filename
# from functools import reduce


app = Blueprint('user', __name__)

# Autologin for BackOffice Dashboard 

@app.route('/login', methods = ["GET"])
def Login():
	return render_template('users/login.html')

@app.route('/logout', methods = ["GET", "POST"])
def Logout():
	Auth.logout()
	return redirect(url_for('user.Login'))

@app.route('/login', methods = ["POST"])
def Post_Login():
	email = request.form.get('email')
	password = request.form.get('password')
	user = UserModel().get_user_by_password(email,password)
	if user:
		Auth.login(user)
		return redirect(url_for('user.app_dashboard'))
	else:
		flash('Invalid Email or Password')
		return redirect(url_for('user.Login'))

@app.route('/otp_login', methods = ["GET"])
def Otp_login():
	return render_template('users/otp_login.html')

@app.route('/otp_login', methods = ["POST"])
def Post_Otp_login():
	email = request.values.get("email")
	user = UserModel().get_user_by_email(email)
	if user:
		user_id = user["user_id"]
		SendOtpMail(user_id)
		user_id = Cryptography.encrypt(int(user_id))
		return redirect(url_for('user.OtpPage',user_id=user_id))
	else:
		flash('Invalid Email')
		return redirect(url_for('user.Otp_login'))

@app.route('/otp_page/<user_id>', methods = ["GET"])
def OtpPage(user_id):
	encrypt_user_id = unquote(user_id)
	user_id         = Cryptography.decrypt(user_id)
	user_id         = int(user_id)
	return render_template('users/otp_new.html',encrypt_user_id=encrypt_user_id,user_id=user_id)
	
@app.route('/resend_otp/<user_id>', methods = ["GET","POST"])
def Resend_otp(user_id):
	encrypt_user_id = unquote(user_id)
	user_id         = int(Cryptography.decrypt(user_id)) 
	SendOtpMail(user_id)
	return redirect(url_for('user.OtpPage',user_id=encrypt_user_id))

def SendOtpMail(user_id):
	random.seed(time.perf_counter())
	now         = datetime.now()
	user        = UserModel().get_member(user_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(user_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")
		header_logo = "https://common-application.s3.ap-southeast-1.amazonaws.com/ksos_logo.png"
		support_email = "ksoshelpdesk@gmail.com"
		subject = str(otp_random)+" - OTP for KSOS MCQ submission application , valid upto "+str(date.day)+" "+str(full_month_name)+" "+str(date.year)+" "+str(hour)+":"+str(minute)+" "+period
		to   = user["email"]
		html    = render_template('users/email/otp_generation_mail.html',user_id=user_id,header_logo=header_logo,data=user,otp=otp_random,otp_expire_at=otp_expire_at,support_email=support_email)
		EMAIL.sendMail(subject,html,to)
		flash("An OTP has been sent to your email id "+ Helper.email_mask(to),'success')
		return 'success'

	else : 
		return "fail"

@app.route('/otp', methods = ["GET","POST"])
def Otp():
	user_id     = request.values.get("user_id")
	user_id     = int(Cryptography.decrypt(user_id))
	now         = datetime.now()
	pin_1       = request.values.get('otp')
	otp         = pin_1
	user_data  = UserModel().get_member(user_id) # db call 1
	encrypt_user_id  = Cryptography.encrypt(int(user_id))
	if user_data["email"] == Helper.testmail and int(otp) == 9999 :
		Auth.login(user_data)
		return redirect(url_for('user.app_dashboard'))
		
	if user_data["email"] in Helper.master_email_ids:
		Auth.login(user_data)
		return redirect(url_for('user.app_dashboard'))
		
	if(int(otp) == int(user_data['otp'])) :
		data1    = {'otp' : None, 'otp_verified_at':now}
		expire_on_db  = UserModel().update_member(user_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):
			flash("Expired!OTP valid for 30 mintue")
			return redirect(url_for('user.OtpPage',user_id=encrypt_user_id))
		else:
			Auth.login(user_data)
			return redirect(url_for('user.app_dashboard'))
	else:
		flash("Incorrect OTP.  Please provide the correct OTP")
		return redirect(url_for('user.OtpPage',user_id=encrypt_user_id))
	
@app.route('/app_dashboard', methods = ["GET"])
@RouteGroup.login_required
def app_dashboard():
	return render_template('users/app_index.html')
	

@app.route('/dashboard', methods = ["GET"])
@RouteGroup.login_required
def dashboard():
	user_id = Auth.get_user().get('user_id')
	incomplete = UserModel().get_incomplete_user_questions(user_id)
	completed = UserModel().get_complete_user_questions(user_id)
	selected  = UserModel().get_selected_user_questions(user_id)
	return render_template('users/dashboard.html',incomplete=incomplete,completed=completed,selected=selected)

@app.route('/question_index/<status_id>',methods=["GET"])
@RouteGroup.login_required
def question_index(status_id):
	user_id = Auth.get_user().get('user_id')
	questions = UserModel().get_all_questions(user_id,status_id)
	return render_template('users/question_index.html',questions=questions,status_id=status_id)

@app.route('/new_question', methods = ["GET"])
@RouteGroup.login_required
def new_question():
	user_id = Auth.get_user().get('user_id')
	q_id = UserModel().insert_new_question(user_id)
	q_id = Cryptography.encrypt(int(q_id))
	return redirect(url_for('user.question_edit',q_id=q_id))

@app.route('/question_edit/<q_id>', methods = ["GET"])
@RouteGroup.login_required
def question_edit(q_id):
	q_id = int(Cryptography.decrypt(q_id))
	question = UserModel().get_question(q_id)
	categories = UserModel().get_mcq_category()
	opt_data = UserModel().get_question_option(q_id)
	return render_template('users/question_edit.html',q_data=question,opt_data=opt_data,categories=categories)

@app.route('/question_view/<q_id>', methods = ["GET"])
@RouteGroup.login_required
def question_view(q_id):
	q_id = int(Cryptography.decrypt(q_id))
	question = UserModel().get_question(q_id)
	opt_data = UserModel().get_question_option(q_id)
	return render_template('users/question_view.html',q_data=question,opt_data=opt_data)

@app.route('/question_edit/<q_id>',methods=["POST"])
@RouteGroup.login_required
def question_post(q_id):
	en_q_id = q_id
	q_id = int(Cryptography.decrypt(q_id))
	category    = request.values.getlist('category') or None
	category_ids    = ','.join(category)
	question = request.form.get('question') or None
	explanation = request.form.get('explanation') or None
	q_data = {
		'question':question,
		'explanation':explanation,
		'category_ids': category_ids,
	}
	correct = request.form.get('opt')
	crt_new = request.values.get('crt_new')
	opt_count = request.values.get('opt_count')
	option = []
	for i in range(1,int(opt_count)+1):
		print(i)
		data = {
					"opt_id":request.values.get("opt_"+str(i)+"_id") or None,
					"option_val":request.values.get("option_"+str(i)),
					"is_answer": 1 if int(correct) == int(i) else None,
					"q_id":q_id
				}
		option.append(data)
	
	UserModel().insert_update_opt(option)
	if int(crt_new) == 2:
		UserModel().update_question(q_data,q_id)
		return redirect(url_for('user.question_edit',q_id=en_q_id))
	else:
		if int(crt_new) == 1:
			q_data['status_id'] = 1
			UserModel().update_question(q_data,q_id)
			return redirect(url_for('user.new_question'))
		else:
			q_data['status_id'] = 1
			UserModel().update_question(q_data,q_id)
			return redirect(url_for('user.dashboard'))


@app.route('/img_upload/<q_id>', methods = ["GET", "POST"])
@RouteGroup.login_required 
def Img_upload(q_id):
	file       = request.files.get('file')
	bucketname = 'common-application'
	if file and bucketname:
		img = UserModel().get_img_upload_by_q_id(q_id)
		if img and img["image_link"]:
			foldername  = img["image_link"]
			foldername  = foldername.replace("https://"+bucketname+".s3-ap-southeast-1.amazonaws.com/", "")
			s3          = boto3.resource("s3",aws_access_key_id='AKIAILLDAQ7NFUMVOYLQ',aws_secret_access_key='EEudWCsWeCIt/J9/z5m5htmUdGFJNzWFPvNQBIp/')
			response    =  s3.Object(bucketname, foldername).delete() 
			data = {
				 'image_link': ''    
			}
			UserModel().update_question(data,q_id)
		else:
			pass
		data_1          = {}
		acl             = "public-read"
		s3              = boto3.client("s3",aws_access_key_id='AKIAILLDAQ7NFUMVOYLQ',aws_secret_access_key='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')
		filename        = secure_filename(file.filename)
		split_tup       = os.path.splitext(filename)
		file_name       = split_tup[0]
		file_extension  = split_tup[1]
		file_str        = "attachment"+str(file_extension)
		try:
			bucket     = bucketname
			foldername_1 = 'MCQ_uploads'
			foldername_2 = 'KSOS'
			file_path  = "https://"+bucketname+".s3-ap-southeast-1.amazonaws.com/"+foldername_1+"/"+foldername_2+"/"+str(q_id)+"/"
			data     = {
						'image_link': file_path+file_str+"?"+str(Helper.getcurrenttimestamp()),
						 }
			update_data = UserModel().update_question(data,q_id)
			response    = s3.upload_fileobj(file, bucket,foldername_1+'/'+foldername_2+'/'+str(q_id)+'/'+ file_str, ExtraArgs={"ACL": acl,"ContentType": file.content_type})
		except ClientError as e:
			logging.error(e)
		return jsonify(data)
	else:
		return jsonify()

@app.route('/remove_img', methods = ["GET", "POST"])
@RouteGroup.login_required 
def Remove_img():
	q_id = request.values.get('q_id')
	img       = UserModel().get_img_upload_by_q_id(q_id)
	if img:
		bucketname = 'common-application'  
		foldername = img["image_link"]
		foldername = foldername.replace("https://"+bucketname+".s3-ap-southeast-1.amazonaws.com/", "")
		s3         = boto3.resource("s3",aws_access_key_id='AKIAILLDAQ7NFUMVOYLQ',aws_secret_access_key='EEudWCsWeCIt/J9/z5m5htmUdGFJNzWFPvNQBIp/')
		response   = s3.Object(bucketname, foldername).delete() 
		data = {
				 'image_link': ''    
			}
		UserModel().update_question(data,q_id)
	else:
		pass
	return jsonify('success')

@app.route('/participate_dashboard', methods = ["GET", "POST"])
@RouteGroup.login_required 
def Participate_dashboard():
	user_id = Auth.get_user().get('user_id')
	completed_session = UserModel().get_completed_sessions(user_id)
	now = datetime.now().strftime('%Y-%m-%d  %H:%M')
	upcoming_session = UserModel().get_upcoming_sessions(now)
	active_sessions = UserModel().get_active_session(now)
	return render_template('/users/participate_dashboard.html',completed_session=completed_session,upcoming_session=upcoming_session,active_sessions=active_sessions)

@app.route('/question/<session_id>', methods = ["GET"])
@RouteGroup.login_required 
def question(session_id):
	user_id = Auth.get_user().get('user_id')
	q_id = request.values.get('q_id') or None
	data = UserModel().get_question_data(session_id,q_id,user_id)
	session_data  = data[0]
	question_data = data[1]
	opt_data      = data[2]
	return render_template('/users/question_page.html',session_data=session_data,question_data=question_data,opt_data=opt_data,session_id=session_id)

@app.route('/question/<session_id>', methods = ["POST"])
@RouteGroup.login_required 
def post_question(session_id):
	q_id = request.values.get('q_id')
	user_id = Auth.get_user().get('user_id')
	opt  = request.values.get("option_val")
	data = {
		'session_id' : session_id,
		'opt_id'     : opt,
		'user_id'    : user_id,
		'q_id'       : q_id
	}
	UserModel().insert_user_option(data)
	return redirect(url_for('user.question',session_id=session_id,q_id=q_id))