def filters(self):
def get_label_name(name, column):
if not name:
for c in self.columns:
if c["key"] == str(column.expression) or c["expr"] == column:
name = c["name"]
break
else:
name = _("Unknown")
return name
def _get_type(type_, default=None):
import types
if isinstance(default, types.TypeType):
default = _TYPES.get(default.__name__)
else:
default = default or "text"
return _TYPES.get(type_, default)
filters = []
from flask.ext.report.utils import get_column_operator
for k, v in self._filters.items():
column, op_ = get_column_operator(k, self.columns, self.report_view)
default = None
try:
default = column.type.python_type
except NotImplementedError:
pass
except AttributeError:
default = "select"
result = {"name": get_label_name(v.get("name"), column), "col": k, "ops": v.get("operators"), 'shown': v.get('shown'),
"type": _get_type(v.get("value_type"), default), 'opts': [], 'proxy': False}
if hasattr(column, "property") and hasattr(column.property, "direction"):
def _iter_choices(column):
model = column.property.mapper.class_
from flask.ext.report.utils import get_primary_key
pk = get_primary_key(model)
for row in self.report_view.db.session.query(model):
yield getattr(row, pk), unicode(row)
result["opts"] = list(_iter_choices(column))
filters.append(result)
for k, f in self.proxy_filter_map.items():
filters.append({
'name': f.name,
'col': f.name,
'ops': f.operators,
'shown': f.shown,
'type': f.type,
'opts': f.options,
'proxy': True
})
return filters
def get_query(self, filters):
def get_operator(op):
return self.__special_chars[op]
query = self.query
from flask.ext.report.utils import get_column_operator
for filter_ in filters:
column, op_ = get_column_operator(filter_["col"], self.columns, self.report_view)
if op_ == "filter":
method_ = query.filter
elif op_ == "having":
method_ = query.having
if hasattr(column, "property") and hasattr(column.property, "direction"):
column = column.property.local_remote_pairs[0][1]
query = method_(get_operator(filter_["op"])(column, filter_["val"]))
return query
def query(self):
q = self.data_set.query
if self.filters:
from flask.ext.report.utils import get_column_operator
for name, params in self.filters.items():
column, op_ = get_column_operator(name, self.data_set.columns, self.report_view)
if hasattr(column, "property") and hasattr(column.property, "direction"):
column = column.property.local_remote_pairs[0][1]
if not isinstance(params, list):
params = [params]
for param in params:
operator_, value = self._get_operator_and_value(param)
if op_ == "filter":
q = q.filter(operator_(column, value))
elif op_ == "having":
q = q.having(operator_(column, value))
if self.literal_filter_condition is not None:
q = q.filter(self.literal_filter_condition)
all_columns = dict((c['name'], c) for c in self.data_set.columns)
return q
