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 get_field_partner():
""" function that is called when you visit /field_partner, gets all the FPs """
# gets database values from query string, if missing is None
kwargs = {}
kwargs["email"] = request.args.get("email")
kwargs["org_name"] = request.args.get("org_name")
kwargs["pm_id"] = request.args.get("pm_id")
kwargs["due_date"] = request.args.get("due_date")
kwargs["app_status"] = request.args.get("app_status")
kwargs["instructions"] = request.args.get("instructions")
kwargs = {k: v for k, v in kwargs.items() if v is not None}
if len(kwargs) == 0:
field_partner_list = serialize_list(FieldPartner.query.all())
else:
field_partner_list = serialize_list(
FieldPartner.query.filter_by(**kwargs).all()
)
for field_partner in field_partner_list:
field_partner["documents"] = serialize_list(
Document.query.filter(Document.userID == field_partner["_id"]).all()
)
return create_response(data={"field_partner": field_partner_list})
def get_all_events():
event_category_ids = request.args.getlist('event_category_ids[]')
if not event_category_ids:
return create_response(
data={"events": serialize_list(eventService.getAll())})
return create_response(
data={
"events":
serialize_list(
eventService.getEventWithCategories(event_category_ids))
})
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 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 get_data():
"""Retrive widgets data. arguments are filters."""
if request.args:
data = Widget.query.filter_by(**request.args.to_dict()).all()
else:
data = Widget.query.all()
return create_response(data={"data": serialize_list(data)})
def get_company_info():
ticker = request.args.get('ticker')
if ticker is not None and ticker != "":
company = Company.query.filter_by(ticker=ticker).first_or_404()
return create_response(data={"data": company.to_dict()})
companies = Company.query.all()
return create_response(data={"data": serialize_list(companies)})
def get_connections():
query_params = request.args
connection_id = query_params.get('id')
if (not(connection_id)):
connections = Connection.query.all()
return create_response(data={"connections": serialize_list(connections)})
###### If there was a specific connection as parameter...
connection_details = Connection.query.get(connection_id).get_fields()
return create_response(data={"connection_details": connection_details})
def get_document():
"""
Gets all documents that can be specified using a query string
"""
# gets database values from query string, if missing is None
kwargs = {}
kwargs["fileID"] = request.args.get("fid")
kwargs["userID"] = request.args.get("uid")
kwargs["status"] = request.args.get("status")
kwargs["docClassID"] = request.args.get("docClassID")
kwargs["fileName"] = request.args.get("fileName")
# refines kwargs to remove all the None values and only search by values provided
kwargs = {k: v for k, v in kwargs.items() if v is not None}
# if no search parameters provided return all documents
if len(kwargs) == 0:
docs = Document.query.all()
# if there are query arguments the following occurs
else:
# Unpacks the search values in our dictionary and provides them to Flask/SQLalchemy
docs = Document.query.filter_by(**kwargs).all()
# adds the corresponding document class to each document
for doc in docs:
doc.docClass = DocumentClass.query.get(doc.docClassID).to_dict()
# separate documents by different statuses and return based on this
pending = [i for i in docs if i.status == "Pending"]
verified = [i for i in docs if i.status == "Approved"]
missing = [i for i in docs if i.status == "Missing"]
rejected = [i for i in docs if i.status == "Rejected"]
return create_response(
status=200,
data={
"documents": {
"Pending": serialize_list(pending),
"Approved": serialize_list(verified),
"Missing": serialize_list(missing),
"Rejected": serialize_list(rejected),
}
},
)
def get_sentences():
query_params = request.args
sentence_id = query_params.get('id')
if (not(sentence_id)):
sentences = Sentence.query.all()
return create_response(data={"sentences": serialize_list(sentences)})
###### If there was a specific sentence as parameter...
sentence = Sentence.query.get(sentence_id)
sentence_details = sentence.__dict__
sentence_details.pop('_sa_instance_state', None)
# return sentence.connection.user_id
return create_response(data={"sentence": sentence_details})
def get_known_faces():
# faces = Face.query.join(Person).filter_by(profile_face=True)
faces = Face.query.filter_by(profile_face=True).all(
) #.join(Person, Face.person_id_by_human == Person.id)
serialized_faces = serialize_list(faces)
# serialized_people = [face.person_by_human.to_dict() for face in faces]
# logger.info(people_for_faces)
for i in range(len(serialized_faces)):
serialized_faces[i]['person_by_human'] = faces[
i].person_by_human.to_dict()
logger.info(serialized_faces)
return create_response({"Faces": serialized_faces})
def robot_data_list(args):
data_list_total_length = len(Data.query.all())
data_list = Data.query.order_by(
Data.create_time.desc()).paginate(page=int(args["page"]),
per_page=int(args["size"]),
error_out=False).items
if data_list:
return create_response(data={
"data": serialize_list(data_list),
"total": data_list_total_length
},
code=0)
else:
return create_response(data=[], code=5001, message="data is not exist")
def get_readings():
data = request.form
from_time_str = data.get("from", "2020-01-01 00:00:00")
from_time = datetime.strptime(from_time_str, '%Y-%m-%d %H:%M:%S')
if data.get("to") is None:
to_time = datetime.now()
else:
to_time_str = data.get("to")
to_time = datetime.strptime(to_time_str, '%Y-%m-%d %H:%M:%S')
readings = Reading.query.filter(Reading.timestamp <= to_time).filter(
Reading.timestamp >= from_time)
return create_response(data={"readings": serialize_list(readings)})
def get_flyers_in_map():
params = request.args.to_dict()
flyers = []
if params and params['top']:
top, bottom, left, right = itemgetter('top', 'bottom', 'left', 'right')(params)
flyers = SearchFlyer.query.filter(
SearchFlyer.latitude <= top,
SearchFlyer.latitude >= bottom,
SearchFlyer.longitude <= right,
SearchFlyer.longitude >= left,
)
else:
flyers = SearchFlyer.query.all()
return create_response(data={"flyers": serialize_list(flyers)})
def get_list(args):
robot_list_total_length = len(Robot.query.all())
robot_list = Robot.query.order_by(
Robot.create_time.desc()).paginate(page=int(args["page"]),
per_page=int(args["size"]),
error_out=False).items
if robot_list:
return create_response(
data={
"data": serialize_list(robot_list),
"total": robot_list_total_length
},
code=0,
)
else:
return create_response(data={}, code=3001, message="data is not exist")
def get_daily_price_info():
ticker = request.args.get('ticker')
start_date = request.args.get('start_date')
end_date = request.args.get('end_date')
prices = Price.query
if ticker is not None and ticker != "":
prices = prices.filter_by(ticker=ticker)
if start_date is not None and start_date != "":
prices = prices.filter(Price.price_date > start_date)
if end_date is not None and end_date != "":
prices = prices.filter(Price.price_date < end_date)
return create_response(data={"data": serialize_list(prices.all())})
def get_recommendations():
ticker = request.args.get('ticker')
start_date = request.args.get('start_date')
end_date = request.args.get('end_date')
recommendations = Recommendation.query
if ticker is not None and ticker != "":
recommendations = recommendations.filter_by(ticker=ticker)
if start_date is not None and start_date != "":
recommendations = recommendations.filter(
Recommendation.recommendation_date > start_date)
if end_date is not None and end_date != "":
recommendations = recommendations.filter(
Recommendation.recommendation_date < end_date)
return create_response(
data={"data": serialize_list(recommendations.all())})
def get_messages():
kwargs = {}
kwargs["pm_id"] = request.args.get("pm_id")
kwargs["fp_id"] = request.args.get("fp_id")
kwargs["to_fp"] = request.args.get("to_fp")
kwargs["doc_id"] = request.args.get("doc_id")
kwargs = {k: v for k, v in kwargs.items() if v is not None}
if len(kwargs) == 0:
messages = Message.query.all()
else:
messages = Message.query.filter_by(**kwargs).all()
# add the corresponding name to the message
for message in messages:
if message.to_fp == True:
message.name = PortfolioManager.query.get(message.pm_id).name
else:
message.name = FieldPartner.query.get(message.fp_id).org_name
return create_response(data={"messages": serialize_list(messages)})
def return_accesses():
data = request.get_json()
logger.info("Data recieved: %s", data)
if "user_id" not in data:
msg = "No user ID provided for accesses."
logger.info(msg)
return create_response(status=422, message=msg)
if "access_id" not in data:
accesses = db.session.query(Access).filter(
Access.user_id == data["user_id"]
).all()
return create_response(data={"accesses": serialize_list(accesses)})
#If a specific acceess ID was passed...
access = db.session.query(Access).filter(
Access.id == data["access_id"],
Access.user_id == data["user_id"]
).first()
access_details = access.__dict__
access_details.pop('_sa_instance_state', None)
return create_response(data={
"access": access_details
})
def return_sentences():
data = request.get_json()
logger.info("Data recieved: %s", data)
if "user_id" not in data:
msg = "No user ID provided for sentences."
logger.info(msg)
return create_response(status=422, message=msg)
if "sentence_id" not in data:
sentences = db.session.query(Sentence).filter(
Sentence.id.in_(
db.session.query(Access.model_id).filter(Access.user_id == data["user_id"], Access.model=='sentence')
)
).all()
# return sentences
return create_response(data={"sentences": serialize_list(sentences)})
sentence = db.session.query(Sentence).filter(
Sentence.id == data["sentence_id"],
Sentence.id.in_(db.session.query(Access.model_id).filter(Access.user_id == data["user_id"], Access.model=='sentence'))
).first()
sentence_details = sentence.__dict__
sentence_details.pop('_sa_instance_state', None)
return create_response(data={"sentence": sentence_details})
def return_connections():
data = request.get_json()
logger.info("Data recieved: %s", data)
if "user_id" not in data:
msg = "No user ID provided for connection(s)."
logger.info(msg)
return create_response(status=422, message=msg)
if "connection_id" not in data: #We return all connections that user has access to
connections = db.session.query(Connection).filter(
Connection.id.in_(
db.session.query(Access.model_id).filter(Access.user_id == data["user_id"], Access.model=='connection').all()
)
).all()
return create_response(data={"connections": serialize_list(connections)})
connection = db.session.query(Connection).filter(
Connection.id == data["connection_id"],
Connection.id.in_(
db.session.query(Access.model_id).filter(Access.user_id == data["user_id"], Access.model=='connection').all()
)
).first()
connection_details = connection.get_fields()
connection_details.pop('_sa_instance_state', None)
return create_response(data={"connection": connection_details})
def getemails():
root_created_by = request.args.get('root_created_by', None)
if root_created_by is None:
return Response(json.dumps({'error': 'need subscriber'}),
mimetype='application/json',
status=400)
original_links = Link.query.filter_by(created_by=root_created_by).all()
all_links = []
parent_links = original_links
print(original_links)
while parent_links is not None and len(parent_links) > 0:
all_links = all_links + parent_links
parent_links_ids = (l.id for l in parent_links)
print('PARENT LINK IDS IS', parent_links_ids)
next_links = Link.query.filter(
Link.parent_link_id.in_(parent_links_ids)).all()
parent_links = next_links
#get all the emails for these links
all_links_ids = (l.id for l in all_links)
emails = Email.query.filter(Email.parent_link_id.in_(all_links_ids)).all()
return Response(json.dumps(serialize_list(emails)),
mimetype='application/json',
status=200)
def return_dashboards():
data = request.get_json()
logger.info("Data recieved: %s", data)
if "user_id" not in data:
msg = "No user ID provided for dashboards."
logger.info(msg)
return create_response(status=422, message=msg)
if "dashboard_id" not in data:
dashboards = db.session.query(Dashboard).filter(
Dashboard.id.in_(
db.session.query(Access.model_id).filter(Access.user_id == data["user_id"], Access.model=='dashboard').all()
)
).all()
return create_response(data={"dashboards": serialize_list(dashboards)})
#If a specific dashboard ID was passed...
dashboard = db.session.query(Dashboard).filter(
Dashboard.id == data["dashboard_id"],
Dashboard.id.in_(
db.session.query(Access.model_id).filter(Access.user_id == data["user_id"], Access.model=='dashboard').all()
)
).first()
return create_response(data={
"dashboard": dashboard.export()
})
def get_persons():
persons = Person.query.all()
return create_response(data={"persons": serialize_list(persons)})
def get_flyers():
flyers = SearchFlyer.query.all()
return create_response(data={"flyers": serialize_list(flyers)})
def post_reply(flyer_id):
messages = Message.query.all()
return create_response(data={"messages": serialize_list(messages)})
def get_all_event_category():
return create_response(
data={
"event-categories": serialize_list(eventCategoryService.getAll())
})
def get_users():
users = Users.query.all()
return create_response(data={"users": serialize_list(users)})
def alllinks():
body = request.json
links = Link.query.all()
return Response(json.dumps(serialize_list(links)),
mimetype='application/json',
status=200)
def get_all_items():
return create_response(data={"items": serialize_list(db.get_items())})
