Sindbad~EG File Manager

import base64
from io import BytesIO
# from tkinter import Image
from flask import Flask, request, Blueprint, jsonify, json,redirect, url_for,flash, render_template,session, app
from core.library.route_group import RouteGroup
from core.library.helper import Helper
from core.model.BOModel import BOModel
import datetime
from datetime import datetime
import time
from PIL import Image


app = Blueprint('backoffice', __name__)

# Author : Nallasamy
# Date : 25-01-2025
# Version : 1

# --Login Page--
# @app.route('/', methods=["GET","POST"])
# def Home():
# 	return redirect(url_for("backoffice.LoginPage"))

@app.route('/', methods=["GET","POST"])
@app.route('/login_page',methods = ["GET", "POST"])
def LoginPage():
	return render_template('Backoffice/bo_login.html')

@app.route('/post_login',methods = ["GET", "POST"])
def PostLogin():
	
	email = request.values.get('email')
	if email:
		
		data = {
			'email':email,
		}
		session['sess_data']=data
		return redirect(url_for('backoffice.ViewIndex'))
	else:
		return redirect(url_for('backoffice.LoginPage'))
	
# --Logout--

@app.route('/logout',methods = ["GET", "POST"])
def Logout():
	session.pop('sess_data')
	session.pop('_flashes',None)
	return redirect(url_for('backoffice.LoginPage'))

# --Conference

@app.route('/view_index',methods = ["GET","POST"])
def ViewIndex():
	data=BOModel().get_app_conference()
	return render_template('Backoffice/mobileapp_conference.html',data=data)

# --Dashboard--

@app.route('/view_dashboard/<as_id>',methods = ["GET", "POST"])
@RouteGroup.login_required
def ViewDashboard(as_id):
	data = BOModel().get_app_shema(as_id)
	session['soc_data']=data
	app_schema= data['app_schema']
	schema_check = BOModel().check_app_schema(app_schema)
	count = schema_check[0]['COUNT(*)']
	# print(count)
	if count == 1:
		data=BOModel().get_menu_count(app_schema)
		data1=BOModel().get_splash_count(app_schema)
		data2=BOModel().get_banner_count(app_schema)
		data3=BOModel().get_tabmenu_count(app_schema)
		data4=BOModel().get_count("pages",app_schema)
		data5=BOModel().get_count("asset",app_schema)
		ctdata = {
			"pgct" : data4,
			"asct" : data5,
		}

		return render_template('Backoffice/bo_dashboard.html',data=data,data1=data1,data2=data2,data3=data3,ctdata=ctdata,as_id=as_id)
	else:
		flash(f'{app_schema} schema not found','errorMsg')
		return redirect(url_for('backoffice.ViewIndex'))
		
# --Menu Table--

@app.route('/get_menu/<menu_id>/<as_id>',methods = ["GET", "POST"])
@app.route('/get_menu/<as_id>',methods = ["GET", "POST"])
@RouteGroup.login_required
def GetMenuTable(as_id,menu_id=None,bann_id=None):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	data=BOModel().get_menu_table(app_schema)
	asset=BOModel().get_asset_table(app_schema)
	if menu_id:
		menu_id=menu_id
		datas=BOModel().get_menu_id(menu_id,app_schema)
	else:
		menu_id=None
		datas = None
	return render_template('Backoffice/menu.html',data=data,as_id=as_id,asset=asset,datas=datas,menu_id=menu_id)


@app.route('/view_menu/<as_id>',methods = ["GET", "POST"])
@RouteGroup.login_required
def ViewMenuIndex(as_id):
	status = request.values.get('status')
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	data=BOModel().get_menu_table(app_schema)
	data1=BOModel().get_menu_count(app_schema)
	return render_template('Backoffice/view_menu.html',data=data,data1=data1,as_id=as_id,status=status)

