def fake_user():
data = [{
"username": 17020001,
"password": 17020001,
"code": 17020706,
"full_name": "Rudolph Clynmans",
"role": 1
}, {
"username": 17020002,
"password": 17020002,
"code": 17020707,
"full_name": "Nelson Guidini",
"role": 1
}, {
"username": 17020003,
"password": 17020003,
"code": 17020708,
"full_name": "Ira Shay",
"role": 1
}, {
"username": 17020004,
"password": 17020004,
"code": 17020709,
"full_name": "Rodina Padwick",
"role": 1
}, {
"username": 17020005,
"password": 17020005,
"code": 17020710,
"full_name": "Tait Gofforth",
"role": 1
}, {
"username": 17020006,
"password": 17020006,
"code": 17020711,
"full_name": "Aubert Sibbet",
"role": 1
}, {
"username": 17020007,
"password": 17020007,
"code": 17020712,
"full_name": "Amabel Tapin",
"role": 1
}, {
"username": 17020008,
"password": 17020008,
"code": 17020713,
"full_name": "Morgun Donnellan",
"role": 1
}, {
"username": "******",
"password": "******",
"code": 1,
"full_name": "Le dinh thanh",
"role": 2
}]
with db.atomic():
for data_dict in data:
User.create(**data_dict)
def to_object_from_dict(user_obj: dict, **kwargs):
user = User(user_obj['email'], user_obj['password'], authenticated=user_obj['authenticated'])
user.registered_events = kwargs['registered_events']
user.created_events = kwargs['created_events']
# logger.debug(user)
return user
def get_list(self):
user = User()
list_user = user.select().dicts().execute()
data = []
for i in list_user:
data.append(i)
print(list_user)
return {"success": True, "users": data}
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 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
def add_user(self, user: User):
user = UserDBMapper(user)
logger.debug("Inserting: " + str(user.to_db_object()))
all_users = list(self.get_all_users())
for user_present in all_users:
if user.email == user_present.email:
raise DuplicateUserException(user)
self.table.insert(user.to_db_object())
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_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 authenticate(username, password):
users = User()
try:
user = User.get(User.username == username)
print(user.password)
if user and safe_str_cmp(user.password.encode('utf-8'),
password.encode('utf-8')):
return user
return None
except:
return None
def register():
if current_user.is_authenticated:
return redirect(url_for('info'))
form = RegistrationForm()
if form.validate_on_submit():
user = User(username=form.username.data, email=form.email.data)
user.password = bcrypt.generate_password_hash(form.password.data)
db.session.add(user)
db.session.commit()
flash(*messages['login.new'])
return redirect(url_for('login'))
return render_template('rejestracja.html', title='Register', form=form)
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 init_tables():
StorageDb.connect()
try:
MenuItem.create_table(True)
ChartInfo.create_table(False)
User.create_table(True)
MenuItem.create_table(True)
SimplePageConfig.create_table(True)
ReportInfo.create_table(True)
Connection.create_table(True)
SQLquery.create_table(True)
ServerConfig.create_table(True)
User.create(login='******', password='******', name='Test User')
create_menu_item("/admin/" ,'Home', -1, 'SimplePage', 1)
SimplePageConfig.create(title="Admin Home", text="This is admin home")
create_menu_item("/app/" ,'Home', -1, 'SimplePage', 2)
SimplePageConfig.create(title="Home", text="This is the home page")
create_menu_item("/admin/" ,'UpdateDB', 0, 'UpdateDB', 3)
SimplePageConfig.create(title="Menu", text="This is the Menu page")
create_menu_item("/admin/" ,'Report Creator', 0, 'ReportCreator', 4)
SimplePageConfig.create(title="Config", text="This is the Config page")
create_menu_item("/app/" ,'Reports', -1, 'Reports', 5)
create_menu_item("/app/" ,'Charts', 4, 'Charts', 8)
create_menu_item("/admin/" ,'Chart Creator', 4, 'ChartCreator', 9)
Connection.create(name="local", description="", connection_engine="mysql", \
connection_login="******", connection_password="******", \
connection_host ="127.0.0.1", \
connection_defaultdb="mysql", connection_port = 3306)
SQLquery.create(name='test', description='', sql="""SELECT *
FROM mysql.user
""", connection_id=1)
ReportInfo.create(name="Users", description="Report description", source_type='SQLquery', \
source_id=1, cache_duration=86000, row_callback=""""fnRowCallback": function( nRow, aData, iDisplayIndex ) {
$('td:eq(2)', nRow).html('<a href="/testpage?' + aData[2] + '"> link </a>');
return nRow;
},""")
ServerConfig.create(key="CookieKey", value=random_string(50))
ServerConfig.create(key="AppName", value="EazyReport")
ServerConfig.create(key="CacheFolder", value="cache")
except Exception, e:
print "Database already exists", e
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_update_in_bulk(self):
users = list()
length = 3
for _ in range(length):
username = self.person.username()
email = self.person.email(domains=["gmail.com", "aol.com"])
password = self.person.password(length=50)
users.append(User(username, email, password))
self.db.session.add_all(users)
User.update_all(users, address={"city": "Dhaka"})
self.assertTrue(any(user.address != {} for user in users))
for user in users:
self.assertEqual(user.address.get("city"), "Dhaka")
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 setUp(self) -> None:
self.user = User('*****@*****.**', 'password')
self.event_scheduler = EventScheduler(self.user)
self.event = self.event_scheduler.create_event("Event One",
'2020-01-12 20:30:00',
'2020-01-12 22:30:00',
False)
def _upload_profile_pic():
print("profile pic", flush=True)
data = request.files.getlist("file[]")
for file in data:
if file.filename == "":
return respond_error("No filename uploaded", 400)
filename = secure_filename(file.filename)
extension = filename.split(".")[-1]
if extension not in ALLOWED_EXTENSIONS:
return respond_error(f"{extension} not allowed", 400)
result = []
for file in data:
filename = secure_filename(file.filename)
db_file = File(filename=filename, owner=g.user.id)
db_file.save()
file.save(os.path.join(os.environ["UPLOAD_DIR"], db_file.unique_id))
result.append(db_file.to_dict())
print(result[0], flush=True)
user = User.get_or_none(User.id == g.user.id)
if user is not None:
user.profile_picture = result[0]['unique_id']
user.save()
print(result, flush=True)
return respond(result, 201)
def delete(self, id):
try:
user = User.get(User.id);
user.delete()
return {"success": True, "message": "Thành công"}
except Exception as e:
return {"success": False, "message": "Thất bại",}
def test_user_mode(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)
self.assertIsNotNone(user)
self.user = user
def get_user_by_username(username):
print(username)
user = User.get_or_none(User.username == username)
if user is not None:
return respond(user.to_dict(), 201)
else:
return respond_error("No user found", 404)
def get_lawyer_cases(id):
print(id)
lawyer = User.get_or_none(User.id == id)
reviews = Cases.select().where(Cases.lawyer == lawyer).order_by(
Cases.pub_at.desc())
reviews = [r.to_dict() for r in reviews]
return respond(reviews, 201)
def get_reviews(id):
lawyer = User.get_or_none(User.id==id)
if lawyer is not None:
review = Review.select().where(Review.lawyer == id).order_by(Review.pub_at.desc())
review = [r.to_dict() for r in review]
return respond(review, 201)
else:
return respond("No review", 500)
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 setUp(self):
server.config['TESTING'] = True
self.client = server.test_client()
db.create_all()
self.user = User('*****@*****.**', 'super-secret-password')
db.session.add(self.user)
db.session.commit()
def check_login():
user = User.authenticate(request.form['Username'], request.form['Password'])
if user:
login_user(user)
flash(*messages['login.correct'])
else:
flash(*messages['login.invalid'])
return redirect('/login')
def add_user(self, new_user: UserEntity):
new_user = User()
new_user.id = new_user.id
new_user.name = new_user.name
new_user.picture_url = new_user.picture_url
new_user.status_message = new_user.status_message
db.session.add(new_user)
db.session.commit()
def get_profile():
user = g.user
user = User.get_or_none(User.id == user["id"])
data = user.to_dict()
membership = Membership.get_or_none(Membership.user == user.id)
data["membership"] = membership.to_dict()
return respond_data(data)
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 init_admin_user():
admin_user = User.query.filter_by(pseudo="admin").first()
if admin_user == None:
service.logMessage(".INIT : Ajout de l'admin")
u = User("admin", "pass")
service.addObject(u)
service.logMessage(".INIT : Ajout de l'utilisateur 'admin'")
else:
service.logMessage(".INIT : Admin OK")
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_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 auth(self):
r1 = Role(name="Admin",descr="Administrator")
r1.put()
r2 = Role(name="User",descr="User")
r2.put()
u1 = User(uname='sa',
pword=self.shash('admin'),
role=r1)
u1.put()
u2 = User(uname='guest',
pword=self.shash('user'),
role=r2)
u2.put()
def test_users():
users = User.find_all()
return dict(users=users)
