def createFolder():
if isLoggedIn():
fName = request.form["name"].strip()
if not (fName):
return jsonify({
'data': "Please Provide folder name",
'error': True
})
if "/" in fName:
return jsonify({
'data': "Folder Name doesn't include /",
'error': True
})
folder = Files(fName, session['username'], session['path'], "", 1, 1)
try:
db.session.add(folder)
db.session.commit()
except Exception as e:
if 'IntegrityError' in str(e):
print(str(e))
return jsonify({'data': "Folder already exist", 'error': True})
return jsonify({'data', str(e)})
return getCurrentUserFiles()
return redirect(url_for('index'))
def add_file(self,
filepath=None,
mime_type='text/plain',
contents=None,
title=None):
if filepath is None:
filename = str(uuid.uuid4())
filepath = os.path.join(current_app.config['UPLOAD_DIRECTORY'],
self.request.id, filename)
else:
filename = os.path.basename(filepath)
self.filepaths.append(filepath)
# create an empty file if the specified path does not exist
if not fu.exists(filepath):
fu.makedirs(os.path.dirname(filepath), exist_ok=True)
with open(filepath, 'w') as fp:
fp.write(contents or ''.join(
random.choice(ascii_letters)
for _ in range(random.randrange(100, 500))))
response = Files(self.request.id, PRIVATE, title or filename,
filename, mime_type, fu.getsize(filepath),
fu.get_hash(filepath))
# TODO: add Events FILE_ADDED
create_object(response)
return response
def add_file(
self,
title=None,
filepath=None,
name=None, # will be ignored if filepath supplied
privacy=response_privacy.PRIVATE,
user=None):
if filepath is None:
filename = name or fake.file_name(extension='txt')
filepath = os.path.join(current_app.config["UPLOAD_DIRECTORY"],
self.request.id, filename)
else:
filename = os.path.basename(filepath)
if not fu.exists(filepath):
fu.makedirs(os.path.dirname(filepath), exist_ok=True)
with open(filepath, "w") as fp:
fp.write(fake.file_content())
self.__files.append(filepath)
response = Files(
self.request.id,
privacy=privacy,
title=title or fake.title(),
name=filename,
mime_type=fu.get_mime_type(filepath),
size=fu.getsize(filepath),
hash_=fu.get_hash(filepath),
)
create_object(response)
self.__create_event(event_type.FILE_ADDED, response, user)
return response
def editFile():
_version = request.form['versNo']
newVersion = int(_version) + 1
file = Files(title=request.form['title'],
body=request.form['code'],
private=request.form['isPrivate'],
version=newVersion,
author=current_user)
db.session.add(file)
db.session.commit()
flash('File edited')
return jsonify({'status': 'OK'})
def insert_attachment_file(doc_type, fid, filename, filepath, filetype):
'''This method is to store attachment files such as CVs and personal statements into the database'''
form = Forms.get(Forms.fid == fid)
file = Files(filepath = filepath, filename=filename, filetype = filetype)
file.save()
if doc_type == "cv":
try:
form.cv = file
except Exception as e:
print (e)
return False
if doc_type =="statement":
try:
form.personal_statement = file
except Exception as e:
print (e)
return False
form.save()
return form
def dash():
form = UploadFile()
files = Files.query.filter_by(username=current_user.username).all()
if form.validate_on_submit():
file = request.files['uploaded_file']
file_md5 = hashlib.md5(file.read()).hexdigest()
file.seek(0)
check_for_existing = Files.query.filter_by(
username=current_user.username, md5=file_md5).first()
if check_for_existing is None:
file_name = Files.query.filter_by(fileName=file.filename).first()
if file_name is not None:
if (file_name.fileName == file.filename):
file.filename = os.path.splitext(
file.filename)[0] + ' - ' + str(
uuid.uuid4())[:8] + os.path.splitext(
file.filename)[1]
if current_app.config['UPLOAD_AZURE_BLOB']:
upload_to_azure_storage_blob(file)
else:
upload_to_local_storage(file)
obj = Files(username=current_user.username,
fileName=file.filename,
md5=file_md5)
db.session.add(obj)
db.session.commit()
flash('File Uploaded Successfully', 'success')
return redirect(url_for('dashboard.dash'))
else:
if (file.filename == check_for_existing.fileName):
flash('File Already Exists', 'danger')
else:
flash('File Already Exists as ' + check_for_existing.fileName,
'danger')
return redirect(url_for('dashboard.dash'))
return render_template("dashboard/dashboard.html",
title="Dashboard",
files=files,
form=form)
def addFile():
_title = request.form['filename']
_code = request.form['inputCode']
if request.form.get('private') is None:
_private = 0
else:
_private = 1
_version = 1
file = Files(title=request.form['filename'],
body=request.form['inputCode'],
private=_private,
version=_version,
author=current_user)
db.session.add(file)
db.session.commit()
flash('File added')
return redirect(url_for('index'))
def saveFile():
_id = request.form['id']
file = Files.query.filter_by(id=_id)
exists = None
for data in file:
newFile = Files(title=data.title,
data=data.body,
private=1,
version=1,
author=current_user)
db.session.add(newFile)
db.session.commit()
exists = db.session.query(Files.title).filter_by(
title=newFile.title).filter_by(author=current_user).scalar()
#print(exists, file=sys.stderr)
if exists is not None:
flash('Saved to User')
return jsonify({'status': 'OK'})
else:
return jsonify({'status': 'An Error occured'})
def upload():
if isLoggedIn:
if request.method == 'POST':
for key, file in request.files.items():
currentT = time.time()
currentT = str(currentT)
oFileName = file.filename
filename = currentT + file.filename
fileD = Files(oFileName, session['username'], session['path'],
0, 0, 0, filename, "0B")
print("-----------------------------")
print(filename)
try:
db.session.add(fileD)
db.session.commit()
file.save(
os.path.join(APP_ROOT + "/" + uploadFolder + "/",
filename))
fileD.size = os.stat(
os.path.join(APP_ROOT + "/" + uploadFolder + "/",
filename)).st_size
fileD.humanReadableSize = humanReadableSize(fileD.size)
if not fileD.users.totalSize:
fileD.users.totalSize = 0
fileD.users.totalSize += fileD.size
session["totalSize"] = humanReadableSize(
fileD.users.totalSize)
db.session.commit()
except Exception as e:
if 'IntegrityError' in str(e):
return jsonify({
'data':
"File already exist (delete exising file first)",
'error': True
})
return jsonify({'data': str(e), 'error': True})
return getCurrentUserFiles()
return jsonify({'data': "Error:Something went wrong", 'error': True})
def db_update_data():
details = get_all_file_details()
# Update Files
for lang, files in details.items():
for file in files:
path = file["path"]
if Files.query.filter(Files.path == path).count() == 0:
db.session.add(Files(path=path))
db.session.commit()
db_file = Files.query.filter(Files.path == path).first()
db_file.lang = lang
db_file.orig_path = file["orig_path"]
db_file.rev, db_file.orig_rev = svn_compare(
path, db_file.orig_path, regex)
db.session.commit()
# Update Lang
lang_stat = db_get_lang_from_files()
for lang, stat in lang_stat.items():
if Lang.query.filter(Lang.lang == lang).count() == 0:
db.session.add(Lang(lang=lang))
db.session.commit()
db_lang = Lang.query.filter(Lang.lang == lang).first()
db_lang.updated = stat["updated"]
db_lang.outdated = stat["outdated"]
db_lang.ignored = stat["ignored"]
db.session.commit()
# Update Meta
if Meta.query.filter(Meta.key == "last_updated").count() == 0:
db.session.add(Meta(key="last_updated"))
db.session.commit()
db_time = Meta.query.filter(Meta.key == "last_updated").first()
db_time.value = str(int(time.time()))
db.session.commit()
def create_request(title,
description,
category,
tz_name,
agency_ein=None,
first_name=None,
last_name=None,
submission=DIRECT_INPUT,
agency_date_submitted_local=None,
email=None,
user_title=None,
organization=None,
phone=None,
fax=None,
address=None,
upload_path=None,
custom_metadata=None):
"""
Creates a new FOIL Request and associated Users, UserRequests, and Events.
:param title: request title
:param description: detailed description of the request
:param tz_name: client's timezone name
:param agency_ein: agency_ein selected for the request
:param first_name: first name of the requester
:param last_name: last name of the requester
:param submission: request submission method
:param agency_date_submitted_local: submission date chosen by agency
:param email: requester's email address
:param user_title: requester's organizational title
:param organization: requester's organization
:param phone: requester's phone number
:param fax: requester's fax number
:param address: requester's mailing address
:param upload_path: file path of the validated upload
:param custom_metadata: JSON containing all data from custom request forms
"""
# 1. Generate the request id
request_id = generate_request_id(agency_ein)
# 2a. Generate Email Notification Text for Agency
# agency_email = generate_email_template('agency_acknowledgment.html', request_id=request_id)
# 2b. Generate Email Notification Text for Requester
# 3a. Send Email Notification Text for Agency
# 3b. Send Email Notification Text for Requester
# 4a. Calculate Request Submitted Date (Round to next business day)
date_created_local = utc_to_local(datetime.utcnow(), tz_name)
if current_user.is_agency:
date_submitted_local = agency_date_submitted_local
else:
date_submitted_local = date_created_local
# 4b. Calculate Request Due Date (month day year but time is always 5PM, 5 Days after submitted date)
due_date = get_due_date(date_submitted_local, ACKNOWLEDGMENT_PERIOD_LENGTH,
tz_name)
date_created = local_to_utc(date_created_local, tz_name)
date_submitted = local_to_utc(date_submitted_local, tz_name)
# 5. Create Request
request = Requests(id=request_id,
title=title,
agency_ein=agency_ein,
category=category,
description=description,
date_created=date_created,
date_submitted=date_submitted,
due_date=due_date,
submission=submission,
custom_metadata=custom_metadata)
create_object(request)
guid_for_event = current_user.guid if not current_user.is_anonymous else None
# 6. Get or Create User
if current_user.is_public:
user = current_user
else:
user = Users(guid=generate_guid(),
email=email,
first_name=first_name,
last_name=last_name,
title=user_title or None,
organization=organization or None,
email_validated=False,
terms_of_use_accepted=False,
phone_number=phone,
fax_number=fax,
mailing_address=address,
is_anonymous_requester=True)
create_object(user)
# user created event
create_object(
Events(request_id,
guid_for_event,
event_type.USER_CREATED,
previous_value=None,
new_value=user.val_for_events,
response_id=None,
timestamp=datetime.utcnow()))
if upload_path is not None:
# 7. Move file to upload directory
upload_path = _move_validated_upload(request_id, upload_path)
# 8. Create response object
filename = os.path.basename(upload_path)
response = Files(request_id,
RELEASE_AND_PRIVATE,
filename,
filename,
fu.get_mime_type(upload_path),
fu.getsize(upload_path),
fu.get_hash(upload_path),
is_editable=False)
create_object(obj=response)
# 8. Create upload Event
upload_event = Events(user_guid=user.guid,
response_id=response.id,
request_id=request_id,
type_=event_type.FILE_ADDED,
timestamp=datetime.utcnow(),
new_value=response.val_for_events)
create_object(upload_event)
# Create response token if requester is anonymous
if current_user.is_anonymous or current_user.is_agency:
create_object(ResponseTokens(response.id))
role_to_user = {
role.PUBLIC_REQUESTER: user.is_public,
role.ANONYMOUS: user.is_anonymous_requester,
}
role_name = [k for (k, v) in role_to_user.items() if v][0]
# (key for "truthy" value)
# 9. Create Event
timestamp = datetime.utcnow()
event = Events(user_guid=user.guid
if current_user.is_anonymous else current_user.guid,
request_id=request_id,
type_=event_type.REQ_CREATED,
timestamp=timestamp,
new_value=request.val_for_events)
create_object(event)
if current_user.is_agency:
agency_event = Events(user_guid=current_user.guid,
request_id=request.id,
type_=event_type.AGENCY_REQ_CREATED,
timestamp=timestamp)
create_object(agency_event)
# 10. Create UserRequest for requester
user_request = UserRequests(
user_guid=user.guid,
request_user_type=user_type_request.REQUESTER,
request_id=request_id,
permissions=Roles.query.filter_by(name=role_name).first().permissions)
create_object(user_request)
create_object(
Events(request_id,
guid_for_event,
event_type.USER_ADDED,
previous_value=None,
new_value=user_request.val_for_events,
response_id=None,
timestamp=datetime.utcnow()))
# 11. Create the elasticsearch request doc only if agency has been onboarded
agency = Agencies.query.filter_by(ein=agency_ein).one()
# 12. Add all agency administrators to the request.
if agency.administrators:
# b. Store all agency users objects in the UserRequests table as Agency users with Agency Administrator
# privileges
_create_agency_user_requests(request_id=request_id,
agency_admins=agency.administrators,
guid_for_event=guid_for_event)
# 13. Add all parent agency administrators to the request.
if agency != agency.parent:
if (agency.parent.agency_features is not None
and agency_ein in agency.parent.agency_features.get(
'monitor_agency_requests', []) and agency.parent.is_active
and agency.parent.administrators):
_create_agency_user_requests(
request_id=request_id,
agency_admins=agency.parent.administrators,
guid_for_event=guid_for_event)
# (Now that we can associate the request with its requester AND agency users.)
if current_app.config['ELASTICSEARCH_ENABLED'] and agency.is_active:
request.es_create()
return request_id
def viewform(request):
usercheck = user_permission_check(request)
if user_permission_check(request) == "2":
return HttpResponseRedirect("/404")
elif user_permission_check(request) == "3":
return HttpResponseRedirect("/404")
elif user_permission_check(request) == "1":
navbardash = True
if not request.GET.get("id"):
return HttpResponseRedirect("/dashboard")
else:
if request.GET.get('successfulupload') == str(1):
successform = 1
elif request.GET.get('successfulupload') == str(0):
successform = 2
user = request.user
formid_get = request.GET.get("id")
ecfdata_info = EcfData.objects.get(id=formid_get)
if ecfdata_info.user_id == user.id:
userdata = User.objects.get(id=ecfdata_info.user_id)
moduledata_info = ModuleData.objects.filter(
ecfdata_id=formid_get)
# Code for viewing and downloading the uploaded files
fileupload_data = Files.objects.filter(ecfdata_id=formid_get)
totalmodules = 0
pendingmod = 0
approvedmod = 0
rejectedmod = 0
finalmod = -1
for item in moduledata_info:
totalmodules += 1
if item.approved == 0:
pendingmod += 1
elif item.approved == 1:
approvedmod += 1
elif item.approved == 2:
rejectedmod += 1
if totalmodules == pendingmod:
finalmod = 0
elif totalmodules == approvedmod:
finalmod = 1
elif totalmodules == rejectedmod:
finalmod = 2
elif pendingmod >= 1:
finalmod = 4
else:
finalmod = 3
# If new files are requested by the secretary
if request.method == "POST":
foreignid = request.GET.get('id')
ecfdataid = EcfData.objects.get(id=foreignid)
form = extraUpload(request.POST, request.FILES)
if form.is_valid():
filestore = Files(document=request.FILES['fileinput'],
ecfdata_id=ecfdataid.id)
filestore.pk = None
filestore.save()
ecfdataid.moreproof = False
ecfdataid.save()
context = {}
allusers = User.objects.all()
secretaryCheck = allusers.select_related('profile')
for item in secretaryCheck:
if item.profile.userpower == 2:
send_mail(
'More proof uploaded for form #' +
str(ecfdataid.id),
render_to_string(
'emails/secretary/moreproofuploaded.txt',
context),
sendingemailaddress,
[item.email],
fail_silently=True,
)
return HttpResponseRedirect("/viewform?id=" +
foreignid +
"&successfulupload=1")
else:
return HttpResponseRedirect("/viewform?id=" +
foreignid +
"&successfulupload=0")
else:
form = extraUpload()
return render(request, 'viewform.html', locals())
else:
return HttpResponseRedirect("/404")
def newform(request):
usercheck = user_permission_check(request)
if user_permission_check(request) == "2":
return HttpResponseRedirect("/404")
elif user_permission_check(request) == "3":
return HttpResponseRedirect("/404")
elif user_permission_check(request) == "1":
navbarnew = True
units = request.GET.get('units')
unitsx = request.GET.get('units', 0)
x = int(unitsx)
if (x <= 0) or (x == None) or (x > 10):
return HttpResponseRedirect("/units?nounits=1")
else:
if units:
units = range(1, int(units) + 1)
if request.method == "POST":
unitsx = request.GET.get('units', 0)
x = int(unitsx)
form = NewEcf(request.POST, request.FILES, units_no=x)
user = request.user
if form.is_valid():
ukvisa = form.cleaned_data['ukvisa']
coursename = form.cleaned_data['coursename']
studyyear = form.cleaned_data['studyyear']
numberofunits = form.cleaned_data['numberofunits']
durationenddate = form.cleaned_data['durationenddate']
durationstartdate = form.cleaned_data['durationstartdate']
circumstance = form.cleaned_data['circumstance']
detailecf = form.cleaned_data['detailecf']
ecfdata = EcfData(user=user,
ukvisa=ukvisa,
coursename=coursename,
studyyear=studyyear,
numberofunits=numberofunits,
durationenddate=durationenddate,
durationstartdate=durationstartdate,
circumstance=circumstance,
detailecf=detailecf)
ecfdata.save()
foreignid = EcfData.objects.get(id=ecfdata.id)
filestore = Files(document=request.FILES['fileinput'],
ecfdata=foreignid)
filestore.pk = None
filestore.save()
listunitcode = []
listtype = []
liststartdate = []
listenddate = []
listaction = []
for item in range(1, ecfdata.numberofunits + 1):
listunitcode.append("unitcode" + str(item))
listtype.append("type" + str(item))
liststartdate.append("startdate" + str(item))
listenddate.append("enddate" + str(item))
listaction.append("action" + str(item))
for i in range(0, ecfdata.numberofunits):
foreignid = EcfData.objects.get(id=ecfdata.id)
unitcode = form.cleaned_data[listunitcode[i]]
type = form.cleaned_data[listtype[i]]
startdate = form.cleaned_data[liststartdate[i]]
enddate = form.cleaned_data[listenddate[i]]
action = form.cleaned_data[listaction[i]]
moduledata = ModuleData(
unitcode=unitcode,
type=type,
startdate=startdate,
enddate=enddate,
action=action,
ecfdata=foreignid,
)
moduledata.pk = None
moduledata.save()
context = {}
send_mail(
'Submmited New Form #' + str(ecfdata.id),
render_to_string('emails/newform.txt', context),
sendingemailaddress,
[user.email],
fail_silently=True,
)
studentpubdata = User.objects.all()
studcheck = studentpubdata.select_related('profile')
for item in studcheck:
if item.profile.userpower == 2:
send_mail(
'New form #' + str(ecfdata.id) +
' submitted',
render_to_string(
'emails/secretary/newform.txt',
context),
sendingemailaddress,
[item.email],
fail_silently=True,
)
return HttpResponseRedirect("/dashboard?success=1")
else:
return HttpResponseRedirect("/dashboard?success=0")
else:
form = NewEcf(units_no=x)
return render(request, 'newform.html', locals())
def addReport():
subject = request.form.get('subject')
sender = session.get('uname')
recipients = request.form.get('recipient')
copier = request.form.get('copier')
conclusion = request.form.get('conclusion')
need = request.form.get('need')
bug = request.form.get('bug')
purposes = request.form.get('purposes')
environment = request.form.get('environment')
files = request.files.getlist('file')
version = request.form.get('version')
updateContext = request.form.get('updateContext')
testReport = request.form.get('testReport')
attention = request.form.get('attention')
sendTime = datetime.datetime.now().date()
creater = session.get('uname')
type = request.form.get("type")
isSend = request.form.get("isSend")
recipients = recipients.split(',')
copier = copier.split(',')
needs = ""
if need:
needIdArr = need.split(',')
for needId in needIdArr:
i = Need.query.filter(Need.id == needId).first()
need_str = '<div>' + i.title + ' ' + i.priority + ' ' + i.status + ' ' + i.handler + ' ' + i.start_time + ' ' + i.end_time + '</div>'
needs = needs + need_str
bugs = ""
if bug:
bugIdArr = bug.split(',')
for bugId in bugIdArr:
i = Bugs.query.filter(Bugs.id == bugId).first()
createTime = i.createTime.strftime("%Y-%m-%d")
bug_str = '<div>' + i.title + ' ' + i.severity + ' ' + i.priority + ' ' + i.iteration + ' ' \
+ i.status + ' ' + i.handler + ' ' + i.creater + ' ' + createTime + '</div>'
bugs = bugs + bug_str
if type == '1':
if isSend == 'Y':
text_body = "这是测试报告"
text_html = "<html><header><h2>" + subject + "测试报告</h2></header>" \
"<body><div><b>一、测试结论</b></div>" + conclusion + \
"<div><b>二、测试目的</b></div>" + purposes + \
"<div><b>三、测试环境</b></div>" + environment + \
"<div><b>四、版本需求列表</b></div>" + needs + \
"<div><b>五、版本缺陷列表</b></div>" + bugs + "</body></html>"
send_email(subject, sender, recipients + copier, text_body,
text_html)
status = "已发送"
else:
status = "草稿"
if type == '2':
if isSend == 'Y':
text_body = "这是发布报告"
text_html = "<html><header><h2>" + subject + "发布报告</h2></header>" \
"<body><div><b>一、版本号</b></div>" + version + \
"<div><b>二、更新内容</b></div>" + updateContext + \
"<div><b>三、需求列表</b></div>" + needs + \
"<div><b>四、测试报告</b></div>" + testReport + \
"<div><b>五、注意事项</b></div>" + attention + \
"</body></html>"
send_email(subject, sender, recipients + copier, text_body,
text_html)
status = "已发送"
else:
status = "草稿"
report = Report(subject=subject,
recipients=";".join(recipients),
copier=";".join(copier),
conclusion=conclusion,
purposes=purposes,
environment=environment,
version=version,
updateContext=updateContext,
testReport=testReport,
attention=attention,
sendTime=sendTime,
creater=creater,
type=type,
status=status,
needs=need,
bugs=bug)
db.session.add(report)
db.session.commit()
if files:
for fname in files:
new_fname = r'F:/tapd-demo/files/' + fname.filename
fname.save(new_fname) # 保存文件到指定路径
# 文件下载地址
file_download = "http://localhost:8088/" + fname.filename
file = Files(name=fname.filename,
address=file_download,
report_id=report.id)
db.session.add(file)
db.session.commit()
return 'success'
def media():
global requestedRequests
global i
global directory
global coursesList
global videoDuration
# Extract fields from extension request
req = request.json
url = req['url']
name = req['name']
courseName = req['courseName']
videoDuration = req['videoDuration']
name = name.split('\n')[0]
courseName = re.sub('[^0-9a-zA-Z]+', '_', courseName)
name = re.sub('[^0-9a-zA-Z]+', '_', name)
if(courseName not in coursesList):
c = Course(coursename=courseName)
db.session.add(c)
db.session.commit()
getCourseList()
directory = f"{path_to_directory}/{courseName}"
video_pattern = ""
is_video = False
is_videoHD = re.search(video_patternHD, url)
is_videoFHD = re.search(video_patternFHD, url)
if(is_videoFHD):
is_video = True
video_pattern = video_patternFHD
if(is_videoHD):
is_video = True
video_pattern = video_patternHD
is_audio = re.search(audio_pattern, url)
# There is only one GET request if the wideo is a mp4
is_mp4 = re.search(mp4_pattern, url)
if is_mp4:
requestedRequests.add(video_pattern)
requestedRequests.add(audio_pattern)
fname = handle_windows_path(f"{directory}/video_{i}_{name}.mp4")
print(f"downloading {fname}")
urllib.request.urlretrieve(url, fname)
print(f"downloading {fname}")
courseID = db.session.query(Course).filter_by(coursename=courseName).first().id
verbose_cls()
i += 1
# If course uses .aac and .ts we have to filter for unique requests
if(len(requestedRequests) < 2):
courseID = db.session.query(Course).filter_by(coursename=courseName).first().id
if is_video and video_pattern not in requestedRequests:
fname = handle_windows_path(f"{directory}/video_{i}_{name}.ts")
print(f"downloading {fname}")
#urllib.request.urlretrieve(url, fname)
while(download(url, fname) is False):
print(f"downloading {fname}")
print(f"Error during downloading {fname}")
requestedRequests.add(video_pattern)
f = Files(filename=f"video_{i}_{name}.ts", course_id=courseID)
#db.session.add(f)
#db.session.commit()
print(f"Downloaded {fname}")
if is_audio and audio_pattern not in requestedRequests:
fname = handle_windows_path(f"{directory}/audio_{i}_{name}.aac")
print(f"downloading {fname}")
#urllib.request.urlretrieve(url, fname)
while(download(url, fname) is False):
print(f"downloading {fname}")
print(f"Error during downloading {fname}")
requestedRequests.add(audio_pattern)
f = Files(filename=f"audio_{i}_{name}.aac", course_id=courseID)
#db.session.add(f)
#db.session.commit()
print(f"Downloaded {fname}")
if len(requestedRequests) == 2:
verbose_cls()
i += 1
if(automatic):
clearRequests()
return ""