@app.route('/post_menu/<menu_id>/<as_id>',methods = ["GET", "POST"])
@app.route('/post_menu/<as_id>',methods = ["GET", "POST"])
def PostMenu(as_id,menu_id=None):
# 	confid=request.values.get("confid") or None
	name=request.values.get("menuname") or None
	description=request.values.get("description") or None
	parentid=request.values.get("parentid") or None
	menu_icon = request.files.get("menu_icon") or None
	if menu_icon:
		menuicon_file=Helper.imageToBase64(menu_icon)

	navigation_menu=request.values.get("navigation_menu") or None
	navmenu=request.files.get("navmenu") or None
	if navmenu:
		navmenu_file=Helper.imageToBase64(navmenu)
	
	is_visible=request.values.get("is_visible") or None
	orderby=request.values.get("orderby") or None
	data ={
		'title':name,
		'description':description,
		'parent_id':parentid,
		'navigation_menu':navigation_menu,
		'is_visible':is_visible,
		'order_by':orderby,
		'created_at':datetime.now(),
		'updated_at':datetime.now()
	}
	if menu_icon:
		data.update({'image':menuicon_file})
	if navmenu:
		data.update({'menu_icon':navmenu_file})
	
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	titlename=BOModel().get_menu_title(name,app_schema)
	if menu_id:
		title=BOModel().get_menu_title_id(name,menu_id,app_schema)
		if title is None:
			data.pop('created_at')
			BOModel().update_menu_data(menu_id,data,app_schema)
			msg={'status':0,'msg':"Updated"}
			return jsonify(msg)
		else:
			msg={'status':1,'msg':"Menu Name is Already exists"}
			return jsonify(msg)
	else:
		if titlename is None:
			menu_id=BOModel().insert_menu_table(data,app_schema)
			data={'menu_id':menu_id}
			return jsonify(data)
		else:
			msg={'status':1,'msg':"Menu Name is Already exists"}
			return jsonify(msg)
	

@app.route('/delete_menu/<val>/<as_id>',methods = ["GET", "POST"])
def DeleteMenu(val,as_id):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	if int(val) == 1 :
		menu_id = request.values.get('menu_id')
	else:
		checkbox=request.values.getlist('delete_chb')
		menu_id=",".join(checkbox)
	BOModel().delete_menu_by_id(menu_id,app_schema)
	msg={'status':2,'msg':"Successfully Deleted!"}
	return jsonify(msg)

# --Splash_Screen--

@app.route('/view_splash/<as_id>',methods = ["GET", "POST"])
@RouteGroup.login_required
def ViewSplash(as_id):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	data=BOModel().get_splash_table(app_schema)
	return render_template('Backoffice/splash_screen.html',data=data,as_id=as_id)

@app.route('/delete_splash/<int:splash_id>/<as_id>',methods = ["GET", "POST"])
def DeleteSplash(splash_id,as_id):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	BOModel().delete_splash_by_id(splash_id,app_schema)
	msg={'status':1,'msg':"Successfully Deleted!"}
	return jsonify(msg)

@app.route('/duplicate_splash/<as_id>',methods = ["GET", "POST"])
def DuplicateSplash(as_id):
	current_dt = datetime.now()
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	BOModel().get_duplicate_splash(current_dt,app_schema)
	msg={'status':2,'msg':"Duplicate Splash Screen"}
	return jsonify(msg)

@app.route('/post_splash/<splash_id>/<as_id>',methods = ["GET", "POST"])
def PostSplash(as_id,splash_id):
	# basecode=request.values.get("image_data")
	# file_name=request.values.get('file_name')
	file=request.files['file']
	img_base64=Helper.imageToBase64(file)

	data={
		'image_data':img_base64,
		'updated_at':datetime.now()
	}
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	BOModel().update_splash_data(splash_id,data,app_schema)
	data={'img_data':img_base64,'msg':'success','status':'1'}
	return jsonify(data)



# --Banner--

@app.route('/get_banner/<ban_id>/<as_id>',methods = ["GET", "POST"])
@app.route('/get_banner/<as_id>',methods = ["GET", "POST"])
@RouteGroup.login_required
def GetBanner(as_id,ban_id=None):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	data=BOModel().get_banner_table(app_schema)
	if ban_id:
		datas=BOModel().get_banner_table_id(ban_id,app_schema)
	else:
		datas = None
	return render_template('Backoffice/banner.html',as_id=as_id,data=data,datas=datas)

