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)