def initialize_data(self) -> None:
with transaction(commit=True) as db:
# Active User
active_user = Users(id=self.active_user_id,
password=self.password).save(db)
# Leave User
leave_user = Users(
id=self.leave_user_id,
password=self.password,
leave=Users.LEAVE,
leave_dt=datetime.now().strftime('%Y-%m-%d %H:%M:%S')).save(db)
setattr(self, 'active_uid', active_user.row_id)
setattr(self, 'leave_uid', leave_user.row_id)
for i in range(0, 2):
response = client.put("/v1/users/session",
json={
'id': self.active_user_id,
'password': self.password
})
assert response.status_code == HTTPStatus.OK
# 테스트 메소드 수 만큼 setup 호출로 테스트 완료가 조금 걸린다
time.sleep(1)
def initialize_data(self) -> None:
with transaction(commit=True) as db:
# Active User
active_user = Users(id=self.active_user_id, password=self.password).save(db)
# Leave User
leave_user = Users(
id=self.leave_user_id,
password=self.password,
leave=Users.LEAVE,
leave_dt=datetime.now().strftime('%Y-%m-%d %H:%M:%S')).save(db)
setattr(self, 'active_uid', active_user.row_id)
setattr(self, 'leave_uid', leave_user.row_id)
def create_session(self, username, token,admin): self.username = username self.token = token user = Users() usuario = user.get_user(username) self.email = usuario['email'] self.admin = admin
def log_user():
sesion = Session()
new = request.get_json()
usuario = new['username']
token_angular = request.headers.get('Authorization')
#Verificamos si el usuario tiene una sesión activa
if token_angular:
if sesion.exist_session(usuario, token_angular):
respuesta = {'error': True, 'mensaje': 'Ya has iniciado sesión.'}
return json.dumps(respuesta)
user = Users()
clave = new['password']
if sesion.exist_sesion(usuario):
deletesesion = sesion.delete_session(usuario)
db.session.delete(deletesesion)
db.session.commit()
if user.login(usuario, clave):
res = create_session(usuario, user.is_Admin(usuario))
respuesta = {
'error': False,
'mensaje': 'Inicio de sesión exitoso.',
'token': res
}
return json.dumps(respuesta)
else:
respuesta = {
'error': True,
'mensaje': 'Usuario o Contraseña incorrectos.'
}
return json.dumps(respuesta)
def agregarcarrito():
sesion = Session()
usuario = request.headers.get('username')
token_angular = request.headers.get('Authorization')
#Verificamos si el usuario tiene una sesión activa
if token_angular:
if sesion.exist_session(usuario, token_angular):
car = Carrito()
user = Users()
datos_user = user.get_user(usuario)
datos = request.get_json()
res = car.exist_prod(datos_user['id'], datos['id_prod'])
if res == 1:
car.agg_prod(datos_user['id'], datos['id_prod'])
db.session.add(car)
respuesta = {
'error': False,
'mensaje': 'Producto agregado exitosamente.'
}
else:
respuesta = {
'error': False,
'mensaje': 'Cantidad aumentada exitosamente.'
}
db.session.commit()
return json.dumps(respuesta)
respuesta = {'error': True, 'mensaje': 'Debes iniciar sesión.'}
return json.dumps(respuesta)
def token():
server_error = {
'status_code': 500
}
if request.method == 'POST':
if not request.form['email']:
flash('Please enter email', 'error')
else:
user = Users(request.form['email'], request.form["access_token"],
request.form["refresh_token"])
exists = db.session.query(Users).filter_by(
email=user.email).scalar() is not None
if exists:
query_user = Users.query.filter_by(email=user.email).first()
query_user.access_token = user.access_token
query_user.refresh_token = user.refresh_token
db.session.commit()
resp_dict = {
'status_code': 200,
'email': user.email,
'access_token': user.access_token,
'refresh_token': user.refresh_token
}
return json.dumps(resp_dict)
else:
resp_dict = {'status_code': 404, 'message': 'User not found'}
return json.dumps(resp_dict)
return json.dumps(server_error)
def create_user():
if request.method == "POST":
users = Users.objects(user=request.form['user'])
emails = Users.objects(email=request.form['email'])
user = Users(
name=request.form['name'],
user=request.form['user'],
email=request.form['email'],
password=generate_password_hash(request.form['password']),
birth=request.form['birth']
)
client = loads(user.to_json())
if users:
flash('This username already in use!','danger')
return render_template('users/create.html',user=client)
elif emails:
flash('This email address already in use!','danger')
return render_template('users/create.html',user=client)
elif request.form['password'] != request.form['confirm_password']:
flash('Passwords don\'t match!','danger')
return render_template('users/create.html',user=client)
else:
user.save()
send_confirmation(user)
flash('Sucess! Login to continue!','success')
return redirect(url_for('login'))
else:
return render_template('users/create.html',user=None)
def post(self):
name = request.json.get('name')
username = request.json.get('username')
user = Users(name=name, username=username)
db.session.add(user)
db.session.commit()
return {'result': 'User added.'}
def tokenCheck():
if request.method == 'OPTIONS':
return
userData = {}
userString = request.headers.get(configs.SECRET_KEY, None)
if userString is None:
response = jsonify(api_response.failed('authentication', ''))
response.status_code = 401
return response
if 'auth' in request.url:
if userString != configs.SECRET_KEY_HASH:
response = jsonify(api_response.failed('authentication', ''))
response.status_code = 401
return response
else:
userKey = request.headers.get('user-key', None)
if userKey is None:
response = jsonify(api_response.failed('authentication', ''))
response.status_code = 401
return response
userData = Users(mongo, False).get({'key': str(userKey)})
if not bool(userData):
response = jsonify(api_response.failed('authentication', ''))
response.status_code = 401
return response
g.user = userData
def create_user(self):
"""Helper function creates user for tests"""
user = Users(username=self.test_user,
name=self.test_user_name,
email=self.test_user_email,
password=generate_password_hash(self.test_user_password))
user.add()
def login():
server_error = {
'status_code': 500
}
if request.method == 'POST':
if not request.form['email']:
flash('Please enter email', 'error')
else:
user = Users(request.form['email'], "", "")
exists = db.session.query(Users).filter_by(
email=user.email).scalar() is not None
if exists:
query_user = db.session.query(Users).filter_by(
email=user.email).first()
app.logger.debug(query_user)
resp_dict = {
'status_code': 200,
'email': query_user.email,
'access_token': query_user.access_token,
'refresh_token': query_user.refresh_token
}
return json.dumps(resp_dict)
else:
db.session.add(user)
db.session.commit()
flash('Record was successfully added')
resp_dict = {
'status_code': 200,
'email': user.email,
'access_token': user.access_token,
'refresh_token': user.refresh_token
}
return json.dumps(resp_dict)
return json.dumps(server_error)
def create_session(username, admin):
user = Users()
token = user.create_password("secret")
sesion = Session()
sesion.create_session(username, token, admin)
db.session.add(sesion)
db.session.commit()
return token
def before_request():
"""Initialize globals before processing the request."""
g.user = None
# Checking of non static file is requested
if '/static/' not in request.path:
# initializing user id user_id is in session
if 'user_id' in session:
g.user = Users().get_user_by_id(session['user_id'])
def add_user(self, user: UserCreate) -> Users:
user_in = Users(
username=user.username,
name=user.name,
email=user.email,
hashed_password=get_password_hash(user.password),
)
res = db.users.insert_one(user_in.dict(by_alias=True))
return res
def __init__(self, config, api_response, mongo_connection):
self.config = config
self.startTime = datetime.now()
self.api_response = api_response
self.users = Users(mongo_connection, False)
self.parser = reqparse.RequestParser()
def retrieve(uid: int):
try:
with transaction() as db:
user = Users(row_id=uid).find_by_row_id(db)
return user.to_dict()
except NotFoundUserException:
raise
except Exception as e:
raise InternalServerException(message=f"서버 에러가 발생했습니다",
exc_detail=str(e))
def logout(uid):
try:
with transaction(commit=True) as db:
user = Users(row_id=uid).logout(db)
return {"uid": user.row_id}
except NotFoundUserException:
raise
except Exception as e:
raise InternalServerException(message=f"서버 에러가 발생했습니다",
exc_detail=str(e))
def init_database_models(self):
db_conf = config.app_cfg['postgresql_teamleader']
table_names = config.app_cfg['table_names']
self.companies = Companies(db_conf, table_names)
self.contacts = Contacts(db_conf, table_names)
self.departments = Departments(db_conf, table_names)
self.events = Events(db_conf, table_names)
self.invoices = Invoices(db_conf, table_names)
self.projects = Projects(db_conf, table_names)
self.users = Users(db_conf, table_names)
def user_new():
username = request.form.get('username')
name = request.form.get('name')
user = Users(username, name)
db.session.add(user)
db.session.commit()
return jsonify({user.id: {
'username': user.username,
'name': user.name,
}})
def login(data):
try:
with transaction(commit=True) as db:
user = Users(id=data.id,
password=data.password).find_by_id_password(db)
user.login(db)
return {"uid": user.row_id}
except NotFoundUserException:
raise
except Exception as e:
raise InternalServerException(message=f"서버 에러가 발생했습니다",
exc_detail=str(e))
def register(username: str = Body(...),
email: str = Body(...),
password: str = Body(...),
name: str = Body(...),
optIn: bool = Body(...),
db: Session = Depends(get_db)):
try:
user = db.query(Users).filter(Users.email == email).first()
if not user:
# check user has valid login in CCB
req = {
'username': username,
'password': password,
'keep_me_logged_in': True
}
res = requests.post('https://thirdave.ccbchurch.com/api/login',
json=req)
if res.status_code == 200:
# add new user to db
new_user = Users(username=username,
email=email,
name=name,
password=get_password_hash(password),
wants_emails=optIn)
db.add(new_user)
db.commit()
db.refresh(new_user)
# generate auth token
access_token_expires = timedelta(minutes=120 * 24 * 8)
auth_token = create_access_token(
data={"user_uuid": str(new_user.uuid)},
expires_delta=access_token_expires)
return {
"access_token": auth_token.decode(),
"message": "Successfully registered.",
"status": "Success",
"user": new_user.to_json()
}
else:
return 404
else:
return 400
except Exception as e:
print(e)
db.rollback()
return 500
finally:
db.close()
def log_user():
if request.method == 'POST':
user = Users()
usuario = request.form['usuario']
clave = request.form['clave']
if user.exist_user(usuario,clave):
respuesta = {'error':False,'mensaje':'Usuario logueado'}
return json.dumps(respuesta)
else:
respuesta = {'error':True,'mensaje':'Contrasena o Usuario incorrectos'}
return json.dumps(respuesta)
return render_template('login.html')
def register():
if current_user.is_authenticated:
return redirect(url_for('main.index'))
form = RegistrationForm()
if form.validate_on_submit():
user = Users(email=form.email.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
send_confirmation_email(user)
flash(Markup('A confirmation email has been sent to you by email.'), "info")
return redirect(url_for('auth.login'))
return render_template('auth/register.html', title='Register', form=form)
def unregister(uid):
try:
with transaction(commit=True) as db:
user = Users(row_id=uid).find_by_row_id(db)
if user.leave == Users.ACTIVE:
user.unregister(db)
return {"uid": user.row_id, "leave_dt": user.leave_dt}
except NotFoundUserException:
raise
except Exception as e:
raise InternalServerException(message=f"서버 에러가 발생했습니다",
exc_detail=str(e))
def hello():
with db.auto_commit():
a = Users()
b =Topic()
db.session.add(b)
a.email="1213s21aa2"
a.password="******"
db.session.add(a)
return "嘻嘻嘻"
def perfil():
sesion = Session()
new = request.get_json()
usuario = request.headers.get('username')
token_angular = request.headers.get('Authorization')
print(usuario)
#Verificamos si el usuario tiene una sesión activa
if token_angular:
if sesion.exist_session(usuario, token_angular):
user = Users()
datos = user.get_user(usuario)
return json.dumps(datos)
respuesta = {'error': True, 'mensaje': 'No has iniciado sesión.'}
return json.dumps(respuesta)
def initialize_data(self) -> None:
with transaction(commit=True) as db:
# Active User
active_user = Users(id=self.active_user_id, password=self.password).save(db)
# Leave User
leave_user = Users(
id=self.leave_user_id,
password=self.password,
leave=Users.LEAVE,
leave_dt=datetime.now().strftime('%Y-%m-%d %H:%M:%S')).save(db)
response = client.put("/v1/users/session", json={
'id': self.active_user_id,
'password': self.password
})
assert response.status_code == HTTPStatus.OK
response = response.json()
assert response.get('session') is not None
setattr(self, 'active_uid', active_user.row_id)
setattr(self, 'active_session_key', response.get('session'))
setattr(self, 'leave_uid', leave_user.row_id)
def register(data):
try:
with transaction(commit=True) as db:
user = Users(id=data.id, password=data.password)
user.save(db)
return {
"uid": user.row_id,
"created_at": user.created_dt.strftime("%Y-%m-%d %H:%M:%S"),
}
except ConflictUserException:
raise
except Exception as e:
raise InternalServerException(message=f"서버 에러가 발생했습니다",
exc_detail=str(e))
def editPerfil():
sesion = Session()
usuario = request.headers.get('username')
token_angular = request.headers.get('Authorization')
#Verificamos si el usuario tiene una sesión activa
if token_angular:
if sesion.exist_session(usuario, token_angular):
user = Users()
NewUser = request.get_json()
valido, error = user.exist_user_perfil(NewUser['id'],
NewUser['username'],
NewUser['email'])
if valido == 0:
password = user.create_password(NewUser['password'])
user.edit_perfil(NewUser['id'], NewUser['email'],
NewUser['username'], password)
sesion = Session()
sesion.edit_session(error, NewUser['email'],
NewUser['username'])
db.session.commit()
respuesta = {
'error': False,
'mensaje': 'Perfil editado exitosamente.'
}
return json.dumps(respuesta)
else:
if error == 'email':
respuesta = {
'error': True,
'mensaje': 'Email ya registrado, seleccione otro.'
}
return json.dumps(respuesta)
else:
respuesta = {
'error':
True,
'mensaje':
'Nombre de usuario ya registrado, seleccione otro.'
}
return json.dumps(respuesta)
respuesta = {
'error': True,
'mensaje': 'Debes iniciar sesión.',
"token": token_angular
}
return json.dumps(respuesta)
def revision(project_id, revision_id):
"""Page with the list of all projects."""
project = Projects().get(id=project_id)
revision = Revisions().get(project_id=project_id, revision_id=revision_id)
diff = revision.get('diff')
lexer = get_lexer_by_name("diff", stripall=True)
formatter = HtmlFormatter(style=get_style_by_name('colorful'))
formatted_diff = highlight(diff, lexer, formatter)
user = Users().get(id=revision.get('contributor_id'))
return render_template(
'revision.html',
revision=revision,
project=project,
user=user,
diff=formatted_diff,
diff_styles=HtmlFormatter().get_style_defs('.highlight'))