async def log_in(self, email: str, password: str) -> 'AuthMediator':
try:
user = await self.fetch_pg_user(email)
except Exception as e:
print(f'Error fetching user from DB: {}', e)
return self
if not user:
self.message = 'No user found with that email'
return self
# Initialize the default User object
user_obj = User()
# If the entered password == the password in the DB, store
# the user data from Postgres in the User object and return the User object
if user_obj.check_password(password, user['password'],
os.getenv('BCRYPT_SALT', None)):
self.hermes_user = User(user['id'], user['email'], password,
user['name'], user['permission_level'],
user['last_fetch'], user['creds'])
return self.hermes_user
else:
self.message = 'Error logging in.'
return self
def find_user_or_404(self):
value = self.get_user_by_criterion()
user = db.find(where={value["criterion"]: value["value"]})
if user is None:
raise NotFoundUser(NOT_FOUND_USER)
return User(**user)
def register3(self, UserPhone, PassWord, NickName):
try:
user = User()
nq = User.query.filter_by(UserPhone=UserPhone).all()
if len(nq) != 0:
state = 0
msg = "此手机号已经被注册了亲！"
array = {'state': state, 'msg': msg}
return array
m = hashlib.md5()
m.update(PassWord.encode('utf-8'))
PassWord = m.hexdigest()
user.PassWord = PassWord
user.NickName = NickName
user.UserPhone = UserPhone
user.UserPhoto = 'http://7xrqhs.com1.z0.glb.clouddn.com/default1.jpg'
user.Experience = 0
user.UserSex = 2
db.session.add(user)
db.session.commit()
state = 1
msg = "成功！"
array = {'state': state, 'msg': msg}
return array
except Exception as e:
print(e)
state = 0
msg = "出现奇怪的错误了，一会再试试吧！"
array = {'state': state, 'msg': msg}
return array
def init():
"""initialize database and directories"""
try:
remakedir(settings.DATA_DIR_PATH)
remakedir(settings.DEMO_DIR_PATH)
remakedir(settings.THUMBNAIL_DIR_PATH)
except:
print sys.exc_info()
try:
if os.path.exists(settings.DB_PATH):
os.remove(settings.DB_PATH)
init_db()
if getpwuid(os.getuid())[0] == 'root':
os.chown(settings.DB_PATH, apache_uid, apache_gid)
except:
print sys.exc_info()
try:
role_admin = UserRole('admin', 'for administrators')
db_session.add(role_admin)
user_admin = User('admin', role=role_admin)
db_session.add(user_admin)
db_session.commit()
db_session.remove()
except:
print sys.exc_info()
def test_current_user(db, session):
user = User(name="sam", institution="UofM")
entry = Entry(description="desc", template="temp", user=user)
session.add_all([user, entry])
session.commit()
current_users = [user[0] for user in db.session.query(User.name).all()]
assert user.name in current_users
def create_user(username, password, admin):
hashed_password = generate_password_hash(password, method='sha256')
user = User(public_id=str(uuid.uuid4()),
username=username,
password=hashed_password,
admin=admin)
db.session.add(user)
db.session.commit()
def test_many_many_relationship(db, session):
user = User(name="sam", institution="UofM")
entry = Entry(description="desc", template="temp", user_saves=user)
session.add_all([user, entry])
session.commit()
assert entry in user.saved_entries
assert user in entry.user_saves
def process_userinfo(user_info):
curr = User()
curr.id = user_info['sub']
curr.username = user_info['name']
if 'https://hackquarantine.com/user_metadata' in user_info:
curr.student_status = bool(
user_info['https://hackquarantine.com/user_metadata']
['student_status']) or False
# only me, hacky but quick
curr.admin = (user_info['sub'] == config.ADMIN_ID)
return curr
def create_user(self, **kwargs):
if self.validate_email(kwargs["email"]):
user = User.get(email=kwargs["email"])
if user is None:
if kwargs.get("role_id") is None:
role = Role.get(description="user")
else:
role = Role.get(role_id=kwargs["role_id"])
passwd_encode = generate_password_hash(kwargs["password"])
user = User(city_id=kwargs["city_id"],
email=kwargs["email"],
password=passwd_encode,
name=kwargs["name"],
nickname=kwargs["nickname"],
gender=kwargs["gender"],
active=True,
birth_date=datetime.strptime(
kwargs["birth_date"], "%d/%m/%Y"),
role_id=role,
street=kwargs["street"],
number=kwargs["number"],
complement=kwargs["complement"],
district=kwargs["district"],
postal_code=kwargs["postal_code"],
create_date=datetime.now())
user.flush()
phones = kwargs["phone"]
self.add_phones_user(phones, user)
commit()
response = {
"user_id": user.user_id,
"nickname": user.nickname,
"name": user.name,
"email": user.email,
"gender": user.gender,
"role": role.description,
"role_id": role.role_id,
"street": user.street,
"city": user.city_id.city,
"city_id": user.city_id.city_id,
"state": user.city_id.state_id.state,
"state_id": user.city_id.state_id.state_id,
"number": user.number,
"complement": user.complement,
"district": user.district,
"postal_code": user.postal_code,
"phones": kwargs["phone"]
}
else:
response = {"message": "Email exist", "type": "ERROR"}
else:
response = {"message": "Email not valide", "type": "ERROR"}
return json.dumps(response)
def edit_user_values(self, value, msg):
user = self.find_user_or_404()
print(f"Edytujesz uzytkownika: {user}")
new_value = str(input(msg))
db.update(user, values={value: new_value})
returned_where = {
"username": new_value if value == "username" else user.username
}
updated_user = db.find(where=returned_where)
print(User(**updated_user))
def register():
if current_user.is_authenticated:
return redirect(url_for('panel.panel'))
form = RegistrationForm()
if form.validate_on_submit():
user = User(email=form.email.data, username=form.username.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
flash("Account created", 'info')
return redirect(url_for('auth.login'))
return render_template('auth/register.html', form=form, title="Register")
def setUpClass(self):
u = User.objects(username="******", password="******")
if len(u) > 0:
u.delete()
u = User()
u.username = "******"
u.password = "******"
u.save()
self.user = u
now = datetime.datetime.now()
r = Reservation.get_between(now, now + datetime.timedelta(days=1))
r.delete()
def user_cookie():
user = None
if 'uid' in session:
user = User.query.filter(User.cookie_id == str(session['uid'])).first()
if user is None:
session['uid'] = uuid4()
data = User(str(session['uid']))
db_session.add(data)
db_session.commit()
user = User.query.filter(User.cookie_id == str(session['uid'])).first()
return user
def test_relationship(db, session):
user = User(name="Sam", institution="UofM")
entry = Entry(description="Smarty", template="template", user=user)
print(db.session.execute('show tables').fetchall())
print(db.session.execute('select * from entries').fetchall())
print(db.session.execute('select * from test.entries').fetchall())
session.add_all([user, entry])
session.commit()
assert entry in user.submissions
assert entry.user is user
async def create_user(self):
data = await self.request.post()
user = User(name=data["name"])
user.api_key = user.generate_api_key()
try:
await user.save(self.request.app["db"])
except DuplicateKeyError:
return aiohttp.web.json_response({"error": f"user already exists"},
status=409)
return aiohttp.web.json_response(
user.to_json(),
status=201,
)
def recreateDB():
Base.metadata.reflect(bind=_engine)
Base.metadata.drop_all(_engine, checkfirst=True)
Base.metadata.create_all(_engine, checkfirst=True)
for data in yaml.load_all(open('tests/dummy/users.yaml'),
Loader=yaml.FullLoader):
user = User(**data)
s.add(user)
s.commit()
for data in yaml.load_all(open('tests/dummy/dogs.yaml'),
Loader=yaml.FullLoader):
dog = Dog(**data)
s.add(dog)
s.commit()
def register_user():
data = request.get_data()
data = json.loads(data)
username = data['username']
password = data['password']
users = User.objects(username=username, password=password)
if len(users) > 0:
return jsonify({'id': -1}), 409
else:
user = User()
user.username = username
user.password = password
user.privilege = 0
user.save()
return jsonify(user.get_dict()), 201
def _save(self, data):
data['public_id'] = str(uuid.uuid4())
if "password" in data:
data['password'] = generate_password_hash(data['password'],
method='sha256')
if ("admin" in data) and (data['admin'].lower() == "true"):
data['admin'] = True
else:
data['admin'] = False
user = User(**data)
db.session.add(user)
db.session.commit()
return user
def oauth_callback():
if not current_user.is_anonymous:
return redirect(url_for('index'))
oauth = VkSignIn()
social_id, name, image_url, friends_count = oauth.callback()
if social_id is None:
flash('Authentication failed.')
return redirect(url_for('index'))
user = User.objects(social_id=social_id).first()
if not user:
user = User(social_id=social_id, ).save()
login_user(user, True)
values = {
'name': name,
'friends_count': friends_count,
'image_url': image_url,
}
session.update(values)
return redirect(url_for('index'))
def authorized(oauth_token):
next_url = request.args.get('next') or url_for('index')
if oauth_token is None:
flash("Authorization failed.")
return redirect(next_url)
session['oauth_token'] = oauth_token
me = github.get('user')
user_id = me['login']
user = User.query.filter_by(id=user_id).first()
if user is None:
user = User(id=user_id, uid=user_id, name=me['name'], source='github')
user.last_login = DateUtil.now_datetime()
user.save()
RequestUtil.login(session, user_id)
return redirect(next_url)
def register():
if current_user.is_authenticated:
return redirect(url_for('posts.access'))
form = RegistrationForm()
if form.validate_on_submit():
hashed_password = bcrypt.generate_password_hash(
form.password.data).decode('utf-8')
user = User(username=form.username.data,
email=form.email.data,
password=hashed_password)
db.session.add(user)
db.session.commit()
flash(
f'your account has been created successfully !! Your username is {form.username.data}!',
'success')
return redirect(url_for('users.signin'))
return render_template("register.html",
title="Price Tracker-Register",
form=form)
def adminpassword():
"""set admin password"""
admin_username = "******"
password = getpass.getpass()
if len(password)<8:
print "dame"
return
admin = User.query.get(1)
if not admin:
userrole = UserRole.query.get('admin')
admin = User(admin_username, userrole)
db_session.add(admin)
admin.set_password(password)
db_session.commit()
db_session.remove()
print "update successfully"
def execute(self):
users = db.find_all()
if not len(users):
print(EMPTY_USERS)
for user in users:
print(User(**user))
def _user_row_mapper(row):
if row:
return User(row[0], row[1], row[2])
else:
return None
# -*- coding: utf-8 -*-
from app.db import Base, User, Address
from settings import SQLALCHEMY_ENGINE, SQLALCHEMY_SESSION
if __name__ == '__main__':
Base.metadata.create_all(SQLALCHEMY_ENGINE)
session = SQLALCHEMY_SESSION()
session.add_all([
User(name='ed', fullname='Ed Jones', password='******'),
User(name='wendy', fullname='Wendy Williams', password='******'),
User(name='mary', fullname='Mary Contrary', password='******'),
User(name='fred', fullname='Fred Flinstone', password='******')
])
jack = User(name='jack', fullname='Jack Bean', password='******')
jack.addresses = [
Address(email_address='*****@*****.**'),
Address(email_address='*****@*****.**')
]
session.add(jack)
session.commit()
from app import create_app
from app.db import Degree, User, db
from config import Development
config = Development()
app = create_app(config)
db.create_all()
username = raw_input('Initial user to add (zID): ')
user = User()
user.zid = username
db.session.add(user)
degree = Degree()
degree.code = 0
degree.name = 'Unknown'
db.session.commit()
sets_dict = dict()
for i, item in enumerate(sets):
db_item = Set(item.type, item.name, item.active, item.description)
db_session.add(db_item)
db_session.commit()
last = Set.query.order_by(Set.id).all()[-1].id
sets_dict[item.id] = last
print(sets_dict)
with open("./old_database/users.pkl", "rb") as input:
sets = pickle.load(input)
users_dict = dict()
for i, item in enumerate(sets):
db_item = User(item.cookie_id)
db_session.add(db_item)
db_session.commit()
last = User.query.order_by(User.id).all()[-1].id
users_dict[item.id] = last
print(users_dict)
with open("./old_database/records.pkl", "rb") as input:
records = pickle.load(input)
records_dict = dict()
for i, item in enumerate(records):
db_item = Record(item.position, sets_dict[item.set_id])
db_session.add(db_item)
db_session.commit()
