def put(self, ident): data = self.request.data entity = get_one(self.session, Entity, id=ident) # to ensure that the entity exists if 'parent_id' in data: get_one(self.session, Entity, id=data['parent_id']) entity.parent_id_fk = data['parent_id'] # add tags and meta for key in data: if 'tag_' in key: tag = get_one(self.session, EntityTag, entity=entity, tag_id_fk=key.split('_')[1]) tag.value = data[key] elif 'meta_' in key: meta = get_one(self.session, EntityMeta, entity=entity, meta_id_fk=key.split('_')[1]) meta.value = data[key] self.session.commit() update_last_data_modification_ts(self.session) return { 'success': True, 'ID': entity.id, }
def put(self, ident): data = self.request.data alert = get_one(self.session, Alert, id=ident) if 'entity_id' in data: entity = get_one(self.session, Entity, id=data['entity_id']) alert.entity_id_fk = entity.id if 'series_id' in data: series = get_one(self.session, SeriesAttribute, id=data['series_id']) alert.series_id_fk = series.id if 'alert_predicate_type' in data: alert.alert_predicate_type = data['alert_predicate_type'] if 'value' in data: alert.value = data['value'] if 'is_enabled' in data: alert.is_enabled = data['is_enabled'] if 'alert_recipient_email' in data: alert.alert_recipient_email = data['alert_recipient_email'] # reset last check status alert.last_check_status = None self.session.commit() return { 'success': True, 'ID': alert.id, }
def __enter__(self): self._session = Session() self._entity = get_one(self._session, Entity, id=self._entity_id) self._entity_measurement_names = {} for measurement_id in self._measurements: if measurement_id not in self._entity_measurement_names: measurement_name = get_one(self._session, SeriesAttribute, id=measurement_id).name self._entity_measurement_names[measurement_id] = measurement_name return self
def delete(self, entity_type_id, ident): entity_type = get_one(self.session, EntityType, id=entity_type_id) # check if route is correct meta = get_one(self.session, MetaAttribute, entity_type=entity_type, id=ident) now = time.time() meta.delete_ts = now for entity_meta in get_all(self.session, EntityMeta, attribute=meta): entity_meta.delete_ts = now self.session.commit() update_last_data_modification_ts(self.session) return {'success': True}
def get(self, entity_type_id, ident=None): entity_type = get_one(self.session, EntityType, id=entity_type_id) if ident is None: return [ series.to_dict() for series in get_all( self.session, SeriesAttribute, entity_type=entity_type) ] else: return get_one(self.session, SeriesAttribute, entity_type=entity_type, id=ident).to_dict()
def get(self, entity_type_id, ident=None): entity_type = get_one(self.session, EntityType, id=entity_type_id) if ident is None: return [ tag.to_dict() for tag in get_all( self.session, TagAttribute, entity_type=entity_type) ] else: return get_one(self.session, TagAttribute, entity_type=entity_type, id=ident).to_dict()
def test_put_updates_fields(self): result = get_handler(EntityHandler, { 'tag_1': 'tag_foo', 'meta_1': 'meta_foo' }).put(1) self.assertEqual({'success': True, 'ID': 1}, result) self.assertEqual(len(get_all(Session(), EntityTag)), 1) self.assertEqual(len(get_all(Session(), EntityMeta)), 1) self.assertEqual( get_one(Session(), EntityTag, entity_id_fk=1).value, 'tag_foo') self.assertEqual( get_one(Session(), EntityMeta, entity_id_fk=1).value, 'meta_foo')
def __init__(self, request_id: int, payload: dict): super().__init__(request_id, payload) self._last_data_timestamp = 0 session = Session() self._measurement = get_one(session, SeriesAttribute, id=self._raw_payload.measurement_id, exception_cls=ValueError) self._entity = get_one(session, Entity, id=self._raw_payload.node_id, exception_cls=ValueError) self._run_assertions()
def post(self): data = self.request.data entity = get_one(self.session, Entity, id=data['entity_id']) series = get_one(self.session, SeriesAttribute, id=data['series_id']) alert = Alert(entity=entity, series=series, alert_predicate_type=data['alert_predicate_type'], value=data['value'], is_enabled=data['is_enabled'], alert_recipient_email=data['alert_recipient_email']) self.session.add(alert) self.session.commit() return {'success': True, 'ID': alert.id}
def put(self, entity_type_id, ident): data = self.request.data entity_type = get_one(self.session, EntityType, id=entity_type_id) # check if route is correct meta = get_one(self.session, MetaAttribute, entity_type=entity_type, id=ident) if 'name' in data: meta.name = data['name'] self.session.commit() update_last_data_modification_ts(self.session) return { 'success': True, 'ID': meta.id, }
def delete(self, entity_type_id, ident): entity_type = get_one(self.session, EntityType, id=entity_type_id) # check if route is correct tag = get_one(self.session, TagAttribute, entity_type=entity_type, id=ident) now = time.time() tag.delete_ts = now for entity_tag in get_all(self.session, EntityTag, attribute=tag): entity_tag.delete_ts = now self.session.commit() update_last_data_modification_ts(self.session) return {'success': True}
def put(self, entity_type_id, ident): data = self.request.data entity_type = get_one(self.session, EntityType, id=entity_type_id) series = get_one(self.session, SeriesAttribute, entity_type=entity_type, id=ident) if 'refresh_time' in data: series.refresh_time = data['refresh_time'] if 'is_favourite' in data: series.is_favourite = data['is_favourite'] self.session.commit() update_last_data_modification_ts(self.session) return {'success': True, 'ID': series.id}
def delete(self, entity_type_id, ident): now = time.time() entity_type = get_one(self.session, EntityType, id=entity_type_id) # check if route is correct series = get_one(self.session, SeriesAttribute, entity_type=entity_type, id=ident) series.delete_ts = now for alert in series.alerts: alert.delete_ts = now self.session.commit() update_last_data_modification_ts(self.session) return {'success': True}
def post(self): data = self.request.data entity_type = get_one(self.session, EntityType, id=data['entity_type_id']) # check if we got all tags and meta tag_ids = sorted( int(key.split('_')[1]) for key in data if 'tag_' in key) meta_ids = sorted( int(key.split('_')[1]) for key in data if 'meta_' in key) self._assert_got_all_needed_tag_and_meta_ids(entity_type, tag_ids, meta_ids) entity = Entity( entity_type=entity_type, parent=None if data['parent_id'] is None else get_one( self.session, Entity, id=data['parent_id']), ) self.session.add(entity) # add tags and meta for key in data: if 'tag_' in key: self.session.add( EntityTag( entity=entity, attribute=get_one(self.session, TagAttribute, id=int(key.split('_')[1])), value=data[key], )) elif 'meta_' in key: self.session.add( EntityMeta( entity=entity, attribute=get_one(self.session, MetaAttribute, id=int(key.split('_')[1])), value=data[key], )) self.session.commit() update_last_data_modification_ts(self.session) return { 'success': True, 'ID': entity.id, }
def __init__(self, entity_id: int, aggregation_length: int, aggregation_type: str, measurement_id: int): super().__init__(entity_id, aggregation_length, aggregation_type) self._measurement_id = measurement_id self._measurement = get_one(Session(), SeriesAttribute, id=measurement_id)
def put(self, ident): data = self.request.data entity_type = get_one(self.session, EntityType, id=ident) if 'name' in data: entity_type.name = data['name'] # add tags, meta and series if 'tags' in data: for tag in data['tags']: self.session.add( TagAttribute( entity_type=entity_type, name=tag, )) if 'meta' in data: for meta in data['meta']: self.session.add( MetaAttribute( entity_type=entity_type, name=meta, )) if 'series' in data: for series in data['series']: self.session.add( SeriesAttribute( entity_type=entity_type, name=series, )) self.session.commit() update_last_data_modification_ts(self.session) return { 'success': True, 'ID': entity_type.id, }
def get(self, ident=None): if ident is None: return [ entity.to_dict(deep=False) for entity in get_all(self.session, Entity) ] else: return get_one(self.session, Entity, id=ident).to_dict(deep=False)
def delete(self, ident): alert = get_one(self.session, Alert, id=ident) now = time.time() alert.delete_ts = now self.session.commit() update_last_data_modification_ts(self.session) return {'success': True}
def get(self, ident=None): if ident is None: return [ entity_type.to_dict() for entity_type in get_all(self.session, EntityType) ] else: return get_one(self.session, EntityType, id=ident).to_dict()
def test_put_updates_name(self): result = get_handler(MetaAttributeHandler, { 'name': 'meta_foo' }).put(1, 1) self.assertEqual({'success': True, 'ID': 1}, result) self.assertEqual(len(get_all(Session(), MetaAttribute)), 4) self.assertEqual( get_one(Session(), MetaAttribute, id=1).name, 'meta_foo')
def test_delete_removes_object_and_dependants(self): result = get_handler(EntityTypeHandler).delete(1) self.assertEqual({'success': True}, result) self.assertEqual(len(get_all(Session(), EntityType)), 1) self.assertEqual(get_one(Session(), EntityType).id, 2) self.assertEqual(len(get_all(Session(), TagAttribute)), 1) self.assertEqual(len(get_all(Session(), SeriesAttribute)), 0) self.assertEqual(len(get_all(Session(), MetaAttribute)), 1) self.assertEqual(len(get_all(Session(), Entity)), 1)
def post(self, entity_type_id): data = self.request.data entity_type = get_one(self.session, EntityType, id=entity_type_id) tag = TagAttribute(entity_type=entity_type, name=data['name']) self.session.add(tag) self.session.commit() update_last_data_modification_ts(self.session) return {'success': True, 'ID': tag.id}
def post(self, entity_type_id): data = self.request.data entity_type = get_one(self.session, EntityType, id=entity_type_id) series = SeriesAttribute(entity_type=entity_type, name=data['name'], type=data.get('type', 'real'), refresh_time=data.get('refresh_time'), is_favourite=data.get('is_favourite', False)) self.session.add(series) self.session.commit() update_last_data_modification_ts(self.session) return {'success': True, 'ID': series.id}
def __init__(self, request_id: int, payload: dict): super().__init__(request_id, payload) session = Session() self._entity = get_one(session, Entity, id=self._raw_payload.node_id, exception_cls=ValueError) self._requested_data = [ create_measurement_handler(self._raw_payload.node_id, self._raw_payload.aggregation_length, self._raw_payload.aggregation_type, data) for data in self._raw_payload.requested_data ] self._run_assertions()
def delete(self, ident): entity = get_one(self.session, Entity, id=ident) now = time.time() entity.delete_ts = now for tag in entity.tags: tag.delete_ts = now for meta in entity.meta: meta.delete_ts = now for alert in entity.alerts: alert.delete_ts = now for child in entity.children: child.parent = entity.parent self.session.commit() update_last_data_modification_ts(self.session) return {'success': True}
def get(self, ident=None): if ident: # TODO this data is also cached, we can retrieve it from there mapped_measurements = { ser_attr.id: ser_attr.to_tree_dict() for ser_attr in get_all(self.session, SeriesAttribute) } tree_model = get_one(self.session, Entity, id=ident) return { "tree_metadata": tree_model.map_nodes(), "tree": tree_model.tree_structure_dict(), "measurements_metadata": mapped_measurements, "timestamp": get_last_data_modification_ts(self.session), } else: last_update_ts = get_last_data_modification_ts(self.session) if last_update_ts > self._cached_tree['timestamp']: self._update_cache() return self._cached_tree
def test_put_updates_name(self): result = get_handler(EntityTypeHandler, {'name': 'bar'}).put(1) self.assertEqual({'success': True, 'ID': 1}, result) self.assertEqual(len(get_all(Session(), EntityType)), 1) self.assertEqual(get_one(Session(), EntityType, id=1).name, 'bar')
def test_delete_non_leaf_changes_parent_id_of_children(self): result = get_handler(EntityHandler).delete(1) self.assertEqual({'success': True}, result) self.assertEqual(get_one(Session(), Entity, id=2).parent_id_fk, None)
def __init__(self, entity_id, filename): self._entity = get_one(Session(), Entity, id=entity_id) self._filename = filename
def get(self, ident=None): if ident is None: return [alert.to_dict() for alert in get_all(self.session, Alert)] else: return get_one(self.session, Alert, id=ident).to_dict()