def main():
app = Application()
app.master.title('Portal')
app.database.add_role('admin', ['add_remove_user', 'add_remove_role'])
ryan = db.User('ryan', '1234', ['admin'])
kunle = db.User('kunle', '12345', ['admin'])
app.database.add_user(kunle)
app.database.add_user(ryan)
app.mainloop()
def setUp(self):
self.s=db.create_sessionmaker('sqlite://')()
u=db.User(name='test',password='******') # password is 'pass'
self.s.add(u)
u=db.User(name='test_1',password='******') # password is 'pass'
self.s.add(u)
u=db.User(name='test_2',password='******') # password is 'pass'
self.s.add(u)
u=db.User(name='admin',password='******') # password is 'pass'
self.s.add(u)
self.s.commit()
def post(self):
# Get information from the signup forms.
first_name = self.request.get('firstname')
last_name = self.request.get('lastname')
email = self.request.get('email')
password = self.request.get('password')
address = self.request.get('address')
gender = self.request.get('gender')
birthday = self.request.get('birthday')
interests = self.request.get('interests')
# Use mail API to check if the email is valid.
if not mail.is_email_valid(email):
error = "The provided email is not valid."
self.render("signup.html", error=error)
# Check if the email is in user database.
user = database.User.all().filter('email =', email).get()
if user:
error = "You have already signed up. Please go to login page."
self.render("signup.html", error=error)
# Store new user in the database and send email to the user.
else:
self.send_signup(email, first_name)
database.User(first_name=first_name,
last_name=last_name,
email=email,
password=hash_str(password.strip()),
address=address,
gender=gender,
birthday=birthday,
interests=interests,
offensive_score=0,
no_of_quotes=0).put()
self.redirect('/login')
def register():
register_form = forms.RegisterForm(request.form)
title = 'REGISTER'
if request.method == 'POST' and register_form.validate():
email = register_form.email.data
passw = register_form.password.data
#comprobar que no este en la base de datos
user = database.User.query.filter_by(email=email).first()
if user is None:
user = database.User(email = email, password = passw)
database.db.session.add(user)
database.db.session.commit()
msg = Message('Gracias por tu registro!', sender = app.config['MAIL_USERNAME'], recipients=[user.email])
msg.html = render_template('email.html')
#mail.send(msg)
success_message = 'Usuario registrado'
category = "alert alert-success alert-dismissible"
flash(success_message, category)
return redirect( url_for('index') )
else:
error_message = 'Ya existe este usuario'
category = "alert alert-danger alert-dismissible"
flash(error_message, category)
return render_template('register.html', title=title, form=register_form)
def register_user_enters(bot, update):
"""
One or more users enter the group, the bot should register the change.
"""
success, (chat, user, chat_member) = register_update(bot, update)
if not success:
return
me = bot.get_me()
for new_user in update.effective_message.new_chat_members:
if new_user == me:
# TODO Set chat active
continue
chat_member = db.ChatMember(new_user, update.effective_chat)
new_user = db.User(new_user)
if not new_user.exists():
new_user.commit()
if not chat_member.exists():
chat_member.commit()
else:
# TODO Set chat member active
pass
def api_v1_user_register():
f_data = f.request.form
username = f_data.get("username")
password = f_data.get("password")
if username is None or password is None:
return f.jsonify({
"result": "error",
"reason": "Missing username or password."
})
user = d.session.query(
database.User).filter_by(username=username).one_or_none()
if user is not None:
return f.jsonify({
"result": "error",
"reason": "Username already in use."
})
salt = bcrypt.gensalt()
bcrypted_password = bcrypt.hashpw(bytes(password, encoding="utf8"), salt)
new_user = database.User(username=username,
password=bcrypted_password,
admin=False)
d.session.add(new_user)
d.session.commit()
return f.jsonify({
"result": "success",
"description": "New user created.",
"user": new_user.json()
})
def register_user_leaves(bot, update):
"""
A user left the chat, the bot should register the change.
"""
success, (chat, user, chat_member) = register_update(bot, update)
if not success:
return
left_user = update.effective_message.left_chat_member
if left_user == bot.get_me():
# TODO Set chat inactive
return
chat_member = db.ChatMember(left_user,
update.effective_chat,
is_active=False)
left_user = db.User(left_user)
if not left_user.exists():
left_user.commit()
if not chat_member.exists():
chat_member.commit()
else:
# TODO Set chat member inactive
pass
def register():
form = forms.RegistrationForm()
if request.method == 'POST' and form.validate():
existing_user = db.User.objects(username=form.username.data).first()
if existing_user is None:
# Create the new user, stored with hashed passwords
hashpass = generate_password_hash(form.password.data,
method='sha256')
newUser = db.User(addedby='self',
username=form.username.data,
firstname=form.firstname.data,
lastname=form.lastname.data,
email=form.email.data,
passwordhash=hashpass,
roleassignments=[])
newUser.save()
newUser.update(addedby=newUser)
# If it's the first user, assign them to the admin role
if (len(db.User.objects()) == 1):
newRole = db.RoleAssignment(role='admin',
user=newUser,
addedby=newUser,
addeddate=datetime.utcnow(),
iscurrent=True)
newRole.save()
newUser.update(push__roleassignments=newRole)
return redirect('/login')
else:
form.username.errors.append('User already exists')
return render_template('register.html', form=form)
def register():
register_form = forms.RegisterForm(request.form)
title = 'REGISTER'
tituloPag = 'Registro'
if request.method == 'POST' and register_form.validate():
email = register_form.email.data
passw = register_form.password.data
#comprobar que no este en la base de datos
user = database.User.query.filter_by(email=email).first()
if user is None:
user = database.User(email=email, password=passw)
database.db.session.add(user)
database.db.session.commit()
success_message = 'Usuario {} registrado'.format(email)
category = "alert alert-success alert-dismissible"
flash(success_message, category)
session['email'] = email
return redirect(url_for('index'))
else:
error_message = 'Ya existe este usuario'
category = "alert alert-danger alert-dismissible"
flash(error_message, category)
return render_template('register.html',
title=title,
form=register_form,
tituloPag=tituloPag)
def user_to_db(user_id, chat_id, username=None, first_name=None, last_name=None):
session = db.Session()
entry = db.User(user_id=user_id, username=username, first_name=first_name,
last_name=last_name)
entry.chats.append(db.Chat(chat_id=chat_id))
session.merge(entry)
session.commit()
def approve_request(bot, update):
query = update.callback_query
telegram_id = query.message.chat_id
session = database.RegistrySession[telegram_id]
request = list(database.Request.select(lambda c: c.status == 0))[session.request_c]
database.Actions(implementer=str(telegram_id), action="approved registry request for",
implementee=str(request.telegramID))
enrolled_user = database.User(telegramID=request.telegramID,
phone=request.phone,
address=request.address,
priority=request.faculty,
alias=request.alias,
name=request.name)
database.Request[request.id].status = 1
session.request_c = 0
# Editing message
bot.edit_message_text(text="Request has been successfully approved (Telegram ID: " + str(request.telegramID) + ")", chat_id=query.message.chat_id,
message_id=query.message.message_id)
bot.send_message(text="Your request has been approved!", chat_id=int(enrolled_user.telegramID))
request.delete()
database.RegistrySession[telegram_id].request_c = 0
commit()
def login():
if request.method == 'POST':
username = request.form.get('username', None)
password = request.form.get('password', None)
redirect_url = request.form.get('redirect_url', '')
if redirect_url is '':
redirect_url = url_for('index')
user = database.User(username=username)
try:
dbuser = database.User.query.filter_by(username=user.username).one()
except:
dbuser = None
if dbuser is not None: # check password
user.set_password(password, dbuser.salt)
if dbuser is None or user.password != dbuser.password:
flash(u'Niepoprawna nazwa użytkownika lub hasło', 'error')
else:
session['user_id'] = dbuser.id
flash(u'Zalogowano użytkownika', 'success')
return redirect(redirect_url)
redirect_url = request.args.get('redirect_url', '')
return render_template('login.html', redirect_url=redirect_url)
def decorator(update: Update, context: CallbackContext):
session = db.Session()
tg_user: User = update.effective_user
if not session.query(db.User).filter(db.User.id == tg_user.id).first():
session.add(db.User(id=tg_user.id, is_admin=False))
session.commit()
session.close()
func(update, context)
def create_database_user(discord_user: discord.User) -> database.User:
if (database.session.query(
database.User).filter_by(discord_id=discord_user.id).first()
is not None):
raise RuntimeError(f"User #{discord_user.id} already exists")
user = database.User(discord_id=discord_user.id,
username=get_full_username(discord_user))
database.add_to_database(user)
return user
def register2():
email = request.form.get('email')
username = request.form.get('username')
password = request.form.get('password')
re_password = request.form.get('password2')
if password == re_password:
user = database.User(email=email, username=username, password=password)
database.add_info(user)
return 'content'
else:
pass
return 'fail'
async def generate_user(self, session=None):
name = self.name
local_session = False
if session is None:
local_session = True
session = database.Session()
user = session.query(database.User).filter_by(name=name).first()
if not user:
user = database.User(name=name)
session.add(user)
session.commit()
if local_session:
session.close()
return user
def reg():
if flask.request.method == "GET":
return flask.render_template("reg.html")
elif flask.request.method == "POST":
data = flask.request.form
print(data)
new_user = database.User(data['login'] , data['pass'])
result = db.registration(new_user)
print("123")
if result[0]:
return 'все ок'
else:
return result[1]
def signup(username=Form(...),
email=Form(...),
password=Form(...),
db: database.Session = Depends(database.get_db)):
if db.query(database.User).filter_by(username=username).first():
raise HTTPException(status_code=status.HTTP_302_FOUND,
detail='Username taken')
elif db.query(database.User).filter_by(email=email).first():
raise HTTPException(status_code=status.HTTP_302_FOUND,
detail='Email address already in use')
elif len(username) <= 3:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN,
detail='Username must be longer than 3 characters')
elif len(username) >= 25:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail='Username is too long. Maximum length: 25 characters')
elif len(password) < 7:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN,
detail='Password must be 8 characters or more')
elif len(password) >= 40:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail='Password is too long. Maximum length: 40 characters')
elif PasswordStats(password).strength() <= float(0.350):
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=
'Password is not strong enough. Try adding some symbols or numbers your password'
)
elif len(email) >= 75:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail='Email is too long. Must be less than 75 characters')
try:
valid = validate_email(email)
email = valid.email
except EmailNotValidError as e:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail='Email address not supported. Please use another email.')
else:
pwd_hash = Hash.get_password_hash(str(password))
db_user = database.User(username=username,
email=email,
password=pwd_hash)
db.add(db_user)
db.commit()
db.refresh(db_user)
return models.User(username=username, email=email, password=password)
def register(user_name: str, user_fullname: str, user_password: str):
hash_pass = hash_password(user_password, user_name)
new_user = database.User(name=user_name,
fullname=user_fullname,
password=hash_pass)
session = database.Session()
try:
session.add(new_user)
session.commit()
logger.info(f"User registered : {new_user}")
except:
logger.info(f"User not registered because of an error: {new_user}")
return False
return True
def cmd_adduser(self, nick, args, admin):
"""Felhasználó hozzáadása. Használat: !adduser user"""
if admin:
if args:
database.session.add(database.User(name=args.split()[0]))
try:
database.session.commit()
except sqlalchemy.exc.IntegrityError:
return 'Már létezik felhasználó ilyen névvel.'
else:
return args.split()[0] + ' hozzáadva!'
else:
return cmd_help(nick, 'adduser', admin)
else:
return autherror
def update_db_entry(self,
auth,
name,
pub,
bio,
check,
privacy,
pin=None,
password=None):
dbc = self.settings["local_store"]
with dbc.lock:
session, owner_of_cid = dbc.get_by_id_ig(pub)
if owner_of_cid and owner_of_cid.name != name:
session.close()
self.set_status(400)
self.json_payload(error_codes.ERROR_DUPE_ID)
return 0
session, mus = dbc.get_ig(name, session)
if not mus:
mus = database.User()
elif mus.public_key != auth:
session.close()
self.set_status(400)
self.json_payload(error_codes.ERROR_NAME_TAKEN)
return 0
mus.name = name
mus.public_key = pub
mus.checksum = check
mus.privacy = privacy
mus.timestamp = datetime.datetime.now()
mus.sig = self.settings["crypto_core"].sign(mus)
mus.bio = bio
mus.pin = pin
if password:
mus.password = password
ok = dbc.update_atomic(mus, session)
if not ok:
session.close()
self.set_status(400)
self.json_payload(error_codes.ERROR_DUPE_ID)
return 0
if hooks:
hooks.did_update_record(self.settings["hooks_state"],
database.StaleUser(mus))
session.close()
return 1
def saveToDatabase(rawData):
userid = rawData.get('player')['userid']
logg(f' [{userid}] saving data to database...')
# save to table users
user = database.User.query.get(userid)
if user == None:
database.db.session.add(
database.User(userid=userid,
username=rawData.get('player')['username'],
cost=rawData.get('cost'),
old_cost=rawData.get('old_cost'),
player=rawData.get('player'),
pp=rawData.get('pp'),
time=rawData.get('time')))
else:
user.name = rawData.get('player')['username'],
user.cost = rawData.get('cost'),
user.player = rawData.get('player'),
user.pp = rawData.get('pp'),
user.time = rawData.get('time')
# save to table tables
table = database.Table.query.get(userid)
if table == None:
database.db.session.add(
database.Table(userid=userid,
table=rawData.get('table'),
time=rawData.get('time')))
else:
table.userid = userid
table.table = rawData.get('table'),
table.time = rawData.get('time')
# add the record
database.db.session.add(
database.Record(userid=userid,
username=rawData.get('player')['username'],
cost=rawData.get('cost'),
old_cost=rawData.get('old_cost'),
player=rawData.get('player'),
pp=rawData.get('pp'),
time=rawData.get('time')))
database.db.session.commit()
logg(f' [{userid}] complete!')
def signup():
if get_current_user() is not None:
return redirect(url_for('home_page'))
if request.method == 'GET':
return render_template('signup.html')
elif request.method == 'POST':
name = request.form['name']
username = request.form['username']
email = request.form['email']
password = request.form['password']
# Create new user
new_user = database.User(name=name,
username=username,
email=email,
password=password)
new_user = database.save_object(new_user)
# Return to homepage
return make_login_response(redirect(url_for('home_page')), new_user.id)
def create_user():
c = request.get_json(silent=True)
newuser = json.loads(request.form["values"])
if newuser["id"] not in database.cacheusers:
user = database.User(id=newuser['id'],
username=newuser['username'],
password=newuser['password'],
fullname=newuser['fullname'])
database.session.add(user)
database.session.commit()
for i in newuser:
database.cachemessages[newuser["id"]] = [
newuser['username'], newuser['password'], newuser['fullname']
]
return 'User created'
return "The id is already in use"
def login():
if flask.request.method == "GET":
# считываем куки
q = flask.request.cookies.get('sid')
res = flask.make_response(flask.render_template("login.html"))
return res
elif flask.request.method == "POST":
data = flask.request.form
auth_user = database.User(data['login'], data['pass'])
result = db.auth(auth_user)
if result[0]:
response = flask.make_response(flask.redirect(f"/profile/{data['login']}"))
response.set_cookie('sid', result[1])
return response
else:
return result[1]
def login():
username = flask.request.args.get('username', None)
if username == 'garfield':
user = flask.g.session.query(
database.User).filter(database.User.name == username).first()
if not user:
user = database.User(name=username)
flask.g.session.add(user)
flask.g.session.commit()
flask.ext.login.login_user(user)
flask.flash('Logged in successfully.')
return flask.redirect('/gallery')
return flask.render_template('login.html')
def get_user(session, username):
"""Get a user from the database."""
user = session.query(database.User) \
.filter_by(username=username) \
.first()
if user is None:
user = database.User(
username=username,
lastactivity=datetime.datetime.now(),
trust=False,
)
session.add(user)
else:
user.lastactivity = datetime.datetime.now()
session.flush()
session.commit()
return user
def create_user():
"""
Handles creating a user with an rfid and a name associated with it. The rfid is the
id of the chip of the user and the name of the user is included.
Creation of a user is done via a get request that contains the unique rfid, first,
and last names of the user. The rfid needs to match the rfid of the chip that would
represent the user.
rfid (str): A string representation of the rfid
name (str): The name of the user
"""
# Get the data for the user
rfid = request.args.get('rfid')
first_name = request.args.get('first_name')
last_name = request.args.get('last_name')
# Create a new user and save the user to the database
user = database.User(rfid=rfid, first_name=first_name, last_name=last_name)
user.save()
return Response(status=200)
async def register(self):
try:
db.User(
**{
'user_id': self._id,
'chat_id': self._chat_id,
'name': self._name,
'verified': False
}).save()
await bot.send_message(
self._chat_id, f'{self._name}, Добро пожаловать!🤘\n'
f'Напиши @DOMINOkaty чтобы продолжить работу с ботом')
await self._state.set_state('wait_for_verified')
except NotUniqueError:
user_messages_to_delete[self._id] = [
(await
bot.send_message(self._chat_id,
'Это имя уже занято😥\n Попробуй другое'))
]
def register(self, user_id, chat_id, name):
database.User(**{
'user_id': user_id,
'chat_id': chat_id,
'name': name
}).save()
try:
if database.User.objects(user_id=user_id).first():
# Добавить логи в таком формате [Line | Status | Time | ALL DATA]
pass
elif not database.User.objects(user_id=user_id).first():
# Добавить логи в таком формате [Status | Time | ALL DATA]
pass
else:
# Добавить логи в таком формате [Line | Status | Time | ALL DATA]
pass
except Exception:
# Добавить логи в таком формате [Line | Exception | Time | ALL DATA]
pass
