def edit_mentor(id):
data = request.get_json()
try:
account_type = int(request.args["account_type"])
except:
msg = "Level param doesn't exist or isn't an int"
return create_response(status=422, message=msg)
# Try to retrieve account profile from database
account = None
try:
if account_type == Account.MENTEE:
account = MenteeProfile.objects.get(id=id)
elif account_type == Account.MENTOR:
account = MentorProfile.objects.get(id=id)
else:
msg = "Level param doesn't match existing account types"
return create_response(status=422, message=msg)
except:
msg = ""
if account_type == Account.MENTEE:
msg = "No mentee with that id"
elif account_type == Account.MENTOR:
msg = "No mentor with that id"
logger.info(msg)
return create_response(status=422, message=msg)
if not edit_profile(data, account):
msg = "Couldn't update profile"
return create_response(status=500, message=msg)
account.save()
return create_response(status=200, message=f"Success")
def get_replies(flyer_id):
data = request.get_json()
logger.info("Data recieved: %s", data)
if "sender" not in data:
msg = "No sender provided for reply."
logger.info(msg)
return create_response(status=422, message=msg)
flyer = SearchFlyer.query.get(flyer_id)
sender = data['sender']
data['content'] = f'{sender} se quiere contactar con vos por tu aviso.'
data['flyer_id'] = flyer_id
data['recipient'] = flyer.created_by
data['status'] = 'sent'
# create SQLAlchemy Object
message = Message(**data)
# commit it to database
db.session.add_all([message])
db.session.commit()
submit_notification(
flyer.created_by, {
'title': '¡Respondieron tu aviso!',
'body': f'{sender} se quiere contactar con vos por tu aviso.',
'flyer_id': flyer_id
})
return create_response(
message=f"Successfully created message with id: {message.id}",
data={"message": message.to_dict()})
def update_app_status(id):
""" function that is called when you visit /field_partner/update/<id>, updates an FP's app status info """
fp = FieldPartner.query.get(id)
data = request.form
if data is None:
return create_response(status=400, message="No data provided to update FP")
if "app_status" in data:
fp.app_status = data.get("app_status")
if "instructions" in data:
fp.instructions = data.get("instructions")
if "email" in data:
fp.email = data.get("email")
if "org_name" in data:
fp.org_name = data.get("org_name")
if "pm_id" in data:
fp.pm_id = data.get("pm_id")
if "due_date" in data:
fp.due_date = data.get("due_date")
ret = fp.to_dict()
db.session.commit()
return create_response(data={"field_partner": ret})
def rendezvous():
code = request.args.get('code')
dest = Destination.query.filter(Destination.code == code).all()
if not dest:
users = User.query.filter(User.code == code).all()
lats = [user.lat for user in users]
lons = [user.lon for user in users]
centr_lat = sum(lats) / len(lats)
centr_lon = sum(lons) / len(lons)
global gmaps
response = gmaps.places_nearby(location=(centr_lat, centr_lon),
rank_by='distance',
type="store")
loc = response['results'][0]['geometry']['location']
lat, lon = loc['lat'], loc['lng']
dest = Destination(lat, lon, code)
dest.add_dest()
return create_response(data={"lat": lat, "lon": lon})
elif len(dest) == 1:
dest = dest[0]
return create_response(data={"lat": dest.lat, "lon": dest.lon})
else:
return create_response(status=500)
def post_user_data():
data = request.get_json()
logger.info("Data recieved: %s", data)
if "email" not in data:
msg = "No email provided."
logger.info(msg)
return create_response(status=422, message=msg)
email = data['email']
user_data = UserData.query.filter_by(email= email).first()
if user_data:
user_data.push_token = data['push_token']
else:
user_data = UserData(**data)
# commit it to database
db.session.add_all([user_data])
db.session.commit()
return create_response(
message=f"Successfully update user data",
data={ "message": user_data.to_dict() }
)
def download_accounts_info():
data = request.args
account_type = int(data.get("account_type", 0))
accounts = None
try:
admins = Admin.objects()
admin_ids = [admin.firebase_uid for admin in admins]
if account_type == Account.MENTOR:
accounts = MentorProfile.objects(firebase_uid__nin=admin_ids)
elif account_type == Account.MENTEE:
accounts = MenteeProfile.objects(firebase_uid__nin=admin_ids)
except:
msg = "Failed to get accounts"
logger.info(msg)
return create_response(status=422, message=msg)
if account_type == Account.MENTOR:
return download_mentor_accounts(accounts)
elif account_type == Account.MENTEE:
return download_mentee_accounts(accounts)
msg = "Invalid input"
logger.info(msg)
return create_response(status=422, message=msg)
def create_person():
data = request.get_json()
logger.info("Data received: %s", data)
if "name" not in data:
msg = "No name provided for person."
logger.info(msg)
return create_response(status=422, message=msg)
if "email" not in data:
msg = "No email provided for person."
logger.info(msg)
return create_response(status=422, message=msg)
if "password" not in data:
msg = "No password provided for person."
logger.info(msg)
return create_response(status=422, message=msg)
if db.session.query(
User.id).filter_by(email=data["email"]).scalar() is not None:
msg = "!!!!"
logger.info(msg)
return create_response(status=422, message=msg)
new_user = User(name=data["name"],
email=data["email"],
password=generate_password_hash(data["password"]),
isAdmin=False)
db.session.add(new_user)
db.session.commit()
return create_response(
message=
f"Successfully created person {new_user.name} with id: {new_user.id}")
def create_visualization():
data = request.get_json()
logger.info("Data recieved: %s", data)
if "name" not in data:
msg = "No name provided for visualization."
logger.info(msg)
return create_response(status=422, message=msg)
if "sentence_id" not in data:
msg = "No sentence ID provided for visualization."
logger.info(msg)
return create_response(status=422, message=msg)
if "type" not in data:
msg = "No type provided for visualization."
logger.info(msg)
return create_response(status=422, message=msg)
if "comment" not in data:
data["comment"] = ""
# create SQLAlchemy Object
new_visualization = Visualization(
name = data["name"],
sentence_id = data["sentence_id"],
comment = data["comment"],
params = data["params"],
type = data["type"]
)
db.session.add(new_visualization)
db.session.commit()
db.session.add(Access(user_id = data["user_id"], model = 'visualization', model_id = new_visualization.id, level = 'admin'))
db.session.commit()
return create_response(
message=f"Successfully created visualization {new_visualization.name} with id: {new_visualization.id}"
)
def edit_visualization():
data = request.get_json()
logger.info("Data recieved: %s", data)
if "visualization_id" not in data:
msg = "No ID provided for visualization."
logger.info(msg)
return create_response(status=422, message=msg)
if "name" not in data:
msg = "No name provided for visualization."
logger.info(msg)
return create_response(status=422, message=msg)
if "sentence_id" not in data:
msg = "No sentence ID provided for visualization."
logger.info(msg)
return create_response(status=422, message=msg)
if "comment" not in data:
data["comment"] = ""
# create SQLAlchemy Object
if "params" not in data:
msg = "No params provided for line chart visualization."
logger.info(msg)
return create_response(status=422, message=msg)
visual = Visualization.query.get(data["visualization_id"])
visual.name = data["name"]
visual.sentence_id = data["sentence_id"]
visual.comment = data["comment"]
visual.params = data["params"]
visual.type = data["type"]
# commit it to database
db.session.commit()
return create_response(
message=f"Successfully edited visualization {visual.name} with id: {visual.id}"
)
def edit_sentence():
data = request.get_json()
logger.info("Data recieved: %s", data)
if "sentence_id" not in data:
msg = "No sentence ID provided for sentence."
logger.info(msg)
return create_response(status=422, message=msg)
if "name" not in data:
msg = "No name provided for sentence."
logger.info(msg)
return create_response(status=422, message=msg)
if "sql_query" not in data:
msg = "No SQL query provided for sentence."
logger.info(msg)
return create_response(status=422, message=msg)
if "connection_id" not in data:
msg = "No connection ID provided for sentence."
logger.info(msg)
return create_response(status=422, message=msg)
if "comment" not in data:
data["comment"] = ""
# Fetch Sentence
sentence = Sentence.query.get(data["sentence_id"])
# Perform edit
sentence.connection_id = data["connection_id"]
sentence.name = data["name"]
sentence.sql_query = data["sql_query"]
sentence.comment = data["comment"]
sentence.visual_query_params = data["visual_query_params"]
# Commit it to database
db.session.commit()
return create_response(
message=f"Successfully edited sentence {sentence.name} with id: {sentence.id}"
)
def return_visualizations():
data = request.get_json()
logger.info("Data recieved: %s", data)
if "user_id" not in data:
msg = "No user ID provided for visualizations."
logger.info(msg)
return create_response(status=422, message=msg)
if "visualization_id" not in data:
visualizations = db.session.query(Visualization).filter(
Visualization.id.in_(
db.session.query(Access.model_id).filter(Access.user_id == data["user_id"], Access.model=='visualization').all()
)
).all()
# return visualizations
return create_response(data={"visualizations": serialize_list(visualizations)})
# If there was a specific visualization requested, fetch it and return it
visualization = db.session.query(Visualization).filter(
Visualization.id == data["visualization_id"],
Visualization.id.in_(
db.session.query(Access.model_id).filter(Access.user_id == data["user_id"], Access.model=='visualization').all()
)
).first()
visualization_details = visualization.get_fields()
# visualization_details.pop('_sa_instance_state', None)
return create_response(data={"visualization": visualization_details})
def test_connection():
data = request.get_json()
logger.info("Data recieved: %s", data)
if "name" not in data:
msg = "No name provided for connection."
logger.info(msg)
return create_response(status=422, message=msg)
if "user_id" not in data:
msg = "No user_id provided for connection."
logger.info(msg)
return create_response(status=422, message=msg)
if "comment" not in data:
data["comment"] = ""
if ("type" not in data):
msg = "No type provided for connection."
logger.info(msg)
return create_response(status=422, message=msg)
# create SQLAlchemy Object
if data["type"] == "postgres":
new_conn = Connection(
name= data["name"],
type= data["type"],
params= data["params"],
user_id = data["user_id"],
comment = data["comment"]
)
try:
new_conn.start_connection()
return create_response(message=f"Test OK!")
except:
return create_response(status=422, message="FAILED")
def create_connection():
data = request.get_json()
logger.info("Data recieved: %s", data)
if "name" not in data:
msg = "No name provided for connection."
logger.info(msg)
return create_response(status=422, message=msg)
if "user_id" not in data:
msg = "No user_id provided for connection."
logger.info(msg)
return create_response(status=422, message=msg)
if "comment" not in data:
data["comment"] = ""
if ("type" not in data):
msg = "No type provided for connection."
logger.info(msg)
return create_response(status=422, message=msg)
# create SQLAlchemy Object
new_conn = Connection(
name= data["name"],
type= data["type"],
params= data["params"],
user_id = data["user_id"],
comment = data["comment"]
)
# commit it to database
db.session.add(new_conn)
db.session.commit()
db.session.add(Access(user_id = data["user_id"], model = 'connection', model_id = new_postgres.id, level = 'admin'))
db.session.commit()
return create_response(
message=f"Successfully created connection {new_conn.name} with id: {new_conn.id}"
)
def get_account(id):
try:
account_type = int(request.args["account_type"])
except:
msg = "Missing account_type param or account_type param is not an int"
return create_response(status=422, message=msg)
account = None
try:
if account_type == Account.MENTEE:
account = MenteeProfile.objects.get(id=id)
elif account_type == Account.MENTOR:
account = MentorProfile.objects.get(id=id)
else:
msg = "Level param doesn't match existing account types"
return create_response(status=422, message=msg)
except:
msg = ""
if account_type == Account.MENTEE:
msg = "No mentee with that id"
elif account_type == Account.MENTOR:
msg = "No mentor with that id"
logger.info(msg)
return create_response(status=422, message=msg)
return create_response(data={"account": account})
def get_predictive_rates():
actual_rates = None
predictive_rates = None
tract_id = request.args.get("tract_id", None)
actual_year = request.args.get("actual_year", None)
if not actual_year:
actual_year = "2010"
if tract_id:
actual_rates = get_response_rates_by_year(actual_year, tract_id, None)
predictive_rates = get_predictive_by_tract_id(PREDICTIVE_2020,
tract_id)
else:
return create_response(status=422,
message="Missing request parameters")
return create_response(
status=200,
data={
actual_year: actual_rates,
PREDICTIVE_2020: predictive_rates
},
message="Success",
)
def create_dashboard():
data = request.get_json()
logger.info("Data recieved: %s", data)
if "name" not in data:
msg = "No name provided for dashboard."
logger.info(msg)
return create_response(status=422, message=msg)
if "comment" not in data:
data["comment"] = ""
# create SQLAlchemy Object
new_dash = Dashboard(
name = data["name"],
comment = data["comment"])
# commit it to database
new_dash.visualizations=[]
for vis in data["visualizations"]:
dash_vis = DashboardsVisualizations(
visualization = Visualization.query.get(vis["_id"]),
order = vis["order"]
)
new_dash.visualizations.append(dash_vis)
db.session.add(new_dash)
db.session.commit()
db.session.add(Access(user_id = data["user_id"], model = 'dashboard', model_id = new_dash.id, level = 'admin'))
db.session.commit()
return create_response(
message=f"Successfully created dashboard {new_dash.name} with id: {new_dash.id}"
)
def edit_game(game_id):
game = Game.query.get(game_id)
if game is None:
return create_response(status=400, message="Game not found")
data = request.form
if data is None:
return create_response(status=400, message="No changes made")
# Edit the description, image, and thumbnail
description = data.get("description")
image = data.get("image")
thumbnail = data.get("thumbnail")
if description is not None:
game.description = description
db.session.commit()
if image is not None:
game.image = image
db.session.commit()
if thumbnail is not None:
game.thumbnail = thumbnail
db.session.commit()
# DO NOT REMOVE PRINT STATEMENT
print(game)
return create_response(data={"game": get_game_dict(game)},
message="Game successfully edited")
def edit_dashboard():
data = request.get_json()
logger.info("Data recieved: %s", data)
if "dashboard_id" not in data:
msg = "No ID provided for dashboard."
logger.info(msg)
return create_response(status=422, message=msg)
if "name" not in data:
msg = "No name provided for dashboard."
logger.info(msg)
return create_response(status=422, message=msg)
if "comment" not in data:
data["comment"] = ""
# Fetch Dashboard
dash = Dashboard.query.get(data["dashboard_id"])
# Edit it
dash.name = data["name"]
dash.comment = data["comment"]
dash.visualizations=[]
for vis in data["visualizations"]:
dash_vis = DashboardsVisualizations(
visualization = Visualization.query.get(vis["_id"]),
order = vis["order"]
)
dash.visualizations.append(dash_vis)
# commit it to database
db.session.commit()
return create_response(
message=f"Successfully edited dashboard {dash.name} with id: {dash.id}. ",
data= {"visualizations": serialize_list(dash.visualizations)}
)
def create_person():
data = request.get_json()
logger.info("Data recieved: %s", data)
if "name" not in data:
msg = "No name provided for person."
logger.info(msg)
return create_response(status=422, message=msg)
if "email" not in data:
msg = "No email provided for person."
logger.info(msg)
return create_response(status=422, message=msg)
# create SQLAlchemy Objects
new_person = Person(name=data["name"])
email = Email(email=data["email"])
new_person.emails.append(email)
# commit it to database
db.session.add_all([new_person, email])
db.session.commit()
return create_response(
message=
f"Successfully created person {new_person.name} with id: {new_person.id}"
)
def create_access():
data = request.get_json()
logger.info("Data recieved: %s", data)
if "user_id" not in data:
msg = "No user ID provided for access."
logger.info(msg)
return create_response(status=422, message=msg)
if "model" not in data:
msg = "No model provided for access."
logger.info(msg)
return create_response(status=422, message=msg)
if "model_id" not in data:
msg = "No model ID provided for access."
logger.info(msg)
return create_response(status=422, message=msg)
if "level" not in data:
msg = "No access level provided for access."
logger.info(msg)
return create_response(status=422, message=msg)
# Create SQLAlchemy Object
new_access = Access(
user_id = data["user_id"],
model = data["model"],
model_id = data["model_id"],
level = data["level"])
# Commit it to database
db.session.add(new_access)
db.session.commit()
return create_response(
message=f"Successfully created access with id: {new_access.id}"
)
def login_person():
data = request.get_json()
logger.info("Data received: %s", data)
if "email" not in data:
msg = "No email provided for person/"
logger.info(msg)
return create_response(status=422, message=msg)
if "password" not in data:
msg = "No password provided for person."
logger.info(msg)
return create_response(status=422, message=msg)
user = User.query.filter_by(email=data["email"]).first()
if user and check_password_hash(user.password, data["password"]):
access_token = create_access_token(identity=data["email"],
expires_delta=timedelta(minutes=30),
user_claims={
"user": user.name,
"admin": user.isAdmin
})
return create_response(status=200, message={"token": access_token})
return create_response(status=401, message="Sorry :(")
def create_sensor():
data = request.form
logger.info(str(data.keys()))
logger.info("Data recieved: %s", data)
if "name" not in data:
msg = "No name provided for sensor."
logger.info(msg)
return create_response(status=422, message=msg)
if "location" not in data:
msg = "No location provided for sensor."
logger.info(msg)
return create_response(status=422, message=msg)
# create SQLAlchemy Objects
new_sensor = Sensor(name=data["name"], location=data["location"])
# commit it to database
db.session.add_all([new_sensor])
db.session.commit()
return create_response(
message=
f"Successfully created sensor {new_sensor.name} with id: {new_sensor.id}",
data={
"id": new_sensor.id,
"name": new_sensor.name,
"location": new_sensor.location
})
def delete_request(appointment_id):
try:
request = AppointmentRequest.objects.get(id=appointment_id)
mentor = MentorProfile.objects.get(id=request.mentor_id)
mentee = MenteeProfile.objects.get(id=appointment.mentee_id)
except:
msg = "No appointment or account found with that id"
logger.info(msg)
return create_response(status=422, message=msg)
if mentee.email_notifications:
start_time = appointment.timeslot.start_time.strftime(
f"{APPT_TIME_FORMAT} GMT")
res_email = send_email(
recipient=mentee.email,
subject="Mentee Appointment Notification",
data={
"name": mentor.name,
"date": start_time,
"approved": False
},
template_id=MENTEE_APPT_TEMPLATE,
)
if not res_email:
logger.info("Failed to send email")
request.status = APPT_STATUS["REJECTED"]
request.save()
return create_response(status=200, message=f"Success")
def verify_email():
data = request.json
email = data.get("email")
verification_link = None
try:
# TODO: Add ActionCodeSetting for custom link/redirection back to main page
verification_link = firebase_admin_auth.generate_email_verification_link(
email)
except ValueError:
msg = "Invalid email"
logger.info(msg)
return create_response(status=422, message=msg)
except FirebaseError as e:
msg = e.message
logger.info(msg)
return create_response(status=422, message=msg)
if not send_email(
recipient=email,
subject="Mentee Email Verification",
data={"link": verification_link},
template_id=USER_VERIFICATION_TEMPLATE,
):
msg = "Could not send email"
logger.info(msg)
return create_response(status=422, message=msg)
return create_response(message="Sent verification link to email")
def edit_fav_mentor():
try:
data = request.get_json()
logger.info(data)
mentor_id = data["mentor_id"]
mentee_id = data["mentee_id"]
favorite = bool(data["favorite"])
except:
msg = "invalid parameters provided"
logger.info(msg)
return create_response(status=422, message=msg)
print()
try:
mentee = MenteeProfile.objects.get(id=mentee_id)
if not favorite and mentor_id in mentee.favorite_mentors_ids:
mentee.favorite_mentors_ids.remove(mentor_id)
msg = (
f"Deleted mentor: {mentor_id} from mentee: {mentee.name} favorite list"
)
elif favorite and mentor_id not in mentee.favorite_mentors_ids:
mentee.favorite_mentors_ids.append(mentor_id)
msg = f"Added mentor: {mentor_id} to mentee: {mentee.name} favorite list"
else:
msg = "Request already processed"
mentee.save()
except:
msg = "Failed to saved mentor as favorite"
logger.info(msg)
return create_response(status=422, message=msg)
return create_response(status=200, message=msg)
def refresh_token():
data = request.json
token = data.get("token")
claims = firebase_admin_auth.verify_id_token(token)
firebase_uid = claims.get("uid")
role = claims.get("role")
profile_model = get_profile_model(role)
profile_id = None
try:
profile = profile_model.objects.get(firebase_uid=firebase_uid)
profile_id = str(profile.id)
except:
msg = "Could not find profile"
logger.info(msg)
return create_response(status=422, message=msg)
return create_response(
status=200,
data={
"token":
firebase_admin_auth.create_custom_token(firebase_uid, {
"role": role,
"profileId": profile_id
}).decode("utf-8"),
},
)
def get_portfolio_manager():
""" function that is called when you visit /portfolio_manager """
token = request.headers.get("token")
headers = {"Content-type": "application/x-www-form-urlencoded", "token": token}
message, info = verify_token(token)
if message != None:
return create_response(status=400, message=message)
if info == "fp":
return create_response(
status=400, message="You do not have permission to create new documents!"
)
kwargs = {}
kwargs["email"] = request.args.get("email")
kwargs["name"] = request.args.get("name")
kwargs = {k: v for k, v in kwargs.items() if v is not None}
if len(kwargs) == 0:
portfolio_manager_list = serialize_list(PortfolioManager.query.all())
else:
portfolio_manager_list = serialize_list(
PortfolioManager.query.filter_by(**kwargs).all()
)
return create_response(data={"portfolio_manager": portfolio_manager_list})
def register(args):
"""Register a new user.
Validates that the name is not already taken. Hashes the
password for security.
"""
name = args["name"]
email = args["email"]
password = args["password"]
user_exist = User.query.filter_by(email=email).first()
if user_exist:
return create_response(data={}, code=1001, message="email is already used.")
else:
user_instance = User(name=name)
user_instance.password = generate_password_hash(password)
user_instance.email = email
try:
db.session.add(user_instance)
db.session.commit()
except Exception:
db.session.rollback()
token = generate_confirmation_token(email)
html = render_template("mail/register.html", ctx={"name": name, "token": token})
print(html)
send_mail(subject="Verify Email Address",
sender=config.get('base').MAIL_USERNAME,
recipients=[email],
html=html,
)
return create_response(data={"name": name, "email": email}, message="send verify email successfully", code=0)
def delete_document(id):
"""
Deletes all documents related to a document class in database
"""
token = request.headers.get("token")
headers = {
"Content-type": "application/x-www-form-urlencoded",
"token": token
}
message, info = verify_token(token)
if message != None:
return create_response(status=400, message=message)
if info == "fp":
return create_response(
status=400,
message="You do not have permission to delete documents!")
# gets all document <id> native to db and sees if == to docClassID. Then deletes
Document.query.filter((Document.id == str(id))).delete()
db.session.commit()
return create_response(status=200, message="success")
def edit_book(user_id):
user_data = request.get_json()
if invalid_book_data(user_data):
return create_response(
message="Missing name, author, grade, year, or published field",
status=422,
data={"status": "fail"},
)
book_to_edit = Book.query.get(user_data["book_id"])
if book_to_edit is None:
return create_response(message="Book not found",
status=422,
data={"status": "fail"})
book_to_edit.name = user_data["name"]
book_to_edit.author = user_data["author"]
book_to_edit.grade = user_data["grade"]
book_to_edit.year = user_data["year"]
book_to_edit.cover_url = user_data.get("cover_url", "")
book_to_edit.published = user_data["published"]
db.session.commit()
return create_response(message="Successfully edited book",
status=200,
data={"status": "success"})
