def update_team(team_id):
session = current_app.db.session
owner_id = get_jwt_identity()
body: dict = request.get_json()
found_team: TeamModel = TeamModel.query.filter_by(id=team_id).first()
if not found_team:
return {
"error": "Not found any team that matches the requested ID."
}, HTTPStatus.NOT_FOUND
if found_team.owner_id != owner_id:
return {"error": "You are not the owner of this Team."}, HTTPStatus.FORBIDDEN
for key, value in body.items():
setattr(found_team, key, value)
session.add(found_team)
session.commit()
return {
"team": {
"team_name": found_team.team_name,
"team_description": found_team.team_description,
"owner_id": found_team.owner_id,
"team_create_date": found_team.team_created_date,
}
}, HTTPStatus.OK
def post(self):
parse = reqparse.RequestParser()
parse.add_argument("name", type=str, required=True)
parse.add_argument("nickname", type=str, required=True)
parse.add_argument("email", type=str, required=True)
parse.add_argument("password", type=str, required=True)
parse.add_argument("phone", type=str, required=True)
parse.add_argument("link_profile_picture", type=str, required=True)
parse.add_argument("bio", type=str, required=True)
kwargs = parse.parse_args()
new_user = UserModel(
name=kwargs.name,
nickname=kwargs.nickname,
email=kwargs.email,
phone=kwargs.phone,
link_profile_picture=kwargs.link_profile_picture,
bio=kwargs.bio,
)
new_user.password = kwargs.password
session = current_app.db.session
session.add(new_user)
session.commit()
serializer = user_schema.dump(new_user)
return {"data": serializer}, HTTPStatus.OK
def patch(self, user_id):
parse = reqparse.RequestParser()
parse.add_argument("name", type=str)
parse.add_argument("nickname", type=str)
parse.add_argument("email", type=str)
parse.add_argument("password", type=str)
parse.add_argument("phone", type=str)
parse.add_argument("link_profile_picture", type=str)
parse.add_argument("bio", type=str)
kwargs = parse.parse_args()
user = UserModel.query.get_or_404(user_id)
for key, value in kwargs.items():
if value:
if key != "password":
setattr(user, key, value)
if kwargs.password:
setattr(user, "password", kwargs.password)
session = current_app.db.session
session.add(user)
session.commit()
serializer = user_schema.dump(user)
return {"data": serializer}, HTTPStatus.OK
def owner_purge_user(team_id):
session = current_app.db.session
res = request.get_json()
user_idt = res.get("user_id")
owner_idt = get_jwt_identity()
excluir_registro = TeamUserModel.query.filter(
TeamUserModel.team_id == team_id,
TeamUserModel.user_id == user_idt,
TeamModel.owner_id == owner_idt,
).first()
try:
if excluir_registro.team.owner_id == owner_idt:
session.delete(excluir_registro)
session.commit()
return {
f"the user {excluir_registro.user.nickname} has been expelled": f"{excluir_registro.team.team_name}",
}, HTTPStatus.OK
else:
return {
"error": "You aren't the owner of the team"
}, HTTPStatus.UNAUTHORIZED
except AttributeError:
return {"error": "Team id or user id incorrects."}, HTTPStatus.NOT_FOUND
def register_user(login, password, mail, name) -> User:
session = db_session.create_session()
user = User()
auth = Auth()
user.is_approved = False
user.name = name
user.role = 'user'
user.key = geherate_key()
auth.login = login
auth.password = password
auth.email = mail
user.auth.append(auth)
session.add(user)
session.flush()
application = Applications()
print(user.id)
application.user_id = user.id
application.login = login
session.add(application)
session.commit()
session.close()
return user
def delete_user(id):
session = db_session.create_session()
user = session.query(User).get(id)
auth = user.auth[0]
session.delete(user)
session.delete(auth)
session.commit()
session.close()
def delete(self, user_id):
user = UserModel.query.get_or_404(user_id)
session = current_app.db.session
session.delete(user)
session.commit()
return {
"data": f"User {user_id} has successfully been deleted"
}, HTTPStatus.OK
def leave_team():
session = current_app.db.session
res = request.get_json()
team_idt = res.get("team_id")
user_id = get_jwt_identity()
TeamUserModel.query.filter_by(user_id=user_id, team_id=team_idt).delete()
session.commit()
return {"message": "Leave team"}, HTTPStatus.OK
def admin_decline_user(id):
if check_user(id):
session = db_session.create_session()
user = session.query(User).get(id)
session.delete(user)
session.delete(
session.query(Applications).filter(
Applications.user_id == id).first())
session.commit()
session.close()
return True
def admin_accept_user(id):
if check_user(id):
session = db_session.create_session()
user = session.query(User).get(id)
user.is_approved = True
application = session.query(Applications).filter(
Applications.user_id == id).first()
session.delete(application)
session.commit()
session.close()
return True
def hw_add_cadastro(request):
session = SessionLocal()
senha = request["senha"]
hash_obj = hashlib.md5(f"{senha}".encode())
md5_value = hash_obj.hexdigest()
cadastro = Cadastro(nome=request["nome"],
email=request["email"],
senha=md5_value)
cadastro_json = populate_cadastro([cadastro])
session.add(cadastro)
session.commit()
session.close()
return cadastro_json
def delete_reservation(reservation_id):
session = Session()
try:
reservation = session.query(Reservation).filter_by(
id=int(reservation_id)).one()
except Exception:
abort(404, description="Reservation not found")
auth_check(reservation.user_id, auth.current_user())
session.delete(reservation)
session.commit()
return jsonify({"Success": "Reservation has been deleted"}), 200
def create_category():
session = current_app.db.session
body_category = request.get_json()
name = body_category.get('name')
new_category = CategoryModel(name=name)
session.add(new_category)
session.commit()
return {
'category': {
'id': new_category.id,
'name': new_category.name
}
}, HTTPStatus.CREATED
def register_admin(login, password, mail, name) -> User:
session = db_session.create_session()
user = User()
auth = Auth()
user.is_approved = True
user.name = name
user.role = 'admin'
user.key = geherate_key()
auth.login = login
auth.password = password
auth.email = mail
user.auth.append(auth)
session.add(user)
session.commit()
session.close()
def create_user():
session = Session()
data = request.get_json()
try:
user = User(**data)
except:
return jsonify({"Message": "Invalid input"}), 405
user.hash_password()
session.add(user)
session.commit()
return jsonify({"Success": "User has been created"}), 200
def update_reservation(reservation_id):
session = Session()
try:
reservation = session.query(Reservation).filter_by(
id=int(reservation_id)).one()
except:
abort(404, description="Reservation not found")
auth_check(reservation.user_id, auth.current_user())
data = request.get_json()
try:
if data.get('from_date', None):
d = datetime.strptime(data['from_date'], '%Y-%m-%d')
reservation.from_date = d.date()
if data.get('to_date', None):
d = datetime.strptime(data['to_date'], '%Y-%m-%d')
reservation.to_date = d.date()
if data.get('audience_id', None):
reservation.audience_id = data['audience_id']
except Exception:
return jsonify({"Message": "Invalid input"}), 405
compare_dates(reservation.from_date, reservation.to_date)
try:
audience = session.query(Audience).filter_by(
id=int(reservation.audience_id)).one()
except:
abort(404, description="Audience not found")
reservations = session.query(Reservation).filter_by(
audience_id=int(audience.id)).all()
for reserv_other in reservations:
if reserv_other.id != reservation.id:
check_dates(reservation.from_date, reserv_other.from_date,
reserv_other.to_date)
check_dates(reservation.to_date, reserv_other.from_date,
reserv_other.to_date)
session.commit()
return jsonify({"Success": "Reservation has been changed"}), 200
def delete_user(user_id):
session = Session()
auth_check(user_id, auth.current_user())
user = session.query(User).filter_by(id=int(user_id)).one()
reservations = session.query(Reservation).filter_by(
user_id=int(user_id)).all()
session.delete(user)
for reservation in reservations:
session.delete(reservation)
session.commit()
return jsonify({"Success": "User has been deleted"}), 200
def create_audience():
session = Session()
data = request.get_json()
try:
audience = Audience(**data)
except Exception:
abort(405, description="Invalid input")
if not data['size'] > 0 and data['capacity'] > 0:
abort(405, description="Invalid input")
session.add(audience)
session.commit()
return jsonify({"Success": "Audience has been created"}), 200
def delete_team(team_id):
session = current_app.db.session
owner_id = get_jwt_identity()
team_to_be_deleted: TeamModel = TeamModel.query.filter_by(
owner_id=owner_id, id=team_id
).first()
if not team_to_be_deleted:
return {"error": "Invalid team ID"}, HTTPStatus.NOT_FOUND
session.delete(team_to_be_deleted)
session.commit()
return {"message": f"Deleted team with ID: {team_id}"}, HTTPStatus.OK
def update_user(user_id):
auth_check(user_id, auth.current_user())
session = Session()
user = session.query(User).filter_by(id=int(user_id)).one()
data = request.get_json()
if data.get('first_name', None):
user.first_name = data['first_name']
if data.get('second_name', None):
user.second_name = data['second_name']
if data.get('user_name', None):
user.user_name = data['user_name']
if data.get('password', None):
user.password = data['password']
user.hash_password()
session.commit()
return jsonify({"Success": "User has been changed"}), 200
def create_reservation():
session = Session()
data = request.get_json()
try:
user = session.query(User).filter_by(id=int(data.pop('user_id'))).one()
except Exception:
abort(404, description="User not found")
try:
audience = session.query(Audience).filter_by(
id=int(data.pop('audience_id'))).one()
except:
abort(404, description="Audience not found")
d = datetime.strptime(data['from_date'], '%Y-%m-%d')
data['from_date'] = d.date()
d = datetime.strptime(data['to_date'], '%Y-%m-%d')
data['to_date'] = d.date()
compare_dates(data['from_date'], data['to_date'])
reservations = session.query(Reservation).filter_by(
audience_id=int(audience.id)).all()
for reserv_other in reservations:
check_dates(data['from_date'], reserv_other.from_date,
reserv_other.to_date)
check_dates(data['to_date'], reserv_other.from_date,
reserv_other.to_date)
reservation = Reservation(**data, user_r=user, audience_r=audience)
session.add(reservation)
session.commit()
return jsonify({"Success": "Reservation has been created"}), 200
def register_team():
session = current_app.db.session
res = request.get_json()
team_name = res.get("team_name")
team_description = res.get("team_description")
owner_id = get_jwt_identity()
new_team = TeamModel(
team_name=team_name, team_description=team_description, owner_id=owner_id
)
session.add(new_team)
session.commit()
return {
"team": {
"team_name": new_team.team_name,
"team_description": new_team.team_description,
"owner_id": new_team.owner_id,
"team_created_date": new_team.team_created_date,
}
}, HTTPStatus.CREATED
def delete_category(id):
session = current_app.db.session
category_filter = CategoryModel.query.get(id)
session.delete(category_filter)
session.commit()
return {}, HTTPStatus.NO_CONTENT
