def test_build_report(self):
"""
testing the report finds the correct amount of transactions
"""
r = Report(trans_obj='acquisition')
r.buildReport()
self.assertEqual(r.trans.count(), 3)
def importc(self):
datere = re.compile(r"([0-9\-]+) ([0-9:]+)")
reports = Report.all()
for report in reports:
report.delete()
imp = csv.reader(open("doc/import.csv", "rb"))
boat = None
for row in imp:
boatid = string.upper(row[1])
if boat == None:
boat = Boat.get_by_key_name(boatid, parent=self.dbuser)
# logging.error(row[0])
report = Report(parent=boat)
parsedate = datere.match(row[0])
date = parsedate.group(1) + " " + parsedate.group(2)
tm = time.strptime(date, "%Y-%m-%d %H:%M:%S")
report.created = datetime.datetime.utcfromtimestamp(time.mktime(tm))
report.lat = float(row[2])
report.lon = float(row[3])
payload = {"comment": row[4].replace("</b>", "")}
# logging.error(payload)
report.setPayload(payload)
report.put()
def test_build_report_transactions(self):
"""
I test that a report can be generated soley on company, division or region
"""
t1 = self.fstore(Transaction())
t1.company_id = self.comp1.id
t1.division_id = self.div1.id
t1.trans_type = u'New Lease'
t2 = self.fstore(Transaction())
t2.company_id = self.comp1.id
t2.division_id = 23
t2.trans_type = u'New Lease'
t3 = self.fstore(Transaction())
t3.company_id = self.comp1.id
t3.division_id = self.div1.id
t3.region_id = self.reg1.id
t3.trans_type = u'New Lease'
self.store.commit()
r = Report(companies=[self.comp1.id], divisions=[self.div1.id])
r.buildReport()
self.assertEqual(r.trans.count(), 2)
r = Report(companies=[self.comp1.id])
r.buildReport()
self.assertEqual(r.trans.count(), 3)
r = Report(companies=[self.comp1.id], divisions=[self.div1.id], regions=[self.reg1.id])
r.buildReport()
self.assertEqual(r.trans.count(), 1)
def generate_report(self):
report = Report()
projects = self.projects_finder.find_all()
if len(projects) == 0:
report.message = NO_PROJECTS_FOUND_MESSAGE
else:
for project in projects:
project_report = self._generate_report_for_project(project)
if self._any_outdated_requirement(project_report):
report.add_project_report(project_report)
return report
def test_avg_value_add(self):
"""
Testing the average value added of all transactions in the report
"""
self.nl1.value_add = 25
self.nl2.value_add = 50
self.store.commit()
r = Report(trans_obj='acquisition')
r.buildReport()
self.assertEqual(r.avg_value_add, Dec('37.5'))
def test_avg_base_rent(self):
"""
Determines the avg base rent across transactions
"""
self.nl1.average_base_rent = 1523.34
self.nl2.average_base_rent = 32152.56
self.store.commit()
r = Report(trans_obj='acquisition')
r.buildReport()
self.assertEqual(r.avg_base_rent, Dec('16837.95'))
def test_num_of_surveys(self):
"""
Total count of surveys from transactions
"""
self.t1.survey_id = '1'
self.t2.survey_id = '2'
self.store.commit()
r = Report(trans_obj='acquisition')
r.buildReport()
self.assertEqual(r.num_survey_responses, 2)
def POST(self):
i = web.input(comp_cbox=[], div_cbox=[], reg_cbox=[], area_cbox=[])
reports = []
report = Report(client_id=i.client_id, trans_obj=i.trans_obj)
report.buildReport()
reports.append(report)
if i.trans_obj == 'acquisition':
return jrender('/dashboard/acq_report.html', {'reports':reports})
else:
return jrender('/dashboard/disp_report.html', {'reports':reports})
def test_rfp_on_time(self):
"""
checks the percentage of rfps on time
"""
self.nl1.rfp_on_time = True
self.nl2.rfp_on_time = True
self.nl3.rfp_on_time = False
self.store.commit()
r = Report(trans_obj='acquisition')
r.buildReport()
self.assertEqual(r.rfp_ontime, Dec('66.67'))
def report():
if g.no_anonymous_reporting and g.user.is_anonymous:
return Response(
json.dumps(
[{"msg": "Not logged in or unsufficient privileges."}],
indent=4 if c3bottles.debug else None
),
mimetype="application/json",
status=401
)
number = request.values.get("number")
try:
Report(
dp=DropPoint.get(number),
state=request.values.get("state")
)
except ValueError as e:
return Response(
json.dumps(e.args, indent=4 if c3bottles.debug else None),
mimetype="application/json",
status=400
)
else:
db.session.commit()
return Response(
DropPoint.get_dp_json(number),
mimetype="application/json"
)
def report(number=None):
if number:
dp = DropPoint.get(number)
else:
dp = DropPoint.get(request.values.get("number"))
if not dp or dp.removed:
return render_template(
"error.html",
heading="Error!",
text="Drop point not found.",
)
state = request.values.get("state")
if state:
if g.no_anonymous_reporting and g.user.is_anonymous:
abort(401)
from model.report import Report
try:
Report(dp=dp, state=state)
except ValueError as e:
return render_template(
"error.html",
text="Errors occurred while processing your report:",
errors=[v for d in e.args for v in d.values()])
else:
db.session.commit()
return render_template(
"success.html",
heading="Thank you!",
text="Your report has been received successfully.")
else:
return render_template("report.html", dp=dp)
def download(self):
lines = []
id = string.upper(self.request.get("id"))
boat = Boat.get_by_key_name(id, parent=self.dbuser)
lines.append('<?xml version="1.0" encoding="utf-8" ?>')
lines.append(
'<gpx version="1.1" creator="sailtrack" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.topografix.com/GPX/1/1" xsi:schemaLocation="http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd">'
)
if boat != None:
reports = Report.all()
reports.ancestor(boat)
reports.order("created")
for report in reports:
comment = ""
if report.payload != None and report.payload != "":
comment = report.getPayload()["comment"]
lines.append(' <wpt lat="%f" lon="%f">' % (report.lat, report.lon))
lines.append(" <time>%s</time>" % (report.created.strftime("%Y-%m-%dT%H:%M:%SZ")))
lines.append(" <name>%s</name>" % (escape(comment)))
lines.append(" <sym>circle</sym>")
lines.append(" <type>WPT</type>")
lines.append(" </wpt>")
self.setContentType("text/plain")
lines.append("</gpx>")
return "\n".join(lines)
def test_survey_ratio(self):
"""
ratio of transactions with surveys
"""
self.t1.survey_sent = '2011-05-01'
self.t1.survey_id = 1
self.t2.survey_sent = '2011-05-01'
self.store.commit()
r = Report(trans_obj='acquisition')
r.buildReport()
self.assertEqual(r.survey_resp_ratio, Dec('50.0'))
def test_avg_time_on_market(self):
"""
This smells like a duplicate to me
"""
self.t1.engage_date = '2011-05-01'
self.nl1.lease_execution_date = '2011-05-02'
self.t2.engage_date = '2011-05-01'
self.nl2.lease_execution_date = '2011-05-03'
self.store.commit()
r = Report(trans_obj='acquisition')
r.buildReport()
self.assertEqual(r.avg_time_on_market, Dec('1.5'))
def test_total_recovery(self):
"""
Tracks the total dollars recovered from dispositions
"""
self.build_disp()
self.sl1.actual_recovery = 1000.67
self.sl2.actual_recovery = 4000.14
self.s1.sale_price = 20000.00
self.store.commit()
r = Report(trans_obj='disposition')
r.buildReport()
self.assertEqual(r.total_recovery, Dec('25000.81'))
def persist(self,reportd,mail_message):
boats = Boat.all()
boats.filter("passcode = ", reportd['passcode'])
boats.filter("active =", True)
emaillog=EmailLog()
emaillog.rawemail=db.Text(mail_message.original.as_string())
#TODO: I don't like this way of figuring out if we got any rows
count=0
for boat in boats:
if (boat.key().name()==string.upper(reportd['boat'])):
count=count+1
break # Return the first one
else:
boat=None
if (count <1 or boats == None or boat == None):
logging.error("Unable to persist report could not find boat "+string.upper(reportd['boat'])+":"+reportd['passcode'])
else:
report=Report(parent=boat)
report.lat=reportd['lat']
report.lon=reportd['lon']
payload={
'comment' : reportd['comment']
}
report.setPayload(payload)
report.put()
emaillog.report_ref=report
reportd['time']=strftime("%Y/%m/%d %H:%M", gmtime())
self.outbound(boat,reportd)
emaillog.put()
def get_meeting_report():
cc = CalendarConnection()
meetings = cc.meetings
# _print_calendar_results_as_json(meetings)
rep = Report(meetings)
data = rep.printable_data
rep.write_report_html(data)
# ihm_slack.post_report_to_slack(*data)
#
meetings_list = rep.meetings_list
ihm_db._add_row_to_db(meetings_list)
ihm_db.write_db_to_csv()
ihm_db.write_csv_to_json()
generate_charts(data)
open_charts_in_browser()
def test_meet_bov_recovery(self):
"""
Test percentage of bov recovery that meet or exceeded expectations
"""
self.build_disp()
self.sl1.actual_recovery = 1000
self.sl2.actual_recovery = 500
self.sl1.expected_recovery = 700
self.sl2.expected_recovery = 600
self.store.commit()
r = Report(trans_obj='disposition')
r.buildReport()
self.assertEqual(r.meet_bov_recovery, Dec('50.0'))
def test_market_survey_ontime(self):
"""
Test that the market survey on time percentage is correct
"""
self.t1.engage_date = '2011-05-01'
self.t2.engage_date = '2011-05-01'
self.nl1.market_survey = True
self.nl1.market_survey_date = '2011-05-03'
self.nl2.market_survey = True
self.nl2.market_survey_date = '2011-06-15'
self.store.commit()
r = Report(trans_obj='acquisition')
r.buildReport()
self.assertEqual(r.market_survey_ontime, Dec('50.0'))
def test_bov_on_time(self):
"""
Number of BOVs compared to BOVs ontime
"""
self.build_disp()
self.sl1.bov_ontime = True
self.sl2.bov_ontime = False
self.sl3.bov_ontime = True
self.sl1.bov_date = '2011-05-11'
self.sl2.bov_date = '2011-05-11'
self.sl3.bov_date = '2011-05-11'
self.store.commit()
r = Report(trans_obj='disposition')
r.buildReport()
self.assertEqual(r.bov_on_time, Dec('66.67'))
def test_avg_deal_close(self):
"""
Tracks the days bewteen engagement date and deal closing
"""
self.t1.engage_date = '2011-05-01'
self.nl1.lease_execution_date = '2011-05-02'
self.t2.engage_date = '2011-05-01'
self.nl2.lease_execution_date = '2011-05-03'
self.store.commit()
r = Report(trans_obj='acquisition')
r.buildReport()
self.assertEqual(r.avg_days_deal_close, Dec('1.5'))
#missing data from one transaction, result should not be affectd.
self.t3.engage_date = '2011-05-01'
self.store.commit()
r = Report(trans_obj='acquisition')
r.buildReport()
self.assertEqual(r.avg_days_deal_close, Dec('1.5'))
def test_meet_bov_timing(self):
"""
Test percentage of bov timing that meet or exceeded expectations
"""
self.build_disp()
self.sl1.bov_expected_timing = 10
self.sl1.bov_actual_timing = 9
self.sl2.bov_expected_timing = 10
self.sl2.bov_actual_timing = 10
self.sl3.bov_expected_timing = 10
self.sl3.bov_actual_timing = 11
self.store.commit()
r = Report(trans_obj='disposition')
r.buildReport()
self.assertEqual(r.meet_bov_timing, Dec('66.67'))
self.sl3.bov_actual_timing = 10
self.store.commit()
r = Report(trans_obj='disposition')
r.buildReport()
self.assertEqual(r.meet_bov_timing, Dec('100.0'))
def get(self, report_id=None):
report = None
if report_id:
report = Report.report_get(report_id)
if not report:
report = {
'title' : '',
'summary' : '',
'url': '',
'img' : 0,
}
self.render(report=report)
def test_construction_exceptions(self):
states = Report.states
dp = DropPoint(1, lat=0, lng=0, level=1)
with self.assertRaisesRegexp(ValueError, "drop point"):
Report(None)
with self.assertRaisesRegexp(ValueError, "state"):
Report(dp)
time_in_future = datetime.today() + timedelta(hours=1)
with self.assertRaisesRegexp(ValueError, "future"):
Report(dp, time=time_in_future, state=states[0])
with self.assertRaisesRegexp(ValueError, "not a datetime"):
Report(dp, time="foo", state=states[0])
with self.assertRaisesRegexp(ValueError, "state"):
Report(dp, state="whatever")
def test_sqft_reduction(self):
"""
testing the net difference btween old sqft and new sqft
"""
self.nl1.old_sqft = 100
self.nl1.new_sqft = 75
self.nl2.old_sqft = 400
self.nl2.new_sqft = 200
self.store.commit()
r = Report(trans_obj='acquisition')
r.buildReport()
self.assertEqual(r.sqft_reduction, 225)
#missing data from one transaction, result should not be affected.
self.nl3.old_sqft = 400
self.store.commit()
self.assertEqual(r.sqft_reduction, 225)
def map(self):
track=[]
marker=None
boatid=string.upper(self.request.get('boat'))
showmarkers=string.upper(self.request.get('markers'))
showinfo=string.upper(self.request.get('popup'))
zoom=self.request.get('zoom')
#TODO: Validate input
if (zoom==''):
zoom=6
if (showmarkers==''):
showmarkers='true'
if (showinfo==''):
showinfo='false'
boats=Boat.all()
# TODO: Is there a better way to filter this? We can't use key_name because we don't know ancestor
for boat in boats:
logging.error(boat.key().name() + " vs " + boatid)
if (boat.key().name()!=boatid):
boat=None;
else:
break
if (boats != None and boat!=None):
reports=Report.all()
reports.ancestor(boat)
reports.order("created")
for report in reports:
#logging.error(report.payload)
entry={}
entry['date']=report.created.strftime("%Y-%m-%d %H:%M:%S")
entry['lat']='%.2f' % (report.lat)
entry['lon']='%.2f' % (report.lon)
entry['boat']=boat.key().name()
comment=''
if (report.payload!=None and report.payload!=''):
comment=report.getPayload()['comment']
entry['comment']=comment
track.append(entry)
marker=entry # This is the last one
values={}
values['marker']=marker
values['track']=track
values['zoom']=zoom
values['showmarkers']=string.lower(showmarkers)
values['showinfo']=string.lower(showinfo)
return self.render('map',values)
def get_report(self):
cnds = self.navb.conditions()
report = {}
try:
rcd = Report.get_report(self.navb.kw.get('tbl'),
self.navb.kw.get('id'))
#print "DB REDORD: ", rcd
if rcd:
try:
report = parse_report_cols(rcd)
#print "REPORT: ", report
except Exception, e:
#print e
pass
except Exception, e:
#print "ERROR READING REPORT: ", e
pass
def test_build_report_acq_expressions(self):
"""
I test that we can build some basic expressions on the acq obj
"""
t1 = self.fstore(Transaction())
nl1 = self.fstore(NewLease())
self.store.commit()
t1.company_id = self.comp1.id
t1.trans_type = 'New Lease'
t1.trans_manager = 3
nl1.old_sqft = 100
nl1.trans_id = t1.id
t2 = self.fstore(Transaction())
nl2 = self.fstore(NewLease())
self.store.commit()
t2.company_id = self.comp1.id
t2.trans_type = 'New Lease'
t2.trans_manager = 1
nl2.old_sqft = 200
nl2.trans_id = t2.id
t3 = self.fstore(Transaction())
le1 = self.fstore(LeaseExtension())
self.store.commit()
t3.company_id = self.comp1.id
t3.trans_type = 'Lease Extension'
t3.trans_manager = 1
le1.market_survey_date = '05-15-2011'
le1.old_sqft = 100
le1.trans_id = t3.id
self.store.commit()
# ONE FILTER == CONSTRAINT
filters = {
'objects':['New Lease'],
'fields':['nl2'],
'constraints':['=='],
'args':['100'],
'operators':['none']}
r = Report(companies=[self.comp1.id], filters=filters, trans_obj='acquisition')
r.buildReport()
self.assertEqual(r.trans.count(), 1)
# TWO FILTERS
filters = {
'objects':['New Lease', 'New Lease'],
'fields':['nl2', 'nl2'],
'constraints':['>', '>'],
'args':['500', '101'],
'operators':['none','or']}
r = Report(companies=[self.comp1.id], filters=filters, trans_obj='acquisition')
r.buildReport()
self.assertEqual(r.trans.count(), 1)
# FOUR FILTERS TWO OBJECTS
filters = {
'objects':['Transaction', 'Transaction', 'New Lease', 'New Lease'],
'fields':['ttpe', 'tman', 'nl6', 'nl2'],
'constraints':['==', '==', '==', '<'],
'args':['New Lease', '1', '05-15-2011', '300'],
'operators':['none','and', 'and', 'and']}
nl2.market_survey_date = '05-15-2011'
self.store.commit()
r = Report(companies=[self.comp1.id], filters=filters, trans_obj='acquisition')
r.buildReport()
self.assertEqual(r.trans.count(), 1)
# FOUR FILTERS TWO OBJECTS
filters = {
'objects':[
'Transaction', 'Transaction', 'Transaction',
'New Lease', 'Lease Extension', 'New Lease',
'Lease Extension'],
'fields':['ttpe', 'ttpe', 'tman', 'nl6', 'le6', 'nl2', 'le2'],
'constraints':['==', '==', '==', '==', '==', '<', '<'],
'args':['New Lease', 'Lease Extension', '1', '05-15-2011', '05-15-2011', '300', '300'],
'operators':['none','or', 'and', 'and', 'or', 'and', 'or']}
r = Report(companies=[self.comp1.id], filters=filters, trans_obj='acquisition')
r.buildReport()
self.assertEqual(r.trans.count(), 2)
def test_reporting(self):
states = Report.states
dp = DropPoint(1, lat=0, lng=0, level=1)
first_time = datetime.today()
first_state = states[0]
first_report = Report(dp, state=first_state, time=first_time)
db.session.commit()
self.assertEqual(first_report.time, first_time,
"Report creation time not as expected.")
self.assertEqual(first_report.state, first_state,
"Report state not as expected.")
self.assertEqual(
dp.reports[0], first_report,
"First report not first report of associated drop point.")
self.assertEqual(dp.get_last_report(), first_report,
"get_last_report() did not return first report.")
self.assertEqual(dp.get_last_state(), first_state,
"get_last_state() did not return state.")
self.assertEqual(dp.get_total_report_count(), 1,
"get_total_report_count() not as expected.")
self.assertEqual(dp.get_new_report_count(), 1,
"get_new_report_count() not as expected.")
self.assertEqual(
dp.get_new_reports()[0], first_report,
"First element returned by get_new_reports() not the report wanted."
)
second_time = datetime.today()
second_state = states[-1]
second_report = Report(dp, state=second_state, time=second_time)
db.session.commit()
self.assertEqual(second_report.state, second_state,
"Report state not as expected.")
self.assertEqual(
dp.reports[-1], second_report,
"Second report not last report of associated drop point.")
self.assertEqual(dp.get_last_report(), second_report,
"get_last_report() did not return second report.")
self.assertEqual(dp.get_last_state(), second_state,
"get_last_state() did not return second state.")
self.assertEqual(dp.get_total_report_count(), 2,
"get_total_report_count() not as expected.")
self.assertEqual(dp.get_new_report_count(), 2,
"get_new_report_count() not as expected.")
self.assertEqual(
dp.get_new_reports()[0], second_report,
"First element returned by get_new_reports() not the report wanted."
)
def test_construction(self):
actions = Visit.actions
dp = DropPoint(1, lat=0, lng=0, level=1)
first_time = datetime.today()
first_action = actions[1]
first_visit = Visit(dp, action=first_action, time=first_time)
db.session.commit()
self.assertEqual(
first_visit.time, first_time,
"Visit creation time not as expected."
)
self.assertEqual(
first_visit.action, first_action,
"Visit action not as expected."
)
self.assertEqual(
dp.visits[0], first_visit,
"First visit not first visit of associated drop point."
)
self.assertEqual(
dp.get_last_visit(), first_visit,
"get_last_visit() did not return first visit."
)
report_time = datetime.today()
report_state = Report.states[0]
report = Report(dp, state=report_state, time=report_time)
second_time = datetime.today()
second_action = actions[0]
second_visit = Visit(dp, action=second_action, time=second_time)
db.session.commit()
self.assertEqual(
second_visit.action, second_action,
"Visit action not as expected."
)
self.assertEqual(
dp.visits[-1], second_visit,
"Second visit not last visit of associated drop point."
)
self.assertEqual(
dp.get_last_visit(), second_visit,
"get_last_visit() did not return second visit."
)
self.assertNotEqual(
dp.get_last_state(), report_state,
"get_last_state() returns unchanged state after visit."
)
self.assertEqual(
dp.get_new_report_count(), 0,
"get_new_report_count() nonzero after visit."
)
self.assertFalse(
dp.get_new_reports(),
"get_new_reports() returned something not False after visit."
)
self.assertEqual(
dp.get_last_report(), report,
"get_last_report() did not return report after visit."
)
self.assertEqual(
dp.get_total_report_count(), 1,
"get_total_report_count() not as expected after visit."
)
def report(self, state=None, time=None):
Report(self, time=time, state=state)
def POST(self):
i = web.input(comp_cbox=[], div_cbox=[], reg_cbox=[], area_cbox=[])
reports = []
# COMBINED REPORT
if i.display == 'Combined':
report = Report(client_id=i.client_id, companies=i.comp_cbox, divisions=i.div_cbox, regions=i.reg_cbox, areas=i.area_cbox, trans_obj=i.trans_obj, fiscal=i.fiscal)
report.buildReport()
reports.append(report)
# SEPERATE REPORT
else:
for cid in i.comp_cbox:
report = Report(client_id=i.client_id, companies=[cid], trans_obj=i.trans_obj, fiscal=i.fiscal)
report.buildReport()
reports.append(report)
for did in i.div_cbox:
report = Report(client_id=i.client_id, divisions=[did], trans_obj=i.trans_obj, fiscal=i.fiscal)
report.buildReport()
reports.append(report)
for rid in i.reg_cbox:
report = Report(client_id=i.client_id, regions=[rid], trans_obj=i.trans_obj, fiscal=i.fiscal)
report.buildReport()
reports.append(report)
for aid in i.area_cbox:
report = Report(client_id=i.client_id, areas=[aid], trans_obj=i.trans_obj, fiscal=i.fiscal)
report.buildReport()
reports.append(report)
if i.trans_obj == 'acquisition':
if i.export == 'PDF':
html = jrender('/dashboard/acq_report_pdf.html', {'reports':reports})
tmp = tempfile.TemporaryFile('w+b', prefix='tmp', suffix='.pdf')
pdf = pisa.CreatePDF(str(html), tmp, '/var/www/webapps/static/')
tmp.seek(0, 2)
filesize = tmp.tell()
tmp.seek(0)
if pdf.err:
print 'PDF ERROR'
if pdf.warn:
print 'WARNING'
web.header('Content-Length', filesize)
web.header('Content-Type', 'application/pdf')
web.header('Content-Disposition', 'attachment; filename=%s' % 'Report.pdf')
return tmp.read()
if i.export == 'XLS':
sheets = []
for r in reports:
sheets.append(r.buildExcelData())
xls = make_excel(sheets)
xls.seek(0, 2)
filesize = xls.tell()
xls.seek(0)
web.header('Content-Length', filesize)
web.header('Content-Type', 'application/excel')
web.header('Content-Disposition', 'attachment; filename=%s' % 'Report.xls')
return xls.read()
return jrender('/dashboard/acq_report.html', {'reports':reports})
else:
return jrender('/dashboard/disp_report.html', {'reports':reports})
def read():
data = DataAccess.fetch_all('select * from report', [])
return jsonify([Report(*a) for a in data])
def test_build_report_transactions_expressions(self):
"""
I test that we can build some basic expressions on the transaction obj
"""
t1 = self.fstore(Transaction())
t1.company_id = self.comp1.id
t1.trans_type = 'New Lease'
t1.trans_manager = 3
t2 = self.fstore(Transaction())
t2.company_id = self.comp1.id
t2.trans_type = 'New Lease'
t2.trans_manager = 1
t3 = self.fstore(Transaction())
t3.company_id = self.comp1.id
self.store.commit()
# ONE FILTER == CONSTRAINT
filters = {
'objects':['Transaction'],
'fields':['ttpe'],
'constraints':['=='],
'args':['New Lease'],
'operators':['none']}
r = Report(companies=[self.comp1.id], filters=filters)
r.buildReport()
self.assertEqual(r.trans.count(), 2)
# TWO FILTERS
filters = {
'objects':['Transaction', 'Transaction'],
'fields':['ttpe', 'tman'],
'constraints':['==', '=='],
'args':['New Lease', '1'],
'operators':['none','and']}
r = Report(companies=[self.comp1.id], filters=filters)
r.buildReport()
self.assertEqual(r.trans.count(), 1)
# THREE FILTERS NO RESULTS
filters = {
'objects':['Transaction', 'Transaction', 'Transaction'],
'fields':['ttpe', 'tman', 'eda'],
'constraints':['==', '==', '=='],
'args':['New Lease', '1', '05-15-2011'],
'operators':['none','and', 'and']}
r = Report(companies=[self.comp1.id], filters=filters)
r.buildReport()
self.assertEqual(r.trans.count(), 0)
# THREE FILTERS
filters = {
'objects':['Transaction', 'Transaction', 'Transaction'],
'fields':['ttpe', 'tman', 'eda'],
'constraints':['==', '==', '=='],
'args':['New Lease', '1', '05-15-2011'],
'operators':['none','and', 'and']}
t2.engage_date = '05-15-2011'
self.store.commit()
r = Report(companies=[self.comp1.id], filters=filters)
r.buildReport()
self.assertEqual(r.trans.count(), 1)
# SINGLE FILTER < CONSTRAINT
filters = {
'objects':['Transaction'],
'fields':['eda'],
'constraints':['<'],
'args':['05-20-2011'],
'operators':['none']}
r = Report(companies=[self.comp1.id], filters=filters)
r.buildReport()
self.assertEqual(r.trans.count(), 1)
self.assertEqual(r.trans.one().trans_manager, 1)
def get(self):
report_list = Report.reports()
self.render(report_list=report_list)
def get(self):
li = Report.reports()
self.render(li=li)
def post(self):
o = self.json
o.__dict__.update(is_del=DEL_FLAG.TRUE)
Report.report_upsert(o)
self.finish()
def post(self):
o = self.json
Report.report_upsert(o)
self.finish(o.__dict__)
