def get_table_kwargs(self) -> Dict[str, List[Tuple[str, Column]]]:
credit_lines = models.CreditLine.objects.filter(
user=self.request.user).order_by("priority")
extra_cols = [] # type: List[Tuple[str, Column]]
def get_linkify_func(
col_name: str) -> Callable[[Mapping[str, Any]], str]:
"""Returns a function to linkify each column.
This takes advantage of closures to generate a separate
linkify function for each column. See django-tables2 docs
for more information on what these callables look like.
"""
def linkify_func(record: Mapping[str, Any]) -> str:
return tables.linkify_statement(col_name, record["month"])
return linkify_func
for cl in credit_lines:
extra_cols.append((
cl.name,
Column(
attrs={"td": dict(align="right")},
orderable=False,
linkify=get_linkify_func(cl.name),
),
))
extra_cols.append(
("Total", Column(attrs={"td": dict(align="right")},
orderable=False)))
return {"extra_columns": extra_cols}
class ProductTable(Table):
title = TemplateColumn(
verbose_name=_('Title'),
template_name='dashboard/catalogue/product_row_title.html',
order_by='title',
accessor=A('title'))
image = TemplateColumn(
verbose_name=_('Image'),
template_name='dashboard/catalogue/product_row_image.html',
orderable=False)
product_class = Column(verbose_name=_('Product type'),
accessor=A('product_class'),
order_by='product_class__name')
gift = Column(verbose_name=_('Is Gift'), order_by='gift')
variants = TemplateColumn(
verbose_name=_("Variants"),
template_name='dashboard/catalogue/product_row_variants.html',
orderable=False)
stock_records = TemplateColumn(
verbose_name=_('Stock records'),
template_name='dashboard/catalogue/product_row_stockrecords.html',
orderable=False)
actions = TemplateColumn(
verbose_name=_('Actions'),
template_name='dashboard/catalogue/product_row_actions.html',
orderable=False)
class Meta(DashboardTable.Meta):
model = Product
fields = ('upc', 'date_updated')
sequence = ('title', 'upc', 'image', 'product_class', 'variants',
'stock_records', '...', 'date_updated', 'actions')
order_by = '-date_updated'
class ServerTable(Table):
pulp_site = Column(verbose_name='Pulp Site')
hostname = Column()
empty_text = "There are no Pulp servers configured."
def render_pulp_site(self, record):
return ServerView.make_link(record.pulp_site, record.server_slug)
class ListStreamTable(tables.Table):
name = Column(verbose_name="Stream")
details = Column(verbose_name="Description")
creators = Column(verbose_name="Creator", accessor="creators__0")
items = Column()
restrict = Column(verbose_name="Open")
streams = {
"alias": "Address alias registrations",
"DOI": "Open Stream that maps DOI to ISCC",
"ISBN": "Open Stream that maps ISBN to ISCC",
"iscc": "Public ISCC Registry",
"smart-license": "Public Smart License Registry",
"test": "Stream for test data",
"timestamp": "Open timestamping with SHA-256",
}
class Meta:
attrs = {"class": "table table-sm table-striped table-hover"}
def render_name(self, value):
return format_html('<a href="/stream/{}">{}</a>', value, value)
def render_details(self, value, record):
value = value.get("info")
if not value:
value = self.streams.get(record["name"])
return value
def render_restrict(self, value):
return not value["read"]
class ParentRequirementTable(Table):
document = Column(verbose_name='Doc.')
uid = Column(verbose_name='Parent req')
actions = Column(empty_values=())
class Meta:
template_name = "django_tables2/bootstrap4.html"
def __init__(self, data=None, item=None):
self._item = item
super().__init__(data, attrs={'class': 'table table-sm'})
# noinspection PyUnusedLocal
@staticmethod
def render_uid(value, record):
# type: (str, Item) -> str
return format_html(
'<a id="{}" href="{}">{}</a>', record.uid,
reverse('item-details',
args=[record.document.prefix, record.uid.value]), value)
def render_actions(self, record):
# type: (Item) -> str
html = format_html('<div class="btn-toolbar"><div class="btn-group">')
html += format_html(
'<a href="{}" class="btn btn-outline-primary btn-sm" title="Unlink parent req"><i class="fa fa-unlink"></i></a>',
reverse('item-action-target',
args=[
self._item.document.prefix, self._item.uid.value,
'unlink', record.uid
]))
html += format_html('</div></div>')
return html
class SQRTable(Table):
quiz = Column("Quiz")
attempt = Column("Attempt")
cur_quest = Column("Question")
score = Column("Score")
details = Column("Details", empty_values=(), orderable=False)
class Meta:
model = StudentQuizResult
attrs = {'class': 'paleblue'}
fields = ['quiz', 'attempt', 'cur_quest', 'score']
def render_cur_quest(self, value, record):
if value == 0:
return "Completed"
else:
return value
def render_details(self, value, record):
return format_html(
'<a href="{}">Details</a>',
reverse('quiz_details',
kwargs={
'sqr_pk': record.pk,
'quiz_pk': record.quiz.pk,
'course_pk': record.quiz.course.pk,
}))
class BlockTable(tables.Table):
height = LinkColumn(verbose_name="Height", orderable=True)
time = DateTimeColumn(verbose_name="Time (UTC)",
format="Y-m-d H:i:s",
orderable=True)
miner = LinkColumn(verbose_name=settings.MEX_MINER)
txcount = Column(verbose_name="TXs", orderable=True)
size = Column(orderable=True)
class Meta:
model = Block
fields = ("height", "time", "miner", "txcount", "size")
order_by = ("-height", )
attrs = {"class": "table table-sm table-striped table-hover"}
orderable = False
def render_height(self, record=None):
link = reverse("block-detail", args=[str(record.hash)])
return mark_safe(
'<a href="{}" class="badge badge-info"><i class="fas fa-cube"></i> {}</a>'
.format(link, record.height))
def render_miner(self, record=None):
link = reverse("address-detail", args=[str(record.miner)])
return mark_safe('<a href="{}">{}</a>'.format(link, record.miner))
class MarkedQuestionTable(Table):
# Record is a MarkedQuestion
problem_str = MathColumn()
choices = Column(empty_values=())
test = Column(empty_values=())
class Meta:
attrs = {'class': 'paleblue'}
model = MarkedQuestion
fields = ['category', 'problem_str', 'choices']
def render_choices(self, value, record):
return format_html(
'<a href={}>Edit Choices</a>',
reverse('edit_choices',
kwargs={
'mq_pk': record.pk,
'quiz_pk': record.quiz.pk,
'course_pk': record.quiz.course.pk,
}))
def render_test(self, value, record):
return format_html(
'<a href={}>Test</a>',
reverse('test_quiz_question',
kwargs={
'mq_pk': record.pk,
'quiz_pk': record.quiz.pk,
'course_pk': record.quiz.course.pk,
}))
class BlockTable(tables.Table):
height = LinkColumn(verbose_name='Height', orderable=True)
time = DateTimeColumn(verbose_name='Time (UTC)',
format="Y-m-d H:i:s",
orderable=True)
miner = LinkColumn(verbose_name=settings.MEX_MINER)
txcount = Column(verbose_name='TXs', orderable=True)
size = Column(orderable=True)
class Meta:
model = Block
fields = (
'height',
'time',
'miner',
'txcount',
'size',
)
order_by = '-height',
attrs = {'class': 'table table-sm table-striped table-hover'}
orderable = False
def render_height(self, record=None):
link = reverse('block-detail', args=[str(record.hash)])
return mark_safe(
'<a href="{}" class="badge badge-info"><i class="fas fa-cube"></i> {}</a>'
.format(link, record.height))
def render_miner(self, record=None):
link = reverse('address-detail', args=[str(record.miner)])
return mark_safe('<a href="{}">{}</a>'.format(link, record.miner))
class CollaborationTable(tables.Table):
people = Column(order_by='members')
description = Column(order_by='project__text')
def render_project(self, record, value):
return mark_safe('<a href="%s">%s</a>' %
(record.get_absolute_url(), value))
def render_labs(self, record, value):
return mark_safe('<a href="%s">%s</a>' %
(record.get_absolute_url(), value.count()))
def render_members(self, record, value):
return mark_safe('<a href="%s">%s</a>' %
(record.get_absolute_url(), record.members.count()))
def render_people(self, record, value):
return mark_safe("; ".join([
'<a href="%s">%s</a>' %
(member.get_url(), member.password or member.last_name)
for member in record.members.all()
]))
# def render_description(self, record, value):
# return markdown(value)
class Meta:
model = Collaboration
attrs = {'class': 'paleblue'}
exclude = ('id', )
fields = ('project', 'labs', 'members', 'people', 'description')
class Results(tables.Table):
name = Column()
type = Column()
entries = Column()
wetSession = Column()
view = TemplateColumn(
template_name='results/table/results_view_column.html')
class MarksTable(Table):
""" Used for displaying a student's individual marks. The score and percent
will render differently if a note has been submitted for this work.
`record' will therefore be a StudentMark object
"""
name = Column(verbose_name="Name", empty_values=())
out_of = Column(verbose_name="Out of", empty_values=())
score = Column(verbose_name="Score", empty_values=())
percent = Column(verbose_name="Percent", empty_values=())
class Meta:
attrs = {'class': 'paleblue'}
def render_name(self, value, record):
return record.category.name
def render_out_of(self, value, record):
return str(record.category.out_of)
def render_score(self, value, record):
notes = record.has_note()
if notes:
return html_for_notes(notes)
else:
return value
def render_percent(self, value, record):
notes = record.has_note()
if notes:
return html_for_notes(notes)
else:
if record.score:
return str(round(100*record.score/record.category.out_of,2))
else:
return ''
class ConfigComplianceGlobalFeatureTable(BaseTable):
"""Table for feature compliance report."""
name = Column(accessor="rule__feature__slug", verbose_name="Feature")
count = Column(accessor="count", verbose_name="Total")
compliant = Column(accessor="compliant", verbose_name="Compliant")
non_compliant = Column(accessor="non_compliant",
verbose_name="Non-Compliant")
comp_percent = PercentageColumn(accessor="comp_percent",
verbose_name="Compliance (%)")
class Meta(BaseTable.Meta):
"""Metaclass attributes of ConfigComplianceGlobalFeatureTable."""
model = models.ConfigCompliance
fields = [
"name", "count", "compliant", "non_compliant", "comp_percent"
]
default_columns = [
"name",
"count",
"compliant",
"non_compliant",
"comp_percent",
]
class GitFileStatus(Table):
selected = CheckBoxColumn()
name = Column(verbose_name='File name')
status_text = Column(verbose_name='Status')
actions = Column(empty_values=())
class Meta:
template_name = "django_tables2/bootstrap4.html"
def __init__(self, data=None):
super().__init__(data, attrs={'class': 'table table-sm'})
@staticmethod
def render_name(value, record):
return format_html(
f'<a href="?f={record.base_name}">{record.name}</a>')
@staticmethod
def render_actions(_record):
# type: (Item) -> str
html = format_html('<div class="btn-toolbar"><div class="btn-group">')
html += format_html(
'<a href="{}" class="btn btn-outline-primary btn-sm" title="Unlink parent req"><i class="fa fa-edit"></i></a>',
reverse('index', args=[]))
html += format_html('</div></div>')
return html
class VMTemplateTable(BaseTable):
template_name = LinkColumn("template-detail",
args=[A("cluster.slug"),
A("template_name")],
verbose_name="name")
description = Column()
cluster = LinkColumn("cluster-detail",
args=[A("cluster.slug")],
accessor="cluster.slug",
verbose_name="cluster")
os = Column(verbose_name='OS')
memory = Column(verbose_name='RAM')
disk_space = Column()
vcpus = Column(verbose_name='vCPUs')
class Meta:
sequence = ("template_name", "description", "cluster", "os", "memory",
"disk_space", "vcpus")
order_by = ("template_name")
empty_text = "No Templates"
def render_os(self, value):
return render_os(value)
def render_memory(self, value):
return render_storage(value)
def render_disk_space(self, value):
return render_storage(value)
class BusinessSaleTable(DashboardTable):
isp = TemplateColumn(
verbose_name=u'用户',
template_name='dashboard/business/business_sale_row_isp.html',
)
ispname = TemplateColumn(
verbose_name=u'商家名称',
template_name='dashboard/business/business_sale_row_ispname.html',
)
upc = TemplateColumn(
verbose_name=u'商品代码',
template_name='dashboard/business/pickup_store_row_upc.html',
order_by='product__upc')
created_date = Column(verbose_name=u'成交日期')
can_pickup_quantity = Column(verbose_name=u'待提取量')
yet_pickup_quantity = TemplateColumn(
verbose_name=u'已提取量',
template_name='dashboard/business/business_sale_row_yetpick.html',
)
caption = u'商品销售情况'
icon = 'sitemap'
class Meta(DashboardTable.Meta):
model = TradeComplete
fields = ('product', 'c_type', 'unit_price', 'quantity', 'total',
'can_pickup_quantity', 'created_date')
sequence = ('isp', 'ispname', 'product', 'upc', 'c_type', 'unit_price',
'quantity', 'total', 'can_pickup_quantity',
'yet_pickup_quantity', 'created_date')
order_by = '-created_date'
def get_context_data(self, **kwargs) -> Dict[str, Any]:
context = super().get_context_data(**kwargs)
fmt = "%b_%y"
orig = thirteen_months_ago()
first = datetime.date(year=orig.year, month=orig.month, day=1)
now = timezone.now()
last = datetime.date(year=now.year, month=now.month, day=1)
# Add each month to the header
cols = []
cur = first
while cur <= last:
cols.append(cur.strftime(fmt))
cur = first_day_month_after(cur)
linkify_func = self.get_category_linkify_func(self.object.id)
extra_cols = [("category",
Column(accessor="category", linkify=linkify_func))]
extra_cols.extend([(c, Column(attrs={"td": dict(align="right")}))
for c in cols])
qs = oys_qs(user=self.request.user, class_id=self.object.id)
t = self.table_class(data=qs, extra_columns=extra_cols)
context["table"] = t
return context
class ClusterTable(BaseTable):
cluster = LinkColumn("cluster-detail",
args=[A("slug")],
accessor="slug",
verbose_name='cluster')
description = Column()
version = Column(accessor="info.software_version",
orderable=False,
default="unknown")
hypervisor = Column(accessor="info.default_hypervisor",
orderable=False,
default="unknown")
master_node = LinkColumn("node-detail",
kwargs={
"cluster_slug": A("slug"),
"host": A("info.master")
},
accessor="info.master",
orderable=False,
default="unknown")
nodes = Column(accessor="nodes.count", orderable=False)
vms = Column(accessor="virtual_machines.count",
verbose_name='VMs',
orderable=False)
class Meta:
empty_text = "No Clusters"
sequence = ("cluster", "description", "version", "hypervisor",
"master_node", "nodes", "vms")
order_by = ("cluster")
def render_hypervisor(self, value):
return hv_prettify(value)
class RollingAdTable(DashboardTable):
title = LinkColumn('dashboard:ad-rolling_ad-update', args=[A('pk')])
image = TemplateColumn(
verbose_name=_('Image'),
template_name='dashboard/ad/rolling_ad_row_image.html',
orderable=False)
link_url = URLColumn(verbose_name=_(u'链接地址'),
accessor='link_url',
orderable=False)
description = TemplateColumn(
verbose_name=_("Description"),
accessor='description',
orderable=False,
template_code='{{ record.description|default:""|striptags'
'|cut:" "|truncatewords:6 }}')
order_num = Column(verbose_name=_(u'顺序'),
accessor='order_num',
orderable=True)
valid = Column(verbose_name=_(u'开启'), accessor='valid', orderable=False)
actions = TemplateColumn(
verbose_name=_('Actions'),
template_name=
'dashboard/ad/rolling_ad_row_actions.html', #'dashboard/ad/rolling_ad_row_actions.html',
orderable=False)
icon = "sitemap"
class Meta(DashboardTable.Meta):
model = RollingAd
fields = ('title', 'position', 'image', 'link_url', 'order_num',
'description', 'valid')
sequence = ('title', 'position', 'image', 'link_url', 'order_num',
'description', 'valid', 'actions')
order_by = '-order_num'
class GroupTable(Table):
row_class = Column(visible=False,
empty_values=()) #used to highlight some rows
involvement = Column(empty_values=())
def render_row_class(self, value, record):
if record.status == Group.STB:
return 'info'
if record.status == Member.ACT:
return 'success'
def render_involvement(self, value):
try:
count = Affiliation.objects.values(group=value).count()
return unicode(count)
except:
return unicode('None')
class Meta:
model = Group
fields = (
'type',
'acronym',
'title',
'desc',
'involvement',
)
attrs = {"class": "table"}
class SDKApplicationTable(DashboardTable):
application_id = Column(verbose_name=_("Application ID"), orderable=False)
first_name = Column(verbose_name=_("First Name"), orderable=False)
last_name = Column(verbose_name=_("Last Name"), orderable=False)
application_status = Column(verbose_name=_("Status"), orderable=False)
prequal_details = TemplateColumn(
verbose_name=_("Pre-Qualification Details"),
template_name="wfrs/dashboard/_sdk_application_row_prequal_link.html",
orderable=False,
)
created_datetime = TZAwareDateTimeColumn(verbose_name=_("Created On"),
order_by="created_datetime",
format="D, N j Y, P")
modified_datetime = TZAwareDateTimeColumn(
verbose_name=_("Last Modified On"),
order_by="modified_datetime",
format="D, N j Y, P",
)
class Meta(DashboardTable.Meta):
sequence = (
"application_id",
"first_name",
"last_name",
"application_status",
"prequal_details",
"created_datetime",
"modified_datetime",
)
class ProductTable(Table):
title = TemplateColumn(
template_name='dashboard/catalogue/product_row_title.html',
order_by='title',
accessor=A('get_title'))
image = TemplateColumn(
template_name='dashboard/catalogue/product_row_image.html',
orderable=False)
product_class = Column(verbose_name=_("Type"),
accessor=A('get_product_class.name'),
order_by=('product_class__name'))
parent = LinkColumn('dashboard:catalogue-product',
verbose_name=_("Parent"),
args=[A('parent.pk')],
accessor=A('parent.title'))
children = Column(accessor=A('children.count'), orderable=False)
stock_records = Column(accessor=A('stockrecords.count'), orderable=False)
actions = TemplateColumn(
template_name='dashboard/catalogue/product_row_actions.html',
orderable=False)
class Meta(DashboardTable.Meta):
model = Product
fields = ('upc', 'date_created')
sequence = ('title', 'upc', 'image', 'product_class', 'parent',
'children', 'stock_records', '...', 'date_created',
'actions')
order_by = '-date_created'
class MeetingTable(Table):
row_class = Column(visible=False,
empty_values=()) #used to highlight some rows
totals = Column(verbose_name='Présents/Excusés', empty_values=())
details = Column(verbose_name='Détails', empty_values=())
def render_row_class(self, record):
if record.when < timezone.now():
return 'danger'
def render_totals(self, record):
return '{} / {}'.format(
Meeting_Attendance.objects.filter(meeting=record,
present=True).count(),
Meeting_Attendance.objects.filter(meeting=record,
present=False).count())
def render_details(self, record):
link = '<center><a class="btn btn-info btn-sm" href="/meetings/list/{}/"><i class="fa fa-list"></i></a></center>'.format(
escape(record.num))
return mark_safe(link)
class Meta:
model = Meeting
fields = (
'title',
'when',
'location',
'totals',
'details',
)
attrs = {"class": "table table-striped"}
class AllQuizTable(Table):
out_of = Column("Points", empty_values=())
immediate_solutions = Column("Solutions Visible", empty_values=())
class Meta:
model = Quiz
attrs = {'class': 'paleblue'}
exclude = ['id', '_cat_list']
def render_immediate_solutions(self, value, record):
return record.solutions_are_visible
def render_out_of(self, value, record):
return record.out_of
def render_cat_list(self, value, record):
return len(cat_list)
def render_tries(self, value, record):
# Returns the value or infinity if value is 0
return value or format_html('∞')
def render_name(self, value, record):
return format_html('<a href={}>{}</a>',
reverse('quiz_admin',
kwargs={'quiz_pk': record.pk,}
), value
)
class Meta(BaseTable.Meta):
"""Metaclass attributes of ConfigComplianceDeleteTable."""
device = Column(accessor="device__name", verbose_name="Device Name")
compliance = Column(accessor="compliance", verbose_name="Compliance")
model = models.ConfigCompliance
fields = ("device", "feature", "compliance")
class MeetingTable(Table):
row_class = Column(visible=False,
empty_values=()) #used to highlight some rows
totals = Column(verbose_name='Présents/Excusés', empty_values=())
details = Column(verbose_name='Détails', empty_values=())
def render_row_class(self, record):
if record.when < date.today():
return 'danger'
def render_totals(self, record):
return '{} / {}'.format(record.attendance.all().count(),
record.excused.all().count())
def render_details(self, record):
link = '<a class="btn btn-default btn-sm" href="/meetings/list/{}/"><span class="glyphicon glyphicon-list"></span></a>'.format(
escape(record.num))
return mark_safe(link)
class Meta:
model = Meeting
fields = (
'title',
'when',
'location',
'totals',
'details',
)
attrs = {"class": "table table-striped"}
class SeeAllMarksTable(Table):
last_name = Column(verbose_name="Last Name")
first_name = Column(verbose_name="First Name")
username = Column(verbose_name="UTORid")
number = Column(verbose_name="Student Number")
class Meta:
attrs = {'class': 'paleblue'}
row_attrs = {'data-active': lambda record: record.user.is_active}
class TournamentTable(CustomTable):
id = Column(linkify=True)
name = Column(linkify=True)
class Meta:
model = Tournament
fields = ('id', 'name', 'date', 'season', 'num_teams',
'num_novice_debaters')
class TrackingTable(Table):
type = Column()
date = Column()
user = Column()
description = Column()
tags = Column()
def render_tags(self, record):
return ', '.join((str(t) for t in record.tags.all()))
class TeamTable(CustomTable):
id = Column(linkify=True)
name = Column(linkify=True)
class Meta:
model = Team
fields = ('id',
'name',
'debaters_display')