@app.route('/post_banner/<ban_id>/<as_id>',methods = ["GET", "POST"])
@app.route('/post_banner/<as_id>',methods = ["GET", "POST"])
def PostBanner(as_id,ban_id=None):
# 	confid=request.values.get("confid") or None
	banner_name=request.values.get("banner_name") or None
	banner_type=request.values.get("banner_type") or None
	# new_update=request.values.get("new_update") 
	# banner_basecode=request.values.get("banner_basecode") or None
	banner_file=request.files.get("banner_file") or None
	if banner_file:
		banner_basecode=Helper.imageToBase64(banner_file)
	order_by = request.values.get("order_by") or None
	is_visible=request.values.get("is_visible") or None
	banner_view=request.values.get("banner_view") or None
	data ={
		'banner_name':banner_name,
		'banner_type':banner_type,
		'order_by':order_by,
		'is_visible':is_visible,
		'banner_view':banner_view,
		'created_at':datetime.now(),
		'updated_at':datetime.now()
	}
	if banner_file:
		data.update({'banner_data':banner_basecode})

	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	if ban_id:
			data.pop('created_at')
			BOModel().update_banner_data(ban_id,data,app_schema)
			msg={'status':0,'msg':"Updated"}
			return jsonify(msg)
	else:
		BOModel().insert_banner_table(data,app_schema)
		msg={'status':1,'msg':"Inserted"}
		return jsonify(msg)
	

@app.route('/view_banner/<as_id>',methods = ["GET", "POST"])
@RouteGroup.login_required
def ViewBannerIndex(as_id):
	status = request.values.get('status')
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	data=BOModel().get_banner_table(app_schema)
	data1=BOModel().get_banner_count(app_schema)
	return render_template('Backoffice/view_banner.html',data=data,data1=data1,as_id=as_id,status=status)

@app.route('/delete_banner/<val>/<as_id>',methods = ["GET", "POST"])
def DeleteBanner(val,as_id):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	if int(val) == 1 :
		ban_id = request.values.get('ban_id')
	else:
		checkbox=request.values.getlist('delete_chb')
		ban_id=",".join(checkbox)
	BOModel().delete_banner_by_id(ban_id,app_schema)
	msg={'status':2,'msg':"Successfully Deleted!"}
	return jsonify(msg)


# --Tab Menu--

@app.route('/tab_menu/<tab_id>/<as_id>',methods = ["GET", "POST"])
@app.route('/tab_menu/<as_id>',methods = ["GET", "POST"])
@RouteGroup.login_required
def GetTabMenu(as_id,tab_id = None):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	data=BOModel().get_tabmenu_table(app_schema)
	if tab_id:
		datas=BOModel().get_tabmenu_table_id(tab_id,app_schema)
	else:
		datas = None
	return render_template('Backoffice/tab_menu.html',as_id=as_id,data=data,datas=datas)

@app.route('/post_tabmenu/<tab_id>/<as_id>',methods = ["GET", "POST"])
@app.route('/post_tabmenu/<as_id>',methods = ["GET", "POST"])
def PostTabMenu(as_id,tab_id=None):
# 	confid=request.values.get("confid") or None
	tab_name=request.values.get("tab_name") or None
	tab_file=request.files.get("tab_file") or None
	if tab_file:
		tab_basecode=Helper.imageToBase64(tab_file)
	tab_content=request.values.get("tab_content") or None
	page_id=request.values.get("page_id") or None
	is_visible=request.values.get("is_visible") or None
	order_by = request.values.get("order_by") or None
	data ={
	    
		'tab_name':tab_name,
		'tab_content':tab_content,
		'page_id':page_id,
		'is_visible':is_visible,
		'order_by':order_by,
		'created_at':datetime.now(),
		'updated_at':datetime.now()
	}
	if tab_file:
		data.update({'tab_data':tab_basecode})
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	if tab_id:
			data.pop('created_at')
			BOModel().update_tabmenu_data(tab_id,data,app_schema)
			msg={'status':0,'msg':"Updated"}
			return jsonify(msg)
	else:
		BOModel().insert_tabmenu_table(data,app_schema)
		msg={'status':1,'msg':"Inserted"}
		return jsonify(msg)



