def create(self, username, password, code, full_name, role):
try:
user = User(username=username, password=password, code=code, full_name=full_name, role=role)
user.save()
return {"success": True, "message": "Thành công"}
except Exception as e:
return {"success": False, "message": "Thất bại"}
def test_user_level(self):
username = self.person.username()
email = self.person.email(domains=["gmail.com"])
password = self.person.password(length=25)
user_level = UserLevelEnum.ADMIN
user = User(username=username, email=email, password=password, _user_level=user_level)
user.save()
self.assertEqual(user._user_level, user_level)
def test_user_check_password(self):
username = self.person.username()
email = self.person.email(domains=["gmail.com"])
password = self.person.password(length=25)
user = User(username=username, email=email, password=password)
user.save()
self.assertTrue(user.check_password(password))
self.assertFalse(user.check_password("wrong password"))
def test_user_duplicate_error(self):
username = self.person.username()
email = self.person.email(domains=["gmail.com"])
password = self.person.password(length=25)
user = User(username=username, email=email, password=password)
user.save()
user2 = User(username=username, email=email, password=password)
user2, error = user2.save()
self.assertTrue(error)
self.assertTrue("duplicate key value violates unique constraint" in user2)
def test_user_json_property(self):
username = self.person.username()
email = self.person.email(domains=["gmail.com"])
password = self.person.password(length=25)
user = User(username=username, email=email, password=password)
user.save()
user_json: Dict[str, Any] = user.json
self.assertEqual(user_json.get("uid"), user.uid)
self.assertEqual(user_json.get("username"), user.username)
self.assertEqual(user_json.get("email"), user.email)
def test_user_phone(self):
username = self.person.username()
email = self.person.email(domains=["gmail.com"])
password = self.person.password(length=25)
user_level = UserLevelEnum.SUPER_ADMIN
user = User(username=username, email=email, password=password, _user_level=user_level)
user.save()
self.assertListEqual(user.phones, [])
phones = ["01711111110", "01600000001"]
user, err = user.update(phones=phones)
self.assertFalse(err)
self.assertListEqual(user.phones, phones)
self.assertEqual(len(user.phones), len(phones))
def get_new_user() -> User:
person = Person()
username = person.username()
email = person.email(domains=["gmail.com", "yahoo.com"])
password = person.password(length=25)
user = User(username=username, email=email, password=password)
user, error = user.save()
return user
async def user_register(cls, request):
def set_body(status=RET.OK, token=None, uid=None):
body = dict()
body['status'] = status
body['msg'] = error_map.get(status, 'status not def')
if status == RET.OK:
body['token'] = token
expires = int(
(datetime.datetime.now() +
datetime.timedelta(minutes=1)).timestamp() * 1000)
body['expires'] = expires
body['user_email'] = request.get('data', {}).get('email', None)
body['uid'] = uid
return body
if not request["data"]:
return set_body(RET.PARAMERR)
client_data = request.get("data", {})
user_email = client_data.get('email', None)
password = client_data.get('password', None)
phone = client_data.get('phone', None)
if not all([user_email, password]):
# 这种请求，前端不允许提交空数据
return set_body(RET.PARAMERR)
# 检查该邮箱是否已经存在
user = User.objects.filter(email=user_email)
if user:
return set_body(RET.DATAEXIST)
user = User(email=user_email,
password=encry_pwd(password),
phone=phone)
try:
user.save()
uid = str(user.id)
payload = dict(uid=uid)
token = new_token(payload, new_sec_secret(uid))
#send
print("发送激活邮件")
return set_body(RET.OK, token, uid=str(user.id))
except Exception as e:
except_body = set_body(RET.SERVERERR)
except_body["msg"] = "{} excpetion:{}".format(
body.get("msg", ""), e)
return except_body
def test_user_relationship_vehicles(self):
username = self.person.username()
email = self.person.email(domains=["gmail.com"])
password = self.person.password(length=25)
user_level = UserLevelEnum.ADMIN
user = User(username=username, email=email, password=password, _user_level=user_level)
user.save()
vehicle1 = Vehicle(user.uid, serial_number=f"serial-{Generator.uuid()}")
vehicle2 = Vehicle(user.uid,
serial_number=f"serial-{Generator.uuid()}",
engine_number=f"engine_{Generator.uuid()}")
vehicle3 = Vehicle(user.uid,
serial_number=f"serial-{Generator.uuid()}",
engine_number=f"engine_{Generator.uuid()}",
license_number=f"license-{Generator.uuid()}")
user.vehicles.append(vehicle1)
user.vehicles.append(vehicle2)
user.vehicles.append(vehicle3)
db.session.commit()
find_user = User.query.get(user.uid)
self.assertIsNotNone(find_user)
self.assertTrue(find_user.vehicles != [])
self.assertEqual(len(find_user.vehicles), 3)
self.assertTrue(vehicle1.owner == vehicle2.owner == vehicle3.owner)
vehicles = [vehicle1, vehicle2, vehicle3]
for index, _ in enumerate(vehicles):
self.assertEqual(find_user.vehicles[index].uid, vehicles[index].uid)
self.assertEqual(find_user.vehicles[index].item_type, ItemTypeEnum.VEHICLE)
self.assertEqual(find_user.vehicles[index].is_stolen, vehicles[index].is_stolen)
self.assertEqual(find_user.vehicles[index].gd_copy_number, vehicles[index].gd_copy_number)
self.assertEqual(find_user.vehicles[index].remarks, vehicles[index].remarks)
self.assertEqual(find_user.vehicles[index].remarks, vehicles[index].remarks)
self.assertEqual(find_user.vehicles[index].record_time, vehicles[index].record_time)
self.assertEqual(find_user.vehicles[index].last_update, vehicles[index].last_update)
self.assertEqual(find_user.vehicles[index].serial_number, vehicles[index].serial_number)
self.assertEqual(find_user.vehicles[index].engine_number, vehicles[index].engine_number)
self.assertEqual(find_user.vehicles[index].license_number, vehicles[index].license_number)
def test_user_delete(self):
username = self.person.username()
email = self.person.email(domains=["gmail.com"])
password = self.person.password(length=25)
user_level = UserLevelEnum.SUPER_ADMIN
user = User(username=username, email=email, password=password, _user_level=user_level)
user.save()
find_user: User = User.query.filter(
User.username == username
).first()
self.assertIsNotNone(find_user)
find_user.delete()
find_user: User = User.query.filter(
User.username == username
).first()
self.assertIsNone(find_user)
def test_user_repr(self):
username = self.person.username()
email = self.person.email(domains=["gmail.com"])
password = self.person.password(length=25)
user = User(username=username, email=email, password=password)
user, error = user.save()
self.assertFalse(error)
user_string = str(user)
self.assertIsNotNone(user_string)
def test_user_relationship_cellphones(self):
username = self.person.username()
email = self.person.email(domains=["gmail.com"])
password = self.person.password(length=25)
user_level = UserLevelEnum.USER
user = User(username=username, email=email, password=password, _user_level=user_level)
user.save()
generic = Generic("en")
phone1 = CellPhone(user.uid, imei_1=generic.code.imei())
phone2 = CellPhone(user.uid, imei_1=generic.code.imei(), imei_2=generic.code.imei(),
remarks="Dual sim phone.", is_stolen=True, gd_copy_number=f"GD-{Generator.uuid()}")
phone3 = CellPhone(user.uid, imei_2=generic.code.imei(), is_stolen=False,
remarks="Oneek bhaalo phone!")
user.cell_phones.append(phone1)
user.cell_phones.append(phone2)
user.cell_phones.append(phone3)
db.session.commit()
find_user = User.query.get(user.uid)
self.assertIsNotNone(find_user)
self.assertTrue(find_user.cell_phones != [])
self.assertEqual(len(find_user.cell_phones), 3)
self.assertTrue(phone1.owner == phone2.owner == phone3.owner)
phones = [phone1, phone2, phone3]
for index, _ in enumerate(phones):
self.assertEqual(find_user.cell_phones[index].uid, phones[index].uid)
self.assertEqual(find_user.cell_phones[index].item_type, ItemTypeEnum.CELL_PHONE)
self.assertEqual(find_user.cell_phones[index].is_stolen, phones[index].is_stolen)
self.assertEqual(find_user.cell_phones[index].gd_copy_number, phones[index].gd_copy_number)
self.assertEqual(find_user.cell_phones[index].remarks, phones[index].remarks)
self.assertEqual(find_user.cell_phones[index].remarks, phones[index].remarks)
self.assertEqual(find_user.cell_phones[index].record_time, phones[index].record_time)
self.assertEqual(find_user.cell_phones[index].last_update, phones[index].last_update)
self.assertEqual(find_user.cell_phones[index].imei_1, phones[index].imei_1)
self.assertEqual(find_user.cell_phones[index].imei_2, phones[index].imei_2)
def register():
user_data = request.json
user_data["password"] = User.hash_password(
user_data["password"].encode("utf-8"))
user_data["role"] = UserRole.USER.value
user = User.get_or_none(User.email == user_data.get("email"))
if user:
raise SanoException(400, REGISTER_EXCEPTION, "already registered")
user = User(**user_data)
user.save()
access_token = token_urlsafe(40)
data = user.to_session_dict()
_save_session(access_token, data)
data["access_token"] = access_token
return respond_data(data, 201)
def register_user():
body = request.json
print(body, flush=True)
name = body['name']
email = body['email']
username = body['username']
profile_picture = body['profile_picture']
password = body['password']
user_type = body['user_type']
about = body["about"]
print(password, flush=True)
password_encoded = password.encode('utf-8')
hashed_password = bcrypt.hashpw(password_encoded, bcrypt.gensalt(12))
user = User(name=name, email=email, username=username, password=hashed_password, profile_picture=profile_picture, user_type=user_type)
with db.atomic() as tx:
try:
user.save()
return respond(user.to_dict(), 201)
except Exception as e:
return respond_error(str(e), 500)
def test_user_relationship_laptops(self):
username = self.person.username()
email = self.person.email(domains=["gmail.com"])
password = self.person.password(length=25)
user_level = UserLevelEnum.MODERATOR
user = User(username=username, email=email, password=password, _user_level=user_level)
user.save()
laptop1 = Laptop(user.uid, serial_number="unique_serial_" + Generator.uuid(),
mac_address="unique_mac_" + Generator.uuid(), is_stolen=True)
laptop2 = Laptop(user.uid, serial_number="unique_serial_" + Generator.uuid(),
mac_address="unique_mac_" + Generator.uuid(),
remarks="This laptop is imported and genuine operating system installed.")
user.laptops.append(laptop1)
user.laptops.append(laptop2)
db.session.commit()
find_user = User.query.get(user.uid)
self.assertIsNotNone(find_user)
self.assertTrue(find_user.laptops != [])
self.assertEqual(len(find_user.laptops), 2)
self.assertTrue(laptop1.owner == laptop2.owner)
laptops = [laptop1, laptop2]
for index, laptop in enumerate(laptops):
self.assertEqual(find_user.laptops[index].uid, laptops[index].uid)
self.assertEqual(find_user.laptops[index].item_type, ItemTypeEnum.LAPTOP)
self.assertEqual(find_user.laptops[index].is_stolen, laptops[index].is_stolen)
self.assertEqual(find_user.laptops[index].gd_copy_number, laptops[index].gd_copy_number)
self.assertEqual(find_user.laptops[index].remarks, laptops[index].remarks)
self.assertEqual(find_user.laptops[index].remarks, laptops[index].remarks)
self.assertEqual(find_user.laptops[index].record_time, laptops[index].record_time)
self.assertEqual(find_user.laptops[index].last_update, laptops[index].last_update)
self.assertEqual(find_user.laptops[index].serial_number, laptops[index].serial_number)
self.assertEqual(find_user.laptops[index].mac_address, laptops[index].mac_address)
def test_user_save(self):
username = self.person.username()
email = self.person.email(domains=["gmail.com"])
password = self.person.password(length=25)
user = User(username=username, email=email, password=password)
user, error = user.save()
self.assertFalse(error)
self.assertIsInstance(user, User)
self.assertNotIsInstance(user, str)
self.assertEqual(user.email, email)
self.assertEqual(user.email, email)
self.assertEqual(user.username, username)
self.assertIsInstance(user.joined_at, datetime.datetime)
def test_user_address(self):
username = self.person.username()
email = self.person.email(domains=["gmail.com"])
password = self.person.password(length=25)
user_level = UserLevelEnum.USER
user = User(username=username, email=email, password=password, _user_level=user_level)
user.save()
self.assertDictEqual(user.address, {})
address = {
"area": "Mohakhali",
"city": "Dhaka",
"thana": {
"name": "Banani",
"zip": 1213
}
}
user, err = user.update(address=address)
self.assertFalse(err)
self.assertDictEqual(user.address, address)
self.assertEqual(user.address.get("city"), address.get("city"))
def create_new_user(username: str, email: str, password: str,
**kwargs) -> Union[Tuple[User, bool], Tuple[str, bool]]:
user = User(username=username, email=email, password=password, **kwargs)
return user.save()
