def addreport():
form = AddReportForm()
report = Report()
context = {
'title': "GecMonitor | Add a Report",
'report': report,
'form': form,
'sites': current_user.sites
}
if request.method == 'POST' and form.validate():
report_name = form.report_name.data
selected_sites = form.current_user_sites.data
description = form.description.data
new_report = Report(report_name=report_name,
sites=selected_sites,
description=description)
current_user.reports.append(new_report)
db.session.add(new_report)
db.session.commit()
sites_list = [[site.id, site.gt_global_id]
for site in new_report.sites]
initial_site_scan = InitialSiteScan(sites_list, new_report.id)
initial_site_scan.start()
flash(f"{report_name} has been added to your sites!")
return redirect(url_for("index"))
return render_template("add_report.html", **context)
def reportUser(username):
user = User.query.filter_by(username=username).first()
form = ReportForm()
if form.validate_on_submit():
report = Report(reasonReported=form.reasons.data, report_recipient_id = user.id)
score = user.reportTally #gets report numbers
if form.reasons.data == 'Harrasment':
score += 1
user.reportTally = score
db.session.commit()
elif form.reasons.data == 'Illegal Activities':
score += 3
user.reportTally = score
db.session.commit()
elif form.reasons.data == 'Blackmailing':
score += 2
user.reportTally = score
db.session.commit()
elif form.reasons.data == 'Harmful/Racist messages':
score += 5
user.reportTally = score
db.session.commit()
elif form.reasons.data == 'Stalking':
score += 2
user.reportTally = score
db.session.commit()
db.session.add(report)
db.session.commit()
#accountCheck(user.username)
flash('User has been Reported!')
return redirect(url_for('user', username=username))
return render_template('Report.html', user = user, form=form, title = 'Reporting')
def add_report_to_db(data):
province=Province.query.filter_by(id=int(data['province'])).first()
district=District.query.filter_by(id=int(data['district'])).first()
localbody=LocalBody.query.filter_by(id=int(data['localbody'])).first()
report=Report(province=province.name,district=district.name,localbody=localbody.name,customer_id=data['customer_id'],latitude=data['latitude'],longitude=data['longitude'],ward=data['ward_number'],status="Reported")
db.session.add(report)
db.session.commit()
def add_report():
"""
Add report to the database
"""
add_report = True
form = ReportForm()
if form.validate_on_submit():
report = Report(name=form.name.data,
report_file=secure_filename(
form.report_file.data.filename),
employee=current_user)
f = form.report_file.data
filename = secure_filename(f.filename)
f.save(os.path.join(current_app.config['UPLOAD_FOLDER'], filename))
try:
# add report to the database
db.session.add(report)
db.session.commit()
flash('Đã thêm báo cáo thành công.')
except:
# in case report file already exists
flash('Lỗi: Tên file báo cáo đã tồn tại.')
# redirect to the reports page
return redirect(url_for('home.list_reports'))
# load report template
return render_template('home/report.html',
add_report=add_report,
form=form,
title='Thêm báo cáo')
def test_find_reports(self):
"""Test that the reports that a loan belongs to are found correctly."""
u, v, l, r = self.test_add_user_loan_report()
# Create reports, and assign them to loan l2 except the fifth one
l2 = Loan(balance=100, currency='USD', debtor=u)
db.session.add(l2)
rep = []
for i in range(5):
rep.append(
Report(title="report" + str(i),
body="This is the body of the report",
author=v))
db.session.add(rep[i])
db.session.commit()
for i in range(4):
l2.refer(rep[i])
# Check that all but the fifth are referring l2
for i in range(5):
if i != 4:
self.assertTrue(l2.is_referred(rep[i]))
else:
self.assertFalse(l2.is_referred(rep[i]))
# Check that the rep list is NOT l2.reports
self.assertFalse(l2.reports == rep)
# Check that the first 4 items in rep are in the list of l2.reports
for i in range(len(rep[:4])):
self.assertTrue(rep[i] in l2.reports)
def AssignTask(task_id):
task = Task.query.filter().first()
if task is None:
flash('Такой задачи не существует.')
return redirect(url_for('main.ShowTasks'))
form = AssignmentForm()
if current_user.role == UserRoles.manager:
users = User.query.filter(User.dep_id == current_user.dep_id, User.id != current_user.id, User.role == UserRoles.employee).order_by(User.name).all()
users_list = [(u.id, u.name) for u in users]
else:
users_list = [(current_user.id,current_user.name)]
form.user.choices = users_list
if form.validate_on_submit():
report = Report.query.filter(Report.user_id == form.user.data, Report.date == form.date.data).first()
if report is None:
report = Report(user_id = form.user.data, date = form.date.data)
db.session.add(report)
db.session.commit()
report_task = ReportTask(name = task.name, metric = task.metric, measurement = form.measurement.data, completed = form.completed.data)
if form.comment.data is not None:
report_task.comment = form.comment.data.strip()
db.session.add(report_task)
report_task.report = report
db.session.commit()
flash('Задача успешно назначена сотруднику.')
else:
for error in form.user.errors + form.date.errors + form.measurement.errors + form.completed.errors + form.comment.errors:
flash(error)
return redirect(url_for('main.ShowTasks'))
def publish():
if request.method == "GET":
admin_id = session.get('admin_id')
admin_name = Admin.query.filter(Admin.id == admin_id).first().name
contexts = {"admin_name": admin_name}
return render_template("admin/publish.html", **contexts)
else:
#每次写新报告之前删除之前的报告,根据登录id删除之前的记录
admin_id = session.get('admin_id')
old_record = Report.query.filter(Report.id == admin_id).first()
try:
db.session.delete(old_record)
db.session.commit()
#获取新的report并添加进数据库
except:
pass
name = Admin.query.filter(Admin.id == admin_id).first().name
content = request.form.get('content')
report = Report(id=admin_id,
content=content,
name=name,
admin_id=admin_id)
db.session.add(report)
db.session.commit()
return redirect('/report_show')
def handle_request():
if request.method == 'POST':
if request.files:
username = '******'
filename = images.save(request.files['image'])
url = images.url(filename)
#---------------------
result = predict(filename)
#---------------------
user = User.query.filter_by(username=username).first()
if user is None: user = User(username=username)
report = Report(user=user, data=json.dumps(result))
image = Image(report=report)
image.image_filename = filename
image.image_url = url
db.session.add(user)
db.session.add(report)
db.session.add(image)
db.session.commit()
return 'Report Generated'
return 'No Files Recieved'
return 'Method not POST'
def test_report(self):
self.assertEqual(Report.query.count(), 0)
report = Report(reporter_id='66666666',
reported_id='11111',
report_id=gen_id(),
body='Terrible mate.')
db.session.add(report)
db.session.commit()
self.assertEqual(Report.query.count(), 1)
def report(cert_id):
"""
Return template for report page
"""
cert = Cert.query.get(cert_id)
if cert.file_id is None:
urls = [url_for('static', filename=os.path.join('img', "missing.png"))]
else:
if not cert.file.converted:
cert.file.convert()
urls = cert.file.pngs
form = ReportForm(request.form)
if request.method == 'POST':
if form.validate_on_submit():
form_completed = False
for key, value in form.data.items():
if value != "" and key is not 'csrf_token' and key is not 'submit':
form_completed = True
if not form_completed:
flash("Please complete at least one form field.",
category="warning")
return render_template('report_issue.html',
form=form,
cert=cert,
urls=urls)
else:
form_fields = {
name: data
for name, data in {
'county': form.county.data,
'month': form.month.data,
'day': form.day.data,
'year': form.year.data,
'age': form.age.data,
'number': form.number.data,
'soundex': form.soundex.data,
'first_name': form.first_name.data,
'last_name': form.last_name.data,
'comments': form.comments.data
}.items() if data
}
report = Report(cert_id=cert_id,
user_id=current_user.id,
values=form_fields)
db.session.add(report)
db.session.commit()
flash("Your report has been submitted.", category="success")
return redirect('/')
else:
flash("An error has occurred.")
print(form.errors)
return render_template('report_issue.html',
form=form,
cert=cert,
urls=urls)
def create_report():
data = request.get_json() or {}
if 'guid' not in data or 'latitude' not in data or 'longitude' not in data:
return bad_request('must include guid, latitude, and longitude fields')
report = Report()
report.from_dict(data)
db.session.add(report)
db.session.commit()
response = jsonify(report.to_dict())
response.status_code = 201
return response
def report(user_id):
user = User.query.get(user_id)
form = ReportForm()
if form.validate_on_submit():
report = Report(title = form.title.data, username = current_user.username, body = form.body.data)
db.session.add(report)
db.session.commit()
report.add_report(user, current_user)
db.session.commit()
flash('Your report has been recorded.')
return redirect('/clear_search')
return render_template('report.html', title='Report User', form=form)
def checkin_employee():
id = request.form['id'].strip()
observation = 'Prezent'
employee = Employee.query.get_or_404(id)
report = Report(employee=employee, observations=observation, check_in=True)
db.session.add(report)
db.session.commit()
return json.dumps({'success': True}), 200, {
'ContentType': 'application/json'
}
def multiavscan(sha256):
"""Task to run the AV scanners
:param sha256: File hash
"""
scanned = Sample.query.filter_by(sha256=sha256).first()
file_path = os.path.join(current_app.config['APP_UPLOADS_SAMPLES'], sha256)
av = Scanner(current_app.config['AVSCAN_CONFIG'])
av_report = av.scan(file_path)
scanned.reports.append(Report(type_id=2, report=json.dumps(av_report)))
db.session.add(scanned)
db.session.commit()
def test_add_user_loan_report(self):
"""Test that the test worked."""
u = User(name="Uu")
v = User(name="Vv")
l = Loan(balance=10, currency='GBP', debtor=u)
r = Report(title="The Report",
body="This is the body of the report",
author=v)
db.session.add(u)
db.session.add(v)
db.session.add(r)
db.session.add(l)
db.session.commit()
return u, v, l, r
def specific_report(id):
form = ReportForm()
if form.validate_on_submit():
prev_url = request.args.get('prev')
report_type = request.args.get('type')
if url_parse(prev_url).netloc != '':
return redirect('index')
if report_type.find('post') != -1:
report = Report(reason=form.reason.data,
author=current_user,
post_id=id)
elif report_type.find('comment') != -1:
report = Report(reason=form.reason.data,
author=current_user,
comment_id=id)
else:
report = Report(reason=form.reason.data,
author=current_user,
profile_id=id)
db.session.add(report)
db.session.commit()
flash('Your report has been submitted. Thank you for your feedback!')
return redirect(prev_url)
return render_template('specific_report.html', title='Report', form=form)
def general_report():
form0 = SearchProfileForm()
form = ReportForm()
if form.validate_on_submit():
prev_url = request.args.get('prev')
if url_parse(prev_url).netloc != '':
return redirect(url_for('index'))
report = Report(reason=form.reason.data,
page_of_report=prev_url,
author=current_user)
db.session.add(report)
db.session.commit()
flash('Your report has been submitted. Thank you for your feedback!')
return redirect(prev_url)
return render_template('general_report.html',
form=form,
form0=form0,
title='Report')
def index():
# Build start and end dates
(start, end) = __build_dates_from_request(request)
# Gather filters
filter = request.args.get('group',
default=Filter.no_filter(),
type=__to_attribute_filter)
# Build Repo models
repos = Repo.all_display()
# Group Repos by filter
groups = Group.group_repos(repos, filter, start, end)
# Generate report
report = Report(groups, filter, start, end)
# Build filters
filters = [Filter.no_filter()] + Repo.filterable_attributes()
# Render from template
rendered = render_template("report.html", report=report, filters=filters)
# Build response
return __build_response_with_dates_cookies(rendered, 200, start, end)
def logreport():
request_data = request.get_json()
logged_user = request_data["user"]
user = User.query.filter_by(email=logged_user).first()
if user is not None:
report = Report()
report.email = logged_user
report.report_time = datetime.fromisoformat(
request_data["report_time"])
report.report_time = datetime.utcnow()
report.remaining_trades = request_data["remaining_trades"]
report.open_positions_json = request_data["open_positions"]
report.open_orders_json = request_data["open_orders"]
report.candidates_live_json = request_data["candidates_live"]
report.all_positions_value = request_data["all_positions_value"]
report.net_liquidation = request_data["net_liquidation"]
report.remaining_sma_with_safety = request_data[
"remaining_sma_with_safety"]
report.excess_liquidity = request_data["excess_liquidity"]
report.dailyPnl = request_data["dailyPnl"]
report.api_connected = request_data["api_connected"]
report.last_worker_execution = datetime.fromisoformat(
request_data["last_worker_run"])
report.market_time = datetime.fromisoformat(
request_data["market_time"])
report.market_state = request_data["market_state"]
report.started_time = datetime.fromisoformat(
request_data["started_time"])
report.market_data_error = request_data["market_data_error"]
report.client_version = request_data["client_version"]
report.update_report()
if report.api_connected:
if report.market_state == "Open": # can be none .... in not taken from api...tws not yet connected on first run
check_stop_loss(logged_user, report.net_liquidation)
# check_if_market_fall(logged_user)
# check_for_signals(report.candidates_live_json)
return "Report snapshot stored at server"
else:
return "The user configured is not found on Server the report is not logged"
def upload():
form = UploadForm()
if request.method == 'POST':
if form.validate_on_submit():
username = form.username.data
filename = images.save(request.files['image'])
url = images.url(filename)
#---------------------
result = predict(filename)
#---------------------
user = User.query.filter_by(username=username).first()
if user is None: user = User(username=username)
report = Report(user=user, data=json.dumps(result))
image = Image(report=report)
image.image_filename = filename
image.image_url = url
db.session.add(user)
db.session.add(report)
db.session.add(image)
db.session.commit()
flash(
'User Report for username: {} generated. '.format(
form.username.data), 'success')
return redirect(url_for('report', report_id=report.id))
else:
flash_errors(form)
flash('ERROR! Report was not generated.', 'error')
return render_template('upload.html', title='Upload', form=form)
def one_report(severity, email, days, symptoms):
user = User.query.filter_by(email=email).first()
user_id = user.id
days = datetime.today() - timedelta(days=days)
new_report = Report(severity=severity,
user_id=user_id,
school_id=user.school.id,
date=days)
new_report.symptoms = []
new_report.buildings = []
symptoms = symptoms.split(",")
for symptom in symptoms:
s = Symptom.query.filter_by(name=symptom).first()
if s:
new_report.symptoms.append(s)
for building in user.buildings:
new_report.buildings.append(
Building.query.filter_by(name=building.name).first())
db.session.add(new_report)
db.session.commit()
def addreport(id):
form = AddVisitReport()
visit = Visit.query.filter_by(id=id).first()
partner = Partner.query.filter_by(id=visit.partner).first()
author = current_user.id
if form.validate_on_submit():
report = Report(content=form.report.data, visit_id=id, author=author)
db.session.add(report)
db.session.commit()
flash('Visit report added.')
return redirect(url_for('visitdetails', id=partner.id))
return render_template('addreport.html',
form=form,
visit=visit,
partner=partner)
def test_report(self):
seller = User(username="******",
email="*****@*****.**",
first_name="SellerFirst",
last_name="SellerLast",
address="Seller Address",
card_number="1111111111111111",
security_code="111",
is_seller=True)
seller.set_password('Seller')
db.session.add(seller)
db.session.commit()
buyer = User(username="******",
email="*****@*****.**",
first_name="BuyerFirst",
last_name="BuyerLast",
address="Buyer Address",
card_number="2222222222222222",
security_code="222",
is_seller=False)
buyer.set_password("Buyer")
db.session.add(buyer)
db.session.commit()
report = Report(body='This is a test report for a test seller!')
db.session.add(report)
db.session.commit()
self.assertEqual(report.body,
'This is a test report for a test seller!')
self.assertEqual(seller.reports.all(), [])
self.assertFalse(report in seller.reports)
report.add_report(seller, buyer)
self.assertEqual(seller.reports.count(), 1)
self.assertEqual(seller.reports.first().username, 'ABuyer')
self.assertEqual(seller.reports.first().body,
'This is a test report for a test seller!')
self.assertEqual(seller.reports.first().reported_id, seller.id)
def report():
if Configuration.query.count() == 0:
#TODO return 404 somehow
pass
form = ReportForm()
form.config_id.choices =[(c.id, c.config_name) for c in Configuration.\
query.with_entities(Configuration.id,
Configuration.config_name).all()]
if form.validate_on_submit():
report = Report(report_name=form.report_name.data,
config_id=form.config_id.data,
hour=form.hour.data,
day=form.day.data,
minute=form.minute.data,
query_text=form.query_text.data)
db.session.add(report)
db.session.commit()
# keep this redirect here for a bit till I figure out what to do
# with it
return redirect(url_for('index'))
return render_template('report.html', form=form)
def create_report():
form = CreateReportForm()
if form.validate_on_submit():
lat = float(form.coordinates_lat.data)
lng = float(form.coordinates_lng.data)
zone = int(form.zone.data)
report = Report(user_id=current_user.id,
date=form.date.data,
crime_id=form.crime.data,
crime_hour_id=form.hour.data,
latitude=lat,
longitude=lng,
zone=zone,
details=form.details.data,
reference_id=form.reference.data)
db.session.add(report)
db.session.commit()
return redirect(url_for('user_reports'))
return render_template('create_report.html',
title='Crear Reporte',
active='add_report',
form=form)
def setup_db():
with app.app_context():
db.drop_all()
db.create_all()
db.session.add(
Report(id=4,
content=json.dumps({
"organization":
"Flowers Inc.",
"reported_at":
"2017-11-19",
"created_at":
"2017-11-23",
"inventory": [{
"name": "Flower pot",
"price": "2.00"
}, {
"name": "Roses, 24",
"price": "50.00"
}]
})))
db.session.commit()
def new_report():
rawTime = time.time()
startDate = datetime.datetime.fromtimestamp(rawTime).strftime(
'%Y-%m-%d %H:%M:%S')
substance = request.args.get('substance', "null", type=str)
dosage = request.args.get('dosage', 0, type=int)
dosagelabel = request.args.get('dosagelabel', "null", type=str)
roa = request.args.get('roa', "null", type=str)
source = request.args.get('source', "null", type=str)
tester = startDate + substance + str(dosage) + roa + dosagelabel + source
newReport = Report(StartDate=startDate,
Substance=substance,
Dosage=dosage,
DosageLabel=dosagelabel,
ROA=roa,
Source=source)
db.session.add(newReport)
db.session.commit()
#print("ID pulled from object: " + str(newReport.id), file=sys.stderr)
return jsonify(result=newReport.serialize())
def submit_report():
"""
Create and submit report
"""
form = ReportForm()
form.main_teacher.choices = Teacher.get_teachers_for_choices()
form.assistant_teacher.choices = Teacher.get_teachers_for_choices()
form.submitted_by.choices = Teacher.get_teachers_for_choices()
if form.validate_on_submit():
report = Report(main_teacher_id=form.main_teacher.data,
assistant_teacher_id=form.assistant_teacher.data,
teaching_date=form.teaching_date.data,
teaching_content=form.teaching_content.data,
student_attendance=form.student_attendance.data,
submitted_by_id=form.submitted_by.data)
db.session.add(report)
db.session.commit()
flash(message='Report is successfully submitted.', category='success')
return redirect(url_for('index'))
return render_template('report_submit.html',
title='Submit a Report',
form=form)
def init(password=None):
db_path = app.config['SQLALCHEMY_DATABASE_URI'][10:]
if op.exists(db_path):
if app.config.get('TEST', False):
os.remove(db_path)
else:
raise DatabaseAlreadyInitialisedError(
"Database has already been initialised at {}".format(db_path))
else:
os.makedirs(op.dirname(db_path), exist_ok=True)
db.create_all()
admin_role = Role(ADMIN_ROLE, 'Administrator')
reporter_role = Role(REPORTER_ROLE, 'Reporter')
db.session.add(admin_role) # noqa pylint: disable=no-member
db.session.add(reporter_role) # noqa pylint: disable=no-member
if not app.config.get('TEST', False):
if password is None:
raise Exception("Admin password needs to be provided for "
"production database")
# Add administrator
db.session.add(
User(
'Administrator',
'Account', # noqa pylint: disable=no-member
app.config['ADMIN_EMAIL'],
generate_password_hash(password),
roles=[admin_role],
active=True))
# Add dummy data to test with
else:
scan_types = [
ScanType('Head_t1_mprage'),
ScanType('Head_t2_space_sag_p2_iso'),
ScanType('t1_mprage_sag_p3_iso_1_ADNI'),
ScanType('t2_space_sag_p2_iso'),
ScanType('Head_No MT fl3d_axial_p2_iso'),
ScanType('Shouldnt_be_shown')
]
db.session.add_all(( # noqa pylint: disable=no-member
User('Thomas',
'Close',
'*****@*****.**',
suffixes='PHD',
title='Dr.',
password=generate_password_hash('password'),
middle_name='G.',
roles=[reporter_role, admin_role],
active=True),
User('Parisa',
'Zakavi',
'*****@*****.**',
generate_password_hash('password'),
roles=[reporter_role, admin_role],
active=True)))
subjects = []
for mbi_id, dob, first_name, last_name in [
('MSH103138', '12/03/1952', 'Bob', 'Brown'),
('MSH223132', '05/12/1951', 'Sami', 'Shah'),
('MSH892342', '24/08/1980', 'Bill', 'Bryson'),
('MSH234234', '21/09/1993', 'Jesse', 'Jackson'),
('MSH623177', '15/12/1967', 'Robert', 'Redford'),
('MSH823056', '27/06/2001', 'Danny', 'DeVito'),
('MSH097334', '12/03/1972', 'Boris', 'Becker'),
('MSH097335', '12/03/1972', 'Charlie', 'Chaplin'),
('MSH097336', '12/03/1972', 'Emilio', 'Estevez')
]:
subj = Subject(mbi_id, first_name, last_name,
datetime.strptime(dob, '%d/%m/%Y')) # noqa pylint: disable=no-member
subjects.append(subj)
db.session.add(subj) # pylint: disable=no-member
img_sessions = {}
for subj_id, study_id, xnat_id, scan_date, priority, status in [
(0, 1231, 'MRH100_124_MR02', '10/04/2017', LOW, PRESENT),
(1, 1244, 'SHOULD_NOT_BE_SHOWN_NEWER_SESSION', '11/02/2018', LOW,
PRESENT),
(1, 1254, 'SHOULD_NOT_BE_SHOWN_AS_NOT_FOUND', '12/02/2018', LOW,
NOT_FOUND),
(2, 1366, 'MRH999_999_MR01', '11/10/2017', LOW, PRESENT),
(2, 1500, 'SHOULD_NOT_BE_SHOWN_PREV_REPORT', '11/5/2018',
LOW, PRESENT),
(2, 1600, 'MRH999_999_MR99', '11/1/2019', HIGH, PRESENT),
(3, 3413, 'MRH088_065_MR01', '13/01/2019', MEDIUM, PRESENT),
(4, 4500, 'MRH112_002_MR01', '11/02/2019', LOW, PRESENT),
(5, 5003, 'MRH100_025_MR01', '1/08/2017', MEDIUM, PRESENT),
(6, 9834, 'SHOULD_NOT_BE_SHOWN_AS_NOT_EXPORTED', '10/11/2018', LOW,
PRESENT),
(7, 9835, 'SHOULD_NOT_BE_SHOWN_AS_INVALID', '10/12/2018', LOW,
INVALID_LABEL),
(8, 9836, 'SHOULD_NOT_BE_SHOWN_AS_NOT_PRESENT', '10/10/2018', LOW,
NOT_FOUND)
]:
project_id = xnat_id.split('_')[0]
try:
project = Project.query.filter_by(mbi_id=project_id).one()
except orm.exc.NoResultFound:
project = Project(project_id)
img_session = img_sessions[study_id] = ImgSession(
study_id,
project,
subjects[subj_id],
xnat_id,
datetime.strptime(scan_date, '%d/%m/%Y'),
data_status=status,
priority=priority)
db.session.add(img_session) # noqa pylint: disable=no-member
for i, scan_type in enumerate(
random.sample(scan_types,
random.randint(1,
len(scan_types) - 1))):
db.session.add(
Scan(
i,
img_session,
scan_type, # noqa pylint: disable=no-member
exported=scan_type.clinical))
db.session.commit() # noqa pylint: disable=no-member
# Add report for 1366
img_session = img_sessions[1366]
db.session.add(
Report(
img_session.id,
1,
"Nothing to report",
0, # noqa pylint: disable=no-member
used_scans=img_session.scans,
modality=MRI))
# Set the final scan of the final session to be not-exported, so it
# shouldn't show up
img_sessions[9834].scans[-1].exported = False
db.session.commit() # noqa pylint: disable=no-member
# Add historial reporters for previously reported records
db.session.add_all(( # noqa pylint: disable=no-member
User('Nicholas',
'Ferris',
'*****@*****.**',
generate_password_hash(''.join(
random.choices(string.printable, k=50))),
suffixes='MBBS FRANZCR',
title='Dr.',
roles=[reporter_role],
active=False),
User('Paul',
'Beech',
'*****@*****.**',
generate_password_hash(''.join(
random.choices(string.printable, k=50))),
suffixes='MBBS FRANZCR',
title='Dr.',
roles=[reporter_role],
active=False),
User('AXIS',
'Reporting',
'*****@*****.**',
generate_password_hash(''.join(
random.choices(string.printable, k=50))),
roles=[reporter_role],
active=False)))
db.session.commit() # noqa pylint: disable=no-member
return db_path
def report_message(msg_id, report):
report = Report(msg_id=msg_id, report=report)
db.session.add(report)
db.session.commit()
return report.id
