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 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 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 test_group_delete(self):
FakeDataCreation().insert_device_group(5, 0).insert_device(20)
delete_data = {"device_groups": ["1", "2", "3"]}
token = self.login()
resp = self.client.delete("/api/v1/device/group/delete",
data=json.dumps(delete_data),
content_type="application/json",
headers={"Authorization": f"Bearer {token}"})
logger.debug("Delete Reponse " + resp.status)
data = json.loads(resp.data.decode())
expect = ret.http_resp(ret.RET_OK)
stmt = db.select([sdDeviceGroup.id])
db_changed = [i[0] for i in db.session.execute(stmt).fetchall()]
self.assert200(resp)
self.assertEqual(data, expect)
# test db changed
self.assertEqual(db_changed, [4, 5])
def test_group_update(self):
FakeDataCreation().insert_device_group(5, 0)
rename_data = {"device_groups": [dict(id=str(count), name=f"{name}", display_name="McDonald")
for count, name in zip(range(1, 4), ["hungry", "milk tea", "buddha tea"])]}
token = self.login()
resp = self.client.put("/api/v1/device/group/update",
data=json.dumps(rename_data),
content_type="application/json",
headers={"Authorization": f"Bearer {token}"})
logger.debug("Rename Response " + resp.status)
data = json.loads(resp.data.decode())
query = db.select([func.count()]).where(sdDeviceGroup.display_name == 'McDonald')
db_changed = db.session.execute(query).fetchone()[0]
expect = ret.http_resp(ret.RET_OK)
self.assert200(resp)
self.assertEqual(data, expect)
# test db changed
self.assertEqual(db_changed, 3)
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_geojson_from_sql_results(
results
): # the contents here should be same with "add_device_geojson_to_db (test)"
first_type = "FeatureCollection"
second_type = "Feature"
third_type = "Point"
user_devices_json = dict(type=first_type, features=[])
user_devices_json['features'] = [
{
"type": second_type,
"geometry": {
"type": third_type,
"coordinates": [wgs_x, wgs_y]
},
"properties": {
"id": str(device_id),
"name": name,
"display_name": display_name,
"comment": comment,
"status": status,
"power_status": power_status,
"address": address,
"group_name": group_name,
"group_display_name": group_display_name
}
} for device_id, name, display_name, comment, status, power_status,
wgs_x, wgs_y, address, group_name, group_display_name in results
]
logger.debug("success for generate GeoJSON data.")
convert_null_emptystr(user_devices_json)
combined_json = {"geojson": user_devices_json}
return combined_json
def test_account_getall(self):
user_insertion()
token = self.login()
resp = self.client.get("/api/v1/account/getall",
headers={"Authorization": f"Bearer {token}"})
logger.debug(resp.status)
data = json.loads(resp.data.decode())
ref_json = user_getall_ref_json(2, 10, 1)
self.assert200(resp)
self.assertEqual(data, ref_json)
def test_user_access_authorization_bad(self):
# take account as example
user_insertion()
token = self.login("testcust", "user_2")
resp = self.client.get("/api/v1/account/getall",
headers={"Authorization": f"Bearer {token}"})
logger.debug(resp.status)
data = json.loads(resp.data.decode())
self.assert401(resp)
self.assertEqual(data, {"ret_code": 2008, "ret_desc": "API access authorization fail"})
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 test_group_getall(self):
FakeDataCreation().insert_device_group(5, 0).insert_device(20)
expect = ExpectResponse().compose_response_body().count(5, 20).group_id().name().display_name().user_groups()\
.devices().response()
token = self.login()
resp = self.client.get("/api/v1/device/group/getall", headers={"Authorization": f"Bearer {token}"})
logger.debug(resp.status)
# If not 200, this will crash
data = json.loads(resp.data.decode())
# Expect response is HTTP status 200
self.assert200(resp)
self.assertEqual(data, expect)
def test_account_getdetail(self):
user_insertion()
input_data = dict(users=["2", "3", "4"])
token = self.login()
resp = self.client.post("/api/v1/account/getdetail",
data=json.dumps(input_data),
content_type="application/json",
headers={"Authorization": f"Bearer {token}"})
logger.debug(resp.status)
data = json.loads(resp.data.decode())
ref_json = user_getall_ref_json(2, 5, 2)
ref_json["users"].pop(0)
self.assert200(resp)
self.assertEqual(data, ref_json)
def test_getdetail_device(self):
FakeDataCreation().insert_device_group(5, 0).insert_device(10)
getdetail_data = {"devices": ["1", "2", "3"]}
token = self.login()
resp = self.client.post("/api/v1/device/getdetail",
data=json.dumps(getdetail_data),
content_type="application/json",
headers={"Authorization": f"Bearer {token}"})
logger.debug("get detail Reponse " + resp.status)
text = resp.data.decode()
json_text = json.loads(text)
json_text = json.dumps(json_text, indent=4)
ref_ans = ref_json()
ref_ans = json.dumps(ref_ans, indent=4)
self.assertEqual(json_text, ref_ans)
def test_group_getdetail(self):
FakeDataCreation().insert_schedule_group(2).insert_schedule_item().insert_device_group(5, 5).insert_device(20)
token = self.login()
input_data = {"device_groups": ["1", "2"]}
resp = self.client.post("/api/v1/device/group/getdetail",
data=json.dumps(input_data),
content_type="application/json",
headers={"Authorization": f"Bearer {token}"})
logger.debug(resp.status)
# If not 200, this will crash
data = json.loads(resp.data.decode())
with open(file_dir + r"\stubs\device_group_getdetail.json", "r", encoding="utf-8") as reader:
expect = json.loads(reader.read())
# Expect response is HTTP status 200
self.assert200(resp)
self.assertEqual(data, expect)
def test_group_getallsummary(self):
# FakeDataCreation().insert_device_group(5, 0).insert_device(20)
FakeDataCreation().insert_schedule_group(6).insert_schedule_item().insert_device_group(5, 0)
device_group = db.session.query(sdDeviceGroup).filter(sdDeviceGroup.id == 1).first()
user_group = db.session.query(sdUserGroup).filter(sdUserGroup.id == 1).first()
user_group.rel_dg_ug.append(device_group)
db.session.commit()
# device_group.user_groups.append(user_group)
token = self.login()
resp = self.client.get("/api/v1/device/group/getallsummary", headers={"Authorization": f"Bearer {token}"})
logger.debug(resp.status)
# If not 200, this will crash
rawdata = json.loads(resp.data.decode())
# dg = rawdata.get("device_groups")
sorted_data = sorted(rawdata.get("device_groups"), key=lambda issue: issue.get("id"))
rawdata["device_groups"] = sorted_data
data = json.dumps(rawdata, indent=4)
expect = device_group_getallsummary_ref_ans()
expect = json.dumps(expect, indent=4)
self.assert200(resp)
self.assertEqual(data, expect)
def test_group_join(self):
FakeDataCreation().insert_device_group(5, 0).insert_device(20)
input_data = {"devices": ["17", "18", "19"]}
token = self.login()
resp = self.client.put("/api/v1/device/group/3/join",
data=json.dumps(input_data),
content_type="application/json",
headers={"Authorization": f"Bearer {token}"})
logger.debug("Join Group {} {}".format(resp.status, input_data['devices']))
data = json.loads(resp.data.decode())
expect = ret.http_resp(ret.RET_OK)
self.assert200(resp)
self.assertEqual(data, expect)
query = db.select([sdDevice.id]).where(sdDevice.device_group_id == 3)
devices = [device_id[0] for device_id in db.session.execute(query).fetchall()]
self.assertTrue([9, 10, 11, 12, 17, 18, 19] == devices)
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 test_account_delete(self):
user_insertion()
delete_data = {"users": ["2", "3", "4"]}
token = self.login()
resp = self.client.delete("/api/v1/account/delete",
data=json.dumps(delete_data),
content_type="application/json",
headers={"Authorization": f"Bearer {token}"})
logger.debug("Delete Reponse " + resp.status)
data = json.loads(resp.data.decode())
expect = ret.http_resp(ret.RET_OK)
stmt = db.select([sdUser.id])
db_changed = [i[0] for i in db.session.execute(stmt).fetchall()]
self.assert200(resp)
self.assertEqual(data, expect)
# test db changed
self.assertEqual(db_changed, [1, 5, 6, 7, 8, 9])
def seed():
# Add system customer
logger.debug("Adding system customer")
sys_cust = db.session.query(sdCustomer).filter(sdCustomer.id == 0).first()
if sys_cust:
logger.debug("System customer existed, ignore")
else:
sys_cust = sdCustomer(id=0,
name="system",
display_name="System",
comment="System (Default)")
db.session.add(sys_cust)
# Add system administrator
logger.debug("Adding system administrator")
sys_user = db.session.query(sdUser).filter(sdUser.id == 0).first()
if sys_user:
logger.debug("System administrator existed, ignore")
else:
sys_cust.users.append(sdUser(id=0,
name="admin",
display_name="System Administrator",
password="******",
comment="System Administrator (Default)"))
# Add default device_model
logger.debug("Adding default device model")
default_model = db.session.query(sdDeviceModel).filter(sdDeviceModel.id == 0).first()
if default_model:
logger.debug("Default device model existed, ignore")
else:
default_model = sdDeviceModel(id=0,
name="DEFAULT",
display_name="Default Model for all device model")
db.session.add(default_model)
# Commit transaction
db.session.commit()
