def delete_codec():
delete_ids = get_delete_ids()
query_results = Codec.query.filter(Codec.id.in_(delete_ids)).many()
try:
for codec in query_results:
db.session.delete(codec)
db.session.commit()
except IntegrityError:
raise ReferencedError()
return '', 204
def delete_current_alerts():
delete_ids = get_delete_ids()
query_results = CurrentAlert.query.filter(
CurrentAlert.id.in_(delete_ids)).many()
try:
for alert in query_results:
db.session.delete(alert)
db.session.commit()
except IntegrityError:
raise ReferencedError()
return '', 204
def delete_group_devices(group_id):
group = Group.query.filter(Group.id == group_id).first_or_404()
delete_ids = get_delete_ids()
devices = Device.query \
.join(GroupDevice, GroupDevice.c.deviceIntID == Device.id) \
.filter(GroupDevice.c.groupID == group.groupID,
Device.id.in_(delete_ids)).all()
for device in devices:
group.devices.remove(device)
group.update()
return '', 204
def delete_action():
try:
ids = get_delete_ids()
actions = Action.query.filter(Action.id.in_(ids)).many()
for action in actions:
if action.rules.count() != 0:
raise ReferencedError()
db.session.delete(action)
db.session.commit()
except IntegrityError:
raise ReferencedError()
return '', 204
def delete_data_streams():
delete_ids = get_delete_ids()
data_streams = DataStream.query \
.filter(DataStream.id.in_(delete_ids)) \
.many(allow_none=False, expect_result=len(delete_ids))
try:
for data_stream in data_streams:
db.session.delete(data_stream)
db.session.commit()
except IntegrityError:
raise ReferencedError()
return '', 204
def delete_application():
app_ids = get_delete_ids()
applications = Application.query \
.filter(Application.id.in_(app_ids)) \
.many(allow_none=False, expect_result=len(app_ids))
try:
for app in applications:
app.delete()
db.session.commit()
except IntegrityError:
raise ReferencedError()
return '', 204
def delete_cert_devices(cert_id):
cert = Cert.query.filter(Cert.id == cert_id).first_or_404()
devices_id = get_delete_ids()
devices = Device.query.filter(Device.id.in_(devices_id)) \
.many(allow_none=False, expect_result=len(devices_id))
try:
for device in devices:
cert.devices.remove(device)
db.session.commit()
except IntegrityError:
raise ReferencedError()
return '', 204
def delete_stream_points(stream_id):
data_stream = DataStream.query \
.filter(DataStream.id == stream_id).first_or_404()
delete_ids = get_delete_ids()
delete_data_points = DataPoint.query \
.join(StreamPoint, StreamPoint.c.dataPointIntID == DataPoint.id) \
.filter(DataPoint.id.in_(delete_ids),
StreamPoint.c.dataStreamIntID == stream_id) \
.many(allow_none=False, expect_result=len(delete_ids))
for delete_data_point in delete_data_points:
data_stream.dataPoints.remove(delete_data_point)
data_stream.update()
return '', 204
def delete_rule():
try:
ids = get_delete_ids()
rules = Rule.query \
.filter(Rule.id.in_(ids)) \
.many()
for rule in rules:
db.session.delete(rule)
url = f"{current_app.config.get('STREAM_RULE_URL')}/{rule.id}"
stream_rule_http('delete', url=url)
db.session.commit()
except IntegrityError:
raise ReferencedError()
return '', 204
def delete_group():
delete_ids = get_delete_ids()
query_results = Group.query.filter(Group.id.in_(delete_ids)).many()
try:
for group in query_results:
device_count = db.session.query(db.func.count(GroupDevice.c.deviceIntID)) \
.filter(GroupDevice.c.groupID == group.groupID).scalar()
if device_count > 0:
raise ReferencedError(field='device')
db.session.delete(group)
db.session.commit()
except IntegrityError:
raise ReferencedError()
return '', 204
def delete_data_points():
delete_ids = get_delete_ids()
data_points = DataPoint.query \
.filter(DataPoint.id.in_(delete_ids)) \
.many(allow_none=False, expect_result=len(delete_ids))
try:
for data_point in data_points:
if data_point.dataStreams.count() > 0:
raise ReferencedError(field='dataStream')
db.session.delete(data_point)
db.session.commit()
except IntegrityError:
raise ReferencedError()
return '', 204
def delete_timer_publish():
delete_ids = get_delete_ids()
query_results = TimerPublish.query \
.join(User, User.id == TimerPublish.userIntID) \
.filter(User.tenantID == g.tenant_uid,
TimerPublish.id.in_(delete_ids)) \
.all()
if len(delete_ids) != len(query_results):
raise ParameterInvalid(field='ids')
try:
for query_result in query_results:
db.session.delete(query_result)
db.session.commit()
except IntegrityError:
raise ReferencedError()
return '', 204
def delete_cert():
delete_ids = get_delete_ids()
device_count = db.session \
.query(func.count(CertDevice.c.deviceIntID)) \
.filter(CertDevice.c.certIntID.in_(delete_ids)).scalar()
if device_count > 0:
raise ReferencedError(field='devices')
query_results = Cert.query \
.filter(Cert.id.in_(delete_ids)) \
.many(allow_none=False, expect_result=len(delete_ids))
try:
for cert in query_results:
db.session.delete(cert)
db.session.commit()
except IntegrityError:
raise ReferencedError()
return '', 204
def delete_user():
user_ids = get_delete_ids()
try:
if g.role_id == 1:
User.query \
.filter(User.id.in_(user_ids)) \
.filter(User.roleIntID != 1) \
.delete(synchronize_session='fetch')
else:
User.query \
.filter(User.id.in_(user_ids)) \
.filter(~User.roleIntID.in_([1, 2, 3])) \
.filter(User.id != g.user_id) \
.filter(User.tenantID == g.tenant_uid) \
.delete(synchronize_session='fetch')
db.session.commit()
except IntegrityError:
raise ReferencedError()
return '', 204
def delete_product():
delete_ids = get_delete_ids()
query_results = Product.query \
.filter(Product.id.in_(delete_ids)) \
.many(allow_none=False, expect_result=len(delete_ids))
# check device is included in the delete product
device_count = db.session.query(func.count(Device.id)) \
.join(Product, Device.productID == Product.productID) \
.filter(Product.id.in_(delete_ids)) \
.scalar()
if device_count:
raise ReferencedError(field='device')
try:
for product in query_results:
db.session.delete(product)
db.session.commit()
except IntegrityError:
raise ReferencedError()
return '', 204
def delete_device():
delete_ids = get_delete_ids()
# check endDevice under the delete endDevice
parent_device = db.session.query(db.func.count(EndDevice.id)) \
.filter(EndDevice.parentDevice.in_(delete_ids)) \
.scalar()
if parent_device > 0:
raise ReferencedError(field='parentDevice')
# check endDevice under the delete gateway
gateway_device = db.session.query(db.func.count(EndDevice.id)) \
.filter(EndDevice.gateway.in_(delete_ids)) \
.scalar()
if gateway_device > 0:
raise ReferencedError(field='endDevice')
query_results = Device.query.filter(Device.id.in_(delete_ids)).many()
try:
for device in query_results:
db.session.delete(device)
db.session.commit()
except IntegrityError:
raise ReferencedError()
return '', 204
