Sindbad~EG File Manager
from fileinput import filename
import os
from os import listdir
from os.path import join, dirname, realpath
from sqlalchemy import null
from werkzeug.utils import secure_filename
from flask import Flask, request, Blueprint, jsonify, redirect, url_for,flash, render_template,session,json,Response,app
# import datetime
from datetime import timedelta,date,datetime
# from flask import session, app
from .. import Cryptography,Auth,RouteGroup,Helper
from core.model.MemAppModel import MemAppModel
from core.model.AbstractAdminModel import AbstractAdminModel
# from core.model.MasterTableController import MasterTableController
from core.library.email import EMAIL
import boto3, botocore
from botocore.exceptions import ClientError
from core import app
import logging
import requests
from urllib.parse import unquote
import math,csv,urllib,io
from io import StringIO
import string
import ast
app = Blueprint('memapp', __name__)
@app.route('/member_app_list', methods = ["GET","POST"])
def MemberAppList():
userdata = Auth.user()
if userdata and userdata['admin_email']:
apps= MemAppModel().get_member_applications(userdata['admin_email'])
count = MemAppModel().get_membership_status_count()
return render_template('memberapp_templates/member_app_list.html',apps=apps,count=count)
else:
return redirect(url_for("dashboard.AdminPanelLogin"))
@app.route('/check_society_detail', methods = ["GET","POST"])
def CheckSocietyDetail():
society_name = request.form['society_name']
society_key = request.form['society_key']
society_title = request.form['society_title']
society_initial = request.form['society_initial']
data = {'society_key':society_key,'society_intial':society_initial ,'society_title' : society_title, 'society_name' : society_name, 'created_at' : datetime.now()}
_blank = "_blank"
mesg = " "
mesg_1 = " "
is_valid = True
if society_key :
society_data = MemAppModel().check_society_by_key(society_key)
if society_data :
society_id = society_data.society_id
link = url_for('societies.SocietiesIds',society_id=society_id)
mesg ="Society key already Exists with us ,<a href ="+link+" target="+_blank+" > View</a>"
# flash("Society key already Exists with us","errorMsg")
is_valid = False
if society_name :
society_data = MemAppModel().check_society_by_name(society_name)
if society_data :
society_id = society_data.society_id
link = url_for('societies.SocietiesIds',society_id=society_id)
mesg_1 ="Society name already Exists with us ,<a href ="+link+" target="+_blank+" > View</a>"
is_valid = False
else:
pass
if society_initial :
society_data = MemAppModel().check_society_by_intial(society_initial)
if society_data :
is_society_id = society_data.society_id
link = url_for('societies.SocietiesIds',society_id=is_society_id)
mesg_1 ="Society Initial already Exists with us ,<a href ="+link+" target="+_blank+" > View</a>"
is_valid = False
if is_valid :
society_id = MemAppModel().insert_socities(data)
# link = url_for('memapp.SocietiesIds',society_id=society_id)
suc_mesg = "Added successfully"
data_1 = {'society_id':society_id,'suc_mesg':suc_mesg,'status':1}
else:
data_1 = {
'mesg': mesg,
'mesg1':mesg_1,
'status':2
}
json_data = json.dumps(data_1)
return json_data
# Societies table ----ends.
# @app.route('/download_aws_file', methods = ["GET","POST"])
# def DownloadAwsFile():
# acl="public-read"
# # s3 = boto3.resource('s3')
# s3= boto3.resource("s3",aws_access_key_id='AKIAILLDAQ7NFUMVOYLQ',aws_secret_access_key='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')
# bucket = s3.Bucket('test-memberapp')
# filename = []
# for s3_file in bucket.objects.all():
# filename.append(s3_file.key)
# s3 = boto3.client('s3',aws_access_key_id = ACCESS_KEY,aws_secret_access_key= SECRET_KEY)
# for l in range(len(filename)):
# s3.download_file('bucket_name',filename[l],'filepath'+filename[l])
# return"success"
# @app.route('/download_all_files_from_folder', methods = ["GET","POST"])
# def DownloadAllFilesFromFolder():
# downloaded_files = []
# conf_id=38
# bucket_name='common-application'
# absid = [7453,7397,7450,7447,7451,7687,7699,7720,7707,7416,7709,7725,7731,7744,7749,7775,7689,7719,7696,7760,7757,7767,7755,7761,7754,7764,7751,7732,7733,7734]
# for i in absid:
# folder_prefix = 'abs_uploads/traumacon23/FPEP/'+str(i)+''
# local_directory='D:\\OTSI-EP'
# s3 = boto3.client("s3",aws_access_key_id='AKIAILLDAQ7NFUMVOYLQ',aws_secret_access_key='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')
# try:
# response = s3.list_objects_v2(Bucket=bucket_name, Prefix=folder_prefix)
# # print(response)
# if 'Contents' in response:
# for obj in response['Contents']:
# object_key = obj['Key']
# result = object_key.split('/')
# print(result)
# abs_id = result[3]
# print(abs_id)
# file = result[4]
# print(file)
# if file:
# split_tup = os.path.splitext(file)
# file_name = split_tup[0]
# file_extension = split_tup[1]
# print(file_extension)
# abs_type= MemAppModel().get_abs_typ(abs_id,conf_id)
# if file_extension:
# abs_type=abs_type['abs_type'] + file_extension
# else:
# abs_type=abs_type['abs_type'] + ".pptx"
# print(abs_type)
# local_file_path = os.path.join(local_directory,abs_type)
# s3.download_file(bucket_name, object_key, local_file_path)
# downloaded_files.append(local_file_path)
# else:
# print("No objects found in the specified folder.")
# except Exception as e:
# print(f"Error downloading files: {e}")
# return downloaded_files
# society applications table ----starts.
@app.route('/society_applications', methods = ["POST"])
def SocietyApplications():
society_applications = MemAppModel().get_society_applications()
return render_template('memberapp_templates/society_applications_index.html',data=society_applications)
@app.route('/add_society_applications/<society_id>', methods = ["GET","POST"])
def AddSocietyApplicationsIds(society_id):
data={
'society_id' : society_id,
'created_at' : datetime.now(),
'app_type_id': 1
}
app_id = MemAppModel().insert_society_applications(data)
flash("Inserted successfully","successMsg")
return redirect(url_for('memapp.SocietyApplicationsIds',society_id=society_id))
@app.route('/society_applications_ids/<society_id>/<society_name>', methods = ["GET","POST"])
def SocietyApplicationsIds(society_id,society_name):
btn_active=1
societies = MemAppModel().get_societies_byid(society_id)
society_applications = MemAppModel().get_society_applications_byid(society_id)
return render_template('memberapp_templates/society_applications.html',data_1=societies,data=society_applications,society_id=society_id,society_name=society_name,btn_active=btn_active)
@app.route('/post_society_applications', methods = ["GET","POST"])
def PostSocietyApplications():
app_id = request.form['app_id']
app_title = request.form['app_title']
app_url = request.form['app_url']
app_host = request.form['app_host']
society_id = request.form['society_id']
society_name = request.form['society_name']
paymentgateway_appmaster_id = request.form['paymentgateway_appmaster_id'] or None
paymentgateway_api_url = request.form['paymentgateway_api_url']
member_approve_type = request.form['member_approve_type']
ms_waiting_approval_status_id = request.form['ms_waiting_approval_status_id']
ms_rejected_status_id = request.form['ms_rejected_status_id']
ms_reupdated_status_id = request.form['ms_reupdated_status_id']
ms_approved_status_id = request.form['ms_approved_status_id']
ms_submitted_status_id = request.form['ms_submitted_status_id']
ms_waiting_approval_withoutpay_status_id = request.form['ms_waiting_approval_withoutpay_status_id']
ms_approved_awaitingpayment_status_id = request.form['ms_approved_awaitingpayment_status_id']
navigate_link = request.form['navigate_link']
navigate_link_name = request.form['navigate_link_name']
is_daily_report_mail = request.values.get('is_daily_report_mail') or 0
mail_setting_id = request.form['mail_setting_id']
if app_id:
app_type_id = request.form['app_type_id']
else:
app_type_id = 1
data = {
'app_id' : app_id,
'app_type_id' : app_type_id,
'app_title' : app_title,
'app_url' : app_url,
'app_host' : app_host,
'society_id' : society_id,
'paymentgateway_appmaster_id' : paymentgateway_appmaster_id,
'paymentgateway_api_url' : paymentgateway_api_url,
'member_approve_type' : member_approve_type,
'ms_waiting_approval_status_id' : ms_waiting_approval_status_id,
'ms_rejected_status_id' : ms_rejected_status_id,
'ms_reupdated_status_id' : ms_reupdated_status_id,
'ms_approved_status_id' : ms_approved_status_id,
'ms_submitted_status_id' : ms_submitted_status_id,
'ms_waiting_approval_withoutpay_status_id' : ms_waiting_approval_withoutpay_status_id,
'ms_approved_awaitingpayment_status_id' : ms_approved_awaitingpayment_status_id,
'navigate_link' : navigate_link,
'navigate_link_name' : navigate_link_name,
'is_daily_report_mail' : is_daily_report_mail,
'mail_setting_id' : mail_setting_id,
'updated_at' : datetime.now()
}
if app_id:
get_previous_mem_type = MemAppModel().get_society_applications_byid(society_id)
pre_approve_type = get_previous_mem_type["member_approve_type"]
if pre_approve_type==member_approve_type:
MemAppModel().update_society_applications(app_id,data)
else:
MemAppModel().delet_m_status(society_id)
if member_approve_type=="after payment":
memapro_society_id = 2
MemAppModel().insert_m_status_bulk(society_id,memapro_society_id)
else:
memapro_society_id = 1
MemAppModel().insert_m_status_bulk(society_id,memapro_society_id)
MemAppModel().update_society_applications(app_id,data)
else:
app_id = MemAppModel().insert_society_applications(data)
if member_approve_type=="after payment":
memapro_society_id = 2
MemAppModel().insert_m_status_bulk(society_id,memapro_society_id)
else:
memapro_society_id = 1
MemAppModel().insert_m_status_bulk(society_id,memapro_society_id)
return redirect(url_for('memapp.SocietyMapMembertypeIndex',society_id=society_id,society_name=society_name))
# society applications table ----ends.
# society assets table ---- starts.
@app.route('/society_assets/<society_id>', methods = ["GET","POST"])
def SocietyAssets(society_id):
society_assets = MemAppModel().get_admin_society_assets(society_id)
return render_template('memberapp_templates/society_assets_index.html',data=society_assets,society_id=society_id)
@app.route('/society_assets_ids/<society_asset_id>/<society_id>', methods = ["GET","POST"])
def SocietyAssetsIds(society_asset_id,society_id):
society_assets_byids = MemAppModel().get_admin_society_assets_byids(society_asset_id)
return render_template('memberapp_templates/society_assets.html',data=society_assets_byids,society_id=society_id)
@app.route('/Post_society_assets/<society_asset_id>', methods = ["GET","POST"])
def PostSocietyAssetsIds(society_asset_id):
society_asset_id = request.form['society_asset_id']
society_id = request.form['society_id']
asset_name = request.form['asset_name']
asset_url = request.form['asset_url']
data={
'society_asset_id' : society_asset_id,
'society_id' : society_id,
'asset_name' : asset_name,
'asset_url' : asset_url,
'updated_at' : datetime.now()
}
MemAppModel().update_admin_society_assets(society_asset_id,data)
flash('updated successfully','successMsg')
return redirect(url_for('memapp.SocietyAssetsIds',society_asset_id=society_asset_id,society_id=society_id))
@app.route('/upload_society_assets', methods = ["GET","POST"])
def UploadSociteyAssests():
image = request.files['file']
file_name = request.form['file_name']
if " " in file_name :
file_name = file_name.replace(" ","")
image.save(os.path.join('core/static/temp_images/'+ file_name))
file_path= os.path.join('/static/temp_images/'+ file_name)
data = {
"file_path" : file_path,
'msg' : "success"
}
json_data = json.dumps(data)
return json_data
# society assets table ---- ends.
# member type ------ starts.
@app.route("/member_type/<society_id>" , methods=['GET','POST'])
def MemberType(society_id):
get_member_type = MemAppModel().get_member_type()
return render_template('memberapp_templates/member_type_index.html',data=get_member_type,society_id=society_id)
@app.route("/add_member_type/<society_id>" , methods=['GET','POST'])
def AddMemberType(society_id):
data={
'created_at' : datetime.now()
}
member_type_id = MemAppModel().insert_member_type(data)
flash("Inserted successfully","successMsg")
return redirect(url_for('memapp.MemberTypeByids',member_type_id=member_type_id, society_id=society_id))
@app.route("/member_type_byids/<member_type_id>/<society_id>" , methods=['GET','POST'])
def MemberTypeByids(member_type_id,society_id):
member_type_id = MemAppModel().get_member_type_byids(member_type_id)
return render_template('memberapp_templates/member_type.html',data=member_type_id,society_id=society_id)
@app.route("/post_mmember_type_id/<member_type_id>" , methods=['GET','POST'])
def PostMemberTypeId(member_type_id):
society_id = request.form['society_id']
member_type_id = request.form['member_type_id']
member_type = request.form['member_type']
display_name = request.form['display_name']
data = {
'member_type_id' : member_type_id,
'member_type' : member_type,
'display_name' : display_name,
'updated_at' : datetime.now()
}
MemAppModel().update_member_type(member_type_id,data)
flash('updated successfully','successMsg')
return redirect(url_for('memapp.MemberTypeByids',member_type_id=member_type_id,society_id=society_id))
# member type ------ ends.
# Society Map Member Type ----starts.
@app.route('/society_map_membertype_index/<society_id>/<society_name>', methods = ["GET","POST"])
def SocietyMapMembertypeIndex(society_id,society_name):
btn_active=2
get_member_type = MemAppModel().get_member_type()
society_map_membertype = MemAppModel().get_admin_society_map_membertype(society_id)
return render_template('memberapp_templates/society_map_index.html',data=society_map_membertype,data_1=get_member_type,society_id=society_id,society_name=society_name,btn_active=btn_active)
@app.route('/add_society_map_membertype/<society_id>/<society_name>', methods = ["GET","POST"])
def AddSocietyMapMembertype(society_id,society_name):
member_type = request.form['member_type']
amount = request.form['amount']
display_name = request.form['display_name']
currency = request.form['currency']
currency_symbol = request.form['currency_symbol']
is_active = request.values.get('is_active') or 0
data={
'member_type_id' : member_type,
'amount' : amount,
'display_name' : display_name,
'currency' : currency,
'currency_symbol': currency_symbol,
'is_active' : is_active,
'is_reg' : 1,
'society_id' : society_id,
'created_at' : datetime.now()
}
if member_type.isnumeric()==True:
member_type_id=member_type
is_member_type = MemAppModel().check_member_type(member_type_id,society_id)
if is_member_type:
flash("MemberType Already Exists..","errorMsg")
else:
smmt_id= MemAppModel().insert_admin_society_map_membertype(data)
flash("Inserted successfully","successMsg")
return redirect(url_for('memapp.SocietyMapMembertypeIndex',society_id=society_id,society_name=society_name))
else:
data_1={
'member_type' : member_type,
'display_name' : member_type,
'created_at' : datetime.now()
}
member_type_id = MemAppModel().insert_member_type(data_1)
if member_type_id:
data={
'member_type_id' : member_type_id,
'amount' : amount,
'display_name' : display_name,
'currency' : currency,
'currency_symbol': currency_symbol,
'is_active' : is_active,
'society_id' : society_id,
'created_at' : datetime.now()
}
smmt_id= MemAppModel().insert_admin_society_map_membertype(data)
flash("Inserted successfully","successMsg")
return redirect(url_for('adminmem.SocietyMapMembertypeIndex',society_id=society_id,society_name=society_name))
else:
pass
@app.route('/society_map_membertype/<smmt_id>', methods = ["GET","POST"])
def SocietyMapMembertype(smmt_id):
society_map_membertype = MemAppModel().get_admin_society_map_membertype_id(smmt_id)
data = {
"model_data" : society_map_membertype,
'msg' : "success"
}
json_data = json.dumps(data)
return json_data
@app.route('/post_society_map_membertype/<smmt_id>', methods = ["GET","POST"])
def PostSocietyMapMembertype(smmt_id):
member_type_id = request.form['member_type_id']
amount = request.form['amount']
display_name = request.form['display_name']
currency = request.form['currency']
currency_symbol = request.form['currency_symbol']
is_active = request.values.get('is_active') or 0
data={
'member_type_id' : member_type_id,
'amount' : amount,
'display_name' : display_name,
'currency' : currency,
'currency_symbol' : currency_symbol,
'is_active' : is_active,
'updated_at' : datetime.now()
}
MemAppModel().update_admin_society_map_membertype(smmt_id,data)
flash("updated successfully",'successMsg')
data = {
'msg' : "updated successfully"
}
json_data = json.dumps(data)
return json_data
# Society Map Member Type ----ends.
# m status ------ starts.
@app.route("/m_status/<society_id>/<society_name>" , methods=['GET','POST'])
def MStatus(society_id,society_name):
btn_active = 3
m_status = MemAppModel().get_m_status(society_id)
return render_template('memberapp_templates/m_status_index.html',data=m_status,society_id=society_id,society_name=society_name,btn_active=btn_active)
@app.route("/add_m_status/<society_id>" , methods=['GET','POST'])
def AddMStatus(society_id):
data={
'created_at' : datetime.now(),
'society_id' : society_id
}
m_status_id = MemAppModel().insert_m_status(data)
flash("Inserted successfully","successMsg")
return redirect(url_for('memapp.MStatusByids',m_status_id=m_status_id))
@app.route("/m_status_byids/<m_status_id>" , methods=['GET','POST'])
def MStatusByids(m_status_id):
m_status_ids = MemAppModel().get_m_status_byids(m_status_id)
data = {
"model_data" : m_status_ids,
'msg' : "success"
}
json_data = json.dumps(data)
return json_data
@app.route("/post_m_status/<m_status_id>" , methods=['GET','POST'])
def PostMStatusByids(m_status_id):
m_status_id = request.form['m_status_id']
status_id = request.form['status_id']
status = request.form['status']
display_name = request.form['display_name']
order_no = request.form['order_no']
current_status = request.form['current_status']
status_for_mail = request.form['status_for_mail']
is_disable = request.values.get('is_disable') or 0
data = {
'm_status_id' : m_status_id,
'status_id' : status_id,
'status' : status,
'display_name' : display_name,
'order_no' : order_no,
'current_status' : current_status,
'status_for_mail' : status_for_mail,
'is_disable' : is_disable,
'updated_at' : datetime.now()
}
MemAppModel().update_m_status(m_status_id,data)
flash('updated successfully','successMsg')
data = {
'msg' : "updated successfully"
}
json_data = json.dumps(data)
return json_data
# m status ------ ends.
# m steps ------ starts.
@app.route("/m_steps/<society_id>/<society_name>" , methods=['GET','POST'])
def MSteps(society_id,society_name):
btn_active=4
get_m_steps = MemAppModel().get_m_all_steps()
m_steps = MemAppModel().get_m_steps(society_id)
return render_template('memberapp_templates/m_steps_index.html',data=m_steps,society_id=society_id,data_1=get_m_steps,society_name=society_name,btn_active=btn_active)
@app.route("/add_m_steps/<society_id>/<society_name>" , methods=['GET','POST'])
def AddMSteps(society_id,society_name):
step_no = MemAppModel().get_previous_step(society_id)
step_no = step_no['order_by']
step_name = request.form['step_name']
page_name = request.form['page_name']
get_function_name = request.form['get_function_name']
post_function_name = request.form['post_function_name']
is_visible = request.values.get('is_visible') or 0
data = {
'society_id' : society_id,
'step_no' : step_no,
'step_name' : step_name,
'page_name' : page_name,
'get_function_name' : get_function_name,
'post_function_name': post_function_name,
'is_visible' : is_visible,
'created_at' : datetime.now()
}
if step_name:
check_step_name = MemAppModel().check_step_name(step_name,society_id)
if check_step_name:
flash("This step is already Exists..","errorMsg")
else:
m_steps_id = MemAppModel().insert_m_steps(data)
flash("Inserted successfully","successMsg")
return redirect(url_for('memapp.MSteps',society_id=society_id,society_name=society_name))
@app.route("/m_steps_byids/<m_steps_id>" , methods=['GET','POST'])
def MStepsByids(m_steps_id):
m_steps_ids = MemAppModel().get_m_steps_byids(m_steps_id)
data = {
'model_data' : m_steps_ids,
'msg' : 'success'
}
json_data = json.dumps(data)
return json_data
@app.route("/post_m_steps/<m_steps_id>" , methods=['GET','POST'])
def PostMSteps(m_steps_id):
m_steps_id = request.form['m_steps_id']
step_no = request.form['step_no']
step_name = request.form['step_name']
page_name = request.form['page_name']
get_function_name = request.form['get_function_name']
post_function_name = request.form['post_function_name']
is_visible = request.values.get('is_visible') or 0
data = {
'm_steps_id' : m_steps_id,
'step_no' : step_no,
'step_name' : step_name,
'page_name' : page_name,
'get_function_name' : get_function_name,
'post_function_name': post_function_name,
'is_visible' : is_visible,
'updated_at' : datetime.now()
}
MemAppModel().update_m_steps(m_steps_id,data)
flash('updated successfully','successMsg')
data = {
'msg' : "updated successfully"
}
json_data = json.dumps(data)
return json_data
# m steps ------ ends.
# m attachment type ------ starts.
@app.route("/m_attachment_type/<society_id>/<society_name>" , methods=['GET','POST'])
def MAttachmentType(society_id,society_name):
btn_active = 5
get_member_type = MemAppModel().get_member_type_society(society_id)
get_all_attachement=MemAppModel().get_all_attachtype()
m_attachment_type = MemAppModel().get_m_attachment_type(society_id)
return render_template('memberapp_templates/m_attachment_type_index.html',data=m_attachment_type,society_id=society_id,data_1=get_all_attachement,data_2=get_member_type,society_name=society_name,btn_active=btn_active)
@app.route("/add_m_attachment_type/<society_id>/<society_name>" , methods=['GET','POST'])
def AddMAttachmentType(society_id,society_name):
attach_type = request.form['attach_type']
attach_extension = request.values.getlist('attach_extension') or None
attach_extension = ','.join(attach_extension)
label_name = request.values.get('label_name') or None
is_active = request.values.get('is_active') or 0
if attach_type:
check_attach_type = MemAppModel().check_attach_type(attach_type,society_id)
if check_attach_type:
flash("Attachment Type is Already Exists","errorMsg")
return redirect(url_for('memapp.MAttachmentType',society_id=society_id,society_name=society_name))
else:
get_order_no = MemAppModel().get_order_no(society_id)
order_no = get_order_no['order_no']
get_attach_data = MemAppModel().get_attach_type(attach_type,society_id)
if get_attach_data:
attach_extension = get_attach_data['attach_extension']
label_name = get_attach_data['label_name']
data_1 = {
'attach_type' : attach_type,
'attach_extension' : attach_extension,
'is_active' : is_active,
'society_id' : society_id,
'label_name' : label_name,
'order_no' : order_no,
'created_at' : datetime.now()
}
attach_type_id = MemAppModel().insert_m_attachment_type(data_1)
flash("Inserted successfully","successMsg")
return redirect(url_for('memapp.MAttachmentType',society_id=society_id,society_name=society_name))
else:
return redirect(url_for('memapp.MAttachmentType',society_id=society_id,society_name=society_name))
@app.route("/m_attachment_type_ids/<attach_type_id>" , methods=['GET','POST'])
def MAttachmentTypeIds(attach_type_id):
m_attachment_type = MemAppModel().get_m_attachment_type_byids(attach_type_id)
data = {
"model_data" : m_attachment_type,
'msg' : "success"
}
json_data = json.dumps(data)
return json_data
@app.route("/post_m_attachment_type/<attach_type_id>" , methods=['GET','POST'])
def PostMAttachmentType(attach_type_id):
attach_type_id = request.form['attach_type_id']
attach_type = request.form['attach_type']
attach_extension = request.form['attach_extension']
label_name = request.form['label_name']
order_no = request.form['order_no']
is_active = request.values.get('is_active') or 0
data = {
'attach_type_id' : attach_type_id,
'attach_type' : attach_type,
'attach_extension' : attach_extension,
'label_name' : label_name,
'order_no' : order_no,
'is_active' : is_active,
'updated_at' : datetime.now()
}
MemAppModel().update_m_attachment_type(attach_type_id,data)
flash('updated successfully','successMsg')
data = {
'msg' : "updated successfully"
}
json_data = json.dumps(data)
return json_data
# m attachment type ------ ends.
# map member type attachment ------ starts.
@app.route("/map_membertype_attachment/<society_id>" , methods=['GET','POST'])
def MapMemberTypeAttachment(society_id):
get_all_attachement=MemAppModel().get_all_attachtype()
map_membertype_attachment = MemAppModel().get_map_membertype_attachment(society_id)
return render_template('memberapp_templates/map_membertype_attachment_index.html',data=map_membertype_attachment,society_id=society_id,data_1=get_all_attachement )
@app.route("/add_map_membertype_attachment" , methods=['GET','POST'])
def AddMapMemberTypeAttachment():
society_id = request.form['society_id']
society_name = request.form['society_name']
attach_type_id = request.form['map_attach_type_id']
attach_type = request.form['map_attach_type']
member_type_id = request.values.getlist('member_type')
is_active = request.values.get('is_active') or 0
is_mandatory = request.values.get('is_mandatory') or 0
check_member_type_id = MemAppModel().check_member_type_id(attach_type_id)
lst=[]
if check_member_type_id:
for x in check_member_type_id:
lst.append(x["member_type_id"])
res =[int(i) for i in member_type_id]
result = [v for v in res if v not in lst] or None
value=''
if result is not None:
for i in result:
data = '('+str(i)+','+str(attach_type_id)+','+str(is_active)+','+str(is_mandatory)+')'
value+= str(data)+','
stmt_1=value.rstrip(',')
stmt = "insert into map_membertype_attachment (member_type_id,attach_type_id,is_active,is_mandatory) values"+stmt_1
map_ma_id = MemAppModel().insert_map_membertype_attachment(stmt)
flash("Member Type Mapped successfully","successMsg")
return redirect(url_for('memapp.MAttachmentType',society_id=society_id,society_name=society_name))
else:
flash("All Member Types are Already Mapped","errorMsg")
return redirect(url_for('memapp.MAttachmentType',society_id=society_id,society_name=society_name))
@app.route("/edit_attachment_byids/<attach_type_id>/<society_id>" , methods=['GET','POST'])
def EditAttachmentByids(attach_type_id,society_id):
model_data = MemAppModel().get_m_attachment_type_byids(attach_type_id)
data = {
"model_data" : model_data,
'msg' : "success"
}
json_data = json.dumps(data)
return json_data
@app.route("/edit_map_membertype_attachment/<attach_type_id>/<society_id>" , methods=['GET','POST'])
def EditMapMemberTypeAttachment(attach_type_id,society_id):
attach_type = request.form['attach_type']
data = MemAppModel().get_map_membertype_attachment(society_id,attach_type_id)
mem_type = MemAppModel().not_map_membertype(society_id,attach_type_id)
html_data = render_template('memberapp_templates/map_membertype_attachment_table.html',data=data)
data = {
"html_data" : html_data,
'attach_type' : attach_type,
"data" : mem_type,
'msg' : "success"
}
json_data = json.dumps(data)
return json_data
@app.route("/edit_m_memtype/<map_ma_id>" , methods=['GET','POST'])
def EditMMemtype(map_ma_id):
map_membertype = MemAppModel().get_map_member_type_attachment_byids(map_ma_id)
data = {
"model_data" : map_membertype,
'msg' : "success"
}
json_data = json.dumps(data)
return json_data
@app.route("/post_map_membertype_attachment/<society_id>/<society_name>" , methods=['GET','POST'])
def PostMapMembertypeAttachment(society_id,society_name):
map_ma_id = request.values.get('map_ma_id')
member_type_id = request.values.get('member_type_id')
attach_type_id = request.values.get('attach_type_id')
is_active = request.values.get('is_active') or 0
is_mandatory = request.values.get('is_mandatory') or 0
member_type = request.values.get('member_type')
if member_type_id:
data = {
'map_ma_id' : map_ma_id,
'member_type_id' : member_type_id,
'attach_type_id' : attach_type_id,
'is_active' : is_active,
'is_mandatory' : is_mandatory,
'updated_at' : datetime.now()
}
MemAppModel().update_map_membertype_attachment(map_ma_id,data)
flash('updated successfully','successMsg')
else:
member_type = MemAppModel().get_member_id(member_type)
member_type_id=member_type['member_type_id']
data ={
'member_type_id' : member_type_id,
'attach_type_id' : attach_type_id,
'is_active' : is_active,
'is_mandatory' : is_mandatory,
'created_at' : datetime.now()
}
MemAppModel().insert_map_membertype_attachment(data)
flash('inserted successfully','successMsg')
data = {
'msg' : "updated successfully"
}
json_data = json.dumps(data)
return json_data
# map member type attachment ------ ends.
# m Payment type ------ starts.
@app.route("/m_Payment_type/<society_id>/<society_name>" , methods=['GET','POST'])
def MPaymentType(society_id,society_name):
btn_active = 6
all_payment_type = MemAppModel().get_all_payment()
m_payment_type = MemAppModel().get_m_payment_type(society_id)
return render_template('memberapp_templates/m_payment_type_index.html',data=m_payment_type,society_id=society_id,society_name=society_name,data_1=all_payment_type,btn_active=btn_active)
@app.route("/add_m_payment_type/<society_id>" , methods=['GET','POST'])
def AddMPaymentType(society_id):
payment_type = request.form['payment_type']
society_name = request.form['society_name']
payment_detail = MemAppModel().get_payment(payment_type)
payment_detail = payment_detail[0]
description = payment_detail['description']
payment_content = payment_detail['payment_content']
data = {
'payment_type' : payment_type,
'description' : description,
'payment_content': payment_content,
'society_id' : society_id,
'created_at' : datetime.now(),
'is_membership' : 1
}
if payment_type:
check_payment_type = MemAppModel().check_payment_type(payment_type,society_id)
if check_payment_type:
flash("Payment Type Already Exists. ","errorMsg")
else:
m_payment_id = MemAppModel().insert_m_payment_type(data)
flash("Inserted successfully","successMsg")
return redirect(url_for('memapp.MPaymentType',society_id=society_id,society_name=society_name))
@app.route("/m_Payment_type_ids/<m_payment_id>/<society_name>" , methods=['GET','POST'])
def MPaymentTypeIds(m_payment_id,society_name):
m_payment_type = MemAppModel().get_m_payment_type_byids(m_payment_id)
data = {
"model_data" : m_payment_type,
'msg' : "success"
}
json_data = json.dumps(data)
return json_data
@app.route("/post_m_Payment_type/<m_payment_id>" , methods=['GET','POST'])
def PostMPaymenttype(m_payment_id):
m_payment_id = request.form['m_payment_id']
payment_type = request.form['payment_type']
description = request.form['description']
payment_content = request.form['payment_content']
is_visible = request.values.get('is_visible') or 0
is_membership = request.values.get('is_membership') or 0
data = {
'm_payment_id' : m_payment_id,
'payment_type' : payment_type,
'description' : description,
'payment_content' : payment_content,
'is_visible' : is_visible,
'is_membership' : is_membership
}
MemAppModel().update_m_payment_type(m_payment_id,data)
flash('updated successfully','successMsg')
data = {
'msg' : "updated successfully"
}
json_data = json.dumps(data)
return json_data
# m Payment type ------ ends.
# ms_setting ------ starts.
@app.route("/ms_setting/<society_id>" , methods=['GET','POST'])
def MSSetting(society_id):
ms_setting = MemAppModel().get_ms_setting()
return render_template('memberapp_templates/ms_setting_index.html',data=ms_setting,society_id=society_id)
@app.route("/ms_setting_byids/<society_id>/<society_name>" , methods=['GET','POST'])
def MSSettingByIds(society_id,society_name):
btn_active = 7
ms_setting = MemAppModel().get_ms_setting_byids(society_id)
return render_template('memberapp_templates/ms_setting.html',data=ms_setting,society_id=society_id,society_name=society_name,btn_active=btn_active)
@app.route("/post_ms_setting" , methods=['GET','POST'])
def PostMSSetting():
ms_setting_id = request.form['ms_setting_id']
society_id = request.form['society_id']
society_name = request.form['society_name']
setting_key = request.form['setting_key']
setting_value = request.form['setting_value']
data = {
'ms_setting_id' : ms_setting_id,
'society_id' : society_id,
'setting_key' : setting_key,
'setting_value' : setting_value,
# 'updated_at' : datetime.now()
}
if ms_setting_id:
MemAppModel().update_ms_setting(ms_setting_id,data)
flash('updated successfully','successMsg')
else:
MemAppModel().insert_ms_setting(data)
flash('Inserted successfully','successMsg')
return redirect(url_for('memapp.MSSettingByIds',society_id=society_id,society_name=society_name))
# ms_setting ------ ends.
# Mail Template ----starts.
@app.route("/mail_template_duplicate/<society_id>" , methods=['GET','POST'])
def MailTemplateDuplicate(society_id):
def_society_id = request.form['def_society_id']
society_assets = MemAppModel().insert_mail_template_bulk(society_id,def_society_id)
data = {
'msg' : "success"
}
json_data = json.dumps(data)
return json_data
@app.route("/mail_template_index/<society_id>/<society_name>" , methods=['GET','POST'])
def MailTemplateIndex(society_id,society_name):
btn_active=8
templateData = MemAppModel().get_admin_mail_template_name(society_id)
return render_template('memberapp_templates/mail_index.html',templateData=templateData,society_id=society_id,society_name=society_name,btn_active=btn_active)
@app.route("/add_mail_template/<society_id>/<society_name>" , methods=['GET','POST'])
def AddMailTemplate(society_id,society_name):
template_name = request.form['template_name']
data = {
'template_name' : template_name,
'society_id' : society_id,
'app_type_id' : 1
}
check__admin_mail_template = MemAppModel().check__admin_mail_template(template_name,society_id)
if check__admin_mail_template:
flash("The template name already Exists","errorMsg")
return redirect(url_for('memapp.MailTemplateIndex',society_id=society_id,society_name=society_name))
else:
mail_template_id=MemAppModel().insert_admin_mail_template(data)
return redirect(url_for('memapp.MailTemplate',mail_template_id=mail_template_id,society_id=society_id,society_name=society_name))
@app.route("/post_add_mail_template/<society_id>" , methods=['GET','POST'])
def PostAddMailTemplate(society_id):
mail_template_id = request.form['mail_template_id']
template_name = request.form['template_name']
sub_type = request.form['sub_type']
subject = request.form['subject']
mail_type = request.form['mail_type']
mail_content = request.form['mail_content']
is_active = request.values.get('is_active') or 0
is_backup = request.values.get('is_backup') or 0
is_layout = request.values.get('is_layout') or 0
data = {
'society_id' : society_id,
'app_type_id' : 1,
'template_name' : template_name,
'subject_type' : sub_type,
'subject' : subject,
'mail_type' : mail_type,
'mail_content' : mail_content,
'is_active' : is_active,
'updated_at' : datetime.now(),
'is_send_backup' : is_backup,
'is_layout' : is_layout
}
MemAppModel().update_admin_mail_template(mail_template_id,data)
data ={'msg':'Updated Successfully',}
return json.dumps(data)
@app.route("/mail_template/<mail_template_id>/<society_id>/<society_name>" , methods=['GET','POST'])
def MailTemplate(mail_template_id,society_id,society_name):
mailData = MemAppModel().get_admin_mail_template(society_id,mail_template_id)
is_preview = 0
btn_active=8
datas = render_template('memberapp_templates/bo_mail_template.html',mail_content=mailData.mail_content)
return render_template('memberapp_templates/m_mail_template.html',society_id=society_id,mailData=mailData,datas=datas,is_preview=is_preview,society_name=society_name,btn_active=btn_active)
@app.route("/preview_mail/<society_id>" , methods=['GET','POST'])
def PreviewMail(society_id):
sub_type = request.values.get('sub_type')
subject = request.values.get('subject')
datas = request.values.get('mail_content')
is_layout = request.values.get('is_layout')
if int(is_layout) == 1:
datas = render_template('memberapp_templates/bo_mail_template.html',mail_content=datas)
else:
pass
datas = {'sub_data':subject,'data':datas,"msg" : "successfully" ,"status" : 1}
json_data = json.dumps(datas,default=str)
return json_data
@app.route("/get_preview_mail/<mail_template_id>/<society_id>/<society_name>" , methods=['GET','POST'])
def getPreviewMail(mail_template_id,society_id,society_name):
mailData = MemAppModel().get_admin_mail_template(society_id,mail_template_id)
is_preview = 1
btn_active=8
datas = render_template('memberapp_templates/bo_mail_template.html',mail_content=mailData.mail_content)
return render_template('memberapp_templates/m_mail_template.html',society_id=society_id,mailData=mailData,datas=datas,is_preview=is_preview,society_name=society_name,btn_active=btn_active)
# Mail Template ----ends.
# Export Filter cols ------ starts.
@app.route("/export_filter_cols/<society_id>/<society_name>" , methods=['GET','POST'])
def ExportFilterCols(society_id,society_name):
btn_active=9
export_filter_cols = MemAppModel().get_export_filter_cols(society_id)
cols_name = MemAppModel().get_cols_name()
return render_template('memberapp_templates/export_filter_cols_index.html',data= export_filter_cols,data_1=cols_name,society_id=society_id,society_name=society_name,btn_active=btn_active)
@app.route("/add_export_filter_cols/<society_id>/<society_name>" , methods=['GET','POST'])
def AddExportFilterCols(society_id,society_name):
cols_display_name = request.form['display_name']
cols_value_name = request.form['value_name']
get_order_by = MemAppModel().get_order_by()
orderby = get_order_by['order_no']
data = {
'cols_display_name': cols_display_name,
'cols_value_name' : cols_value_name,
'society_ids' : society_id,
'orderby' : orderby,
'is_visible' : 1,
'created_at' : datetime.now(),
'is_mem' : 1
}
check_export_filter_cols = MemAppModel().check_export_filter_cols(cols_display_name,society_id)
if check_export_filter_cols:
flash("The Column name already Exists","errorMsg")
else:
cols_id = MemAppModel().update_society_ids(society_id,cols_display_name)
if cols_id:
flash("Updated successfully","successMsg")
else:
MemAppModel().insert_export_filter_cols(data)
flash("Inserted successfully","successMsg")
return redirect(url_for('memapp.ExportFilterCols',society_id=society_id,society_name=society_name))
@app.route("/export_filter_cols_byids/<cols_id>" , methods=['GET','POST'])
def ExportFilterColsIds(cols_id):
export_filter_cols = MemAppModel().get_export_filter_cols_byids(cols_id)
data = {
"model_data" : export_filter_cols,
'msg' : "success"
}
json_data = json.dumps(data)
return json_data
@app.route("/post_export_filter_cols/<cols_id>" , methods=['GET','POST'])
def PostExportFilterColumns(cols_id):
society_id = request.values.get('society_id')
society_name = request.values.get('society_name')
cols_display_name = request.form['cols_display_name']
cols_value_name = request.form['cols_value_name']
society_ids = request.form['society_ids']
data = {
'cols_id' : cols_id,
'cols_display_name' : cols_display_name,
'cols_value_name' : cols_value_name,
'society_ids' : society_ids
# 'updated_at' : datetime.now()
}
MemAppModel().update_export_filter_cols(cols_id,data)
flash('updated successfully','successMsg')
data = {
'msg' : "updated successfully"
}
json_data = json.dumps(data)
return json_data
# Export Filter cols ----ends.
# member work type ---- starts.
@app.route("/m_work_type/<society_id>/<society_name>" , methods=['GET','POST'])
def MWorktype(society_id,society_name):
btn_active = 10
all_work_type = MemAppModel().get_all_m_work_type()
m_work_type = MemAppModel().get_m_work_type(society_id)
return render_template('memberapp_templates/m_work_type_index.html',data = m_work_type,data_1=all_work_type,society_id=society_id,society_name=society_name,btn_active=btn_active)
@app.route("/add_m_work_type/<society_id>/<society_name>" , methods=['GET','POST'])
def AddMworkType(society_id,society_name):
work_type = request.form['work_type']
data = {
'work_type' : work_type,
'society_id' : society_id,
'is_active' : 1,
'created_at' : datetime.now()
}
check_work_type = MemAppModel().check_work_type(work_type,society_id)
if check_work_type:
flash("Work Type is Already Exists","errorMsg")
return redirect(url_for('memapp.MWorktype',society_id=society_id,society_name=society_name))
else:
work_type_id = MemAppModel().insert_work_type(data)
flash("Inserted successfully","successMsg")
return redirect(url_for('memapp.MWorktype',society_id=society_id,society_name=society_name))
@app.route("/m_work_type_byids/<work_type_id>" , methods=['GET','POST'])
def MWorkTypeIds(work_type_id):
m_work_type = MemAppModel().get_m_work_type_byids(work_type_id)
data = {
"model_data" : m_work_type,
'msg' : "success"
}
json_data = json.dumps(data)
return json_data
@app.route("/post_work_type/<work_type_id>" , methods=['GET','POST'])
def PostWorkType(work_type_id):
work_type_id = request.form['work_type_id']
work_type = request.form['work_type']
is_active = request.values.get('is_active') or 0
data = {
'work_type' : work_type,
'is_active' : is_active,
'updated_at' : datetime.now()
}
MemAppModel().update_work_type(work_type_id,data)
flash('updated successfully','successMsg')
data = {
'msg' : "updated successfully"
}
json_data = json.dumps(data)
return json_data
# member work type ---- ends.
# Dail Report mail ----- starts
@app.route("/daily_count_report/<society_id>/<society_name>" , methods=['GET','POST'])
def DailyCountReport(society_id,society_name):
btn_active=11
daily_report = MemAppModel().get_daily_report(society_id)
return render_template('memberapp_templates/daily_report_mail.html',data = daily_report,society_id=society_id,society_name=society_name,btn_active=btn_active)
@app.route("/edit_daily_count_report/<report_id>" , methods=['GET','POST'])
def EditDailyCountReport(report_id):
m_daily_report = MemAppModel().get_daily_report_by_ids(report_id)
data = {
"model_data" : m_daily_report,
'msg' : "success"
}
json_data = json.dumps(data)
return json_data
@app.route("/post_daily_report/<report_id>" , methods=['GET','POST'])
def PostDailyReport(report_id):
full_name = request.form['full_name']
email = request.form['email']
mobile = request.form['mobile']
is_active = request.values.get('is_active') or 0
data = {
'full_name' : full_name,
'email' : email,
'mobile' : mobile,
'is_active' : is_active,
'updated_at' : datetime.now()
}
MemAppModel().update_daily_report(report_id,data)
flash('updated successfully','successMsg')
data = {
'msg' : "updated successfully"
}
json_data = json.dumps(data)
return json_data
@app.route("/add_daily_report_mail/<society_id>/<society_name>" , methods=['GET','POST'])
def AddDailyReportMail(society_id,society_name):
full_name = request.form['add_full_name']
email = request.form['add_email']
mobile = request.form['add_mobile']
is_active = request.values.get('add_is_active') or 0
data = {
'full_name' : full_name,
'email' : email,
'mobile' : mobile,
'society_id' : society_id,
'is_mem' : 1,
'is_active' : is_active,
'created_at' : datetime.now()
}
check_email_id = MemAppModel().check_email_id(email,society_id)
if check_email_id:
flash("Email is Already Exists","errorMsg")
else:
daily_report = MemAppModel().insert_daily_report(data)
flash("Inserted successfully","successMsg")
return redirect(url_for('memapp.DailyCountReport',society_id=society_id,society_name=society_name))
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists