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())
