def _delete(cls, token, entity, parameters=None, ids={}): # pragma: no cover if isinstance(entity, integer_types) or isinstance(entity, float_types): ids['id'] = entity response = cls.REST_CLIENT.delete( cls.get_base_uri(cls.endpoint_single(), **ids), headers=make_headers(token), params=parameters ) elif isinstance(entity, BaseAbstractEntity): entity_id = getattr(entity, 'id', None) ids['id'] = entity_id response = cls.REST_CLIENT.delete( cls.get_base_uri(cls.endpoint_single(), **ids), headers=make_headers(token), params=parameters ) else: response = cls.REST_CLIENT.delete( cls.get_base_uri(cls.endpoint_single(), **ids), headers=make_headers(token), params=parameters ) response = cls.REST_CLIENT.handle_response(response) if response is None: return entity if cls.entity_class() is None or not issubclass(cls.entity_class(), BaseAbstractEntity): return response # pragma: no cover else: try: return cls.entity_class().from_dict(response.json()) except ValueError: return response # pragma: no cover
def multi_lookup(cls, token, entity_ids, expand=False, parameters=None): if parameters is None: parameters = {} parameters['expand'] = expand ids = [] for entity_id in entity_ids: ids.append(cls.get_entity_id(entity_id, ReverseLookup)) response = cls.REST_CLIENT.post( cls.get_base_uri(cls.endpoint()), json=ids, headers=make_headers(token), params=parameters ) response = cls.REST_CLIENT.handle_response(response) # handle response r = response.json() lookups = [] for lookup in r.get('lookups', []): lookups.append(ReverseLookup.from_dict(lookup)) errors = {} for entity_id, error in r.get('errorIds', {}).items(): errors[long_(entity_id)] = HttpError.from_dict(error) return MultiReverseLookup(lookups=lookups, error_ids=errors)
def rollup_date(cls, token, rollup_updates, parameters=None): cls.validate_is_entity(rollup_updates, array_types) for rollup_update in rollup_updates: cls.validate_is_entity(rollup_update, RollupUpdate) response = cls.REST_CLIENT.post( cls.get_base_uri(cls.endpoint_rollup()), data=collection_to_json(rollup_updates), headers=make_headers(token), params=parameters) response = cls.REST_CLIENT.handle_response(response) response = response.json() errors = [] for e in response.get('errors', []): http_error = HttpError.from_dict(e) rollup_update = RollupUpdate.from_dict(e.get('rollupUpdate', {})) errors.append( RollupUpdateError(rollup=rollup_update, error_code=http_error.error_code, error_message=http_error.error_message)) rollups = {} for point_id, ru in response.get('rollupUpdates', {}).items(): if point_id not in rollups: rollups[long_(point_id)] = [] for r in ru: rollup = RollupUpdate.from_dict(r) rollup.point_id = long_(point_id) rollups[long_(point_id)].append(rollup) return RollupUpdateResponse(rollup_updates=rollups, errors=errors)
def update_sitegroup_view_config(cls, token, sitegroup_id, view_config, parameters=None): sitegroup_id = cls.get_entity_id(sitegroup_id, SiteGroup) cls.validate_is_entity(view_config, SiteGroupViewConfig) for summary in view_config.summaries: cls.validate_is_entity(summary, SiteGroupSummary) ids = {'id': sitegroup_id} response = cls.REST_CLIENT.put(cls.get_base_uri( cls.endpoint_extra('/meta/viewconfig'), **ids), json=view_config.get_json_data(), headers=make_headers(token), params=parameters) response = cls.REST_CLIENT.handle_response(response) summaries = response.json().get('summaries', []) if isinstance(summaries, array_types): results = [] for r in summaries: if isinstance(r, dict): results.append(SiteGroupSummary.from_dict(r)) else: results = [SiteGroupSummary.from_dict(response.json())] return SiteGroupViewConfig(summaries=results)
def retrieve_data(cls, token, point_ids, start=None, end=None, limit=None, offset=None, order=None, parameters=None): cls.validate_is_entity(point_ids, array_types) if parameters is None: parameters = {} ids = [] for point_id in point_ids: ids.append(cls.get_entity_id(point_id, Point)) if start is not None: if isinstance(start, integer_types) or isinstance(start, datetime): parameters['start'] = datetime_to_ms(start) if end is not None: if isinstance(end, integer_types) or isinstance(end, datetime): parameters['end'] = datetime_to_ms(end) if limit is not None and isinstance(limit, integer_types) and limit > 0: parameters['limit'] = limit if offset is not None and isinstance(offset, integer_types) and offset > 0: parameters['offset'] = offset if order in [DataOrdering.DESCENDING, DataOrdering.ASCENDING]: parameters['order'] = order response = cls.REST_CLIENT.post(cls.get_base_uri( cls.endpoint_retrieve()), json={'pointIds': ids}, headers=make_headers(token), params=parameters) response = cls.REST_CLIENT.handle_response(response) response = response.json() errors = [] for e in response.get('errors', []): errors.append(DataRetrieveError.from_dict(e)) observations = {} for point_id, obs in response.get('observations', {}).items(): if point_id not in observations: observations[long_(point_id)] = [] for o in obs: observation = Observation.from_dict(o) observation.point_id = long_(point_id) observations[long_(point_id)].append(observation) return DataRetrieveResponse(observations=observations, errors=errors)
def get_site_ids_in_sitegroup(cls, token, sitegroup_id, parameters=None): sitegroup_id = cls.get_entity_id(sitegroup_id, SiteGroup) ids = {'id': sitegroup_id} response = cls.REST_CLIENT.get(cls.get_base_uri( cls.endpoint_extra('/sites/rel'), **ids), headers=make_headers(token), params=parameters) response = cls.REST_CLIENT.handle_response(response) return response.json()
def get_all_subject_notification_settings_of_sitegroup( cls, token, sitegroup_id, parameters=None): sitegroup_id = cls.get_entity_id(sitegroup_id, SiteGroup) ids = {'id': sitegroup_id} response = cls.REST_CLIENT.get(cls.get_base_uri( cls.endpoint_extra('/subjects/rel/notifications'), **ids), headers=make_headers(token), params=parameters) response = cls.REST_CLIENT.handle_response(response) return SiteGroupNotificationResponse.from_dict(response.json())
def delete_sitegroup_view_config(cls, token, sitegroup_id, parameters=None): sitegroup_id = cls.get_entity_id(sitegroup_id, SiteGroup) ids = {'id': sitegroup_id} response = cls.REST_CLIENT.delete(cls.get_base_uri( cls.endpoint_extra('/meta/viewconfig'), **ids), headers=make_headers(token), params=parameters) response = cls.REST_CLIENT.handle_response(response) return response
def lookup(cls, token, entity_id, expand=False, parameters=None): if parameters is None: parameters = {} parameters['id'] = cls.get_entity_id(entity_id, ReverseLookup) parameters['expand'] = expand response = cls.REST_CLIENT.get( cls.get_base_uri(cls.endpoint_single()), headers=make_headers(token), params=parameters ) response = cls.REST_CLIENT.handle_response(response) return ReverseLookup.from_dict(response.json())
def remove_site_from_sitegroup(cls, token, sitegroup_id, site_id, parameters=None): sitegroup_id = cls.get_entity_id(sitegroup_id, SiteGroup) site_id = cls.get_entity_id(site_id, Site) ids = {'id': sitegroup_id, 'site_id': site_id} response = cls.REST_CLIENT.delete(cls.get_base_uri( cls.endpoint_extra('/sites/rel/{site_id}'), **ids), headers=make_headers(token), params=parameters) response = cls.REST_CLIENT.handle_response(response) return response
def replay_data(cls, token, point_ids, start=None, end=None, limit=None, offset=None, parameters=None): cls.validate_is_entity(point_ids, array_types) if parameters is None: parameters = {} ids = [] for point_id in point_ids: ids.append(cls.get_entity_id(point_id, Point)) if start is not None: if isinstance(start, integer_types) or isinstance(start, datetime): parameters['start'] = datetime_to_ms(start) if end is not None: if isinstance(end, integer_types) or isinstance(end, datetime): parameters['end'] = datetime_to_ms(end) if limit is not None and isinstance(limit, integer_types) and limit > 0: parameters['limit'] = limit if offset is not None and isinstance(offset, integer_types) and offset > 0: parameters['offset'] = offset response = cls.REST_CLIENT.post(cls.get_base_uri( cls.endpoint_replay()), json={'pointIds': ids}, headers=make_headers(token), params=parameters) response = cls.REST_CLIENT.handle_response(response) response = response.json() errors = [] for e in response.get('errors', []): errors.append(DataRetrieveError.from_dict(e)) return DataRetrieveResponse(errors=errors, observations={})
def _retrieve_all(cls, token, parameters=None, ids={}): # pragma: no cover make_default_offset_limit(parameters) response = cls.REST_CLIENT.get( cls.get_base_uri(cls.endpoint(), **ids), headers=make_headers(token), params=parameters ) response = cls.REST_CLIENT.handle_response(response) if cls.entity_class() is None or not issubclass(cls.entity_class(), BaseAbstractEntity): return response # pragma: no cover else: response_json = response.json() if isinstance(response_json, array_types): results = [] for r in response_json: if isinstance(r, dict): results.append(cls.entity_class().from_dict(r)) return results else: return cls.entity_class().from_dict(response.json())
def delete_data(cls, token, observations, parameters=None): cls.validate_is_entity(observations, array_types) for observation in observations: cls.validate_is_entity(observation, Observation) response = cls.REST_CLIENT.post(cls.get_base_uri( cls.endpoint_delete()), data=collection_to_json(observations), headers=make_headers(token), params=parameters) response = cls.REST_CLIENT.handle_response(response) errors = response.json().get('errors', []) e = [] for error in errors: http_error = HttpError.from_dict(error) observation = Observation.from_dict(error.get('observation', {})) e.append( DataModificationError(observation=observation, error_code=http_error.error_code, error_message=http_error.error_message)) return DataModificationResponse(errors=e)
def on_demand_set_options(cls, token, site_id, asset_id, point_id, control_point_id, parameters=None): site_id = cls.get_entity_id(site_id, Site) asset_id = cls.get_entity_id(asset_id, Asset) point_id = cls.get_entity_id(point_id, Point) control_point_id = cls.get_entity_id(control_point_id, ControlPoint) response = cls.REST_CLIENT.options(cls.get_base_uri( cls.endpoint_set_point_change(), site_id=site_id, asset_id=asset_id, point_id=point_id, id=control_point_id), headers=make_headers(token), params=parameters) cls.REST_CLIENT.handle_response(response) return response.headers.get('Allow', 'OPTIONS').split(',')
def on_demand_read(cls, token, site_id, asset_id, point_id, control_point_id, parameters=None): site_id = cls.get_entity_id(site_id, Site) asset_id = cls.get_entity_id(asset_id, Asset) point_id = cls.get_entity_id(point_id, Point) control_point_id = cls.get_entity_id(control_point_id, ControlPoint) response = cls.REST_CLIENT.post(cls.get_base_uri( cls.endpoint_on_demand_read(), site_id=site_id, asset_id=asset_id, point_id=point_id, id=control_point_id), headers=make_headers(token), params=parameters) cls.REST_CLIENT.handle_response(response) return ControlAudit.from_dict(response.json())
def assign_subject_to_sitegroup(cls, token, sitegroup_id, subject_id, notification_setting, parameters=None): if parameters is None: parameters = {} sitegroup_id = cls.get_entity_id(sitegroup_id, SiteGroup) subject_id = cls.get_entity_id(subject_id, Subject) cls.validate_is_entity(notification_setting, SiteGroupNotificationSetting) parameters['notifySms'] = notification_setting.notify_sms or False parameters['notifyEmail'] = notification_setting.notify_email or False ids = {'id': sitegroup_id, 'subject_id': subject_id} response = cls.REST_CLIENT.post(cls.get_base_uri( cls.endpoint_extra('/subjects/rel/{subject_id}'), **ids), headers=make_headers(token), params=parameters) response = cls.REST_CLIENT.handle_response(response) return response
def on_demand_set(cls, token, site_id, asset_id, point_id, control_point_id, set_point_request, parameters=None): site_id = cls.get_entity_id(site_id, Site) asset_id = cls.get_entity_id(asset_id, Asset) point_id = cls.get_entity_id(point_id, Point) control_point_id = cls.get_entity_id(control_point_id, ControlPoint) cls.validate_is_entity(set_point_request, SetPointRequest) response = cls.REST_CLIENT.post(cls.get_base_uri( cls.endpoint_set_point_change(), site_id=site_id, asset_id=asset_id, point_id=point_id, id=control_point_id), json=set_point_request.get_json_data(), headers=make_headers(token), params=parameters) cls.REST_CLIENT.handle_response(response) return ControlAudit.from_dict(response.json())
def impersonate(cls, token, tenant_id=None, subject_id=None, role=None, expires=True, parameters=None): data = {'expires': expires} if tenant_id is not None and role is not None: data['tenantId'] = tenant_id data['role'] = role elif subject_id is not None: data['subjectId'] = subject_id else: raise InvalidInputException( 422, "Must provide either tenant_id and role OR subject_id") response = cls.REST_CLIENT.post(cls.get_base_uri(cls.ENDPOINT), data=data, headers=make_headers(token), params=parameters) response = cls.REST_CLIENT.handle_response(response) return Token(jwt=response.json()['token'])
def _partial_update(cls, token, entity, parameters=None, ids={}): # pragma: no cover entity_id = getattr(entity, 'id', None) if entity_id is not None: ids['id'] = entity_id if isinstance(entity, BaseAbstractEntity): response = cls.REST_CLIENT.patch( cls.get_base_uri(cls.endpoint_single(), **ids), json=entity.get_json_data(), headers=make_headers(token), params=parameters ) else: response = cls.REST_CLIENT.patch( cls.get_base_uri(cls.endpoint_single(), **ids), data=json.dumps(entity), headers=make_headers(token), params=parameters ) response = cls.REST_CLIENT.handle_response(response) if cls.entity_class() is None or not issubclass(cls.entity_class(), BaseAbstractEntity): return response # pragma: no cover else: return cls.entity_class().from_dict(response.json())
def filter_fetch_assets(): response = cls.REST_CLIENT.get(cls.get_base_uri(cls.endpoint()), headers=make_headers(token), params=parameters) cls.REST_CLIENT.handle_response(response=response) return json_collection_to_entity_collection(response.json(), Asset)
def _create(cls, token, entity, parameters=None, ids={}): # pragma: no cover if isinstance(entity, BaseAbstractEntity): response = cls.REST_CLIENT.post( cls.get_base_uri(cls.endpoint(), **ids), json=entity.get_json_data(), headers=make_headers(token), params=parameters ) else: response = cls.REST_CLIENT.post( cls.get_base_uri(cls.endpoint(), **ids), data=json.dumps(entity), headers=make_headers(token), params=parameters ) response = cls.REST_CLIENT.handle_response(response) if cls.entity_class() is None or not issubclass(cls.entity_class(), BaseAbstractEntity): return response # pragma: no cover else: return cls.entity_class().from_dict(response.json())