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