def run(self):
s = ExpectSolver.storage
_condition = self._enabled_condition or ""
if _condition.strip() != "" and not eval(self._enabled_condition):
return
if not self._enabled:
return
# TODO : this only supports json add more
# send request
root_report: Report
try:
_response = request(
self._request_model.method,
self._url_override or self._request_model.url,
headers=self._headers,
json=self._body,
)
root_report = Report(True, '', name=self._name, tag='main')
except Exception as e:
self._reports.append(
Report(False,
str(e),
name='sending request ' + self._name,
tag='main'))
# create N/A reports for expressions
for expr in self._expressions:
self._reports.append(
Report(None,
'expression ignored',
name=expr.name,
tag='sub'))
return
# check expects
for expr in self._expressions:
expr.request_response = _response
expr.solve()
self._reports.append(
Report(expr.ok,
'pass' if expr.ok else expr.error,
name=expr.name,
tag='sub'))
for save in self._save:
save.request_response = _response
save.solve()
for report in self._reports:
if not report.status:
root_report.status = False
self._reports = [root_report] + self._reports
def report_get_terminal_report():
arg = get_post_arg(request, True)
arg['firm_id'] = g.firm_info['id']
if not 'report_type' in arg:
abort(405)
if arg['report_type'] == 'term':
arg['payment_type'] = Report.TYPE_WHITE
answer = Report().get_term_report(**arg)
else:
answer = Report().get_person_report(**arg)
return jsonify(answer)
def test_print(self):
""" Test both cases when output is empty and when it is not """
# output = []
r1 = Report([])
r1.print()
out, err = self.capfd.readouterr()
assert "No result." in out
# output = [d1]
d1 = Driver('a', 0, 0)
r2 = Report([d1])
r2.print()
out, err = self.capfd.readouterr()
assert "No result." not in out
def test_constructor(self):
""" Test whether constructor sets correctly """
d1 = Driver('a', 0, 0)
d2 = Driver('b', 0, 0)
r = Report([d1, d2])
self.assertListEqual(r.output, [d1, d2])
def test_func_add_history(self):
history = PaymentHistory()
data_wallet = dict(
id=1,
payment_id=self.PAYMENT_ID,
hard_id=self.HARD_ID,
name=self.TEST_STRING,
user_id=self.USER_ID,
discodes_id=self.DISCODES_ID,
card_pan=self.CARD_PAN
)
wallet = PaymentWallet()
wallet.__dict__.update(data_wallet)
data_report = dict(
term_id=self.TERM_ID,
event_id=self.EVENT_ID,
person_id=self.PERSON_ID,
payment_id=self.FIRM_ID,
firm_id=self.FIRM_ID,
creation_date=date_helper.get_current_date(),
)
report = Report()
report.__dict__.update(data_report)
assert history.add_history(wallet, report)
history.delete()
def report_get_money_report():
arg = get_post_arg(request, True)
arg['payment_type'] = Report.TYPE_PAYMENT
arg['firm_id'] = g.firm_info['id']
answer = Report().get_term_report(**arg)
return jsonify(answer)
def get_reports():
cursor.execute(
"SELECT *, (SELECT COUNT(*) FROM report_confirm WHERE report_confirm.report_id = report.id) AS confirm FROM report"
)
t_reports = list()
for t_report in cursor.fetchall():
t_reports.append(
Report(t_report[0], t_report[1], t_report[2], t_report[3],
t_report[4], t_report[5])) #Parsing of tuple to object
return json.dumps([ob.__dict__ for ob in t_reports])
def report_post(is_comment, reported_id):
create_report = False
if not check.logged_in():
return redirect("/")
else:
form = ReportForm(request.form)
if form.validate_on_submit():
try:
#If reported object is a post
if is_comment == 0:
reported_post = Post(reported_id)
if len(
Report.get_user_prev_report(
session.get("user_id", ""), reported_id)) > 0:
return redirect("/post/" + str(reported_id))
else:
reported_comment = Comment(reported_id)
if len(
Report.get_user_prev_report(
session.get("user_id", ""), reported_id)) > 0:
return redirect("/post/" +
str(reported_comment.post_id))
report = Report()
report.submitting_user_id = session.get("user_id", "")
report.violated_rule = form.data["violated_rule"]
report.date = datetime.utcnow()
report.reason_description = form.data["reason_description"]
report.is_comment = is_comment
report.action_taken = None
report.is_dismissed = False
report.post_id = reported_id if is_comment == 0 else None
report.comment_id = reported_id if is_comment == 1 else None
report.save()
flash({
'text': "You have created a report.",
'type': "success"
})
return redirect("/")
except NotImplementedError as error:
return render_template("error.html",
error_type="Failed",
error_info=str(error))
else:
if request.method == "POST":
return render_template(
'report.html',
form=form,
error="Invalid field, please check again.")
else:
return render_template('report.html', form=form)
def delete_report(submitter_id, id):
if not check.logged_in():
flash({'text': "Please sign in.", 'type': "error"})
return redirect("/")
else:
if submitter_id == session.get("user_id", ""):
report = Report(id)
report.delete()
flash({'text': "You have deleted a report.", 'type': "success"})
return redirect("/user/profile/" + str(submitter_id))
else:
flash({
'text': "You can not delete another user's report.",
'type': "error"
})
return redirect("/")
def send_report():
state_id = request.form.get('state_id')
check_state = storage.get('State', state_id)
if check_state is None:
return jsonify({'error': 'Department selected does not exist'})
number_infections = request.form.get('number_infections')
try:
number_infections = w2n.word_to_num(number_infections)
if number_infections < 0 or type(number_infections) is not int:
raise ValueError('Invalid number')
except:
return jsonify({'error': 'The number you typed is invalid'})
new_report = Report(state_id=state_id, infections=number_infections)
new_report.save()
storage.close()
return jsonify({'success': 'Your data was registered correctly'})
def review_reports(id):
#Admins can review reports and decide the result of it.
if check.admin_logged_in():
form = ReviewForm(request.form)
if form.validate_on_submit():
report = Report(id)
action = form.data["action_taken"]
is_dismissed = form.data["is_dismissed"]
report.update_for_review(action,is_dismissed)
return redirect("../")
else:
if request.method == "POST":
return render_template('admin_review.html', form=form, error = "Invalid, field, please check again.")
else:
return render_template('admin_review.html', form=form)
else:
flash({'text': "You have to sign in to your admin account first.", 'type': "error"})
return redirect("/user/login")
def __init__(self, parent=None):
"""
Initialize MainWindow class
"""
super(MainWindow, self).__init__(parent)
self.setupUi(self)
thread = QThread()
thread.currentThread().setObjectName(__appname__)
configfn.check_config_folder() # Check appdata folder in users home
self.textWorkdate.setText(datetime.date.today().isoformat()
) # initialize workdate to current date
self._archivedOrderlines = OrderLine() # Initialize Detail object
self._archivedVisits = Visit() # Initialize Visit object
self._contacts = Contact() # Initialize Contact object
self._customers = Customer() # Initialize Customer object
self._employees = Employee() # Initialize Employee object
self._orderLines = OrderLine()
self._products = Product() # Initialize Product object
self._reports = Report() # Initialize Report object
self._settings = Settings() # Initialize Settings object
self._visits = Visit()
self.buttonArchiveContacts.clicked.connect(self.archive_contacts)
self.buttonArchiveCustomer.clicked.connect(self.archive_customer)
self.buttonArchiveVisit.clicked.connect(self.archive_visit)
self.buttonCreateContact.clicked.connect(self.create_contact)
self.buttonCreateCustomer.clicked.connect(self.create_customer)
self.buttonCreateReport.clicked.connect(self.create_report)
self.buttonCreateVisit.clicked.connect(self.load_visit)
self.buttonGetCustomers.clicked.connect(self.get_customers)
self.buttonGetPricelist.clicked.connect(self.get_pricelist)
self.toolButtonArchiveSettings.clicked.connect(self.archive_settings)
self.toolButtonCustomer.clicked.connect(self.show_page_customer)
self.toolButtonCustomers.clicked.connect(self.show_page_customers)
self.toolButtonCustomerVisits.clicked.connect(
self.show_page_customer_visits)
self.toolButtonExit.clicked.connect(self.app_exit)
self.toolButtonInfo.clicked.connect(self.show_page_info)
self.toolButtonPricelist.clicked.connect(self.show_page_pricelist)
self.toolButtonReport.clicked.connect(self.show_page_report)
self.toolButtonReports.clicked.connect(self.show_page_reports)
self.toolButtonSettings.clicked.connect(self.show_page_settings)
self.toolButtonCustomerVisit.clicked.connect(self.show_page_visit)
self.toolButtonDeleteSalesData.clicked.connect(self.zero_database)
self.toolButtonExportDatabase.clicked.connect(self.data_export)
self.toolButtonImportCsvData.clicked.connect(
self.show_csv_import_dialog)
self.toolButtonImportDatabase.clicked.connect(self.data_import)
self.widgetCustomers.currentItemChanged.connect(
self.on_customer_changed)
self.widgetCustomers.itemDoubleClicked.connect(
self.on_customer_double_clicked)
self.widgetArchivedVisits.currentItemChanged.connect(
self.on_visit_changed)
self.widgetArchivedVisits.setColumnHidden(0, True)
self.widgetArchivedOrderLines.setColumnWidth(0, 30)
self.widgetArchivedOrderLines.setColumnWidth(1, 30)
self.widgetArchivedOrderLines.setColumnWidth(2, 100)
self.widgetArchivedOrderLines.setColumnWidth(3, 150)
self.widgetArchivedOrderLines.setColumnWidth(4, 60)
self.widgetArchivedOrderLines.setColumnWidth(5, 40)
self.widgetCustomers.setColumnHidden(0, True) # ID
self.widgetCustomers.setColumnWidth(1, 100)
self.widgetCustomers.setColumnWidth(2, 100)
self.widgetCustomers.setColumnWidth(3, 100)
self.widgetCustomers.setColumnWidth(4, 250)
self.widgetCustomers.setColumnWidth(5, 60)
self.widgetPricelist.setColumnWidth(0, 70)
self.widgetPricelist.setColumnWidth(1, 100)
self.widgetPricelist.setColumnWidth(2, 150)
self.widgetPricelist.setColumnWidth(3, 50)
self.widgetPricelist.setColumnWidth(4, 50)
self.widgetPricelist.setColumnWidth(5, 50)
self.widgetPricelist.setColumnWidth(6, 50)
self.widgetPricelist.setColumnWidth(7, 50)
self.widgetPricelist.setColumnWidth(8, 50)
self.widgetPricelist.setColumnWidth(9, 50)
self.widgetPricelist.setColumnWidth(10, 50)
self.widgetPricelist.setColumnWidth(11, 50)
self.widgetPricelist.setColumnWidth(12, 50)
self.widgetReports.setColumnHidden(0, True) # ID
self.widgetReports.setColumnWidth(1, 80) # rep_date
self.widgetReports.setColumnWidth(2, 60) # visits
self.widgetReports.setColumnWidth(3, 60) # sale day
self.widgetReports.setColumnWidth(4, 60) # demo day
self.widgetReports.setColumnWidth(5, 100) # turnover day
self.widgetReports.setColumnWidth(6, 50) # km
# self.widgetReports column 7 # supervisor
self.widgetReportVisits.setColumnWidth(0, 150)
self.widgetReportVisits.setColumnWidth(1, 100)
self.widgetReportVisits.setColumnWidth(2, 100)
self.widgetReportVisits.setColumnWidth(3, 60)
self.populate_customer_list()
self.populate_price_list()
try:
cid = self._settings.settings["cust_idx"]
if self._customers.lookup_by_id(cid):
try:
self.widgetCustomers.setCurrentIndex(
self.widgetCustomers.indexFromItem(
self.widgetCustomers.findItems(str(
self._customers.customer["customer_id"]),
Qt.MatchExactly,
column=0)[0]))
self.toolButtonCustomer.click()
except KeyError:
pass
except KeyError:
return
self._reports.load(workdate=self.textWorkdate.text())
self.populate_report_list()
self.populate_report_visit_list()
self.toolButtonReport.click()
def print(self):
""" Output result. """
r = Report(self.output)
r.print()
def generate_report(self):
print("\n")
Print.success("Generating Report")
report = Report(self, self.exp_reports)
report.generate()
def generate_report(params, data):
log = logging.getLogger('task')
error = False
term = Term.query.filter_by(hard_id=params['term_id']).first()
if not term:
log.error('Not found term %s' % params['term_id'])
return False
event = Event.get_by_key(data['event_key'])
if not event:
log.error('Not found event %s' % data['event_key'])
return False
firm_terms = FirmTerm.query.filter_by(term_id=term.id).all()
payments = data['payments']
report_max_date = ''
for payment in payments:
report = Report()
report.term_id = term.id
report.event_id = event.id
report.type = payment['type']
report.payment_id = None
report.amount = payment['amount'] * int(term.factor)
real_person = None
for row in firm_terms:
report.term_firm_id = row.firm_id
query = Person.query
query = query.filter((Person.payment_id == payment['card']) | (
Person.hard_id == int(payment['card'])))
person = query.filter(
Person.firm_id == row.child_firm_id).first()
if not person:
continue
real_person = person
if real_person:
report.name = real_person.name
report.person_id = real_person.id
report.person_firm_id = real_person.firm_id
report.payment_id = real_person.payment_id
else:
report.payment_id = payment['card']
date_pattern = '%Y-%m-%d %H:%M:%S'
date_time_utc = date_helper.convert_date_to_utc(
payment['date_time'], term.tz, date_pattern, date_pattern)
report.creation_date = date_time_utc
if report.creation_date > report_max_date:
report_max_date = report.creation_date
error = report.add_new()
if not error:
ReportSenderTask.lost_report_watcher.delay(term.id,
report_max_date)
return error
def setUp(self):
self.output_folder = os.path.join(os.path.dirname(__file__),
"support_files")
self.output_file = os.path.join(self.output_folder, "test_report.pdf")
self.report = Report(self.output_file)
#!/usr/bin/python3 """ Populates the database with necessary data """ from flask import Flask, render_template, jsonify from models.report import Report from models.news import News from models.state import State import models from models import storage first_state = storage.session.query(State).filter_by(name="Antioquia").first() new_report = Report(infections=12, state_id=first_state.id) print(new_report.to_dict()) print(first_state.to_dict()) storage.new(new_report) storage.save() print(first_state.reports)
def Report(self):
return Report(self)
def test_reports():
with open("./test_data/report_single.json", "r") as j:
data = json.load(j)
report = Report(**data)
return (report.output)
