def response_getdetail(cust_id, device_groups_list): try: device_groups_obj = sdDeviceGroup.get_detail(cust_id, device_groups_list) if not device_groups_obj: return None device_groups = [] for device_group in device_groups_obj: schedules_id, schedules_name = "", "" if device_group.schedule_group: schedules_id = device_group.schedule_group.id schedules_name = device_group.schedule_group.name device_groups.append({"id": str(device_group.id), "name": device_group.name, "display_name": device_group.display_name, "comment": device_group.comment, "create_time": datetime_to_iso8601(device_group.create_time), "update_time": datetime_to_iso8601(device_group.update_time), "user_groups": [str(user_group.id) for user_group in device_group.user_groups], "devices": [str(device.id) for device in device_group.devices], "schedules_id": str(schedules_id), "schedules_name": schedules_name}) response_body = {"device_groups": device_groups} convert_null_emptystr(response_body) return response_body except Exception as e: logger.error(f"failed to fetch data from SQL: {str(e)}") raise
def response_getall_groups(cust_id): try: usergroups = sdUserGroup.getall(cust_id) if not usergroups: return None response_users = [] for usergroup in usergroups: users = [] if usergroup.rel_u_ug: userobj = usergroup.rel_u_ug for user in userobj: # TAG str changed users.append(str(user.id)) response_users.append({ "id": str(usergroup.id), "name": usergroup.name, "display_name": usergroup.display_name, "users": users }) response_body = {"user_groups": response_users} convert_null_emptystr(response_body) logger.debug("success for generate user list.") return response_body except Exception as e: logger.error(f"failed to update data from SQL: {str(e)}") raise finally: db.session.close()
def response_getall(cust_id): try: device_groups_obj = sdDeviceGroup.getall(cust_id) if not device_groups_obj: return None response_body = {} response_body.update({"device_groups": []}) d_in_dg = {} # TAG str changed in for loop for device_group in device_groups_obj: d_in_dg[device_group.id] = [str(device.id) for device in device_group.devices] ugobj = device_group.user_groups involved_ug = [str(ug.id) for ug in ugobj] response_body["device_groups"].append({"id": str(device_group.id), "name": device_group.name, "display_name": device_group.display_name, "user_groups": involved_ug, "devices": d_in_dg[device_group.id]}) logger.debug("success for generate device list.") convert_null_emptystr(response_body) return response_body except Exception as e: logger.error(f"failed to fetch data from SQL: {str(e)}") raise finally: db.session.close()
def getall_devicelist_for_geojson(cust, user, number): if (cust and user) and (number == 0): try: results = db.session.execute(sql_get_all_device, { "cust_id": cust, "vendor_id": cust }).fetchall() logger.debug("success for get data from SQL") return results except Exception as e: logger.error(f"failed for get data from SQL: {str(e)}") db.session.rollback() raise finally: db.session.close() elif cust and user: try: results = db.session.execute(text(sql_get_limit_device), { "cust_id": cust, "vendor_id": cust, "remaining": number }).fetchall() logger.debug("success for get data from SQL") return results except Exception as e: logger.error(f"failed for get data from SQL: {str(e)}") db.session.rollback() raise finally: db.session.close()
def get_codes(cust_id): try: customer = sdCustomer.search_cust(cust_id) # if customer return false, means vendor, vendor should follow customer's code format if not customer: vendor = sdCustomer.search_cust_obj(cust_id) cust_id = vendor.cust_id codes = sdCode.get_codes(cust_id) if not codes: return None codes_table = {} for code in codes: # TAG change str here codes_table.setdefault(get_codes_name(code.code_type), [])\ .append(dict(id=str(code.id), name=code.name, display_name=code.display_name, create_time=datetime_to_iso8601(code.create_time), update_time=datetime_to_iso8601(code.update_time))) response = dict(codes_table=codes_table) return response except Exception as e: logger.error(f"The user input may incorrect, {str(e)}") raise
def response_add(cust_id, payload): try: response_users = [] user_inputs = payload["users"] for user_input in user_inputs: obj = sdUser.add(cust_id, user_input.get("name"), user_input.get("display_name"), user_input.get("password"), user_input.get("email"), user_input.get("telephone"), user_input.get("comment")) db.session.add(obj) db.session.flush() # TAG change str here response_users.append(dict(id=str(obj.id), name=obj.name)) db.session.commit() response_body = {"users": response_users} return response_body except Exception as e: logger.error(f"failed to update data from SQL: {str(e)}") db.session.rollback() raise finally: db.session.close()
def response_getallsummary(cust_id): try: groups = get_all_summary_table(cust_id) if not groups: return None user_groups, schedule_group = response_get_dgug_schedule(cust_id) response_list = [] for group_id, name, display_name, device_count, poweroff_count, warning_count, error_count in groups: # TAG str changed response_list.append({"id": str(group_id), "name": name, "display_name": display_name, "user_groups": user_groups.get(group_id), "schedule_groups": schedule_group.get(group_id), "device_count": device_count, "warning_count": warning_count, "error_count": error_count, "poweroff_count": poweroff_count}) response_body = {"device_groups": response_list} convert_null_emptystr(response_body) logger.debug("success for generate device list.") return response_body except Exception as e: logger.error(f"failed to fetch data from SQL: {str(e)}") raise finally: db.session.close()
def response_get_detail(cust_id, user_list): try: users = sdUser.getdetail(cust_id, user_list) if not users: return None response_users = [] for user in users: ugobj = user.user_groups involved_ug = [str(ug.id) for ug in ugobj] response_users.append(dict(id=str(user.id), name=user.name, display_name=user.display_name, group=involved_ug, email=user.email, telephone=user.telephone, comment=user.comment)) response_body = {"users": response_users} logger.debug("success for generate user list.") convert_null_emptystr(response_body) return response_body except Exception as e: logger.error(f"failed to update data from SQL: {str(e)}") db.session.rollback() raise finally: db.session.close()
def check(cust_id): try: cust = sdCustomer.search(cust_id) return cust except Exception as e: logger.error(f"failed to update data from SQL: {str(e)}") raise finally: db.session.close()
def response_leave_usergroups(cust_id, device_group_id, user_group_list): try: sdDeviceGroup.leave_device_group(cust_id, device_group_id, user_group_list) db.session.commit() except Exception as e: logger.error(f"failed to join users: {str(e)}") db.session.rollback() raise finally: db.session.close()
def response_delete_devices(cust_id, device_list): try: sdDevice.delete(cust_id, device_list) db.session.commit() except Exception as e: db.session.rollback() logger.error(f"The user input may incorrect, {str(e)}") raise finally: db.session.close()
def get_all_summary_table(cust): try: results = db.session.execute(sql_get_all_summary, { "cust_id": cust }).fetchall() logger.debug("success for get data from SQL") return results except Exception as e: logger.error(f"failed for get data from SQL: {str(e)}") finally: db.session.close()
def response_join_groups(cust_id, group_id, devices): try: sdDeviceGroup.join(group_id, devices) db.session.commit() except Exception as e: logger.error(f"failed to join devices: {str(e)}") db.session.rollback() raise finally: db.session.close()
def response_join_users(cust_id, user_group_id, payload): try: user_list = payload["users"] sdUserGroup.join_users(cust_id, user_group_id, user_list) db.session.commit() except Exception as e: logger.error(f"failed to join users: {str(e)}") db.session.rollback() raise finally: db.session.close()
def logout_user(token): try: obj = sdBlacklistToken.revoke_token(token) db.session.add(obj) db.session.commit() except Exception as e: logger.error(f"failed to update data from SQL: {str(e)}") db.session.rollback() raise finally: db.session.close()
def response_delete_groups(cust_id, user_group_list): try: sdUserGroup.delete_all_users(cust_id, user_group_list) sdUserGroup.delete(cust_id, user_group_list) db.session.commit() except Exception as e: logger.error(f"failed to delete data from SQL: {str(e)}") db.session.rollback() raise finally: db.session.close()
def response_update_device(cust_id, payload): try: data = payload["devices"] for device in data: obj = update_device_handler(cust_id, device) db.session.add(obj) db.session.commit() except Exception as e: db.session.rollback() logger.error(f"The user input may incorrect, {str(e)}") raise finally: db.session.close()
def response_delete_groups(cust_id, device_groups): try: # get device_id for join ungroup device_id_list = sdDevice.get_devices_in_groups(cust_id, device_groups) if device_id_list: sdDeviceGroup.join(None, device_id_list) sdDeviceGroup.delete(cust_id, device_groups) db.session.commit() except Exception as e: logger.error(f"failed to update data to SQL: {str(e)}") db.session.rollback() raise finally: db.session.close()
def generate_user_tokens(cust_id, user_id, user_name): try: identity = json.dumps({"cust_id": cust_id, "user_id": user_id, "user_name": user_name}) tokens = { "token": { "access_token": create_access_token(identity=identity), "refresh_token": create_refresh_token(identity=identity) } } return tokens except Exception as e: logger.error(f"failed to generate_user_tokens: {str(e)}") raise
def response_update_groups(cust_id, device_groups): try: for group_id, new_name, new_display_name in device_groups: obj = sdDeviceGroup.update(group_id, new_name, new_display_name) db.session.add(obj) db.session.commit() except Exception as e: logger.error(f"failed to update data to SQL: {str(e)}") db.session.rollback() raise finally: db.session.close()
def response_add_device(cust_id, payload): try: data = payload["devices"] devices = [] for device in data: obj = add_device_handler(cust_id, device) db.session.add(obj) db.session.flush() devices.append(dict(id=str(obj.id), name=obj.name)) db.session.commit() response_body = {"devices": devices} return response_body except Exception as e: logger.error(f"The user input may incorrect, {str(e)}") raise
def response_update_groups(cust_id, payload): try: user_inputs = payload["user_groups"] for user_input in user_inputs: obj = sdUserGroup.update(cust_id, user_input.get("id"), user_input.get("name"), user_input.get("display_name"), user_input.get("comment")) db.session.add(obj) db.session.commit() except Exception as e: logger.error(f"failed to update data from SQL: {str(e)}") db.session.rollback() raise finally: db.session.close()
def response_add_groups(groups, cust_id): try: added_groups = [] for name, display_name in groups: obj = sdDeviceGroup.add(name, display_name, cust_id) db.session.add(obj) db.session.flush() # TAG str changed added_groups.append(dict(id=str(obj.id), name=obj.name)) db.session.commit() response_body = {} response_body.update({"device_groups": added_groups}) return response_body except Exception as e: logger.error(f"failed to update data to SQL: {str(e)}") db.session.rollback() raise finally: db.session.close()
def response_getall(cust_id): try: users = sdUser.getall(cust_id) if not users: return None response_users = [] # TAG str changed in for loop for user in users: ugobj = user.user_groups involved_ug = [str(ug.id) for ug in ugobj] response_users.append(dict(id=str(user.id), name=user.name, display_name=user.display_name, group=involved_ug)) response_body = {"users": response_users} convert_null_emptystr(response_body) logger.debug("success for generate user list.") return response_body except Exception as e: logger.error(f"failed to update data from SQL: {str(e)}") raise finally: db.session.close()
def response_get_detail(cust_id, device_list): try: detail = [] devices = sdDevice.get_detail(cust_id, device_list) for device in devices: controller = None led = None device_group = None if device.controller: controller = dict( id=str(device.controller.id), name=device.controller.name, display_name=device.controller.display_name, comment=device.controller.comment, create_time=datetime_to_iso8601( device.controller.create_time), update_time=datetime_to_iso8601( device.controller.update_time), model_id=device.controller.model.id, serial_no=device.controller.serial_no, model_name=device.controller.model.name, model_display_name=device.controller.model.display_name) if device.led: led = dict( id=str(device.led.id), name=device.led.name, display_name=device.led.display_name, comment=device.led.comment, create_time=datetime_to_iso8601(device.led.create_time), update_time=datetime_to_iso8601(device.led.update_time), model_id=device.led.model.id, serial_no=device.led.serial_no, model_name=device.led.model.name, model_display_name=device.led.model.display_name) if device.device_group: device_group = dict( id=str(device.device_group.id), name=device.device_group.name, display_name=device.device_group.display_name, comment=device.device_group.comment, create_time=datetime_to_iso8601( device.device_group.create_time), update_time=datetime_to_iso8601( device.device_group.update_time)) detail.append( dict(id=str(device.id), name=device.name, display_name=device.display_name, comment=device.comment, status=device.status, power_status=device.power_status, wgs_x=device.wgs_x, wgs_y=device.wgs_y, address=device.address, device_group=device_group, controller=controller, led=led)) convert_null_emptystr(detail) response_body = {"devices": detail} return response_body except Exception as e: db.session.rollback() logger.error(f"The user input may incorrect, {str(e)}") raise finally: db.session.close()