@app.route('/view_tabmenu/<as_id>',methods = ["GET", "POST"])
@RouteGroup.login_required
def ViewTabMenuIndex(as_id):
	status = request.values.get('status')
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	data=BOModel().get_tabmenu_table(app_schema)
	data1=BOModel().get_tabmenu_count(app_schema)
	return render_template('Backoffice/view_tab_menu.html',data=data,data1=data1,as_id=as_id,status=status)

@app.route('/delete_tabmenu/<val>/<as_id>',methods = ["GET", "POST"])
def DeleteTabMenu(val,as_id):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	if int(val) == 1 :
		tab_id = request.values.get('tab_id')
	else:
		checkbox=request.values.getlist('delete_chb')
		tab_id=",".join(checkbox)
	BOModel().delete_tabmenu_by_id(tab_id,app_schema)
	msg={'status':2,'msg':"Successfully Deleted!"}
	return jsonify(msg)

# Author : Vignesh
# date :25-01-2025
# Version : 1

# --Asset Table--

@app.route('/upload_image/<as_id>/<int:asset_id>',methods = ["GET", "POST"])
@app.route('/upload_image/<as_id>',methods = ["GET", "POST"])
@RouteGroup.login_required
def UploadImage(as_id,asset_id=None):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	if request.method == "POST":
		dt = request.get_json()
		imgdt = dt.get("selected_images")
		# action = request.values.get("action")
		action = dt.get("action")
		asset_id = imgdt[0]['asset_id']
		visible = None


		if action == "update":

			if imgdt[0]['is_visible'] == True:
				visible = 1
			else:
				visible = 0
			
			data = {
				"asset_name":imgdt[0]['image_name'],
				"asset_data":imgdt[0]['base64'],
				"asset_type":imgdt[0]['asset_type'],
				"content_type":imgdt[0]['content_type'],
				"created_at":datetime.now(),
				"updated_at":datetime.now(),
				"is_visible":visible
				}

			f = "updateImage"
			duplicate1 = BOModel().checkDuplicate(data,f,asset_id,0,app_schema)
			if duplicate1[0] == 0:
				Imagedata = BOModel().update_asset(asset_id,data,app_schema)
				Resdata = {
					"action":"Updated Succesfully",
					"imagedata":Imagedata,
					"redirect":url_for('backoffice.AssetTable',as_id=as_id,asset_id=Imagedata["asset_id"])
				}
				return jsonify(Resdata)
			else:
				return jsonify({"msg":"Image name already exists update"})

		else:
			resdt = []
			for d in imgdt:
				if d['is_visible'] == True:
					visible = 1
					
				else:
					visible = 0

				data2 = {
					"asset_name":d['image_name'],
					"asset_data":d['base64'],
					"asset_type":d['asset_type'],
					"content_type":d['content_type'],
					"created_at":datetime.now(),
					"updated_at":datetime.now(),
					"is_visible":visible
					}
				
				f = "UploadImage"
				duplicate2 = BOModel().checkDuplicate(data2,f,asset_id,0,app_schema)
				msg=""	
				if duplicate2[0] == 0:
					Imagedata = BOModel().insert_image(data2,app_schema)
				
					Resdata = {
					"action":"Uploaded Successfully",
					"imagedata":Imagedata,
					# "redirect":url_for('backoffice.AssetTable',as_id=as_id,asset_id=Imagedata["asset_id"]),
					"status":1
					}
					resdt.append(Resdata)
					# return jsonify(resdt)
				else:
					img_name2 = d["image_name"]
					Resdata2 = {
					"action":f"{img_name2} not uploaded, Image name already exists",
					"status":2,
					"imgname":img_name2
					}
					
					resdt.append(Resdata2)
			
			return jsonify(resdt)
	else:
		assetdata = None
		if asset_id :
			assetdata = BOModel().GetAssetDataById(asset_id,app_schema)

		return render_template("Backoffice/uploadImage.html",as_id=as_id,assetdata=assetdata)


@app.route('/asset_view/<as_id>',methods = ["GET", "POST"])
@RouteGroup.login_required
def AssetTable(as_id):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	# app_schema = scema(conf_id)
	# scema1 = sc(as_id)
	data = BOModel().GetAssetData("",app_schema)
	return render_template('Backoffice/assetView.html',data=data,as_id=as_id)

