def _payment_record_to_row(payment_record):
from corehq.apps.accounting.views import ManageBillingAccountView
applicable_credit_line = CreditAdjustment.objects.filter(
payment_record_id=payment_record.id).latest(
'last_modified').credit_line
account = applicable_credit_line.account
return [
format_datatables_data(
text=payment_record.date_created.strftime(
SERVER_DATE_FORMAT),
sort_key=payment_record.date_created.isoformat(),
),
format_datatables_data(
text=mark_safe(
make_anchor_tag(
reverse(ManageBillingAccountView.urlname,
args=[account.id]), account.name)),
sort_key=account.name,
),
_get_domain_from_payment_record(payment_record),
payment_record.payment_method.web_user,
format_datatables_data(
text=mark_safe(
'<a href="https://dashboard.stripe.com/payments/%s"'
' target="_blank">%s'
'</a>' % (
payment_record.transaction_id,
payment_record.transaction_id,
)),
sort_key=payment_record.transaction_id,
),
quantize_accounting_decimal(payment_record.amount),
]
def rows(self):
def percent(v1, v2):
try:
return float(v1) * 100.0 / float(v2)
except ZeroDivisionError:
return 0
def get_grade(v):
return 'D' if v < 25 else 'C' if v < 50 else 'B' if v < 75 else 'A'
rows = [[column.header] for column in self.model.columns[2:]]
for block in self.get_blocks_for_district():
self.request_params['hierarchy_block'] = block
q = self.request.GET.copy()
q['hierarchy_block'] = block
self.request.GET = q
rs, block_total = BlockLevelAFReport(self.request,
domain=self.domain).rows
for index, row in enumerate(rs[0:-2]):
value = percent(row[-1]['sort_key'], block_total)
grade = get_grade(value)
if index < 10:
rows[index].append(
format_datatables_data('%.1f%%' % value,
'%.1f%%' % value))
rows[index].append(format_datatables_data(grade, grade))
else:
rows[index].append(row[-1])
val = row[-1]['sort_key']
grade = get_grade(val)
rows[index].append(format_datatables_data(grade, grade))
return rows, 0
def rows(self):
rows = [[column.header] for column in self.model.columns[2:]]
rows.append(["<b>Total number of ASHAs who did not report/not known</b>"])
last_row = ["<b>Total Number of ASHAs under each Facilitator</b>"]
sums = [0] * len(rows)
total = 0
for af in self.get_afs_for_block():
self.request_params['hierarchy_af'] = af[1]
q = self.request.GET.copy()
q['hierarchy_af'] = af[1]
self.request.GET = q
rs, afs_count = BlockLevelMonthReport(self.request, domain=self.domain).rows
total += afs_count
last_row.append(format_datatables_data(afs_count, afs_count))
for index, row in enumerate(rs):
rows[index].append(row[-1])
sums[index] += float(row[-1]['sort_key'])
for index, sum in enumerate(sums):
rows[index].append(format_datatables_data(sum, sum))
last_row.append(format_datatables_data(total, total))
rows.append(last_row)
return rows, total
def rows(self):
test_lots_map = self.test_lots_map
selected_tests = self.selected_tests
old_data = self.data
rows = []
for loc_key in self.keys:
row = [capitalize_fn(loc) for loc in loc_key]
for test in selected_tests:
test_lots = test_lots_map.get(test, None)
if not test_lots:
row.append(format_datatables_data(self.no_value, 0))
continue
total_test_count = 0
for lot_number in test_lots:
temp_key = [loc for loc in loc_key] + [test, lot_number]
data_map = old_data.get(tuple(temp_key), None)
lot_count = data_map["lot_count"] if data_map else None
row.append(
format_datatables_data(lot_count or self.no_value,
lot_count or 0))
total_test_count += data_map["lot_count"] if data_map else 0
row.append(
format_datatables_data(total_test_count or self.no_value,
total_test_count or 0))
rows.append(row)
self.total_row = calculate_total_row(rows)
self.total_row[0] = 'Total'
return rows
def rows(self):
test_lots_map = self.test_lots_map
selected_tests = self.selected_tests
old_data = self.data
rows = []
for loc_key in self.keys:
row = [capitalize_fn(loc) for loc in loc_key]
for test in selected_tests:
test_lots = test_lots_map.get(test, None)
if not test_lots:
row.append(format_datatables_data(self.no_value, 0))
continue
total_test_count = 0
for lot_number in test_lots:
temp_key = [loc for loc in loc_key] + [test, lot_number]
data_map = old_data.get(tuple(temp_key), None)
lot_count = data_map["lot_count"] if data_map else None
row.append(format_datatables_data(lot_count or self.no_value, lot_count or 0))
total_test_count += data_map["lot_count"] if data_map else 0
row.append(format_datatables_data(total_test_count or self.no_value, total_test_count or 0))
rows.append(row)
self.total_row = calculate_total_row(rows)
self.total_row[0] = 'Total'
return rows
def _payment_record_to_row(payment_record):
from corehq.apps.accounting.views import ManageBillingAccountView
applicable_credit_line = CreditAdjustment.objects.filter(
payment_record_id=payment_record.id
).latest('last_modified').credit_line
account = applicable_credit_line.account
return [
format_datatables_data(
text=payment_record.date_created.strftime(SERVER_DATE_FORMAT),
sort_key=payment_record.date_created.isoformat(),
),
format_datatables_data(
text=mark_safe(
make_anchor_tag(
reverse(ManageBillingAccountView.urlname, args=[account.id]),
account.name
)
),
sort_key=account.name,
),
_get_domain_from_payment_record(payment_record),
payment_record.payment_method.web_user,
format_datatables_data(
text=mark_safe(
'<a href="https://dashboard.stripe.com/payments/%s"'
' target="_blank">%s'
'</a>' % (
payment_record.transaction_id,
payment_record.transaction_id,
)),
sort_key=payment_record.transaction_id,
),
quantize_accounting_decimal(payment_record.amount),
]
def rows(self):
def percent(v1, v2):
return float(v1) * 100.0 / float(v2)
def get_grade(v):
return 'D' if v < 25 else 'C' if v < 50 else 'B' if v < 75 else 'A'
rows = [[column.header] for column in self.model.columns[2:]]
for block in self.get_blocks_for_district():
self.request_params['hierarchy_block'] = block
q = self.request.GET.copy()
q['hierarchy_block'] = block
self.request.GET = q
rs, block_total = BlockLevelAFReport(self.request, domain=self.domain).rows
for index, row in enumerate(rs[0:-2]):
value = percent(row[-1]['sort_key'], block_total)
grade = get_grade(value)
if index < 10:
rows[index].append(format_datatables_data('%.1f%%' % value, '%.1f%%' % value))
rows[index].append(format_datatables_data(grade, grade))
else:
rows[index].append(row[-1])
rows[index].append(format_datatables_data('', ''))
return rows, 0
def _get_credit_line_columns_from_credit_line(credit_line):
if credit_line is None:
return ['', '', '', '']
types = [
dict(SoftwareProductType.CHOICES).get(
credit_line.product_type,
"Any"
) if credit_line.product_type is not None else '',
dict(FeatureType.CHOICES).get(
credit_line.feature_type,
"Any"
) if credit_line.feature_type is not None else '',
]
if not any(types):
types = ['Any', 'Any']
return [
format_datatables_data(
text=mark_safe(
make_anchor_tag(
reverse(ManageBillingAccountView.urlname, args=[credit_line.account.id]),
credit_line.account.name
)
),
sort_key=credit_line.account.name,
),
format_datatables_data(
mark_safe(make_anchor_tag(
reverse(EditSubscriptionView.urlname, args=(credit_line.subscription.id,)),
credit_line.subscription
)),
credit_line.subscription.id,
) if credit_line.subscription else '',
] + types
def rows(self):
rows = [[column.header] for column in self.model.columns[2:]]
rows.append(["<b>Total number of ASHAs who did not report/not known</b>"])
last_row = ["<b>Total Number of ASHAs under each Facilitator</b>"]
sums = [0] * len(rows)
total = 0
sum_row_10 = 0
denom_row_10 = 0
for af in self.get_afs_for_block():
self.request_params['hierarchy_af'] = af[1]
q = self.request.GET.copy()
q['hierarchy_af'] = af[1]
self.request.GET = q
rs, afs_count = BlockLevelMonthReport(self.request, domain=self.domain).rows
total += afs_count
last_row.append(format_datatables_data(afs_count, afs_count))
for index, row in enumerate(rs):
rows[index].append(row[-1])
if index == 10:
numbers = re.split('/|\s|%', row[-1]['html'])
sum_row_10 += int(numbers[0])
denom_row_10 += int(numbers[1])
else:
sums[index] += float(row[-1]['sort_key'])
for index, sum in enumerate(sums):
if index == 10:
html = "{0}/{1} {2}%".format(sum_row_10, denom_row_10, sum_row_10 * 100 / denom_row_10)
rows[index].append(format_datatables_data(html, sum_row_10 * 100 / denom_row_10))
else:
rows[index].append(format_datatables_data(sum, sum))
last_row.append(format_datatables_data(total, total))
rows.append(last_row)
return rows, total
def _get_credit_line_columns_from_credit_line(credit_line):
if credit_line is None:
return ['', '', '', '']
types = [
dict(SoftwareProductType.CHOICES).get(credit_line.product_type,
"Any")
if credit_line.product_type is not None else '',
dict(FeatureType.CHOICES).get(credit_line.feature_type, "Any")
if credit_line.feature_type is not None else '',
]
if not any(types):
types = ['Any', 'Any']
return [
format_datatables_data(
text=mark_safe(
make_anchor_tag(
reverse(ManageBillingAccountView.urlname,
args=[credit_line.account.id]),
credit_line.account.name)),
sort_key=credit_line.account.name,
),
format_datatables_data(
mark_safe(
make_anchor_tag(
reverse(EditSubscriptionView.urlname,
args=(credit_line.subscription.id, )),
credit_line.subscription)),
credit_line.subscription.id,
) if credit_line.subscription else '',
] + types
def rows(self):
from corehq.apps.accounting.views import (
WireInvoiceSummaryView, ManageBillingAccountView,
)
rows = []
for invoice in self.invoices:
new_this_month = (invoice.date_created.month == invoice.account.date_created.month
and invoice.date_created.year == invoice.account.date_created.year)
try:
contact_info = BillingContactInfo.objects.get(account=invoice.account)
except BillingContactInfo.DoesNotExist:
contact_info = BillingContactInfo()
account_url = reverse(ManageBillingAccountView.urlname, args=[invoice.account.id])
invoice_url = reverse(WireInvoiceSummaryView.urlname, args=(invoice.id,))
columns = [
format_datatables_data(
mark_safe(make_anchor_tag(invoice_url, invoice.invoice_number)),
invoice.id,
),
format_datatables_data(
mark_safe(make_anchor_tag(account_url, invoice.account.name)),
invoice.account.name
),
invoice.get_domain(),
"YES" if new_this_month else "no",
contact_info.company_name,
contact_info.emails,
contact_info.first_name,
contact_info.last_name,
contact_info.phone_number,
contact_info.first_line,
contact_info.second_line,
contact_info.city,
contact_info.state_province_region,
contact_info.postal_code,
contact_info.country,
invoice.date_start,
invoice.date_end,
invoice.date_due,
get_exportable_column(invoice.subtotal),
get_exportable_column(invoice.balance),
"Paid" if invoice.is_paid else "Not paid",
"YES" if invoice.is_hidden else "no",
]
if not self.is_rendered_as_email:
columns.extend([
mark_safe(make_anchor_tag(invoice_url, 'Go to Invoice'))
])
rows.append(columns)
return rows
def _fmt_duration(duration):
if isinstance(duration, int):
return format_datatables_data(
'<span class="{cls}">{text}</span>'.format(
cls=_bootstrap_class(duration or 0, 60, 20),
text=_('{} seconds').format(duration),
), duration)
else:
return format_datatables_data(
'<span class="label label-default">{text}</span>'.
format(text=_("Unknown"), ),
-1,
)
def _fmt_date(date):
def _timedelta_class(delta):
return _bootstrap_class(delta, timedelta(days=7), timedelta(days=3))
if not date:
return format_datatables_data(u'<span class="label">{0}</span>'.format(_("Never")), -1)
else:
return format_datatables_data(
u'<span class="{cls}">{text}</span>'.format(
cls=_timedelta_class(datetime.utcnow() - date),
text=_(naturaltime(date)),
),
date.toordinal(),
)
def _fmt_date(date):
def _timedelta_class(delta):
return _bootstrap_class(delta, timedelta(days=7), timedelta(days=3))
if not date:
return format_datatables_data(u'<span class="label label-default">{0}</span>'.format(_("Never")), -1)
else:
return format_datatables_data(
u'<span class="{cls}">{text}</span>'.format(
cls=_timedelta_class(datetime.utcnow() - date),
text=_(_naturaltime_with_hover(date)),
),
int(date.strftime("%s")),
)
def username(self, user_id):
try:
username = self.usernames[user_id]
except KeyError:
username = user_id
return format_datatables_data(username, username)
def rows(self):
def format_val(val):
return self.no_value if val is None else val
def avg(values):
sum = 0
for v in values:
sum += v['sort_key'] if v is not None else 0
mean = "%.1f" % (float(sum) / float(len(values)))
return format_datatables_data(mean, mean)
data = []
config = self.report_config
for i in range(0, 3):
config['enddate'] = datetime.datetime(
config['startdate'].year, config['startdate'].month,
calendar.monthrange(config['startdate'].year, config['startdate'].month)[1], 23, 59, 59)
data.append(ASHAFacilitatorsData(config).data)
config['startdate'] += relativedelta(months=1)
rows = [[
column.header,
format_val(column.get_value(data[2])),
format_val(column.get_value(data[1])),
format_val(column.get_value(data[0])),
avg([column.get_value(data[2]), column.get_value(data[1]), column.get_value(data[0])])
] for column in self.model.columns[2:]]
total = [self.model.columns[0].get_raw_value(d) for d in data]
reporting = [self.model.columns[1].get_raw_value(d) for d in data]
not_reporting = [format_datatables_data(i - (j or 0), i - (j or 0)) for i, j in zip(total, reporting)]
rows.append(["<b>Total number of ASHAs who did not report/not known</b>"] + not_reporting +
[avg(not_reporting)])
return rows, sum(total) / len(total)
def _sync_log_to_row(sync_log):
def _fmt_duration(duration):
if isinstance(duration, int):
return format_datatables_data(
'<span class="{cls}">{text}</span>'.format(
cls=_bootstrap_class(duration or 0, 20, 60),
text=_('{} seconds').format(duration),
),
duration
)
else:
return format_datatables_data(
'<span class="label">{text}</span>'.format(
text=_("Unknown"),
),
-1,
)
def _fmt_id(sync_log_id):
return '<a href="/search/?q={id}" target="_blank">{id:.5}...</a>'.format(
id=sync_log_id
)
num_cases = len(sync_log.cases_on_phone)
return [
_fmt_id(sync_log.get_id),
_fmt_date(sync_log.date),
format_datatables_data(num_cases, num_cases),
_fmt_duration(sync_log.duration),
]
def _subscription_to_row(subscription):
from corehq.apps.accounting.views import ManageBillingAccountView
try:
created_by_adj = SubscriptionAdjustment.objects.filter(
subscription=subscription,
reason=SubscriptionAdjustmentReason.CREATE,
).order_by('date_created')[0]
created_by = dict(SubscriptionAdjustmentMethod.CHOICES).get(
created_by_adj.method, "Unknown")
except (SubscriptionAdjustment.DoesNotExist, IndexError):
created_by = "Unknown"
columns = [
subscription.subscriber.domain,
format_datatables_data(
text=mark_safe('<a href="%s">%s</a>' % (
reverse(
ManageBillingAccountView.urlname, args=(subscription.account.id,)
), subscription.account.name)),
sort_key=subscription.account.name,
),
subscription.plan_version.plan.name,
subscription.is_active,
subscription.salesforce_contract_id,
subscription.date_start,
subscription.date_end,
subscription.do_not_invoice,
created_by,
subscription.service_type,
subscription.pro_bono_status,
]
if not self.is_rendered_as_email:
columns.append(mark_safe('<a href="./%d" class="btn btn-default">Edit</a>' % subscription.id))
return columns
def mobile_user_reports(request):
template = "hqadmin/mobile_user_reports.html"
_device_users_by_xform = memoized(device_users_by_xform)
rows = []
logs = DeviceReportEntry.objects.filter(
type__exact="user-report").order_by('domain')
for log in logs:
seconds_since_epoch = int(time.mktime(log.date.timetuple()) * 1000)
rows.append(
dict(domain=log.domain,
time=format_datatables_data(text=log.date,
sort_key=seconds_since_epoch),
user=log.username,
device_users=_device_users_by_xform(log.xform_id),
message=log.msg,
version=(log.app_version or 'unknown').split(' ')[0],
detailed_version=html.escape(log.app_version or 'unknown'),
report_id=log.xform_id))
headers = DataTablesHeader(
DataTablesColumn(_("View Form")), DataTablesColumn(_("Domain")),
DataTablesColumn(_("Time"), sort_type=DTSortType.NUMERIC),
DataTablesColumn(_("User"), sort_type=DTSortType.NUMERIC),
DataTablesColumn(_("Device Users"), sort_type=DTSortType.NUMERIC),
DataTablesColumn(_("Message"), sort_type=DTSortType.NUMERIC),
DataTablesColumn(_("Version"), sort_type=DTSortType.NUMERIC))
context = get_hqadmin_base_context(request)
context["headers"] = headers
context["aoColumns"] = headers.render_aoColumns
context["rows"] = rows
return render(request, template, context)
def data_table(request, domain):
# TODO this should be async (large tables time out)
table_ids = request.GET.getlist("table_id")
try:
sheets = prepare_fixture_html(table_ids, domain)
except FixtureDownloadError as e:
messages.info(request, unicode(e))
raise
sheets.pop("types")
if not sheets:
return {
"headers": DataTablesHeader(DataTablesColumn("No lookup Tables Uploaded")),
"rows": []
}
selected_sheet = sheets.values()[0]
selected_sheet_tag = sheets.keys()[0]
data_table = {
"headers": None,
"rows": None,
"table_id": selected_sheet_tag
}
headers = [DataTablesColumn(header) for header in selected_sheet["headers"]]
data_table["headers"] = DataTablesHeader(*headers)
if selected_sheet["headers"] and selected_sheet["rows"]:
data_table["rows"] = [[format_datatables_data(x or "--", "a") for x in row] for row in selected_sheet["rows"]]
else:
messages.info(request, _("No items are added in this table type. Upload using excel to add some rows to this table"))
data_table["rows"] = [["--" for x in range(0, len(headers))]]
return data_table
def data_table(request, domain):
sheets = download_item_lists(request, domain, html_response=True)
sheets.pop("types")
if not sheets:
return {
"headers":
DataTablesHeader(DataTablesColumn("No lookup Tables Uploaded")),
"rows": []
}
selected_sheet = sheets.values()[0]
selected_sheet_tag = sheets.keys()[0]
data_table = {
"headers": None,
"rows": None,
"table_id": selected_sheet_tag
}
headers = [
DataTablesColumn(header) for header in selected_sheet["headers"]
]
data_table["headers"] = DataTablesHeader(*headers)
if selected_sheet["headers"] and selected_sheet["rows"]:
data_table["rows"] = [[
format_datatables_data(x or "--", "a") for x in row
] for row in selected_sheet["rows"]]
else:
messages.info(
request,
_("No items are added in this table type. Upload using excel to add some rows to this table"
))
data_table["rows"] = [["--" for x in range(0, len(headers))]]
return data_table
def mobile_user_reports(request):
template = "hqadmin/mobile_user_reports.html"
_device_users_by_xform = memoized(device_users_by_xform)
rows = []
logs = DeviceReportEntry.objects.filter(type__exact="user-report").order_by('domain')
for log in logs:
seconds_since_epoch = int(time.mktime(log.date.timetuple()) * 1000)
rows.append(dict(domain=log.domain,
time=format_datatables_data(text=log.date, sort_key=seconds_since_epoch),
user=log.username,
device_users=_device_users_by_xform(log.xform_id),
message=log.msg,
version=(log.app_version or 'unknown').split(' ')[0],
detailed_version=html.escape(log.app_version or 'unknown'),
report_id=log.xform_id))
headers = DataTablesHeader(
DataTablesColumn(_("View Form")),
DataTablesColumn(_("Domain")),
DataTablesColumn(_("Time"), sort_type=DTSortType.NUMERIC),
DataTablesColumn(_("User"), sort_type=DTSortType.NUMERIC),
DataTablesColumn(_("Device Users"), sort_type=DTSortType.NUMERIC),
DataTablesColumn(_("Message"), sort_type=DTSortType.NUMERIC),
DataTablesColumn(_("Version"), sort_type=DTSortType.NUMERIC)
)
context = get_hqadmin_base_context(request)
context["headers"] = headers
context["aoColumns"] = headers.render_aoColumns
context["rows"] = rows
return render(request, template, context)
def _sync_log_to_row(sync_log):
def _fmt_duration(duration):
if isinstance(duration, int):
return format_datatables_data(
'<span class="{cls}">{text}</span>'.format(
cls=_bootstrap_class(duration or 0, 60, 20),
text=_('{} seconds').format(duration),
),
duration
)
else:
return format_datatables_data(
'<span class="label">{text}</span>'.format(
text=_("Unknown"),
),
-1,
)
def _fmt_id(sync_log_id):
href = base_link_url.format(id=sync_log_id)
return '<a href="{href}" target="_blank">{id:.5}...</a>'.format(
href=href,
id=sync_log_id
)
num_cases = len(sync_log.cases_on_phone)
columns = [
_fmt_date(sync_log.date),
format_datatables_data(num_cases, num_cases),
_fmt_duration(sync_log.duration),
]
if self.show_extra_columns:
columns.append(_fmt_id(sync_log.get_id))
return columns
def rows(self):
startdate = self.datespan.startdate
enddate = self.datespan.enddate
old_data = self.data
rows = []
for loc_key in self.keys:
selected_disease = self.request.GET.get('test_type_disease', '')
selected_disease = selected_disease.split(':') if selected_disease else None
diseases = [selected_disease[0]] if selected_disease else self.diseases["ids"]
for disease in diseases:
row = [capitalize_fn(x) for x in loc_key]
disease_names = self.diseases["names"]
index = self.diseases['ids'].index(disease)
row.append(disease_names[index])
for n, day in enumerate(self.daterange(startdate, enddate)):
temp_key = [loc for loc in loc_key]
temp_key.append(datetime.strptime(day, "%Y-%m-%d").date())
temp_key.append(disease)
keymap = old_data.get(tuple(temp_key), None)
day_count = (keymap["day_count"] if keymap else None)
row.append(format_datatables_data(day_count or self.no_value, day_count or 0))
rows.append(row)
self.total_row = calculate_total_row(rows)
self.total_row[0] = 'Total'
return rows
def groupname(self, group_id):
try:
groupname = Group.get(group_id).name
except KeyError:
groupname = group_id
return format_datatables_data(groupname, groupname)
def rows(self):
from corehq.apps.accounting.views import EditSubscriptionView
def get_choice(choice, choices):
for slug, user_text in choices:
if choice == slug:
return user_text
return None
return [
map(lambda x: x or '', [
sub_adj.date_created,
format_datatables_data(
mark_safe(make_anchor_tag(
reverse(EditSubscriptionView.urlname, args=(sub_adj.subscription.id,)),
sub_adj.subscription
)),
sub_adj.subscription.id,
),
sub_adj.subscription.subscriber.domain,
get_choice(sub_adj.reason, SubscriptionAdjustmentReason.CHOICES),
get_choice(sub_adj.method, SubscriptionAdjustmentMethod.CHOICES),
sub_adj.note,
sub_adj.web_user,
])
for sub_adj in self.subscription_adjustments
]
def rows(self):
startdate = self.datespan.startdate
enddate = self.datespan.enddate
old_data = self.data
rows = []
for loc_key in self.keys:
selected_disease = self.request.GET.get('test_type_disease', '')
selected_disease = selected_disease.split(
':') if selected_disease else None
diseases = [selected_disease[0]
] if selected_disease else self.diseases["ids"]
for disease in diseases:
row = [capitalize_fn(x) for x in loc_key]
disease_names = self.diseases["names"]
index = self.diseases['ids'].index(disease)
row.append(disease_names[index])
for n, day in enumerate(self.daterange(startdate, enddate)):
temp_key = [loc for loc in loc_key]
temp_key.append(iso_string_to_date(day))
temp_key.append(disease)
keymap = old_data.get(tuple(temp_key), None)
day_count = (keymap["day_count"] if keymap else None)
row.append(
format_datatables_data(day_count or self.no_value,
day_count or 0))
rows.append(row)
self.total_row = calculate_total_row(rows)
self.total_row[0] = 'Total'
return rows
def _fmt_duration(duration):
if isinstance(duration, int):
return format_datatables_data(
'<span class="{cls}">{text}</span>'.format(
cls=_bootstrap_class(duration or 0, 60, 20),
text=_('{} seconds').format(duration),
),
duration
)
else:
return format_datatables_data(
'<span class="label label-default">{text}</span>'.format(
text=_("Unknown"),
),
-1,
)
def groupname(self, group_id):
try:
groupname = Group.get(group_id).name
except KeyError:
groupname = group_id
return format_datatables_data(groupname, groupname)
def data_table(request, domain):
# TODO this should be async (large tables time out)
table_ids = request.GET.getlist("table_id")
try:
sheets = prepare_fixture_html(table_ids, domain)
except FixtureDownloadError as e:
messages.info(request, unicode(e))
raise Http404()
sheets.pop("types")
if not sheets:
return {
"headers": DataTablesHeader(DataTablesColumn("No lookup Tables Uploaded")),
"rows": []
}
selected_sheet = sheets.values()[0]
selected_sheet_tag = sheets.keys()[0]
data_table = {
"headers": None,
"rows": None,
"table_id": selected_sheet_tag
}
headers = [DataTablesColumn(header) for header in selected_sheet["headers"]]
data_table["headers"] = DataTablesHeader(*headers)
if selected_sheet["headers"] and selected_sheet["rows"]:
data_table["rows"] = [[format_datatables_data(x or "--", "a") for x in row] for row in selected_sheet["rows"]]
else:
messages.info(request, _("No items are added in this table type. Upload using excel to add some rows to this table"))
data_table["rows"] = [["--" for x in range(0, len(headers))]]
return data_table
def rows(self):
def _subscription_to_row(subscription):
from corehq.apps.accounting.views import ManageBillingAccountView
try:
created_by_adj = SubscriptionAdjustment.objects.filter(
subscription=subscription,
reason=SubscriptionAdjustmentReason.CREATE,
).order_by('date_created')[0]
created_by = dict(SubscriptionAdjustmentMethod.CHOICES).get(
created_by_adj.method, "Unknown")
except IndexError, SubscriptionAdjustment.DoesNotExist:
created_by = "Unknown"
columns = [
subscription.subscriber.domain,
format_datatables_data(
text=mark_safe('<a href="%s">%s</a>' % (
reverse(
ManageBillingAccountView.urlname, args=(subscription.account.id,)
), subscription.account.name)),
sort_key=subscription.account.name,
),
subscription.plan_version.plan.name,
subscription.is_active,
subscription.salesforce_contract_id,
subscription.date_start,
subscription.date_end,
subscription.do_not_invoice,
created_by,
subscription.service_type,
subscription.pro_bono_status,
]
if not self.is_rendered_as_email:
columns.append(mark_safe('<a href="./%d" class="btn btn-default">Edit</a>' % subscription.id))
return columns
def username(self, user_id):
try:
username = self.usernames[user_id]
except KeyError:
username = user_id
return format_datatables_data(username, username)
def add_numeric_cell(text, value=None):
if value is None:
try:
value = int(text)
except ValueError:
value = text
cells.append(util.format_datatables_data(text=text, sort_key=value))
def _sync_log_to_row(sync_log):
def _fmt_duration(duration):
if isinstance(duration, int):
return format_datatables_data(
'<span class="{cls}">{text}</span>'.format(
cls=_bootstrap_class(duration or 0, 60, 20),
text=_('{} seconds').format(duration),
),
duration
)
else:
return format_datatables_data(
'<span class="label">{text}</span>'.format(
text=_("Unknown"),
),
-1,
)
def _fmt_id(sync_log_id):
href = base_link_url.format(id=sync_log_id)
return '<a href="{href}" target="_blank">{id:.5}...</a>'.format(
href=href,
id=sync_log_id
)
def _fmt_error_info(sync_log):
if not sync_log.had_state_error:
return u'<span class="label label-success">✓</span>'
else:
return (u'<span class="label label-important">X</span>'
u'State error {}<br>Expected hash: {:.10}...').format(
_naturaltime_with_hover(sync_log.error_date),
sync_log.error_hash,
)
def _get_state_hash_display(sync_log):
try:
return u'{:.10}...'.format(sync_log.get_state_hash())
except SyncLogAssertionError as e:
return _(u'Error computing hash! {}').format(e)
num_cases = sync_log.case_count()
columns = [
_fmt_date(sync_log.date),
format_datatables_data(num_cases, num_cases),
_fmt_duration(sync_log.duration),
]
if self.show_extra_columns:
columns.append(_fmt_id(sync_log.get_id))
columns.append(sync_log.log_format)
columns.append(_fmt_id(sync_log.previous_log_id) if sync_log.previous_log_id else '---')
columns.append(_fmt_error_info(sync_log))
columns.append(_get_state_hash_display(sync_log))
columns.append(_naturaltime_with_hover(sync_log.last_submitted))
columns.append(u'{}<br>{:.10}'.format(_naturaltime_with_hover(sync_log.last_cached),
sync_log.hash_at_last_cached))
return columns
def add_numeric_cell(text, value=None):
if value is None:
try:
value = int(text)
except ValueError:
value = text
cells.append(
util.format_datatables_data(text=text, sort_key=value))
def rows(self):
from corehq.apps.accounting.views import (
EditSubscriptionView,
ManageBillingAccountView,
)
return [
map(lambda x: x or '', [
credit_adj.date_created,
format_datatables_data(
text=mark_safe(
make_anchor_tag(
reverse(ManageBillingAccountView.urlname, args=[credit_adj.credit_line.account.id]),
credit_adj.credit_line.account.name
)
),
sort_key=credit_adj.credit_line.account.name,
),
format_datatables_data(
mark_safe(make_anchor_tag(
reverse(EditSubscriptionView.urlname, args=(credit_adj.credit_line.subscription.id,)),
credit_adj.credit_line.subscription
)),
credit_adj.credit_line.subscription.id,
) if credit_adj.credit_line.subscription else '',
dict(FeatureType.CHOICES).get(
credit_adj.credit_line.feature_type,
dict(SoftwareProductType.CHOICES).get(
credit_adj.credit_line.product_type,
"Any"
),
),
(
credit_adj.credit_line.subscription.subscriber.domain
if credit_adj.credit_line.subscription is not None else (
credit_adj.invoice.subscription.subscriber.domain
if credit_adj.invoice else ''
)
),
dict(CreditAdjustmentReason.CHOICES)[credit_adj.reason],
invoice_column_cell(credit_adj.invoice) if credit_adj.invoice else None,
credit_adj.note,
quantize_accounting_decimal(credit_adj.amount),
credit_adj.web_user,
])
for credit_adj in self.filtered_credit_adjustments
]
def _sync_log_to_row(sync_log):
def _fmt_duration(duration):
if isinstance(duration, int):
return format_datatables_data(
'<span class="{cls}">{text}</span>'.format(
cls=_bootstrap_class(duration or 0, 60, 20),
text=_('{} seconds').format(duration),
),
duration
)
else:
return format_datatables_data(
'<span class="label label-default">{text}</span>'.format(
text=_("Unknown"),
),
-1,
)
def _fmt_id(sync_log_id):
href = base_link_url.format(id=sync_log_id)
return '<a href="{href}" target="_blank">{id:.5}...</a>'.format(
href=href,
id=sync_log_id
)
def _fmt_error_info(sync_log):
if not sync_log.had_state_error:
return u'<span class="label label-success">✓</span>'
else:
return (u'<span class="label label-danger">X</span>'
u'State error {}<br>Expected hash: {:.10}...').format(
_naturaltime_with_hover(sync_log.error_date),
sync_log.error_hash,
)
def _get_state_hash_display(sync_log):
try:
return u'{:.10}...'.format(sync_log.get_state_hash())
except SyncLogAssertionError as e:
return _(u'Error computing hash! {}').format(e)
num_cases = sync_log.case_count()
columns = [
_fmt_date(sync_log.date),
format_datatables_data(num_cases, num_cases),
_fmt_duration(sync_log.duration),
]
if self.show_extra_columns:
columns.append(_fmt_id(sync_log.get_id))
columns.append(sync_log.log_format)
columns.append(_fmt_id(sync_log.previous_log_id) if sync_log.previous_log_id else '---')
columns.append(_fmt_error_info(sync_log))
columns.append(_get_state_hash_display(sync_log))
columns.append(_naturaltime_with_hover(sync_log.last_submitted))
columns.append(u'{}<br>{:.10}'.format(_naturaltime_with_hover(sync_log.last_cached),
sync_log.hash_at_last_cached))
return columns
def numcell(text, value=None):
if value is None:
try:
value = int(text)
if math.isnan(value):
text = '---'
except ValueError:
value = text
return util.format_datatables_data(text=text, sort_key=value)
def invoice_column_cell(invoice):
from corehq.apps.accounting.views import InvoiceSummaryView
return format_datatables_data(
mark_safe(
make_anchor_tag(
reverse(InvoiceSummaryView.urlname, args=(invoice.id, )),
invoice.invoice_number)),
invoice.id,
)
def invoice_column_cell(invoice):
from corehq.apps.accounting.views import InvoiceSummaryView
return format_datatables_data(
mark_safe(make_anchor_tag(
reverse(InvoiceSummaryView.urlname, args=(invoice.id,)),
invoice.invoice_number
)),
invoice.id,
)
def avg(values, idx=None):
sum = 0
denom = 0
for v in values:
if idx == 10:
numbers = re.split('/|\s|%', v['html'])
sum += int(numbers[0])
if int(numbers[1]) > denom:
denom = int(numbers[1])
else:
sum += v['sort_key'] if v is not None else 0
mean = (float(sum) / float(len(values)))
if idx == 10:
percent = mean * 100 / denom
html = "{0}/{1} {2}%".format(int(mean), int(denom), int(percent))
return format_datatables_data(html, percent)
mean = "%.0f" % mean
return format_datatables_data(mean, mean)
def rows(self):
rows = [[column.header] for column in self.model.columns[2:]]
rows.append(
[_("<b>Total number of ASHAs who did not report/not known</b>")])
last_row = [_("<b>Total Number of ASHAs under each Facilitator</b>")]
sums = [0] * len(rows)
total = 0
sum_row_10 = 0
denom_row_10 = 0
for af in self.get_afs_for_block():
self.request_params['hierarchy_af'] = af[1]
q = self.request.GET.copy()
q['hierarchy_af'] = af[1]
self.request.GET = q
rs, afs_count = BlockLevelMonthReport(self.request,
domain=self.domain).rows
total += afs_count
last_row.append(format_datatables_data(afs_count, afs_count))
for index, row in enumerate(rs):
rows[index].append(row[-1])
if index == 10:
numbers = re.split('/|\s|%', row[-1]['html'])
sum_row_10 += int(numbers[0])
denom_row_10 += int(numbers[1])
else:
sums[index] += float(row[-1]['sort_key'])
for index, sum in enumerate(sums):
if index == 10:
try:
percent = sum_row_10 * 100 / denom_row_10
except ZeroDivisionError:
percent = 0
html = "{0}/{1} ({2}%)".format(sum_row_10, denom_row_10,
percent)
rows[index].append(format_datatables_data(html, percent))
else:
rows[index].append(format_datatables_data(sum, sum))
last_row.append(format_datatables_data(total, total))
rows.append(last_row)
return rows, total
def avg(values, idx=None):
sum = 0
denom = 0
for v in values:
if idx == 10:
numbers = re.split('/|\s|%', v['html'])
sum += int(numbers[0])
if int(numbers[1]) > denom:
denom = int(numbers[1])
else:
sum += v['sort_key'] if v is not None else 0
mean = (float(sum) / float(len(values)))
if idx == 10:
try:
percent = mean * 100 / denom
except ZeroDivisionError:
percent = 0
html = "{0}/{1} ({2}%)".format(int(mean), int(denom), int(percent))
return format_datatables_data(html, percent)
mean = "%.0f" % mean
return format_datatables_data(mean, mean)
def rows(self):
def format_val(val):
return self.no_value if val is None else val
def avg(values, idx=None):
sum = 0
denom = 0
for v in values:
if idx == 10:
numbers = re.split(r'/|\s|%', v['html'])
sum += int(numbers[0])
if int(numbers[1]) > denom:
denom = int(numbers[1])
else:
sum += v['sort_key'] if v is not None else 0
mean = (float(sum) / float(len(values)))
if idx == 10:
try:
percent = mean * 100 / denom
except ZeroDivisionError:
percent = 0
html = "{0}/{1} ({2}%)".format(int(mean), int(denom), int(percent))
return format_datatables_data(html, percent)
mean = "%.0f" % mean
return format_datatables_data(mean, mean)
data = []
config = self.report_config
for i in range(0, 3):
config['enddate'] = (
config['startdate'] + relativedelta(months=1) - relativedelta(days=1)
).replace(hour=23, minute=59, second=59)
for index, row_data in ASHAFacilitatorsData(config).data.items():
data.append(row_data)
config['startdate'] += relativedelta(months=1)
rows = [[
column.header,
format_val(column.get_value(data[2])),
format_val(column.get_value(data[1])),
format_val(column.get_value(data[0])),
avg([column.get_value(data[2]), column.get_value(data[1]), column.get_value(data[0])], idx)
] for idx, column in enumerate(self.model.columns[2:])]
total = [self.model.columns[0].get_raw_value(d) for d in data]
reporting = [self.model.columns[1].get_raw_value(d) for d in data]
not_reporting = [format_datatables_data(i - (j or 0), i - (j or 0)) for i, j in zip(total, reporting)]
rows.append([_("<b>Total number of ASHAs who did not report/not known</b>")] + not_reporting +
[avg(not_reporting)])
return rows, sum(total) // len(total)
def rows(self):
rows = list()
data = self._get_data()
for app in data:
rows.append([
'<a href="%s">%s</a>' %
(reverse('project_info',
args=[app._id]), app.copied_from.display_name()),
app.organization_title(), app.project_type,
len(app.copies_of_parent()), app.get_license_display,
format_datatables_data(naturaltime(app.snapshot_time),
app.snapshot_time.toordinal())
])
return rows
def rows(self):
def format_val(val):
return self.no_value if val is None else val
def avg(values, idx=None):
sum = 0
denom = 0
for v in values:
if idx == 10:
numbers = re.split('/|\s|%', v['html'])
sum += int(numbers[0])
if int(numbers[1]) > denom:
denom = int(numbers[1])
else:
sum += v['sort_key'] if v is not None else 0
mean = (float(sum) / float(len(values)))
if idx == 10:
try:
percent = mean * 100 / denom
except ZeroDivisionError:
percent = 0
html = "{0}/{1} ({2}%)".format(int(mean), int(denom), int(percent))
return format_datatables_data(html, percent)
mean = "%.0f" % mean
return format_datatables_data(mean, mean)
data = []
config = self.report_config
for i in range(0, 3):
config['enddate'] = (
config['startdate'] + relativedelta(months=1) - relativedelta(days=1)
).replace(hour=23, minute=59, second=59)
data.append(ASHAFacilitatorsData(config).data)
config['startdate'] += relativedelta(months=1)
rows = [[
column.header,
format_val(column.get_value(data[2])),
format_val(column.get_value(data[1])),
format_val(column.get_value(data[0])),
avg([column.get_value(data[2]), column.get_value(data[1]), column.get_value(data[0])], idx)
] for idx, column in enumerate(self.model.columns[2:])]
total = [self.model.columns[0].get_raw_value(d) for d in data]
reporting = [self.model.columns[1].get_raw_value(d) for d in data]
not_reporting = [format_datatables_data(i - (j or 0), i - (j or 0)) for i, j in zip(total, reporting)]
rows.append([_("<b>Total number of ASHAs who did not report/not known</b>")] + not_reporting +
[avg(not_reporting)])
return rows, sum(total) // len(total)
def rows(self):
from corehq.apps.accounting.views import ManageBillingAccountView
rows = []
for record in self.payment_records:
applicable_credit_line = CreditAdjustment.objects.filter(
payment_record_id=record.id
).latest('last_modified').credit_line
account = applicable_credit_line.account
rows.append([
format_datatables_data(
text=record.date_created.strftime(SERVER_DATE_FORMAT),
sort_key=record.date_created.isoformat(),
),
format_datatables_data(
text=mark_safe(
make_anchor_tag(
reverse(ManageBillingAccountView.urlname, args=[account.id]),
account.name
)
),
sort_key=account.name,
),
applicable_credit_line.subscription.subscriber.domain if applicable_credit_line.subscription else '',
record.payment_method.web_user,
format_datatables_data(
text=mark_safe(
'<a href="https://dashboard.stripe.com/payments/%s"'
' target="_blank">%s'
'</a>' % (
record.transaction_id,
record.transaction_id,
)),
sort_key=record.transaction_id,
),
quantize_accounting_decimal(record.amount),
])
return rows
def _fmt_date(date, include_sort_key=True):
def _timedelta_class(delta):
return _bootstrap_class(delta, timedelta(days=7), timedelta(days=3))
if not date:
text = u'<span class="label label-default">{0}</span>'.format(_("Never"))
else:
text = u'<span class="{cls}">{text}</span>'.format(
cls=_timedelta_class(datetime.utcnow() - date),
text=_(_naturaltime_with_hover(date)),
)
if include_sort_key:
return format_datatables_data(text, _get_sort_key(date))
else:
return text
def group_cell(group_id, group_name):
"""
takes group info, and creates a cell that links to the user status report focused on the group
"""
us_url = reverse('project_report_dispatcher', args=(self.domain, 'worker_activity'))
start_date, end_date = dates_for_linked_reports()
url_args = {
"group": group_id,
"startdate": start_date,
"enddate": end_date,
}
return util.format_datatables_data(
'<a href="%s?%s" target="_blank">%s</a>' % (us_url, urlencode(url_args, True), group_name),
group_name
)
def rows(self):
rows = []
for record in self.payment_records:
rows.append([
format_datatables_data(
text=record.date_created.strftime(USER_DATE_FORMAT),
sort_key=record.date_created.isoformat(),
),
self.get_account(record).name,
self.get_account(record).created_by_domain,
record.payment_method.web_user,
format_datatables_data(
text=mark_safe(
'<a href="https://dashboard.stripe.com/payments/%s"'
' target="_blank">%s'
'</a>' % (
record.transaction_id,
record.transaction_id,
)),
sort_key=record.transaction_id,
),
quantize_accounting_decimal(record.amount),
])
return rows
def _subscription_adjustment_to_row(sub_adj):
from corehq.apps.accounting.views import EditSubscriptionView
return [x or '' for x in [
sub_adj.date_created,
format_datatables_data(
mark_safe(make_anchor_tag(
reverse(EditSubscriptionView.urlname, args=(sub_adj.subscription.id,)),
sub_adj.subscription
)),
sub_adj.subscription.id,
),
sub_adj.subscription.subscriber.domain,
dict(SubscriptionAdjustmentReason.CHOICES).get(sub_adj.reason),
dict(SubscriptionAdjustmentMethod.CHOICES).get(sub_adj.method),
sub_adj.note,
sub_adj.web_user,
]]
def rows(self):
def format_val(val):
return self.no_value if val is None else val
model = self.model
model_data = model.data
total = model.columns[0].get_raw_value(model_data)
reporting = model.columns[1].get_raw_value(model_data)
not_reporting = total - (reporting or 0)
return ([[
column.header,
format_val(column.get_value(model_data)),
format_datatables_data(not_reporting, not_reporting), ''
] for column in model.columns[2:]], format_val(total),
format_val(reporting))
def rows(self):
kwargs = {
'stale': settings.COUCH_STALE_QUERY
} if self.update_after else {}
startkey, endkey = self.start_and_end_keys
kwargs.update({
'db': get_db(),
'couch_view': getattr(self, 'couch_view', None),
'startkey': startkey,
'endkey': endkey
})
for key in self.keys:
row = self.View.get_result(key, **kwargs)
yield [
format_datatables_data(row[c], row[c])
if c in self.View.key_views else self.function_views[c].view(
key, self) for c in self.default_column_order
]
def numeric_cell(val):
if isinstance(val, numbers.Number):
return util.format_datatables_data(text=val, sort_key=val)
else:
return val
def _fmt(self, val):
return format_datatables_data(val, val)
def _fmt_date(self, val):
date_as_num = int(val.strftime("%Y%m%d"))
return format_datatables_data(val.strftime("%m/%d/%Y"), date_as_num)
