def __init__(self, *args, **kwargs):
super(ToasterTable, self).__init__()
if 'template_name' in kwargs:
self.template_name = kwargs['template_name']
self.title = "Table"
self.queryset = None
self.columns = []
# map from field names to Filter instances
self.filter_map = TableFilterMap()
self.total_count = 0
self.static_context_extra = {}
self.empty_state = "Sorry - no data found"
self.default_orderby = ""
def __init__(self, *args, **kwargs):
super(ToasterTable, self).__init__()
if 'template_name' in kwargs:
self.template_name = kwargs['template_name']
self.title = "Table"
self.queryset = None
self.columns = []
# map from field names to Filter instances
self.filter_map = TableFilterMap()
self.total_count = 0
self.static_context_extra = {}
self.empty_state = "Sorry - no data found"
self.default_orderby = ""
class ToasterTable(TemplateView):
def __init__(self, *args, **kwargs):
super(ToasterTable, self).__init__()
if 'template_name' in kwargs:
self.template_name = kwargs['template_name']
self.title = "Table"
self.queryset = None
self.columns = []
# map from field names to Filter instances
self.filter_map = TableFilterMap()
self.total_count = 0
self.static_context_extra = {}
self.empty_state = "Sorry - no data found"
self.default_orderby = ""
# prevent HTTP caching of table data
@cache_control(must_revalidate=True,
max_age=0, no_store=True, no_cache=True)
def dispatch(self, *args, **kwargs):
return super(ToasterTable, self).dispatch(*args, **kwargs)
def get_context_data(self, **kwargs):
context = super(ToasterTable, self).get_context_data(**kwargs)
context['title'] = self.title
context['table_name'] = type(self).__name__.lower()
context['empty_state'] = self.empty_state
return context
def get(self, request, *args, **kwargs):
if request.GET.get('format', None) == 'json':
self.setup_queryset(*args, **kwargs)
# Put the project id into the context for the static_data_template
if 'pid' in kwargs:
self.static_context_extra['pid'] = kwargs['pid']
cmd = request.GET.get('cmd', None)
if cmd and 'filterinfo' in cmd:
data = self.get_filter_info(request, **kwargs)
else:
# If no cmd is specified we give you the table data
data = self.get_data(request, **kwargs)
return HttpResponse(data, content_type="application/json")
return super(ToasterTable, self).get(request, *args, **kwargs)
def get_filter_info(self, request, **kwargs):
self.setup_filters(**kwargs)
search = request.GET.get("search", None)
if search:
self.apply_search(search)
name = request.GET.get("name", None)
table_filter = self.filter_map.get_filter(name)
return json.dumps(table_filter.to_json(self.queryset),
indent=2,
cls=DjangoJSONEncoder)
def setup_columns(self, *args, **kwargs):
""" function to implement in the subclass which sets up
the columns """
pass
def setup_filters(self, *args, **kwargs):
""" function to implement in the subclass which sets up the
filters """
pass
def setup_queryset(self, *args, **kwargs):
""" function to implement in the subclass which sets up the
queryset"""
pass
def add_filter(self, table_filter):
"""Add a filter to the table.
Args:
table_filter: Filter instance
"""
self.filter_map.add_filter(table_filter.name, table_filter)
def add_column(self, title="", help_text="",
orderable=False, hideable=True, hidden=False,
field_name="", filter_name=None, static_data_name=None,
static_data_template=None):
"""Add a column to the table.
Args:
title (str): Title for the table header
help_text (str): Optional help text to describe the column
orderable (bool): Whether the column can be ordered.
We order on the field_name.
hideable (bool): Whether the user can hide the column
hidden (bool): Whether the column is default hidden
field_name (str or list): field(s) required for this column's data
static_data_name (str, optional): The column's main identifier
which will replace the field_name.
static_data_template(str, optional): The template to be rendered
as data
"""
self.columns.append({'title': title,
'help_text': help_text,
'orderable': orderable,
'hideable': hideable,
'hidden': hidden,
'field_name': field_name,
'filter_name': filter_name,
'static_data_name': static_data_name,
'static_data_template': static_data_template})
def set_column_hidden(self, title, hidden):
"""
Set the hidden state of the column to the value of hidden
"""
for col in self.columns:
if col['title'] == title:
col['hidden'] = hidden
break
def set_column_hideable(self, title, hideable):
"""
Set the hideable state of the column to the value of hideable
"""
for col in self.columns:
if col['title'] == title:
col['hideable'] = hideable
break
def render_static_data(self, template, row):
"""Utility function to render the static data template"""
context = {
'extra': self.static_context_extra,
'data': row,
}
context = Context(context)
template = Template(template)
return template.render(context)
def apply_filter(self, filters, filter_value, **kwargs):
"""
Apply a filter submitted in the querystring to the ToasterTable
filters: (str) in the format:
'<filter name>:<action name>'
filter_value: (str) parameters to pass to the named filter
<filter name> and <action name> are used to look up the correct filter
in the ToasterTable's filter map; the <action params> are set on
TableFilterAction* before its filter is applied and may modify the
queryset returned by the filter
"""
self.setup_filters(**kwargs)
try:
filter_name, action_name = filters.split(':')
action_params = unquote_plus(filter_value)
except ValueError:
return
if "all" in action_name:
return
try:
table_filter = self.filter_map.get_filter(filter_name)
action = table_filter.get_action(action_name)
action.set_filter_params(action_params)
self.queryset = action.filter(self.queryset)
except KeyError:
# pass it to the user - programming error here
raise
def apply_orderby(self, orderby):
# Note that django will execute this when we try to retrieve the data
self.queryset = self.queryset.order_by(orderby)
def apply_search(self, search_term):
"""Creates a query based on the model's search_allowed_fields"""
if not hasattr(self.queryset.model, 'search_allowed_fields'):
raise Exception("Search fields aren't defined in the model %s"
% self.queryset.model)
search_queries = None
for st in search_term.split(" "):
queries = None
for field in self.queryset.model.search_allowed_fields:
query = Q(**{field + '__icontains': st})
if queries:
queries |= query
else:
queries = query
if search_queries:
search_queries &= queries
else:
search_queries = queries
self.queryset = self.queryset.filter(search_queries)
def get_data(self, request, **kwargs):
"""
Returns the data for the page requested with the specified
parameters applied
filters: filter and action name, e.g. "outcome:build_succeeded"
filter_value: value to pass to the named filter+action, e.g. "on"
(for a toggle filter) or "2015-12-11,2015-12-12"
(for a date range filter)
"""
page_num = request.GET.get("page", 1)
limit = request.GET.get("limit", 10)
search = request.GET.get("search", None)
filters = request.GET.get("filter", None)
filter_value = request.GET.get("filter_value", "on")
orderby = request.GET.get("orderby", None)
nocache = request.GET.get("nocache", None)
# Make a unique cache name
cache_name = self.__class__.__name__
for key, val in request.GET.items():
if key == 'nocache':
continue
cache_name = cache_name + str(key) + str(val)
for key, val in kwargs.items():
cache_name = cache_name + str(key) + str(val)
# No special chars allowed in the cache name apart from dash
cache_name = re.sub(r'[^A-Za-z0-9-]', "", cache_name)
if nocache:
cache.delete(cache_name)
data = cache.get(cache_name)
if data:
logger.debug("Got cache data for table '%s'" % self.title)
return data
self.setup_columns(**kwargs)
if search:
self.apply_search(search)
if filters:
self.apply_filter(filters, filter_value, **kwargs)
if orderby:
self.apply_orderby(orderby)
paginator = Paginator(self.queryset, limit)
try:
page = paginator.page(page_num)
except EmptyPage:
page = paginator.page(1)
data = {
'total': self.queryset.count(),
'default_orderby': self.default_orderby,
'columns': self.columns,
'rows': [],
'error': "ok",
}
try:
for model_obj in page.object_list:
# Use collection to maintain the order
required_data = collections.OrderedDict()
for col in self.columns:
field = col['field_name']
if not field:
field = col['static_data_name']
if not field:
raise NoFieldOrDataName("Must supply a field_name or"
"static_data_name for column"
"%s.%s" %
(self.__class__.__name__, col)
)
# Check if we need to process some static data
if "static_data_name" in col and col['static_data_name']:
# Overwrite the field_name with static_data_name
# so that this can be used as the html class name
col['field_name'] = col['static_data_name']
try:
# Render the template given
required_data[col['static_data_name']] = \
self.render_static_data(
col['static_data_template'], model_obj)
except (TemplateSyntaxError,
VariableDoesNotExist) as e:
logger.error("could not render template code"
"%s %s %s",
col['static_data_template'],
e, self.__class__.__name__)
required_data[col['static_data_name']] =\
'<!--error-->'
else:
# Traverse to any foriegn key in the field
# e.g. recipe__layer_version__name
model_data = None
if "__" in field:
for subfield in field.split("__"):
if not model_data:
# The first iteration is always going to
# be on the actual model object instance.
# Subsequent ones are on the result of
# that. e.g. forieng key objects
model_data = getattr(model_obj,
subfield)
else:
model_data = getattr(model_data,
subfield)
else:
model_data = getattr(model_obj,
col['field_name'])
# We might have a model function as the field so
# call it to return the data needed
if isinstance(model_data, types.MethodType):
model_data = model_data()
required_data[col['field_name']] = model_data
data['rows'].append(required_data)
except FieldError:
# pass it to the user - programming-error here
raise
data = json.dumps(data, indent=2, cls=DjangoJSONEncoder)
cache.set(cache_name, data, 60*30)
return data
class ToasterTable(TemplateView):
def __init__(self, *args, **kwargs):
super(ToasterTable, self).__init__()
if 'template_name' in kwargs:
self.template_name = kwargs['template_name']
self.title = "Table"
self.queryset = None
self.columns = []
# map from field names to Filter instances
self.filter_map = TableFilterMap()
self.total_count = 0
self.static_context_extra = {}
self.empty_state = "Sorry - no data found"
self.default_orderby = ""
# prevent HTTP caching of table data
@cache_control(must_revalidate=True,
max_age=0,
no_store=True,
no_cache=True)
def dispatch(self, *args, **kwargs):
return super(ToasterTable, self).dispatch(*args, **kwargs)
def get_context_data(self, **kwargs):
context = super(ToasterTable, self).get_context_data(**kwargs)
context['title'] = self.title
context['table_name'] = type(self).__name__.lower()
context['empty_state'] = self.empty_state
return context
def get(self, request, *args, **kwargs):
if request.GET.get('format', None) == 'json':
self.setup_queryset(*args, **kwargs)
# Put the project id into the context for the static_data_template
if 'pid' in kwargs:
self.static_context_extra['pid'] = kwargs['pid']
cmd = request.GET.get('cmd', None)
if cmd and 'filterinfo' in cmd:
data = self.get_filter_info(request, **kwargs)
else:
# If no cmd is specified we give you the table data
data = self.get_data(request, **kwargs)
return HttpResponse(data, content_type="application/json")
return super(ToasterTable, self).get(request, *args, **kwargs)
def get_filter_info(self, request, **kwargs):
self.setup_filters(**kwargs)
search = request.GET.get("search", None)
if search:
self.apply_search(search)
name = request.GET.get("name", None)
table_filter = self.filter_map.get_filter(name)
return json.dumps(table_filter.to_json(self.queryset),
indent=2,
cls=DjangoJSONEncoder)
def setup_columns(self, *args, **kwargs):
""" function to implement in the subclass which sets up
the columns """
pass
def setup_filters(self, *args, **kwargs):
""" function to implement in the subclass which sets up the
filters """
pass
def setup_queryset(self, *args, **kwargs):
""" function to implement in the subclass which sets up the
queryset"""
pass
def add_filter(self, table_filter):
"""Add a filter to the table.
Args:
table_filter: Filter instance
"""
self.filter_map.add_filter(table_filter.name, table_filter)
def add_column(self,
title="",
help_text="",
orderable=False,
hideable=True,
hidden=False,
field_name="",
filter_name=None,
static_data_name=None,
static_data_template=None):
"""Add a column to the table.
Args:
title (str): Title for the table header
help_text (str): Optional help text to describe the column
orderable (bool): Whether the column can be ordered.
We order on the field_name.
hideable (bool): Whether the user can hide the column
hidden (bool): Whether the column is default hidden
field_name (str or list): field(s) required for this column's data
static_data_name (str, optional): The column's main identifier
which will replace the field_name.
static_data_template(str, optional): The template to be rendered
as data
"""
self.columns.append({
'title': title,
'help_text': help_text,
'orderable': orderable,
'hideable': hideable,
'hidden': hidden,
'field_name': field_name,
'filter_name': filter_name,
'static_data_name': static_data_name,
'static_data_template': static_data_template
})
def set_column_hidden(self, title, hidden):
"""
Set the hidden state of the column to the value of hidden
"""
for col in self.columns:
if col['title'] == title:
col['hidden'] = hidden
break
def set_column_hideable(self, title, hideable):
"""
Set the hideable state of the column to the value of hideable
"""
for col in self.columns:
if col['title'] == title:
col['hideable'] = hideable
break
def render_static_data(self, template, row):
"""Utility function to render the static data template"""
context = {
'extra': self.static_context_extra,
'data': row,
}
context = Context(context)
template = Template(template)
return template.render(context)
def apply_filter(self, filters, filter_value, **kwargs):
"""
Apply a filter submitted in the querystring to the ToasterTable
filters: (str) in the format:
'<filter name>:<action name>'
filter_value: (str) parameters to pass to the named filter
<filter name> and <action name> are used to look up the correct filter
in the ToasterTable's filter map; the <action params> are set on
TableFilterAction* before its filter is applied and may modify the
queryset returned by the filter
"""
self.setup_filters(**kwargs)
try:
filter_name, action_name = filters.split(':')
action_params = unquote_plus(filter_value)
except ValueError:
return
if "all" in action_name:
return
try:
table_filter = self.filter_map.get_filter(filter_name)
action = table_filter.get_action(action_name)
action.set_filter_params(action_params)
self.queryset = action.filter(self.queryset)
except KeyError:
# pass it to the user - programming error here
raise
def apply_orderby(self, orderby):
# Note that django will execute this when we try to retrieve the data
self.queryset = self.queryset.order_by(orderby)
def apply_search(self, search_term):
"""Creates a query based on the model's search_allowed_fields"""
if not hasattr(self.queryset.model, 'search_allowed_fields'):
raise Exception("Search fields aren't defined in the model %s" %
self.queryset.model)
search_queries = None
for st in search_term.split(" "):
queries = None
for field in self.queryset.model.search_allowed_fields:
query = Q(**{field + '__icontains': st})
if queries:
queries |= query
else:
queries = query
if search_queries:
search_queries &= queries
else:
search_queries = queries
self.queryset = self.queryset.filter(search_queries)
def get_data(self, request, **kwargs):
"""
Returns the data for the page requested with the specified
parameters applied
filters: filter and action name, e.g. "outcome:build_succeeded"
filter_value: value to pass to the named filter+action, e.g. "on"
(for a toggle filter) or "2015-12-11,2015-12-12"
(for a date range filter)
"""
page_num = request.GET.get("page", 1)
limit = request.GET.get("limit", 10)
search = request.GET.get("search", None)
filters = request.GET.get("filter", None)
filter_value = request.GET.get("filter_value", "on")
orderby = request.GET.get("orderby", None)
nocache = request.GET.get("nocache", None)
# Make a unique cache name
cache_name = self.__class__.__name__
for key, val in request.GET.items():
if key == 'nocache':
continue
cache_name = cache_name + str(key) + str(val)
for key, val in kwargs.items():
cache_name = cache_name + str(key) + str(val)
# No special chars allowed in the cache name apart from dash
cache_name = re.sub(r'[^A-Za-z0-9-]', "", cache_name)
if nocache:
cache.delete(cache_name)
data = cache.get(cache_name)
if data:
logger.debug("Got cache data for table '%s'" % self.title)
return data
self.setup_columns(**kwargs)
if search:
self.apply_search(search)
if filters:
self.apply_filter(filters, filter_value, **kwargs)
if orderby:
self.apply_orderby(orderby)
paginator = Paginator(self.queryset, limit)
try:
page = paginator.page(page_num)
except EmptyPage:
page = paginator.page(1)
data = {
'total': self.queryset.count(),
'default_orderby': self.default_orderby,
'columns': self.columns,
'rows': [],
'error': "ok",
}
try:
for model_obj in page.object_list:
# Use collection to maintain the order
required_data = collections.OrderedDict()
for col in self.columns:
field = col['field_name']
if not field:
field = col['static_data_name']
if not field:
raise NoFieldOrDataName("Must supply a field_name or"
"static_data_name for column"
"%s.%s" %
(self.__class__.__name__, col))
# Check if we need to process some static data
if "static_data_name" in col and col['static_data_name']:
# Overwrite the field_name with static_data_name
# so that this can be used as the html class name
col['field_name'] = col['static_data_name']
try:
# Render the template given
required_data[col['static_data_name']] = \
self.render_static_data(
col['static_data_template'], model_obj)
except (TemplateSyntaxError,
VariableDoesNotExist) as e:
logger.error(
"could not render template code"
"%s %s %s", col['static_data_template'], e,
self.__class__.__name__)
required_data[col['static_data_name']] =\
'<!--error-->'
else:
# Traverse to any foriegn key in the field
# e.g. recipe__layer_version__name
model_data = None
if "__" in field:
for subfield in field.split("__"):
if not model_data:
# The first iteration is always going to
# be on the actual model object instance.
# Subsequent ones are on the result of
# that. e.g. forieng key objects
model_data = getattr(model_obj, subfield)
else:
model_data = getattr(model_data, subfield)
else:
model_data = getattr(model_obj, col['field_name'])
# We might have a model function as the field so
# call it to return the data needed
if isinstance(model_data, types.MethodType):
model_data = model_data()
required_data[col['field_name']] = model_data
data['rows'].append(required_data)
except FieldError:
# pass it to the user - programming-error here
raise
data = json.dumps(data, indent=2, cls=DjangoJSONEncoder)
cache.set(cache_name, data, 60 * 30)
return data