@app.route('/edit_asset/<int:asset_id>/<as_id>',methods = ["GET", "POST"])
@RouteGroup.login_required
def EditAsset(asset_id,as_id):
	return redirect(url_for("backoffice.UploadImage",as_id=as_id,asset_id=asset_id))

@app.route('/delete_asset/<int:asset_id>/<as_id>',methods = ["GET", "POST"])
def DeleteAsset(asset_id,as_id):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	if request.method == "POST":
		dt = request.get_json()
		imgsdt = dt.get("deleteData")
		dlres = BOModel().delete_asset(imgsdt,app_schema)
		if dlres == None:
			return jsonify({"msg":"Not deleted!","msg2":"failed"})
		else:
			return jsonify({"msg":"Successfully all deleted!","msg2":"Success"})
	else:	
		BOModel().delete_asset(asset_id,app_schema)
		flash("Successfully deleted!","successMsg")
		return redirect(url_for('backoffice.AssetTable'))

# --Page--

@app.route('/upload_page/<as_id>',methods = ["GET", "POST"])
@RouteGroup.login_required
def PageForm(as_id):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	if request.method == "POST":
		page_type = request.values.get("page_type")
		page_data = request.values.get("page_data")
		page_name = request.values.get("page_name")
		is_visible = request.values.get("is_visible")
		action = request.values.get("action")
		page_id = request.values.get("page_id")
		
		menuData=BOModel().getMenu(app_schema)

		visible = None
		if is_visible == "true":
			visible = 1
		else:
			visible = 0

		data = {
		"page_type":page_type,
		"page_data":page_data,
		"page_name":page_name,
		"created_at":datetime.now(),
		"updated_at":datetime.now(),
		"is_visible":visible
		}
		if int(page_id) > 0:
			f = "updatePage"
			duplicate1 = BOModel().checkDuplicate(data,f,0,page_id,app_schema)
			if duplicate1[0] == 0:
				Pagedata = BOModel().update_page(page_id,data,app_schema)
				Resdata = {
					"action":"Updated Succesfully",
					"PageData":Pagedata,
					"menuData":menuData
				}
				return jsonify(Resdata)
			else:
				return jsonify({"msg":"page name already exists"})
		else:
			f = "UploadPage"
			duplicate2 = BOModel().checkDuplicate(data,f,0,page_id,app_schema)
				
			if duplicate2[0] == 0:
				PageData2 = BOModel().insert_page(data,app_schema)
				Resdata = {
				"action":"Uploaded Successfully",
				"PageData":PageData2,
				"menuData":menuData
				}
				
				return jsonify(Resdata)
			else:
				return jsonify({"msg":"Page name already exists"})
	
	else:
		page_id = request.values.get("page_id")
		page_data = None
		if page_id and int(page_id) > 0 :
			page_data = BOModel().GetPageData(page_id,app_schema)
		return render_template("Backoffice/pageForm.html",as_id=as_id,data=page_data)
	
	

@app.route('/menu_asset/<as_id>',methods = ["GET", "POST"])
@RouteGroup.login_required
def GetMenu(as_id):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	if request.method == "POST":
		menu_id = request.values.getlist("menu_title[]")
		page_asset = request.values.getlist("page_asset[]")
		page_id = request.values.get("page_id")
		is_visible = request.values.get("is_visible")
		action = request.values.get("action")

		new_menu = list(map(int, menu_id))
		dt2 = {
		"page_id":page_id,
		"updated_at":datetime.now(),

			}
		res2 = BOModel().update_menu(new_menu,dt2,app_schema)
		msg = ""
		if action == "update":
			msg = "menu data updated"
		else:
			msg = "menu data updated"
		res = {
			"msg":msg,
			"res2":res2,
			"menu_update_st":True,
			"redirect":url_for('backoffice.PageTable',as_id=as_id)

			}
		return jsonify(res)

	else:

		menudata = BOModel().getMenu(app_schema)
		assetdata = BOModel().get_asset_table(app_schema)	
		action = request.values.get("action")

		res_action = "insert"
		menudata2 = None
		
		if action == "update":
			page_id = request.values.get("page_id")
			res3 = BOModel().GetAssetMapData(page_id,app_schema)
			# menudata2 = BOModel().getMenu(page_id,app_schema)
			
			menudata2 = BOModel().getMenuId(page_id,app_schema)

			res_action = "update"
			# PageAssetMap = res3[0]
		else:
			res3 = None
		
		data = {
			"menudata":menudata,
			"menudata2":menudata2,
			"assetdata":assetdata
		}
		AssetMenu = render_template("Backoffice/menuTable.html",as_id=as_id,data=data,res3=res3)
		data2 = {
			"html":AssetMenu,
			"action":res_action
		}

		return jsonify(data2)
	
