def signup():
if request.method == 'POST':
user_name = request.form['user_name']
email = request.form['email']
if User.is_user_with_name_in_user_list(user_name):
flash('Username {} is taken. Choose another one'.format(user_name.encode('utf-8')))
temp_user = User(name=None, email=email)
return render_template('user_form.html', action=url_for('signup'),
submit_title="Sign up", user=temp_user)
if User.is_user_with_email_in_user_list(email):
temp_user = User(user_name)
flash('Email {} is taken. Choose another one'.format(email.encode('utf-8')))
return render_template('user_form.html', action=url_for('signup'),
submit_title="Signup", user=temp_user)
password = request.form['password']
confirmed_password = request.form['confirm_password']
if password != confirmed_password:
flash('Input password again')
temp_user = User(user_name, email)
return render_template('user_form.html', action=url_for('signup'),
submit_title="Signup", user=temp_user)
new_user = User(user_name, password, email=email)
new_user.save()
new_user = User.get_by_name(new_user.name)
session['logged_in'] = True
session['user_id'] = new_user.id
session['user_name'] = new_user.name.encode('utf-8')
flash("Welcome {}. You've just signed up!".format(str(session['user_name'])))
return redirect(url_for('td_list'))
return render_template('user_form.html', action=url_for('signup'), submit_title="Signup")
def to_html(self):
values = [x for x in self.vals]
for value in values:
value['from_id'] = '%s, %s' % (value['from_id'], User().select(
[('id', '=', value['from_id'])])[0]['login'])
value['to_id'] = '%s, %s' % (value['to_id'], User().select(
[('id', '=', value['to_id'])])[0]['login'])
res = """
<style>
table,tr,td {
background-color: white;
border: 1px solid black;
color: black;
}
</style>
"""
res += '<table><tr>'
cols = []
if values:
cols = list(values[0].keys())
res += ''.join(['<td><span>%s</span></td>' % x for x in cols])
res += '</tr>'
for val in values:
res += '<tr>'
res += ''.join(['<td><span>%s</span></td>' % val[x] for x in cols])
res += '</tr>'
res += '</table>'
return res
def post(self):
try:
if request.form.get("latest_portfolio_risk"):
new_user = User(email=request.form['email'],
password=request.form['password'],
first_name=request.form['first_name'],
last_name=request.form['last_name'],
age=request.form['age'],
gender=request.form['gender'],
latest_portfolio_risk=request.
form['latest_portfolio_risk'])
else:
new_user = User(email=request.form['email'],
password=request.form['password'],
first_name=request.form['first_name'],
last_name=request.form['last_name'],
age=request.form['age'],
gender=request.form['gender'])
db.session.add(new_user)
db.session.commit()
response = make_response(
jsonify(message="User successfully added to database"), 200)
except Exception as e:
response = make_response(jsonify(message=str(e)), 400)
return response
def add_user():
if request.method == 'POST':
user_name = request.form['user_name']
email = request.form['email']
if User.is_user_with_name_in_user_list(user_name):
flash('Username {} is taken. Choose another one'.format(user_name.encode('utf-8')))
return render_template('user_form.html', action=url_for('add_user'),
submit_title="Add")
if User.is_user_with_email_in_user_list(email):
flash('Email {} is taken. Choose another one'.format(email))
return render_template('user_form.html', action=url_for('add_user'),
submit_title="Add")
password = request.form['password']
confirmed_password = request.form['confirm_password']
if password != confirmed_password:
flash('Input password again')
temp_user = User(user_name, email=email)
return render_template('user_form.html', action=url_for('add_user'),
submit_title="Add", user=temp_user)
new_user = User(user_name, password, email=email)
new_user.save()
if 'is_admin' in session:
new_user = User.get_by_email(email)
new_user.set_admin_status(bool(request.form.get('admin')))
flash("User {} added to user list".format(new_user.name.encode('utf-8')))
return redirect(url_for('admin_panel'))
return render_template('user_form.html', action=url_for('add_user'), submit_title="Add")
def post(cls):
if not User().find_by_email(request.form["email"]):
u = User()
u.email = request.form["email"]
u.password = request.form["password"]
u.name = request.form["name"]
u.save_to_db()
return {"msg": "Utilizador criado com sucesso"}, 200
else:
return {"msg": "Email já existe"}, 401
def test_user_exists(session):
""" test for integrity constraints (double input of unique ID) """
# insert first user
user_1 = User(id=111, name="Test User", is_bot=False)
# insert second user with same properties
# should throw an integrity error
user_2 = User(id=111, name="Test User", is_bot=False)
assert sqlalchemy.exc.IntegrityError
def handle_users():
if request.method == 'POST':
try:
if request.is_json:
data = request.get_json()
new_user = User(name=data['name'],
grade=data['grade'],
address=data['address'],
country=data['country'])
db.session.add(new_user)
db.session.commit()
return {
"message":
f"user {new_user.name} has been created successfully."
}
elif 'file' in request.files:
f = request.files['file']
filename = secure_filename(f.filename)
if not os.path.isdir(app.config['UPLOAD_FOLDER']):
os.mkdir(app.config['UPLOAD_FOLDER'])
if not os.path.exists(
os.path.join(app.config['UPLOAD_FOLDER'], filename)):
f.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
# process File
with open(os.path.join(app.config['UPLOAD_FOLDER'], filename),
'r') as fileUploaded:
header = fileUploaded.readline().strip().split(',')
for l in fileUploaded:
userList = l.strip().split(',')
userDict = dict(zip(header, userList))
#print(userDict)
new_user = User(name=userDict['name'],
grade=userDict['grade'],
address=userDict['address'],
country=userDict['country'])
db.session.add(new_user)
db.session.commit()
return f"{f.filename} Processed"
#return redirect(url_for('uploaded_file', filename=filename))
else:
return {"error": "The request payload is not in JSON format"}
except Exception as e:
return {"Error": str(e)}
elif request.method == 'GET':
try:
users = User.query.all()
results = {}
if users != None:
results = [user.serialize() for user in users]
return {"count": len(results), "users": results}
except Exception as e:
return {"error": str(e)}
def logs_message(data_format, start_date, end_date, from_user, to_user,
content):
domain = []
if start_date:
domain.append(('create_date', '>=', start_date))
if end_date:
domain.append(('create_date', '<=', end_date))
if from_user:
user = User()
if user.select([('login', '=', from_user)]):
domain.append(('from_id', '=', user.vals[0]['id']))
else:
return json.dumps({
'success': 0,
'error': "User '%s' doesn't exist !" % from_user,
'content': None
})
if to_user:
user = User()
if user.select([('login', '=', to_user)]):
domain.append(('to_id', '=', user.vals[0]['id']))
else:
return json.dumps({
'success': 0,
'error': "User '%s' doesn't exist !" % to_user,
'content': None
})
if content:
domain.append(('message', 'ilike', '%' + content + '%'))
message = Message()
message.select(domain, no_datetime=True)
if data_format not in ['json', 'html', 'pdf']:
return json.dumps({
'success': 0,
'error': "Unknow format %s !" % data_format,
'content': None
})
if data_format == 'json':
return json.dumps({
'success': 1,
'error': None,
'content': message.vals
})
if data_format == 'html':
return message.to_html()
if data_format == 'pdf':
binary_pdf = message.to_pdf()
response = make_response(binary_pdf)
response.headers['Content-Type'] = 'application/pdf'
# response.headers['Content-Disposition'] = \
# 'inline; filename=%s.pdf' % 'message_logs.pdf'
return response
return "This is not suppose to arrived be here."
def test_invalid_input(session):
""" test for faulty input, such as lacking arguments, wrong type of arguments """
user_1 = User(id=1)
user_1.save()
user_2 = User(id=2, name=111, is_bot=22)
user_2.save()
with pytest.raises(Exception) as e:
User.get(id=1)
User.get(id=2)
print("Invalid data cannot be entered:", e)
def training(message):
message.text = message.text.replace('/Обучить ', '')
try:
msg = message.text.split('=')
answer = msg[1].lower()
question = msg[0].lower().lstrip()
session = db_session.create_session()
user_all = session.query(User).all()
f = True
for all in user_all:
try:
if f:
for i in mat:
for j in snac:
if j in answer.split() or j in question.split():
answer = answer.replace(j, '')
question = question.replace(j, '')
if i in answer.split() or i in question.split():
bot.send_message(message.chat.id,
'Пиши без мата, друг )')
f = False
break
if f:
if session.query(User).filter(
User.question == question).first():
if session.query(User).filter(
User.answer != answer).first():
if all.question == question:
all.answer += '|' + answer
session.commit()
break
else:
bot.send_message(
message.chat.id,
'Такой ответ уже есть на' + all.question +
' этот вопрос')
break
else:
user = User(
question=question,
answer=answer,
)
session.add(user)
session.commit()
break
except RuntimeError:
bot.send_message(message.chat.id, 'Ошибка')
print('error/training/2_try')
except BaseException:
Error(message)
print('error/training/1_try')
def update_user_by_id(id):
user = User.get_by_id(id)
if not user:
return jsonify({
'status': 'error',
'message': 'user could not be updated'
}), 400
f = request.form
user = User(**user)
if f.get('name'):
user.name = f.get('name')
if f.get('title'):
user.title = f.get('title')
if f.get('bio'):
user.bio = f.get('bio')
if f.get('github'):
user.github = f.get('github')
if f.get('linkedin'):
user.linkedin = f.get('linkedin')
email = f.get('email')
password = f.get('password')
if email:
user.email = email
if password:
user.password = password
user.save()
return jsonify({'status': 'OK', 'user': user.to_dict()}), 200
def setUp(self):
super(TestBook, self).setUp()
self.maxDiff = None
self.app = create_app()
self.session = session
user_obj = User(
username="******",
email="*****@*****.**",
password=pbkdf2_sha256.hash("pass")
)
self.session.add(user_obj)
self.session.flush()
self.user_id = int(user_obj.id)
book_type = BookType(
book_type="normal",
charge="1.5"
)
self.session.add(book_type)
self.session.flush()
self.book_type_id = int(book_type.id)
book_obj = Book(
book_name="python",
book_type_id=self.book_type_id
)
self.session.add(book_obj)
self.session.flush()
self.book_id = int(book_obj.id)
def post(self):
new_user = User.create_user_parser.parse_args()
user_existence = User.find_by_username(new_user.get('username'))
if user_existence:
return "User already exists"
User(**new_user).save_to_db()
return "New user has been added"
def execute_models():
# Settings
models_names = ['markowitz', 'Kmeans', 'blackLitterman', 'mean_gini']
risks = range(1, 6)
with app.app_context():
from models.users import User
from algorithms.create_model import create_model
from models.portfolio import Portfolio
from models.port_user_answers_set import PortUserAnswersSet
uid = str(uuid.uuid4())
user = User(_id=uid)
db.session.add(user)
for model_name in models_names:
for risk in risks:
model = create_model(model_name, risk)
portfolio: Portfolio = model.get_portfolio_object()
db.session.add(portfolio)
db.session.flush()
for pk_of_risk in get_next_answer_set_pk(risk):
pua = PortUserAnswersSet(
user_id=uid,
ans_set_val=pk_of_risk,
portfolios_id=portfolio.id,
portfolios_date_time=portfolio.date_time)
db.session.add(pua)
db.session.commit()
def ActivarUsuario():
if request.method == "POST":
if g.user["activo"] == 0:
usuario = session["username"]
email = request.form["correo"]
newToken = token.createToken(usuario).decode()
yag = yagmail.SMTP('*****@*****.**', 'misiontic2020')
yag.send(
to=email,
subject='Activa tu cuenta',
contents=
'Bienvenido usa el link para activar tu cuenta: http://localhost:5000/users/activate?token='
+ newToken)
else:
flash("El usuario ya habia sido activado previamente")
return redirect(url_for('users.Perfil'))
else:
tok = request.args.get("token")
payload = token.decodeToken(tok)
activatingUser = User()
if activatingUser.Activate(payload):
session.pop("username", None)
return render_template("usuarioActivado.html")
else:
return redirect(url_for("users.SignIn"))
def authRegister():
try:
userId = unicode(uuid.uuid4())
user = User(id=userId,
email=request.json['email'],
phoneNumber=request.json['phoneNumber'],
fullName=request.json['fullName'],
password=request.json['password'],
imageUrl=request.json['imageDownloadLink'])
print(user)
db.session.add(user)
db.session.commit()
except Exception as e:
print(e)
return make_response(jsonify({"status": "Could not create"}),
status.HTTP_409_CONFLICT)
sendUser = user.toDict()
del sendUser["imageUrl"]
return make_response(
jsonify({
"status": "Created",
"token": getJWT(repr(user)),
"user": sendUser
}), status.HTTP_201_CREATED)
def login():
if request.method == 'GET':
return redirect(
url_for('index', incorrectLogin=False, error="Access Denied"))
if request.method == 'POST':
try:
#print(request.form['uni'])
user = User(request.form["uni"], None, request.form["psw"])
res = user.findUser()
pwd = user.getPwd()
user.db_close()
if res[0] is True and pwd == request.form['psw']:
# print("res")
# print(res[1])
session['uid'] = res[1]
return redirect(url_for("LoggedInUsers"))
else:
error = "invalid username/password"
return redirect(
url_for("index",
incorrectLogin=True,
error="incorrect username/password"))
except Exception as e:
print(e)
return redirect(url_for("index"))
def sign_up():
if request.method == 'GET':
return redirect(
url_for('index', incorrectLogin=False, error="Access Denied"))
error = None
if request.method == "POST":
res = None
user = User(request.form["uni"], request.form["email"],
request.form["psw"])
res = user.addUser()
if res != True:
# print("error")
# print(res)
return redirect(url_for("index", error=res, incorrectLogin=True))
elif res is True:
# print("added user")
uid = user.getIDFromName(request.form["uni"])
session['uid'] = uid
user.db_close()
mg = Machine(bm.Base_Model())
machines = mg.get_all_machines()
return render_template("LoggedInUsers.html",
error=error,
machines=machines)
else:
user.db_close()
error = "server error"
return redirect(url_for("index", error=error,
incorrectLogin=False))
def post(self):
username = request.json['username']
password = request.json['password']
admin = False
if username is None or password is None:
abort(400) # missing argumentsfirst_name
if User.query.filter_by(username=username).first() is not None:
abort(400) # exithis.dataSource = datasting user
password_hash = bcrypt.generate_password_hash(password)
new_user = User(username, password_hash, admin)
db.session.add(new_user)
try:
db.session.commit()
except:
db.session.rollback()
finally:
db.session.close()
access_token = create_access_token(identity=username)
refresh_token = create_refresh_token(identity=username)
return {
'message': 'User {} was created'.format(username),
'access_token': access_token,
'refresh_token': refresh_token
}
def send_message(message, dest):
if dest:
dest_user = User()
if dest_user.select([('login', '=', dest)]) and message:
connection, channel = get_pika_connection()
channel.exchange_declare(exchange='logs', exchange_type='fanout')
channel.queue_declare(queue=dest)
channel.basic_publish(exchange='', routing_key=dest, body=message)
log_message(cache.user.vals[0]['id'], dest_user.vals[0]['id'],
message)
connection.close()
return json.dumps({
'success': 1,
'error': None,
'content': "Message successfully send."
})
return json.dumps({
'success':
0,
'error':
"No message provided." if not message else "User %s not found." % dest,
'content':
None
})
def post(self):
username = self.request.get("username")
email = self.request.get("email")
password = hashlib.sha512(b"" +
self.request.get("password")).hexdigest()
rep_password = hashlib.sha512(
b"" + self.request.get("confirm_password")).hexdigest()
if password != rep_password:
return self.write(
"Confirm password and password are not the same!")
if "@" not in email:
return self.write("Invalid email address.")
exist_user = User.query().filter(User.username == username).fetch()
exist_email = User.query().filter(User.email == email).fetch()
exist_pass = User.query().filter(User.password == password).fetch()
if len(exist_user) > 0 or len(exist_email) > 0 or len(exist_pass) > 0:
return self.write(
"User with this username, email or password already exist.")
user = User(username=username, email=email, password=password)
user.put()
return self.redirect_to("login")
def test_add_user(db_models):
obj_in = SignUp(
name="User Test",
document="12345678901",
mail="*****@*****.**",
phone="11-987654321",
password="******",
)
db_user = User(
name=obj_in.name,
document_type=DocumentType.CPF.value,
document=obj_in.document,
birth_date=None,
email=obj_in.mail,
phone=obj_in.phone,
password=obj_in.password.get_secret_value(),
role=Roles.USER.value,
update_email_on_next_login=False,
update_password_on_next_login=False,
)
db_models.add(db_user)
logger.info(db_user)
db_models.commit()
assert db_user.id == 3
assert db_user.role == 2
def SignUp():
if request.method == "POST":
form = FormRegistro(request.form)
if form.validate_on_submit():
name = form.nombre.data
usuario = form.usuario.data
clave = form.password.data
cclave = form.confirmPassword.data
cemail = form.email.data
email = form.confirmEmail.data
newUser = User()
newUser.Registrar(name, usuario, clave, cclave, cemail, email)
if newUser.register:
tok = token.createToken(usuario).decode()
yag = yagmail.SMTP('*****@*****.**',
'misiontic2020')
yag.send(
to=email,
subject='Activa tu cuenta',
contents=
'Bienvenido usa el link para activar tu cuenta: http://localhost:5000/users/activate?token='
+ tok)
return render_template('activarUsuario.html')
else:
for error in newUser.errors:
flash(error)
return render_template('registerUser.html',
form=FormRegistro())
else:
if g.user is not None:
return redirect(url_for('Index'))
return render_template("registerUser.html", form=FormRegistro())
def from_json_to_object(json):
name = json["name"]
email = json["email"]
password = json["password"]
discounts = json["discounts"]
return User(name, email, password, discounts)
def post(self):
if os.environ.get('DISABLE_SIGNUP', "false").lower() == "true":
return JU.make_response("signup is disabled by admin", 403)
name, username, email, password = JU.extract_keys(
request.get_json(), "name", "username", "email", "password")
if JU.null_values(name, username, email, password):
return JU.make_response("invalid data", 400)
if User.find_by_username(username):
return JU.make_response(f"user '{username}' already exists", 409)
if User.find_by_email(email):
return JU.make_response(f"email '{username}' already used", 409)
new_user = User(name=name,
username=username,
email=email,
password=User.hashify(password))
try:
new_user.save_to_db()
access_token = create_access_token(identity=username, fresh=True)
refresh_token = create_refresh_token(identity=username)
return make_response(
{
"message": f"user {username} created",
"access_token": access_token,
"refresh_token": refresh_token
}, 200)
except Exception as e:
print(e)
return JU.make_response("something went wrong", 500)
def registrate_user(self, *, data: UserCreate) -> User:
"""
[Registration]
Raises:
[HTTPException]: Райзится при условии, если пользователь с этим email/username уже зарегистрирован.
Returns:
[UserORM]: Возвращается созданная модель пользователя, в pydantic-модели.
"""
message = "User with this {} is already registered"
if self.get_user_by_email(email=data.email):
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=message.format("mail"))
if self.get_user_by_username(username=data.username):
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=message.format("username"))
hashed = auth_service.get_hash_password(password=data.password)
user = User(username=data.username, email=data.email, password=hashed)
self.database.add(user)
self.database.commit()
self.database.refresh(user)
return user
async def readmeme(self, message):
logging.info('Processing incoming meme.')
current_user = message.author
current_server = message.server
if (current_server is None or current_user is None):
logging.info('Missing info. Discarding.')
return
db_server = self.session.query(Server).filter(
Server.discord_id == current_server.id).first()
if (db_server is None): return
if (not self.is_correct_channel_and_message(message, db_server)):
logging.info('Not in selected channel. Discarding.')
return
db_user = self.session.query(User).filter(
User.discord_id == current_user.id).first()
if (db_user is None):
db_user = User(current_user.id, current_user.name,
current_user.display_name)
self.session.add(db_user)
content = self.get_message_content(message)
self.session.add(
Message(message.id, db_server, db_user, content, message.timestamp,
1, 1))
self.session.commit()
logging.info('Wrote new meme.')
def add_user():
# 从前端Ajax请求中获取用户名
username = request.json.get('username', None)
name = request.json.get('name', None)
email = request.json.get('email', None)
password = request.json.get('password', None)
selected_department = request.json.get('selected_department', None)
selected_position = request.json.get('selected_position', None)
selected_gender = request.json.get('selected_gender', None)
status = request.json.get('status', None)
role = request.json.get('role', None)
status_code = None
user = User(username=username,
name=name,
email=email,
password=generate_password_hash(password),
group_id=selected_department,
position_id=selected_position,
gender=selected_gender,
status=status)
for r in role:
user_role = Role.query.get(r['id'])
user.roles.append(user_role)
try:
db.session.add(user)
db.session.commit()
status_code = 200
except Exception:
status_code = 500
return jsonify(), status_code
def register():
# 从前端Ajax请求中获取用户名
username = request.json.get('username', None)
name = request.json.get('name', None)
email = request.json.get('email', None)
password = request.json.get('password', None)
selected_department = request.json.get('selected_department', None)
selected_position = request.json.get('selected_position', None)
selected_gender = request.json.get('selected_gender', None)
# 用户注册默认状态为0即不允许登录
status = 0
status_code = None
user = User(username=username,
name=name,
email=email,
password=generate_password_hash(password),
group_id=selected_department,
position_id=selected_position,
gender=selected_gender,
status=status)
try:
db.session.add(user)
db.session.commit()
status_code = 200
except Exception:
status_code = 500
return jsonify(), status_code
def update_nickname(self, before, after):
if (after.nick is None):
logging.info('Not a nick update, skipping.')
return
db_user = self.session.query(User).filter(
User.discord_id == before.id).first()
db_server = self.session.query(Server).filter(
Server.discord_id == before.server.id).first()
if (db_server is None):
logging.info(
'Update nick attempt on uninitialized server, aborting.')
return
if (db_user is None):
new_user = User(after.id, after.name, after.nick)
self.session.add(new_user)
db_user = new_user
db_nickname = self.session.query(Nickname).filter(
Nickname.user_id == db_user.id,
Nickname.server_id == db_server.id).first()
if (db_nickname is None):
new_nick = Nickname(db_user, db_server, after.display_name)
self.session.add(new_nick)
else:
db_nickname.display_name = after.display_name
self.session.commit()
logging.info('Updated nickname')
