def download_file():
file_type = request.args.get('fileType', None, type=str)
filename = request.args.get('filename', None, type=str)
download_path = {
'template': 'DOWNLOAD_TEMPLATE_EXCEL_DEST',
'export_excel': 'EXPORT_EXCEL_PATH',
'image': 'UPLOADED_IMAGES_DEST',
'package': 'UPLOADED_PACKAGES_DEST'
}
if not file_type:
raise ParameterInvalid(field='fileType')
if not filename:
raise ParameterInvalid(field='filename')
path = current_app.config.get(download_path.get(file_type))
return send_from_directory(path, filename)
def view_codec_list():
"""
admin: codec list
not admin: query by productID
"""
if g.tenant_uid is None:
query = Codec.query \
.join(Tenant, Tenant.tenantID == Codec.tenantID) \
.join(Product, Product.productID == Codec.productID) \
.outerjoin(User, and_(User.tenantID == Tenant.tenantID,
User.roleIntID == 3, Tenant.company.is_(None))) \
.with_entities(Codec, Tenant.tenantType, Tenant.contactPhone, Product.productName,
func.coalesce(Tenant.company, User.username).label('tenantName'))
record = query.pagination(code_list=['codeStatus', 'tenantType'])
else:
product_uid = request.args.get('productID', type=str)
if product_uid is None:
raise ParameterInvalid(field='productID')
codec_query = Codec.query \
.filter(Codec.productID == product_uid) \
.with_entities(Codec, User.username) \
.first()
if codec_query is None:
return ''
else:
codec, create_user = codec_query
record = codec.to_dict(code_list=['codeStatus'])
record['createUser'] = create_user
return jsonify(record)
def upload_file():
file_type = request.args.get('fileType', None, type=str)
file_type_dict = {
'package': {
'type': 1,
'upload_set': packages
},
'image': {
'type': 2,
'upload_set': images
}
}
if file_type not in file_type_dict.keys():
raise ParameterInvalid(field='fileType')
try:
unique_name = hashlib.md5((str(g.user_id) + str(time.time())).encode()).hexdigest()
upload_set = file_type_dict.get(file_type).get('upload_set')
request_file = request.files.get('file')
file_name = upload_set.save(request_file, name=unique_name + '.')
file_url = '/api/v1/download?fileType=%s&filename=%s' % (file_type, file_name)
except UploadNotAllowed:
raise APIException()
request_dict = {
'fileName': file_name,
'displayName': request_file.filename,
'userIntID': g.user_id,
'fileType': file_type_dict.get(file_type).get('type')
}
upload_info = UploadInfo()
created_upload = upload_info.create(request_dict)
return jsonify({
'name': created_upload.displayName,
'url': file_url,
'uploadID': created_upload.id
}), 201
def devices_event_aggr_data(request_args):
table_dict = {
'hour': 'device_events_hour',
'day': 'device_events_day',
'month': 'device_events_month'
}
time_formats = {
'hour': 'YYYY-MM-DD HH24:00',
'day': 'YYYY-MM-DD',
'month': 'YYYY-MM'
}
query_args = {
'tenantID': g.tenant_uid,
'table': table_dict[request_args['timeUnit']],
'startTime': request_args['startTime'],
'endTime': request_args['endTime'],
'timeFormat': time_formats[request_args['timeUnit']]
}
if request_args.get('deviceID'):
query_args['deviceID'] = request_args['deviceID']
query_sql = _DEVICE_QUERY_SQL.format(**query_args)
elif request_args.get('productID'):
query_args['productID'] = request_args['productID']
query_sql = _PRODUCT_QUERY_SQL.format(**query_args)
elif request_args.get('groupID'):
query_args['groupID'] = request_args['groupID']
query_sql = _GROUP_QUERY_SQL.format(**query_args)
else:
raise ParameterInvalid(field='EventDataObject')
if g.get('app_uid'):
query_sql = filter_app_permission(query_sql)
query_sql = query_sql + """ ORDER BY "countTime" DESC """ # order by
records = fetch_many(query_sql, paginate=True)
return records
def reports_data():
request_args = _validate_request_args()
report_type = request_args.get('reportType')
reports_data_func = REPORTS_TYPE_FUNC.get(report_type)
if not reports_data_func:
raise ParameterInvalid(field='reportsType')
records = reports_data_func(request_args)
return jsonify(records)
def validate_time_range(limit_days: int = 7) -> None:
start_time = request.args.get('start_time', type=str)
end_time = request.args.get('end_time', type=str)
if not (start_time and end_time):
raise ParameterInvalid('start_time or end_time')
try:
start_time = arrow.get(start_time)
except Exception:
raise ParameterInvalid('start_time')
try:
end_time = arrow.get(end_time)
except Exception:
raise ParameterInvalid('end_time')
if end_time.day - start_time.day > limit_days:
raise ParameterInvalid('Time range is greater than 7 days')
def get_delete_ids() -> Set[int]:
""" Get a list of delete id with flask request context """
try:
delete_ids = set([int(delete_id) for delete_id in request.args.get('ids').split(',')])
except Exception:
raise ParameterInvalid(field='ids')
return delete_ids
def _validate_timestamp(request_args):
"""
Validate start_time and end_time, converting to a standard timestamp
"""
time_unit = request_args.get('timeUnit')
start_time = request_args.get('startTime')
end_time = request_args.get('endTime')
if time_unit not in ['hour', 'day', 'month']:
raise ParameterInvalid(field='timeUnit')
if not start_time:
raise ParameterInvalid(field='startTime')
if not end_time:
raise ParameterInvalid(field='endTime')
time_now = arrow.now()
try:
start_time = arrow.get(start_time)
except Exception:
raise ParameterInvalid(field='startTime')
try:
end_time = arrow.get(end_time)
except Exception:
raise ParameterInvalid(field='endTime')
if start_time > time_now:
raise ParameterInvalid(field='startTime')
if start_time >= end_time:
raise ParameterInvalid(field='startTime or endTime')
if time_unit == 'hour' and (end_time - start_time).days > 31:
raise ResourceLimited(field='hour')
request_args['startTime'] = str(start_time)
request_args['endTime'] = str(end_time)
return request_args
def _validate_time_unit():
time_format_dict = {
'hour': "HH24:00", 'day': "YYYY-MM-DD", 'month': "YYYY-MM"
}
time_unit = request.args.get('time_unit', type=str)
if not time_format_dict.get(time_unit):
raise ParameterInvalid(field='time_unit')
time_format = time_format_dict.get(time_unit)
return time_unit, time_format
def _get_paginate_meta(query_sql: AnyStr) -> Tuple[str, dict]:
page = request.args.get('_page', type=int, default=1)
limit = request.args.get('_limit', type=int, default=10)
if limit > 500 or limit <= 0:
raise ParameterInvalid(field='_limit')
if page < 1:
raise ParameterInvalid(field='_page')
offset = (page - 1) * limit
count_sql = f'SELECT COUNT(*) FROM ({query_sql}) AS query_count'
try:
query_count = db.engine.execute(count_sql).scalar()
except Exception as error:
current_app.logger.error(error)
query_count = 0
paginate_sql = f'{query_sql} LIMIT {limit} OFFSET {offset}'
paginate_meta = {"count": query_count, "limit": limit, "page": page}
return paginate_sql, paginate_meta
def list_data_streams():
code_list = ['streamType', 'streamDataType']
product_uid = request.args.get('productID', type=str)
if not product_uid:
raise ParameterInvalid(field='productID')
query = DataStream.query \
.join(Product, DataStream.productID == Product.productID) \
.filter(Product.productID == product_uid) \
.with_entities(DataStream, Product.productName)
records = query.pagination(code_list=code_list)
return jsonify(records)
def delete_invitations():
try:
ids = [int(i) for i in request.args.get('ids').split(',')]
except ValueError:
raise ParameterInvalid(field='ids')
try:
Invitation.query \
.filter(Invitation.id.in_(ids)) \
.filter(Invitation.tenantID == g.tenant_uid) \
.delete(synchronize_session='fetch')
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_role():
try:
ids = [int(i) for i in request.args.get('ids').split(',')]
except ValueError:
raise ParameterInvalid(field='ids')
try:
query = Role.query \
.filter(Role.id.in_(ids)) \
.filter(~Role.id.in_([1, 2, 3])) \
.filter(Role.id != g.role_id) \
.filter(Role.tenantID == g.tenant_uid)
check_request(query).delete(synchronize_session='fetch')
db.session.commit()
except IntegrityError:
raise ReferencedError()
return '', 204
def filter_request_args(model, query):
""" Query by request args """
exclude_args = [
'_page', '_limit', 'paginate', '_sort', '_order', 'startTime',
'endTime', 'createAt', 'msgTime', 'password', 'token', 'id',
'userIntID', 'tenantID'
]
for key, value in request.args.items():
if any([key in exclude_args, value == '', value is None]):
continue
elif key.endswith('_like'):
# 相似类型查询
key = key.replace('_like', '')
if hasattr(model, key) and key not in exclude_args:
column = getattr(model, key)
if not check_column_type(column, value):
continue
query = query.filter(column.ilike(u'%{0}%'.format(value)))
elif key.endswith('_in'):
# 范围查询
key = key.replace('_in', '')
try:
in_value_list = [int(row) for row in value.split(',')]
except Exception:
raise ParameterInvalid(field=key)
if hasattr(model, key) and key not in exclude_args:
column = getattr(model, key)
if not check_column_type(column, value):
continue
query = query.filter(column.in_(in_value_list))
elif key == 'time_name' and value in [
'startTime', 'endTime', 'createAt', 'msgTime'
]:
start_time = request.args.get('start_time')
end_time = request.args.get('end_time')
query = query.filter(
getattr(model, value).between(start_time, end_time))
elif hasattr(model, key):
column = getattr(model, key)
if not check_column_type(column, value):
continue
query = query.filter(column == value)
else:
continue
return query
def list_devices_capability_data():
"""
List the latest capability data of each device under group or gateway
"""
group_id = request.args.get("groupIntID")
gateway_id = request.args.get("gatewayIntID")
if group_id:
group = Group.query.with_entities(Group.groupID) \
.filter(Group.id == group_id).first_or_404()
devices_query = Device.query.with_entities(Device.deviceID, Device.productID) \
.join(GroupDevice, GroupDevice.c.deviceIntID == Device.id) \
.filter(GroupDevice.c.groupID == group.groupID)
elif gateway_id:
devices_query = Device.query.with_entities(Device.deviceID, Device.productID) \
.join(EndDevice, EndDevice.id == Device.id) \
.filter(EndDevice.gateway == gateway_id)
else:
raise ParameterInvalid()
# search by device name
device_name = request.args.get('deviceName_like')
if device_name:
devices_query = devices_query.filter(
Device.deviceName.ilike(f'%{device_name}%'))
devices = devices_query.all()
devices_uid = [device.deviceID for device in devices]
devices_product_uid = [device.productID for device in devices]
events_query = db.session \
.query(DeviceEventLatest.msgTime, DeviceEventLatest.streamID, DeviceEventLatest.deviceID,
Device.deviceName, Device.id.label('deviceIntID'),
column('key').label('dataPointID'), column('value')) \
.select_from(DeviceEventLatest, func.jsonb_each(DeviceEventLatest.data)) \
.join(Device, Device.deviceID == DeviceEventLatest.deviceID) \
.filter(DeviceEventLatest.deviceID.in_(devices_uid)) \
.filter(DeviceEventLatest.dataType == 1)
# filter by data point
data_point_id = request.args.get('dataPointID')
if data_point_id:
events_query = events_query.filter(column('key') == data_point_id)
events = events_query.pagination()
data_points = _get_data_points(devices_product_uid)
events['items'] = _get_capability_data(events['items'], data_points)
return jsonify(events)
def get_task_scheduler_status():
task_scheduler_id = request.args.get('taskID', type=str)
if not task_scheduler_id:
raise ParameterInvalid(field='taskID')
query_task = ActorTask.query \
.filter(ActorTask.taskID == task_scheduler_id) \
.first_or_404()
result = query_task.taskResult if query_task.taskResult else {}
message = result.pop('message', '')
record = {
'status': query_task.taskStatus,
'progress': query_task.taskProgress,
'message': message,
'taskID': query_task.taskID,
'result': result,
}
return jsonify(record)
def list_select_options_topics():
product_uid = request.args.get('productID', type=str)
if not product_uid:
raise ParameterInvalid(field='productID')
product = Product.query.filter_by(productID=product_uid).first_or_404()
if product.cloudProtocol == 3:
record = [{'key': 'ad/#', 'value': 'ad/#'}]
else:
topics = DataStream.query \
.with_entities(DataStream.topic) \
.filter(DataStream.productID == product_uid) \
.many()
record = [{
'key': topic.topic,
'value': topic.topic
} for topic in topics]
return jsonify(record)
def delete_messages():
try:
ids = [int(i) for i in request.args.get('ids').split(',')]
except ValueError:
raise ParameterInvalid(field='ids')
try:
messages = Message.query \
.filter(Message.id.in_(ids),
or_(Message.tenantID == g.tenant_uid,
Message.tenantID.is_(None))) \
.all()
for message in messages:
if message.tenantID is None:
raise APIException()
db.session.delete(message)
db.session.commit()
except IntegrityError:
raise ReferencedError()
return '', 204
def _filter_request_args(query: BaseQueryT) -> BaseQueryT:
""" filter timeUnit args """
time_unit = request.args.get('timeUnit', type=str)
date_now = arrow.now()
time_unit_dict = {
'5m': date_now.shift(minutes=-5),
'1h': date_now.shift(hours=-1),
'6h': date_now.shift(hours=-6),
'1d': date_now.shift(days=-1),
'1w': date_now.shift(weeks=-1)
}
start_time = time_unit_dict.get(time_unit)
if not start_time:
raise ParameterInvalid(field='timeUnit')
str_start_time = start_time.format()
query = query \
.filter(DeviceEvent.msgTime > str_start_time) \
.order_by(desc(DeviceEvent.msgTime)) \
.limit(2048)
return query
