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 callback():
from config import Auth
from src.model import get_google_auth
from src.model import User, db
# Redirect user to home page if already logged in.
if current_user is not None and current_user.is_authenticated():
print("You are authorized...woo")
return redirect(url_for('knowledge.index'))
if 'error' in request.args:
if request.args.get('error') == 'access_denied':
return 'You denied access.'
return 'Error encountered.'
if 'code' not in request.args and 'state' not in request.args:
return redirect(url_for('login'))
else:
# Execution reaches here when user has
# successfully authenticated our app.
google = get_google_auth()
"""
if ( 'oauth_state' in session):
google = get_google_auth(state=session['oauth_state'])
try:
token = google.fetch_token(
Auth.TOKEN_URI,
client_secret=Auth.CLIENT_SECRET,
authorization_response=request.url)
except HTTPError:
return 'HTTPError occurred.'
"""
token = google.fetch_token(Auth.TOKEN_URI,
client_secret=Auth.CLIENT_SECRET,
authorization_response=request.url)
google = get_google_auth(token=token)
resp = google.get(Auth.USER_INFO)
if resp.status_code == 200:
user_data = resp.json()
email = user_data['email']
print "Email id is " + email
user = User.query.filter_by(email=email).first()
exited = True
if user is None:
exited = False
user = User()
user.email = email
user.name = user_data['name']
print "User name is " + user.name
user.tokens = json.dumps(token)
user.avatar = user_data['picture']
db.session.add(user)
db.session.commit()
login_user(user)
if (not exited):
flash(
"Successfully logged in, have a check on your preferences")
return redirect(url_for('knowledge.preference'))
else:
return redirect(url_for('knowledge.index'))
return 'Could not fetch your information.'
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 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_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 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_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 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 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 add_user(self, user: UserEntity):
new_user = User()
new_user.id = user.id
new_user.name = user.name
new_user.picture_url = user.picture_url
new_user.status_message = user.status_message
db.session.add(new_user)
db.session.commit()
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 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_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 db_start():
create_engine('sqlite:///../var/tmp/test.db', convert_unicode=True)
db.create_all()
db.session.commit()
user = User()
user.username = "******"
user.password = bcrypt.generate_password_hash('pppp1234')
user.email = '*****@*****.**'
user.admin = True
db.session.add(user)
db.session.commit()
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 test_add_user_in_bulk(self):
users = list()
length = 5
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)
self.assertTrue(User.query.count() >= length)
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 adduser(uid, admin=False):
#Register a new User
from getpass import getpass
password = getpass()
password2 = getpass(prompt="confirm: ")
if password != password2:
import sys
sys.exit('Error : Password do not match')
#db.create_all()
from src.model import User
user = User(uid=uid, password=password, is_admin=admin)
db.session.add(user)
db.session.commit()
print("User {0} was added successfully ".format(uid))
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_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_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 addUser(form):
if (form['pseudo'] and form['passw']):
exist = User.query.filter_by(pseudo=form['pseudo']).first()
if exist:
return jsonify(error="already exist")
user = User(form['pseudo'], form['passw'])
db.session.add(user)
db.session.commit()
return jsonify(id=user.id, pseudo=user.pseudo)
return jsonify(error="invalid parameters")
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) -> None:
self.user = User('*****@*****.**', 'password')
self.event_scheduler = EventScheduler(self.user)
self.event1 = self.event_scheduler.create_event("Event One",
'2020-01-12 20:30:00',
'2020-01-12 22:30:00',
is_private=True)
self.event2 = self.event_scheduler.create_event("Event two",
'2020-01-12 22:30:00',
'2020-01-12 22:30:00',
is_private=False)
self.event3 = self.event_scheduler.create_event("Event three",
'2020-01-12 20:30:00',
'2020-01-12 22:30:00',
is_private=True)
self.list_view = EventsView([self.event1, self.event2, self.event3])
def post(self):
req = request.get_json()
email = req.get('email')
password = req.get('password')
if email == None or password == None:
return {"msg": "Bad Request json"}, 400
hashed_password = generate_password_hash(password)
try:
query1 = User(username=email, password=hashed_password)
db.session.add(query1)
db.session.commit()
except sqlalchemy.exc.IntegrityError:
return {"msg": "email already exists"}
except Exception as e:
return {"msg": str(e) + ""}, 500
return {"msg": "User Created"}, 201
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_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)