@app.route('/map_asset_page/<as_id>',methods = ["GET", "POST"])
def pageAssetMap(as_id):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	if request.method == "POST":
		page_asset = request.values.getlist("page_asset[]")
		page_id = request.values.get("page_id")
		action = request.values.get("action")

		if not isinstance(page_asset, list):
			page_asset = [page_asset]

		rows = [
			{
				"asset_id": asset_id,
				"page_id": page_id,
				"created_at": datetime.now(),
				"updated_at": datetime.now(),
				"is_visible": 1
			}
			for asset_id in page_asset
		]

		BOModel().insert_assetPageMap(rows,app_schema)
		res = BOModel().GetAssetMapData(page_id,app_schema)
		msg = ""
		resaction = ""
		if action == "update":
			msg = "Asset page data map updated"
			resaction = "update"
		else:
			msg = "Asset page data mapped"
			resaction = "insert"
		res = {
			"msg":msg,
			"res2":res,
			"resaction":resaction,
			"redirect":url_for('backoffice.PageTable',as_id=as_id)
			}
		return jsonify(res)

	else:
		return jsonify("")
	
@app.route('/delete_map_asset_page/<as_id>',methods = ["GET", "POST"])
def DeletePageAssetMap(as_id):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	if request.method == "POST":
		page_asset = request.values.getlist("page_asset[]")
		page_id = request.values.get("page_id")
		action = request.values.get("action")
		res = BOModel().DeleteAssetMapData(page_asset,app_schema)
		msg = ""
		resaction = ""
		if action == "delete":
			msg = "Asset page data deleted"
			resaction = "delete"
		res = {
			"msg":msg,
			"res2":res,
			"resaction":resaction,
			"redirect":url_for('backoffice.PageTable',as_id=as_id)
			}
		return jsonify(res)
	else:
		return jsonify("")
	
@app.route('/search_asset/<as_id>',methods = ["GET", "POST"])
def SearchAssets(as_id):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	page_id = request.values.get("page_id")
	search_val = request.values.get("search_val")
	search_data = BOModel().GetAssetData(search_val,app_schema)
	Asset = render_template("Backoffice/menuTable.html",as_id=as_id,data=search_data)
	data2 = { "html":Asset,}
	return jsonify(data2)

@app.route('/page_view/<as_id>',methods = ["GET", "POST"])
@RouteGroup.login_required
def PageTable(as_id):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	page_id2 = None
	data = BOModel().GetPageData(page_id2,app_schema)
	return render_template('Backoffice/page_view.html',data=data,as_id=as_id)

@app.route('/edit_page/<int:page_id>/<as_id>',methods = ["GET", "POST"])
def EditPage(page_id,as_id):
	return redirect(url_for("backoffice.PageForm",as_id=as_id,page_id=page_id))

@app.route('/delete_page/<int:page_id>/<as_id>',methods = ["GET", "POST"])
def DeletePage(page_id,as_id):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	BOModel().delete_page(page_id,app_schema)
	flash("Successfully deleted!","successMsg")
	return redirect(url_for('backoffice.PageTable',as_id=as_id))

@app.route('/delete_page_all/<int:page_id>/<as_id>',methods = ["GET", "POST"])
def DeletePageAll(page_id,as_id):
	app_schema = BOModel().get_app_shema(as_id)
	app_schema= app_schema['app_schema']
	if request.method == "POST":
		dt = request.get_json()
		pgsdt = dt.get("deleteData")
		dlres = BOModel().delete_page_all(pgsdt,app_schema)
		if dlres == None:
			return jsonify({"msg":"Not deleted!","msg2":"failed"})
		else:
			flash("Successfully all deleted!","successMsg")
			return jsonify({"msg":"Successfully all deleted!","msg2":"Success"})
	else:
		pass