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