def handle_logo(self, data): logo = data.get('logo') logo_dark = data.get('logoDark') if logo is not None: if logo < 1: data.pop('logo') else: upload_info = UploadInfo.query \ .join(User, User.id == UploadInfo.userIntID) \ .filter(UploadInfo.id == logo, User.tenantID == g.tenant_uid) \ .first() if not upload_info: raise DataNotFound(field='logo') if logo_dark is not None: if logo_dark < 1: data.pop('logoDark') else: upload_info = UploadInfo.query \ .join(User, User.id == UploadInfo.userIntID) \ .filter(UploadInfo.id == logo_dark, User.tenantID == g.tenant_uid) \ .first() if not upload_info: raise DataNotFound(field='logoDark')
def validate_from(self, data): product_uid = data.get('productID') product = db.session \ .query(Product.cloudProtocol) \ .filter_tenant(tenant_uid=g.tenant_uid) \ .filter(Product.productID == product_uid) \ .first() if not product: raise DataNotFound(field='productID') device_uid = data.get('deviceID') # device_uid can be '+' or deviceID of device if device_uid != '+': device = db.session \ .query(Device.id) \ .filter_tenant(tenant_uid=g.tenant_uid) \ .filter(Device.productID == product_uid, Device.deviceID == device_uid) \ .first() if not device: raise DataNotFound(field='deviceID') topic = data.get('topic') # If the protocol is LwM2M,the fixed value of topic is 'ad/#' if product.cloudProtocol == 3 and topic != 'ad/#': raise DataNotFound(field='topic') else: data_stream = db.session \ .query(DataStream.topic) \ .filter_tenant(tenant_uid=g.tenant_uid) \ .filter(DataStream.productID == product_uid, DataStream.topic == topic) \ .first() if not data_stream: raise DataNotFound(field='topic')
def validate_uplink_system(self, data): uplink_system = data.get('upLinkSystem') if uplink_system == 1: data['parentDevice'], data['gateway'] = None, None elif uplink_system == 2 and isinstance(data.get('parentDevice'), int): parent_device = data['parentDevice'] end_device_id = EndDevice.query \ .filter_tenant(tenant_uid=g.tenant_uid) \ .filter(EndDevice.id == parent_device) \ .with_entities(EndDevice.id).first() if not end_device_id: raise DataNotFound(field='parentDevice') data['parentDevice'], data['gateway'] = end_device_id, None elif uplink_system == 3 and isinstance(data.get('gateway'), int): gateway = data['gateway'] gateway_id = Gateway.query \ .filter_tenant(tenant_uid=g.tenant_uid) \ .filter(Gateway.id == gateway) \ .with_entities(Gateway.id).first() if not gateway_id: raise DataNotFound(field='gateway') data['parentDevice'], data['gateway'] = None, gateway_id else: raise FormInvalid(field='upLinkSystem') return data
def many(self, limit: int = None, allow_none=True, expect_result: int = None): query = self.filter_tenant() if limit: query = query.limit(limit) result = query.all() if not allow_none and not result: raise DataNotFound(field='url') if not allow_none and len(result) != expect_result: raise DataNotFound(field='url') return result
def validate_data(self, in_data): tenant_uid = in_data.get('tenantID') rule = db.session.query(Rule.id) \ .filter(Rule.id == in_data.get('ruleIntID'), Rule.tenantID == tenant_uid) \ .first() if not rule: raise DataNotFound(field='ruleIntID') device = db.session.query(Device.id) \ .filter(Device.tenantID == tenant_uid, Device.deviceID == in_data.get('deviceID')) \ .first() if not device: raise DataNotFound(field='deviceID')
def backend_callback(): request_dict = request.get_json() request_dict['callback_date'] = datetime.now() if not request_dict: raise DataNotFound() callback_action = request_dict.get('action') handle_action_funcs = { 'client_connected': client_connected_callback, 'client_disconnected': client_disconnected_callback, 'message_acked': message_acked_callback, } if not handle_action_funcs.get(callback_action): raise DataNotFound() handle_action = handle_action_funcs[callback_action] handle_action(request_dict) return '', 201
def validate_devices(self, value): devices_count = Device.query \ .filter_tenant(tenant_uid=g.tenant_uid) \ .filter(Device.deviceID.in_(set(value))) \ .count() if devices_count != len(value): raise DataNotFound(field='devices')
def handle_action_config(record=None): cache = Cache() dict_code = cache.dict_code action_config = record.get('config') action_type = record.get('actionType') record['actionTypeLabel'] = dict_code.get('actionType').get(action_type) \ .get(f'{g.language}Label') if action_type == 1: alert_severity = action_config.get('alertSeverity') severity_label = dict_code.get('alertSeverity').get(alert_severity) \ .get(f'{g.language}Label') action_config['alertSeverityLabel'] = severity_label elif action_type == 3 and action_config.get('token'): ... elif action_type == 4: device_uid = action_config.get('deviceID') device = db.session.query(Device.deviceName) \ .filter_tenant(tenant_uid=g.tenant_uid) \ .filter(Device.deviceID == device_uid) \ .first() if not device: raise DataNotFound(field='deviceID') action_config['deviceName'] = device.deviceName else: pass return record
def export_devices(): device_count = db.session.query(func.count(Device.id)) \ .filter(Device.tenantID == g.tenant_uid).scalar() if device_count and device_count > 10000: raise ResourceLimited(field='devices') if device_count == 0: raise DataNotFound(field='devices') export_url = current_app.config.get('EXPORT_EXCEL_TASK_URL') request_json = { 'tenantID': g.tenant_uid, 'language': g.language } with SyncHttp() as sync_http: response = sync_http.post(export_url, json=request_json) handled_response = handle_task_scheduler_response(response) if handled_response.get('status') == 3: query_status_url = url_for('base.get_task_scheduler_status')[7:] task_id = handled_response['taskID'] record = { 'status': 3, 'taskID': task_id, 'message': 'Devices export is in progress', 'result': { 'statusUrl': f"{query_status_url}?taskID={task_id}" } } else: record = { 'status': 4, 'message': handled_response.get('error') or 'Devices export failed', } return jsonify(record)
def backend(): file_type = request.args.get('fileType', None, type=str) filename = request.args.get('filename', None, type=str) if file_type != 'image': raise DataNotFound(field='url') dst_path = current_app.config.get('LOGOS_PATH') return send_from_directory(dst_path, filename)
def validate_region(self, value): if value is None: return cache = Cache() dict_code_cache = cache.dict_code region_cache = dict_code_cache['region'] if value not in region_cache.keys(): raise DataNotFound(field='region')
def validate_fcnt_check(self, value): if value is None: return cache = Cache() dict_code_cache = cache.dict_code fcnt_check_cache = dict_code_cache['fcntCheck'] if value not in fcnt_check_cache.keys(): raise DataNotFound(field='fcntCheck')
def message_acked_callback(request_dict) -> None: """ Update the publish status when the device receives the publish message """ device_id = request_dict.get('client_id') payload = request_dict.get('payload') if not device_id or not payload: raise DataNotFound() try: load_payload = json.loads(payload) except Exception: raise DataNotFound() task_id = load_payload.get('task_id') if not task_id: raise DataNotFound() publish_log = PublishLog.query.filter(PublishLog.taskID == task_id).first_or_404() publish_log.publishStatus = 2 publish_log.update()
def view_tenant(tenant_id): if g.role_id != 1: raise DataNotFound(field='url') query = db.session.query(Tenant, func.coalesce(Tenant.company, User.username).label('tenantName')) \ .outerjoin(User) \ .filter(Tenant.id == tenant_id) record = query.to_dict(code_list=['tenantType']) return jsonify(record)
def handle_app_groups(self, in_data): groups_uid = in_data.get('groups') if not groups_uid: return in_data groups = Group.query \ .filter_tenant(tenant_uid=g.tenant_uid) \ .filter(Group.groupID.in_(set(groups_uid))).all() if len(groups_uid) != len(groups): raise DataNotFound(field='groups') in_data['groups'] = groups return in_data
def handle_data_points(self, data): product_uid = self.get_origin_obj('productID') data_point_ids = data.get('dataPoints') if not data_point_ids: return data data_points = DataPoint.query \ .filter(DataPoint.productID == product_uid, DataPoint.id.in_(set(data_point_ids))).all() if len(data_points) != len(data_point_ids): raise DataNotFound(field='dataPoints') data['data_points'] = data_points return data
def convert_data_points(self, data): data_point_ids = data.get('dataPoints') if data_point_ids: data_points = DataPoint.query \ .filter_tenant(tenant_uid=g.tenant_uid) \ .filter(DataPoint.id.in_(set(data_point_ids))).all() if len(data_points) != len(data_point_ids): raise DataNotFound(field='dataPoints') else: data_points = [] data['dataPoints'] = data_points return data
def handle_load_data(self, data): product_uid: str = data.get('productID') if not isinstance(product_uid, str): raise FormInvalid(field='productID') product = Product.query. \ filter_tenant(tenant_uid=g.tenant_uid) \ .filter(Product.productID == product_uid).first() if not product: raise DataNotFound(field='productID') data['productID'] = product.productID data['cloudProtocol'] = product.cloudProtocol data = handle_extend_type_attr(data) return data
def handle_origin_data(self, data): product_uid = data.get('productID') if not isinstance(product_uid, str): raise FormInvalid(field='productID') product = Product.query \ .filter_tenant(tenant_uid=g.tenant_uid) \ .filter(Product.productID == product_uid).first() if not product: raise DataNotFound(field='productID') data['productType'] = product.productType data['productID'] = product.productID data['cloudProtocol'] = product.cloudProtocol data['gatewayProtocol'] = product.gatewayProtocol return data
def validate_product(self, value): if self._validate_obj('productID', value): return product = db.session.query(Product.id) \ .filter(Product.userIntID == g.user_id, Product.productID == value) \ .first() if not product: raise DataNotFound(field='productID') codec = db.session.query(Codec.id) \ .filter(Codec.tenantID == g.tenant_uid, Codec.productID == value) \ .first() if codec: raise DataExisted(field='productID')
def handle_loads(self, data): group_id = request.view_args.get('group_id') devices_id = data['devices'] group_devices_id = db.session.query(GroupDevice.c.deviceIntID) \ .join(Group, Group.groupID == GroupDevice.c.groupID) \ .filter(Group.id == group_id).all() add_devices_id = set(devices_id).difference(set(group_devices_id)) if len(group_devices_id) + len(add_devices_id) > 1001: raise ResourceLimited(field='devices') devices = Device.query.filter_tenant(tenant_uid=g.tenant_uid) \ .filter(Device.id.in_(add_devices_id)).all() if len(devices) != len(add_devices_id): raise DataNotFound(field='devices') data['devices'] = devices return data
def update_system_info(): request_dict = request.get_json() if not request_dict: raise APIException() if g.tenant_uid: raise DataNotFound(field='url') system_info_list = SystemInfo.query.all() for system_info in system_info_list: new_value = request_dict.get(system_info.key) if not new_value: continue if isinstance(new_value, bytes): new_value = new_value.decode('utf-8') system_info.value = new_value db.session.commit() return ''
def update_tenant(tenant_id): if g.role_id != 1: raise DataNotFound(field='url') tenant = Tenant.filter(Tenant.id == tenant_id).first_or_404() request_dict = request.get_json() if not request_dict: raise APIException() enable = request_dict.get('enable') if enable not in [0, 1]: raise FormInvalid(field='enable') update_dict = {'enable': enable} updated_tenant = tenant.update(update_dict) record = updated_tenant.to_dict() return jsonify(record)
def handle_user_auth_type(self, data): if 'user_id' not in g: data['userAuthType'] = 1 groups_uid = self.get_request_data(key='groups') auth_type = data.get('userAuthType') if auth_type not in (1, 2): raise FormInvalid(field='userAuthType') if auth_type == 2 and groups_uid: groups = Group.query \ .filter_tenant(tenant_uid=g.tenant_uid) \ .filter(Group.groupID.in_(set(groups_uid))).all() if len(groups_uid) != len(groups): raise DataNotFound(field='groups') data['groups'] = groups else: data.pop('groups', None) return data
def list_tenants(): if g.role_id != 1: raise DataNotFound(field='url') query = db.session.query(Tenant, func.coalesce(Tenant.company, User.username).label('tenantName')) \ .outerjoin(User) tenant_name = request.args.get('tenantName_like') if tenant_name: query = query \ .filter(Tenant.company.ilike(u'%{0}%'.format(tenant_name))) person_tenant_query = db.session \ .query(Tenant, func.coalesce(Tenant.company, User.username).label('tenantName')) \ .join(User, User.tenantID == Tenant.tenantID) \ .filter(User.username.ilike(u'%{0}%'.format(tenant_name))) query = query.union(person_tenant_query) records = query.pagination(code_list=['tenantType']) return jsonify(records)
def signup_invite_user(token): jwt = JWT(current_app.config['SECRET_KEY']) try: data = jwt.loads(token) except Exception: raise FormInvalid(field='token') if not data.get('invitation_id'): raise FormInvalid(field='invitation') invitation = Invitation.query \ .join(Tenant, Tenant.tenantID == Invitation.tenantID) \ .filter(Invitation.id == data.get('invitation_id'), Invitation.inviteStatus == 0, Tenant.enable == 1) \ .first() if not invitation: raise DataNotFound(field='invitation') invitation.inviteStatus = 1 invite_user = { 'roleIntID': invitation.roleIntID, 'tenantID': invitation.tenantID } return invite_user
def first_or_404(self): query = self.filter_tenant() result = query.first() if result is None: raise DataNotFound() return result
def run_code(): """ codec api response { "error": { "decode:": "error message" }, "output": { "status_code": 0, "result": { "data_type": "event", "data": { "humidity": { "time": 1547660823, "value": 34 }, "temperature": { "time": 1547660823, "value": -3.7 } } } } } """ request_json = CodeRunSchema.validate_request() analog_type = request_json.get('analogType') protocol = db.session.query(Product.cloudProtocol) \ .filter(Product.productID == request_json.get('productID')) \ .scalar() if protocol is None: raise DataNotFound(field='productID') request_url = f"http://{current_app.config['CODEC_NODE']}/api/v1/codec" with SyncHttp() as sync_http: response = sync_http.post(request_url, json=request_json) if response.responseCode != 200: try: errors = json.loads(response.responseContent) except Exception: errors = { 'codec': response.responseContent } raise APIException(errors=errors) response_json = json.loads(response.responseContent) # return response if it has error if 'error' in response_json: return jsonify(response_json) output_data = response_json.get('output') status_code = output_data.get('status_code') # If status code is 1(ERROR) # or analog type is 2(encode) # return response without validate if status_code == 1 or analog_type == 2: return jsonify(response_json) result = output_data.get('result') error_dict = {} validate_data, validate_error = DecodeSchema().load(result) for key, value in validate_error.items(): error_dict[key] = value[0][:-1] data_stream = DataStream.query \ .filter(DataStream.productID == request_json.get('productID'), DataStream.tenantID == g.tenant_uid, DataStream.topic == request_json.get('topic'), DataStream.streamID == validate_data.get('stream_id')) \ .first() if not data_stream: raise DataNotFound(field='data_stream') error, passed_data = validate_decode_response(data_stream, validate_data) error_dict.update(error) record = { 'output': { 'status_code': status_code, 'result': passed_data } } if error_dict: record['error'] = error_dict return jsonify(record)
def handle_not_found(error): if request.path.startswith('/api/'): return DataNotFound('url') return error