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 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 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)