def post(self):
""" User login """
payload = request.json
cust_name = str_trim(payload.get("custname"))
user_name = str_trim(payload.get("username"))
user_pass = str_trim(payload.get("password"))
if not (cust_name and user_name and user_pass):
raise BadRequest(ret.http_resp(ret.RET_AUTH_MISSING))
cust = search_cust(cust_name)
if not cust:
raise Unauthorized(ret.http_resp(ret.RET_AUTH_NO_CUST, cust_name))
user = search_user(cust.id, user_name)
if not user:
raise Unauthorized(ret.http_resp(ret.RET_AUTH_NO_USER, user_name))
if user.check_password(user_pass):
resp = generate_user_tokens(str(cust.id), str(user.id), user_name)
resp.update(get_user_role(user.id))
if resp:
return ret.http_resp(ret.RET_OK,
extra=resp), status.HTTP_200_OK
else:
raise Unauthorized(ret.http_resp(ret.RET_AUTH_WRONG_PASS))
def get(self):
""" give User list """
cust_id = aaa_verify()
response = response_getall(cust_id)
if not response:
raise NotFound(ret.http_resp(ret.RET_NOT_FOUND))
return ret.http_resp(ret.RET_OK, extra=response), status.HTTP_200_OK
def post(self):
""" give User list """
cust_id = aaa_verify()
user_list = request.json.get("users")
response = response_get_detail(cust_id, user_list)
if not response:
raise NotFound(ret.http_resp(ret.RET_NOT_FOUND))
return ret.http_resp(ret.RET_OK, extra=response), status.HTTP_200_OK
def get(self):
""" get all device groups """
cust_id = aaa_verify()
response = response_getallsummary(cust_id)
if not response:
raise NotFound(ret.http_resp(ret.RET_NOT_FOUND))
return ret.http_resp(ret.RET_OK, extra=response), status.HTTP_200_OK
def post(self):
""" get detail device """
cust_id = aaa_verify()
device_list = request.json.get("devices")
response = response_get_detail(cust_id, device_list)
if not response:
raise NotFound(ret.http_resp(ret.RET_NOT_FOUND))
return ret.http_resp(ret.RET_OK, extra=response), status.HTTP_200_OK
def post(self):
""" add User """
cust_id = aaa_verify()
payload = request.json
response = response_add(cust_id, payload)
if not response:
raise NotFound(ret.http_resp(ret.RET_NOT_FOUND))
return ret.http_resp(ret.RET_OK, extra=response), status.HTTP_200_OK
def post(self):
""" add group """
cust_id = aaa_verify()
data = request.json
response = response_add_groups(cust_id, data)
if not response:
raise NotFound(ret.http_resp(ret.RET_NOT_FOUND))
return ret.http_resp(ret.RET_OK,
extra=response), status.HTTP_201_CREATED
def post(self):
""" show device group detail """
cust_id = aaa_verify()
data = request.json
device_groups_list = data.get("device_groups")
response = response_getdetail(cust_id, device_groups_list)
if not response:
raise NotFound(ret.http_resp(ret.RET_NOT_FOUND))
return ret.http_resp(ret.RET_OK, extra=response), status.HTTP_200_OK
def post(self):
""" add group """
cust_id = aaa_verify()
data = request.json
add_groups = [(group.get("name"), group.get("display_name")) for group in data.get("device_groups")]
response = response_add_groups(add_groups, cust_id)
if not response:
raise NotFound(ret.http_resp(ret.RET_NOT_FOUND))
return ret.http_resp(ret.RET_OK, extra=response), status.HTTP_201_CREATED
def get(self):
jti = get_raw_jwt().get("jti")
if jti:
is_in_blacklist = sdBlacklistToken.check_is_in_blacklist(jti)
if not is_in_blacklist:
logout_user(jti)
return ret.http_resp(ret.RET_OK), status.HTTP_200_OK
else:
raise Unauthorized(ret.http_resp(ret.RET_AUTH_TOKEN_EXPIRED))
else:
raise Unauthorized(ret.http_resp(ret.RET_AUTH_FAIL))
def test_account_group_join(self):
# TAG add usergroup
input_data = add_user_groups()
token = self.login()
resp = self.client.post("api/v1/account/group/add",
data=json.dumps(input_data),
content_type="application/json",
headers={"Authorization": f"Bearer {token}"})
# TAG add users
input_data = add_user_generate(1, 6)
resp = self.client.post("api/v1/account/add",
data=json.dumps(input_data),
content_type="application/json",
headers={"Authorization": f"Bearer {token}"})
# TAG join users
input_data = {"users": ["1", "2", "3"]}
resp = self.client.put("api/v1/account/group/2/join",
data=json.dumps(input_data),
content_type="application/json",
headers={"Authorization": f"Bearer {token}"})
data = json.loads(resp.data.decode())
expect = ret.http_resp(ret.RET_OK)
self.assert200(resp)
self.assertEqual(data, expect)
query = db.session.query(rel_u_ug).filter(rel_u_ug.c.user_group_id == 2).all()
self.assertTrue([(1, 2), (2, 2), (3, 2)] == query)
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 delete(self):
""" delete group """
cust_id = aaa_verify()
group_id_list = request.json.get("user_groups")
response_delete_groups(cust_id, group_id_list)
return ret.http_resp(ret.RET_OK), status.HTTP_200_OK
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_ug_leave_dg(self):
# TAG add device group
FakeDataCreation().insert_device_group(5, 0).insert_device(20)
# TAG add usergroup
input_data = add_user_groups()
token = self.login()
resp = self.client.post("api/v1/account/group/add",
data=json.dumps(input_data),
content_type="application/json",
headers={"Authorization": f"Bearer {token}"})
# TAG join usergroup
input_data = {"user_groups": ["2", "3"]}
resp = self.client.put("/api/v1/device/group/2/join_ug",
data=json.dumps(input_data),
content_type="application/json",
headers={"Authorization": f"Bearer {token}"})
# TAG leave usergroup
input_data = {"user_groups": ["2"]}
resp = self.client.put("/api/v1/device/group/2/leave_ug",
data=json.dumps(input_data),
content_type="application/json",
headers={"Authorization": f"Bearer {token}"})
data = json.loads(resp.data.decode())
expect = ret.http_resp(ret.RET_OK)
self.assert200(resp)
self.assertEqual(data, expect)
query = db.session.query(rel_dg_ug).filter(rel_dg_ug.c.device_group_id == 2).all()
self.assertTrue([(2, 3)] == query)
def get(self):
""" show device lists """
response = "Hello world !!"
if not response:
raise NotFound(ret.http_resp(ret.RET_NOT_FOUND))
return response, status.HTTP_200_OK
def user_getall_ref_json(start, end, mode):
ret_json = ret.http_resp(ret.RET_OK)
json = []
json.append(dict(id="1", name="testuser", display_name="Test User", group=["1"]))
for num in range(start, end):
if num <= 6:
customer = "NTPC"
else:
customer = "TPC"
if mode == 1:
# TAG change str here
json.append(dict(id=str(num),
name=f"user_{num}",
display_name=f"User_{num} ({customer})",
group=[]))
elif mode == 2:
# TAG change str here
json.append(dict(id=str(num),
name=f"user_{num}",
display_name=f"User_{num} ({customer})",
group=[],
email=email[0],
telephone=telephone[0],
comment="comment here"))
ret_json.update({"users": json})
return ret_json
def put(self):
"""update the selected groups """
cust_id = aaa_verify()
renamed_items = [(rename.get("id"), rename.get("name"), rename.get("display_name"))
for rename in request.json.get("device_groups")]
response_update_groups(cust_id, renamed_items)
return ret.http_resp(ret.RET_OK), status.HTTP_200_OK
def usergroup_getall_ref_json():
ret_json = ret.http_resp(ret.RET_OK)
json = []
location = ["三芝", "淡水", "北投"]
json.append(dict(id="1", name="testuser", display_name="Test User", users=["1"]))
for num, name in enumerate(location):
json.append(dict(id=str(num+2),
name=name,
display_name=f"你好{name}",
users=[]))
ret_json.update({"user_groups": json})
return ret_json
def post(self):
""" give User device list """
cust_id = aaa_verify()
payload = request.json
user_name, device_number = get_cust_user_device(payload)
# using redis to enhance efficiency
namespace = f"traffic_light:device:getall:{cust_id}"
cache = redis_general_get(namespace)
if not cache:
data = getall_devicelist_for_geojson(cust_id, user_name,
device_number)
response = get_geojson_from_sql_results(data)
logger.info(f"cache not found, query from database...")
redis_general_add(namespace, response)
else:
logger.info(f"get all devices using cache: {namespace}")
response = cache
if not response:
raise NotFound(ret.http_resp(ret.RET_NOT_FOUND))
return ret.http_resp(ret.RET_OK, extra=response), status.HTTP_200_OK
def ref_json():
ret_json = ret.http_resp(ret.RET_OK)
json = []
divisor = 10 // 5
for id in range(3):
# TAG change str here
json.append(dict(id=str(id+1),
name=f"testname_{id+1}",
display_name="奇岩的路燈",
comment="測試留言武功蓋世，世界大亂鬥。(){}@#$&*^",
status=0,
power_status=1,
wgs_x=121.8,
wgs_y=21.5,
address="",
dimming=50,
dimming_level=3,
device_group=dict(id=str(id // divisor + 1),
name=f"testgroup_{id // divisor + 1}",
display_name='test_streetlight',
comment="",
create_time='2019-12-18T00:00:00+08:00',
update_time='2019-12-18T00:00:00+08:00'),
controller=dict(id=str(id+1),
name=f"test_controller_{id+1}",
display_name="奇岩的controller",
comment="For Unit Test",
create_time="2019-12-18T00:00:00+08:00",
update_time="2019-12-18T00:00:00+08:00",
model_id=0,
serial_no="BX000{}".format(id+1),
model_name="test_device_model",
model_display_name="Test Device Model"),
led=dict(id=str(id+1),
name=f"test_led_{id+1}",
display_name="Test User",
comment="For Unit Test",
create_time="2019-12-18T00:00:00+08:00",
update_time="2019-12-18T00:00:00+08:00",
model_id=0,
serial_no="BX000{}".format(id + 1),
model_name="test_device_model",
model_display_name="Test Device Model")))
ret_json.update({"devices": json})
return ret_json
def add_device_geojson_to_db(max_device):
ret_json = ret.http_resp(ret.RET_OK)
user_devices_json = {"type": "FeatureCollection",
"features": []}
for number in range(max_device):
status, power_status, dimming = generate_status_dimming(number+1)
each_sample_json = {"type": "Feature",
"geometry": {"type": "Point",
"coordinates": [50.12,
50.12]},
"properties": {"id": str(number),
"name": str(number),
"display_name": "none",
"comment": "null",
"status": status,
"power_status": power_status,
"address": "New Taipei City, Beitou.",
"dimming": dimming,
"dimming_level": dimming_convert(dimming),
"group_name": "testgroup_1",
"group_display_name": "test_streetlight"
}}
user_devices_json["features"].append(each_sample_json)
testing_device_data = sdDevice(id=each_sample_json["properties"]["id"],
name=each_sample_json["properties"]["name"],
display_name=each_sample_json["properties"]["display_name"],
comment=each_sample_json["properties"]["comment"],
create_time="2019-10-22 11:18:55",
update_time="2019-10-22 11:18:55",
dev_type=1,
cust_id=1,
power_status=power_status,
status=each_sample_json["properties"]["status"],
dimming=each_sample_json["properties"]["dimming"],
wgs_x=each_sample_json["geometry"]["coordinates"][0],
wgs_y=each_sample_json["geometry"]["coordinates"][1],
address=each_sample_json["properties"]["address"],
device_group_id=1
)
db.session.add(testing_device_data)
db.session.commit()
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 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 put(self, user_group_id):
""" join schedule groups """
cust_id = aaa_verify()
payload = request.json
response_leave_users(cust_id, user_group_id, payload)
return ret.http_resp(ret.RET_OK), status.HTTP_200_OK
def missing_header_handler(callback):
return ret.http_resp(
ret.RET_AUTH_TOKEN_MISSING), status.HTTP_401_UNAUTHORIZED
def expired_token_handler(callback):
return ret.http_resp(
ret.RET_AUTH_TOKEN_EXPIRED), status.HTTP_401_UNAUTHORIZED
def post(self):
refresh = get_jwt_identity()
token = access_token(refresh)
return ret.http_resp(ret.RET_OK, extra=token), status.HTTP_200_OK
def delete(self):
""" Delete User """
cust_id = aaa_verify()
user_list = request.json.get("users")
response_delete(cust_id, user_list)
return ret.http_resp(ret.RET_OK), status.HTTP_200_OK
def put(self):
""" update device """
cust_id = aaa_verify()
payload = request.json
response_update(cust_id, payload)
return ret.http_resp(ret.RET_OK), status.HTTP_200_OK
