def _from_row(owner_id, dashboard_id, row):
res = Layout()
res.layout_dict = dict(serialize.json_loads(row['layout_def']))
res.layout_props = serialize.json_loads(row['layout_props']) if row['layout_props'] \
else {'by_tile_id': {}}
res.layout_props['by_tile_id'] = dict(res.layout_props['by_tile_id'])
res.owner_id = owner_id
res.dashboard_id = dashboard_id
res.layout_id = row['layout_id']
return res
def select(owner_id, dashboard_id):
"""Selects the :class:`Layout` associated with the dashboard"""
row = c.dao.LayoutDAO.select(owner_id, dashboard_id)
if not row:
return None
res = Layout()
res.layout_dict = dict(serialize.json_loads(row['layout_def']))
res.layout_props = serialize.json_loads(row['layout_props']) if row['layout_props'] \
else {'by_tile_id': {}}
res.layout_props['by_tile_id'] = dict(res.layout_props['by_tile_id'])
res.owner_id = owner_id
res.dashboard_id = dashboard_id
res.layout_id = row['layout_id']
return res
def select_default_series_spec_options(report_id, series_spec_list):
"""Return default options for a list of :class:`SeriesSpec` objects
as a list of dictionaries with the keys:
* ``name`` - the suggested name of the series
* ``color`` - the suggested color of the series
"""
assert isinstance(series_spec_list, list)
series_spec_vals = [
serialize.mjson(series_spec_for_default_options(ss))
for ss in series_spec_list
]
series_spec_val_to_idxs = defaultdict(list)
for i, ssv in enumerate(series_spec_vals):
series_spec_val_to_idxs[ssv].append(i)
res = [{} for _ in xrange(len(series_spec_list))]
options_list = c.dao.OptionsDAO.select_multi(report_id, 'SeriesSpec',
series_spec_vals)
for series_spec_raw, default_options_raw in options_list:
for idx in series_spec_val_to_idxs[series_spec_raw]:
if default_options_raw:
res[idx] = serialize.json_loads(default_options_raw)
return res
def test_custom_types(self):
d = {
'id': uuid.uuid1(),
'id2': uuid.uuid4(),
'dt': datetime.datetime.utcnow(),
'da': datetime.datetime.utcnow(),
'ss': SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
}
self.assertEqual(d, serialize.json_loads(serialize.mjson(d)))
dt = datetime.datetime.utcnow()
self.assertEqual(util.datetime_from_date(dt.date()),
serialize.json_loads(serialize.mjson(dt.date())))
ext_d = json.loads(
serialize.json_dumps_external(util.dictwithout(d, 'ss')))
self.assertEqual(d['id2'].hex, ext_d['id2'])
def __get__(self, obj, objtype):
if not hasattr(obj, self.json_value_prop):
raw_val = obj[self.column]
if raw_val is None:
setattr(obj, self.json_value_prop, self.default())
else:
setattr(obj, self.json_value_prop, serialize.json_loads(raw_val))
return getattr(obj, self.json_value_prop)
def parse_json(s):
if not s or not s.strip():
return None
try:
return serialize.json_loads(s)
except:
raise responses.ExceptionalResponse.bad_request(
'Invalid json value <%s>' % s)
def select_all_dashboards_ordering(self, owner_id):
current_ordering_raw = c.cass.execute_fst(
"""SELECT dashboard_id_ordering
FROM mqe.all_dashboards_properties
WHERE owner_id=?""",
[owner_id])['dashboard_id_ordering']
if current_ordering_raw:
return serialize.json_loads(current_ordering_raw)
return None
def update_default_options(tile):
"""Include the tile's :data:`tile_options` in a pool of default options belonging
to the owner of the tile"""
series_specs = tile.series_specs()
if not series_specs:
return
old_options_list = c.dao.OptionsDAO.select_multi(
tile.report_id, 'SeriesSpec', [
serialize.mjson(series_spec_for_default_options(ss))
for ss in series_specs
])
default_options_by_ss = {}
for ss_do_raw, options_raw in old_options_list:
ss_do = series_spec_for_default_options(
serialize.json_loads(ss_do_raw))
default_options_by_ss[ss_do] = serialize.json_loads(options_raw)
colors = tile.tile_options.get('colors')
to_set = []
for i, ss in enumerate(series_specs):
ss_do = series_spec_for_default_options(ss)
old_options = default_options_by_ss.get(ss_do, {})
new_options = {}
name = ss.params.get('name')
if name:
new_options['name'] = name
color = util.safeget(colors, i)
if color:
new_options['color'] = color
if old_options.get('color') and not new_options.get('color'):
new_options['color'] = old_options['color']
if old_options != new_options:
to_set.append(
(serialize.mjson(ss_do), serialize.mjson(new_options)))
if to_set:
c.dao.OptionsDAO.set_multi(tile.report_id, 'SeriesSpec', to_set)
log.debug('Updated default options from tile %s', tile)
def select_all_dashboards_ordering(self, owner_id):
with cursor() as cur:
cur.execute(
"""SELECT dashboard_id_ordering
FROM all_dashboards_properties
WHERE owner_id=?""", [owner_id])
row = cur.fetchone()
if row:
return serialize.json_loads(row['dashboard_id_ordering'])
return None
def update_user_data(self, d):
"""Update the ``mqe.user.user_data`` column holding a custom JSON-serializable dictionary.
The ``d`` is a dictionary which items will be assigned to the ``user_data`` dictionary.
"""
assert isinstance(d, dict)
row = c.dao.UserDAO.select(self.user_id)
user_data = serialize.json_loads(row['user_data'])
user_data.update(d)
c.dao.UserDAO.update_user_data(self.user_id,
serialize.mjson(user_data))
self['user_data'] = serialize.mjson(user_data)
# clear cached value
del self.user_data
def test_registering_custom_class(self):
@serialize.json_type('A')
class A(object):
def __init__(self):
self.a = 10
def for_json(self):
return {'a': self.a}
@classmethod
def from_rawjson(cls, x):
return A()
doc = serialize.json_loads(serialize.json_dumps({'obj': A()}))
self.assertIsInstance(doc['obj'], A)
def get_tile_data(self, limit=None):
"""Called by :meth:`~mqe.tiles.Tile.get_tile_data`"""
data = {}
data['report_name'] = self.tile.report.report_name
data['latest_extra_ri_data'] = {}
latest_rid = self.tile.report.fetch_latest_instance_id(
self.tile_options['tags'])
if latest_rid is not None:
latest_extra_ri_data = c.dao.ReportInstanceDAO.select_extra_ri_data(
self.tile.report_id, latest_rid)
if latest_extra_ri_data:
data['latest_extra_ri_data'] = serialize.json_loads(
latest_extra_ri_data)
data['series_data'] = []
self.fill_tile_data(data, limit=limit)
if data['series_data']:
data['common_header'] = util.common_value(
sd['common_header'] for sd in data['series_data']
if sd.get('data_points'))
data['generated_tile_title'] = self.generate_tile_title(data)
data[
'generated_tile_title_postfix'] = self.generate_tile_title_postfix(
)
self._set_combined_colors(data)
drawer = create_drawer(self)
drawer.process_tile_data(data)
drawer.process_full_tile_data(data)
return data
def desc(self, expand_content, expand_input=False):
"""Returns a dictionary describing the instance, containing at least ``id``, ``tags`` and
``created`` keys.
:param bool expand_content: whether to include ``rows`` and ``header`` in the result
:param bool expand_input: whether to include user input string under ``input`` key
"""
d = OrderedDict()
d['id'] = self.report_instance_id.hex
d['tags'] = self.all_tags
d['created'] = self.created.isoformat()
if expand_content:
if self.table is not None:
d['rows'] = self._raw_rows_result(self.table.rows)
d['header'] = self.table.header_idxs
else:
d['rows'] = []
d['header'] = []
if expand_input:
if self.parsing_result_desc.get('input_is_json'):
d['input'] = serialize.json_loads(self['input_string'])
else:
d['input'] = self['input_string']
return d
def set(self, owner_id=None, dashboard_id=None, old_layout_id=None):
"""Set a new layout definition for the dashboard (replacing the existing one), using
the current content of the :attr:`layout_dict`. The parameters are optional - if not
specified, the current values of :attr:`owner_id`, :attr:`dashboard_id` and
:attr:`layout_id` are used.
:param owner_id: the owner ID of the dashboard
:param dashboard_id: the dashboard's ID
:param old_layout_id: ``None`` if this should be a new layout definition
for the dashboard, ``layout_id`` of the existing layout otherwise
:return: a ``layout_id`` of a newly set layout if the operation was successful,
``None`` otherwise (ie. when the passed ``old_layout_id`` didn't match the
version in the database)
"""
owner_id = owner_id or self.owner_id
if not owner_id:
raise ValueError('owner_id not set in Layout and not passed as an argument')
dashboard_id = dashboard_id or self.dashboard_id
if not dashboard_id:
raise ValueError('dashboard_id not set in Layout and not passed as an argument')
old_layout_id = old_layout_id or self.layout_id
# a layout def is a layout_dict serialized as a list of items. The list is
# sorted by tile creation time (but this assumption should not be generally made).
new_layout_def = serialize.mjson(sorted(self.layout_dict.items(),
key=lambda (tile_id, vo): tile_id.time))
# Merge old layout_props with new data
old_layout_props_row = c.dao.LayoutDAO.select(owner_id, dashboard_id, ['layout_props'])
if not old_layout_props_row and old_layout_id:
return None
if old_layout_props_row and old_layout_props_row['layout_props']:
old_layout_props = serialize.json_loads(old_layout_props_row['layout_props'])
else:
old_layout_props = {'by_tile_id': []}
by_tile_id = {}
old_by_tile_id = dict(old_layout_props['by_tile_id'])
tile_ids_to_fetch = []
for tile_id in self.layout_dict:
if tile_id in old_by_tile_id:
by_tile_id[tile_id] = old_by_tile_id[tile_id]
elif tile_id in self._included_tiles:
by_tile_id[tile_id] = self.props_of_tile(self._included_tiles[tile_id])
else:
tile_ids_to_fetch.append(tile_id)
tile_dict = Tile.select_multi(dashboard_id, tile_ids_to_fetch)
for tile_id, tile in tile_dict.items():
by_tile_id[tile.tile_id] = self.props_of_tile(tile)
# Compute data for sscreator and tpcreator
sscs_data = set()
master_data = set()
for props in by_tile_id.values():
if props.get('sscs'):
#sscs_data.add((props['report_id'], tuple(props['tags'])))
sscs_data.add(props['report_id'])
if props.get('is_master'):
master_data.add(props['report_id'])
new_layout_props = serialize.mjson({'by_tile_id': by_tile_id.items()})
# Set the new layout
new_layout_id = gen_timeuuid()
res = c.dao.LayoutDAO.set(owner_id, dashboard_id, old_layout_id, new_layout_id,
new_layout_def, new_layout_props)
if not res:
log.info('Setting new layout failed')
return None
# Insert layout_by_report for sscs and tpcreator
c.dao.LayoutDAO.insert_layout_by_report_multi(owner_id, sscs_data, [], 'sscs',
dashboard_id, new_layout_id)
c.dao.LayoutDAO.insert_layout_by_report_multi(owner_id, master_data, [], 'tpcreator',
dashboard_id, new_layout_id)
self.layout_id = new_layout_id
return new_layout_id
def value(self):
if self.value_raw is not undefined:
self.value_py = json_loads(self.value_raw)
if self.value_py is not undefined:
return self.value_py
raise ValueError('No value set for DataPoint')
def fetch_extra_ri_data(self):
"""Fetch the ``extra_ri_data`` passed to :meth:`.process_input` - a custom JSON document"""
raw_res = c.dao.ReportInstanceDAO.select_extra_ri_data(
self.report_id, self.report_instance_id)
return serialize.json_loads(raw_res) if raw_res is not None else None
