def delete_stories(story_id):
to_delete = Story.query.get(story_id)
if to_delete is None:
return create_response(status=404, message='Provided story_id does not exist')
db.session.delete(to_delete)
db.session.commit()
return create_response(message='Story deleted')
def get_user_info():
args = request.args
cur_uid = None
clicked_uid = None
try:
cur_uid = args['cur_uid']
clicked_uid = args['clicked_uid']
except:
return create_response(message='missing required components',
status=411)
sql = text('select * from mealpat_user where "UID"=:uid')
result = db.engine.execute(sql, uid=clicked_uid).first()
if result is None:
return create_response(message='user not exist', status=411)
items = result.items()
# basic info of user
data = {item[0]: item[1] for item in items}
sql = text(
'select name from history h1, history h2, restaurant where h1."UID" =:uid1 and h2."UID"=:uid2 and h1."RID" = h2."RID" and restaurant."RID"=h1."RID"'
)
result = db.engine.execute(sql, uid1=cur_uid, uid2=clicked_uid)
common_restaurant = [row[0] for row in result]
data['common_restaurant'] = common_restaurant
return create_response(data, status=200)
def join_post():
request_json = request.get_json()
data = {}
try:
data['PID'] = int(request_json['PID'])
data['UID'] = int(request_json['UID'])
except:
return create_response(message='missing required components',
status=411)
sql = text('select accompanies, "UID" from post where "PID"=:pid')
result = db.engine.execute(sql, pid=data['PID']).first()
accompanies = result.items()[0][1]
post_owner = result.items()[1][1]
if post_owner == data['UID']:
return create_response(message='you are the owner', status=411)
if data['UID'] in accompanies:
return create_response(message='user have already joined the post',
status=411)
accompanies.append(data['UID'])
sql = text('update post set accompanies=:accompanies where "PID"=:pid')
result = db.engine.execute(sql, pid=data['PID'], accompanies=accompanies)
return create_response(message='join succeed', status=200)
def create_post():
request_json = request.get_json()
data = {}
try:
data['RID'] = int(request_json['RID'])
data['UID'] = int(request_json['UID'])
data['title'] = request_json['title']
data['time'] = datetime.strptime(request_json['time'],
'%Y-%m-%d %H:%M')
except Exception as e:
return create_response(message=str(e), status=411)
# create a new chatroom and get back cid
sql = text('insert into chatroom(messages) \
values (:messages) returning "CID"')
result = db.engine.execute(sql, messages=[]).first()
cid = result.items()[0][1]
# create a new post and get back pid
sql = text(
'insert into post(time, title, "UID", "RID", "CID", accompanies) \
values (:time, :title, :uid, :rid, :cid, :accompanies) returning "PID"'
)
result = db.engine.execute(sql,
time=data['time'],
title=data['title'],
uid=data['UID'],
rid=data['RID'],
cid=cid,
accompanies=[]).first()
pid = result.items()[0][1]
# return the pid
return create_response({"PID": pid}, status=200)
def create_individual_chat():
request_json = request.get_json()
try:
source = request_json['source']
target = request_json['target']
except:
create_response(message='missing required components', status=411)
sql = text(
'select "CID", room_name from individual_chatroom where room_name=:name1 or room_name=:name2'
)
result = db.engine.execute(sql,
name1=str(source) + '_' + str(target),
name2=str(target) + '_' + str(source)).first()
# need to create a new one
if result is None:
# create a new chatroom and get back cid
sql = text(
'insert into individual_chatroom(messages, room_name, owner1, owner2, new_message1, new_message2) \
values (:messages, :room_name, :owner1, :owner2, :new_message, :new_message) returning "CID", room_name'
)
result = db.engine.execute(sql,
messages=[],
room_name=str(source) + '_' + str(target),
owner1=source,
owner2=target,
new_message=False).first()
cid = result.items()[0][1]
room_name = result.items()[1][1]
return create_response({'CID': cid, 'room_name': room_name})
else:
return create_response({'CID': result[0], 'room_name': result[1]})
def get_version_list():
""" Get list of version numbers associated with partner, theme, and product type """
args = request.get_json()
try:
# Get all args from form
partner_name = request.args['partner_name']
theme_name = request.args['loan_theme']
product_type = request.args['product_type']
# Get corresponding ids
mfi_id = Partner.query.filter_by(partner_name=partner_name).first().id
theme_id = Theme.query.filter_by(loan_theme=theme_name).first().id
# Get corresponding rows from RETURNED IDs and names
version_list = list()
for entry in Loan.query.filter_by(partner_id=mfi_id,
theme_id=theme_id,
product_type=product_type):
version_list.append(entry.version_num)
# Return list of version nums under given mfi name, theme id, product type
data = {'version_nums': [str(num) for num in version_list]}
return create_response(data=data, status=200)
except:
return create_response({},
status=400,
message='missing arguments for GET')
def analyze_data():
query = request.get_json()
print(query)
if query == None or query == {} or query['phoneType'] == '':
return create_response(data={
'performance': None,
'battery': None,
'display': None,
'camera': None,
'overall': None,
'articles': None
},
status=200)
analyzedOutput = analyze(query)
articles = [article.serialize() for article in analyzedOutput[5]]
return create_response(data={
'performance': analyzedOutput[0],
'battery': analyzedOutput[1],
'display': analyzedOutput[2],
'camera': analyzedOutput[3],
'overall': analyzedOutput[4],
'articles': articles
},
status=200)
def delete_poi(poi_id):
poi = POI.query.get(poi_id)
if poi is None:
return create_response(status=404, message='POI not found')
db.session.delete(poi)
db.session.commit()
return create_response(message='POI deleted')
def get_version_num():
"""
sending a response with the cersoin number
"""
args = request.args
try:
theme = args['theme']
partner_name = args['partner_name']
product = args['product']
except:
return create_response({},
status=400,
message='missing arguments for GET')
p = Partner.query.filter_by(partner_name=partner_name).first()
t = Theme.query.filter_by(loan_theme=theme).first()
if p is None or t is None or not p.active or not t.active:
return create_response(
{},
status=400,
message='Non-Existent MFI Partner and/or Loan Theme')
loans = Loan.query.filter_by(partner_id=p.id,
theme_id=t.id,
product_type=product).all()
num = 1 + len(loans)
return create_response({'version': num}, status=200)
def name():
try:
persons = Person.query.all()
persons_list = serialize_list(persons)
return create_response(data={'persons': persons_list})
except Exception as ex:
return create_response(data={}, status=400, message=str(ex))
def log_out_user():
token = request.headers.get(auth_tokens.AUTH_TOKEN_HEADER_NAME)
# success = auth_tokens.delete_token(token)
success = True
if success:
return create_response(status=200, message='Successfully logged out')
return create_response(status=400, message='Invalid token')
def log_in():
args = request.args
username = ''
password = ''
try:
username = args['name']
password = args['password']
except:
return create_response(message='missing required components',
status=411)
sql = text(
'select "UID", lati, longi from mealpat_user where name=:name and password=:password'
)
result = db.engine.execute(sql, name=username, password=password).first()
# user = User.query.filter_by(name = username, password = password).first()
if result is None:
return create_response(message='user not exist', status=411)
else:
return create_response(
{
'UID': result[0],
'lati': result[1],
'longi': result[2]
},
status=200)
def sign_up():
request_json = request.get_json()
data = {}
try:
data['name'] = request_json['name']
data['password'] = request_json['password']
except:
return create_response(message='missing required components',
status=411)
if request_json['address'] == '':
data['address'] = None
data['lati'] = None
data['longi'] = None
else:
data['address'] = request_json['address']
map_url = 'https://maps.googleapis.com/maps/api/geocode/json?address=' + request_json[
'address'] + '&' + 'key=' + map_api_key
response = requests.request('GET', map_url)
json_object = response.json()
data['lati'] = json_object['results'][0]['geometry']['location']['lat']
data['longi'] = json_object['results'][0]['geometry']['location'][
'lng']
if request_json['gender'] == '':
data['gender'] = None
elif request_json['gender'] == "male" or request_json['gender'] == "female":
data['gender'] = request_json['gender']
else:
return create_response(message='Gender format incorrect', status=411)
if request_json['phonenumber'] == '':
data['phonenumber'] = None
else:
data['phonenumber'] = request_json['phonenumber']
if request_json['interest'] == '':
data['interest'] = []
else:
data['interest'] = request_json['interest'].split(',')
try:
sql = text(
'insert into mealpat_user(phonenumber, interest, name, password, gender, address, lati, longi) \
values (:phonenum, :interest, :name, :password, :gender, :address, :lati, :longi)'
)
db.engine.execute(sql,
phonenum=data['phonenumber'],
interest=data['interest'],
name=data['name'],
password=data['password'],
gender=data['gender'],
address=data['address'],
lati=data['lati'],
longi=data['longi'])
# new_user = User(data)
# db.session.add(new_user)
# db.session.commit()
return create_response(data, status=200)
except Exception as e:
return create_response(message='username already exist', status=666)
def name():
try:
persons = Person.query.all()
persons_list = serialize_list(persons)
x = create_response(data={"persons": persons_list})
print(type(x[0]))
return create_response(data={"persons": persons_list})
except Exception as ex:
return create_response(data={}, status=400, message=str(ex))
def get_stories():
data = request.args
stories = []
if data.get('poi_id') is not None:
storyPOIs = StoryPOI.query.filter(StoryPOI.poi_id == data['poi_id'])
for sp in storyPOIs:
stories.append(Story.query.get(sp.story_id))
return create_response({'stories': [s.to_dict() for s in stories]})
stories = Story.query.all()
return create_response({'stories': [s.to_dict() for s in stories]})
def removeLT(loan_theme):
"""
Deletes loan theme (sets active to false)
"""
theme = Theme.query.filter_by(loan_theme=loan_theme).first()
if theme is None or theme.active is False:
return create_response(status=422,
message="No such Loan Theme currently exists")
theme.active = False
db.session.commit()
return create_response(message="Update Successful")
def removeMFI(partner_name):
"""
Deletes partner (sets active to false)
"""
partner = Partner.query.filter_by(partner_name=partner_name).first()
if partner is None or partner.active is False:
return create_response(status=422,
message="No such MFI Partner currently exists")
partner.active = False
db.session.commit()
return create_response(message="Update Successful")
def cal_apr():
args = request.args
payload = {}
# not sure if we need to validate again
try:
apr = cal_apr(args['v1'], args['v2'], args['v3'], args['v4'])
return create_response(data={'apr': apr}, status=200)
except:
#TODO status code not sure
create_response({},
status=404,
message='missing components for calculating apr rate')
def delete_map(map_id):
map_obj = Map.query.get(map_id)
if map_obj is None:
return create_response(status=404,
message='Map id {} not found'.format(map_id))
poi_list = POI.query.filter(POI.map_year == map_obj.map_year)
for poi in poi_list:
db.session.delete(poi)
db.session.delete(map_obj)
db.session.commit()
return create_response(status=200, message='Map deleted')
def update_poi(poi_id):
poi = POI.query.get(poi_id)
if poi is None:
return create_response(status=404, message='POI not found')
data = request.get_json()
# Edit poi columns
poi_columns = ['name', 'date', 'description']
edit_poi_columns = [
col for col in poi_columns if data.get(col) is not None
]
for col in edit_poi_columns:
setattr(poi, col, data[col])
# Replace all links, media, and story_id if they were given
if data.get('links') is not None:
for link in Link.query.filter(Link.poi_id == poi_id):
db.session.delete(link)
link_add = [
row_constructor(Link, i, poi_id=poi_id) for i in data['links']
]
db.session.add_all(link_add)
if data.get('media') is not None:
for media in Media.query.filter(Media.poi_id == poi_id):
db.session.delete(media)
media_add = [
row_constructor(Media, i, poi_id=poi_id) for i in data['media']
]
db.session.add_all(media_add)
if data.get('story_ids') is not None:
missing_stories = [
story_id for story_id in data['story_ids']
if Story.query.get(story_id) is None
]
if len(missing_stories):
return create_response(
status=422,
message='POI not created; supplied story_id(s) {} refer to nonexistent stories' \
.format(', '.join(missing_stories))
)
for story_poi_link in StoryPOI.query.filter(StoryPOI.poi_id == poi_id):
db.session.delete(story_poi_link)
story_add = [
row_constructor(StoryPOI, story_id=i, poi_id=poi_id)
for i in data['story_ids']
]
db.session.add_all(story_add)
db.session.commit()
edited_poi = POI.query.get(poi_id)
response_data = {'poi': poi_links_media_stories(edited_poi.to_dict())}
return create_response(response_data, 200, 'POI edited')
def save_loan():
request_json = request.get_json()
payload = {}
try:
# get all variables in the form
#TODO: query database to save loan
return create_response(payload, status=201)
except:
return create_response(
payload,
status=422,
message='missing components for creating new loan')
def get_restaurant_detail(rid):
sql = text('select * from restaurant where "RID"=:rid')
result = db.engine.execute(sql, rid=rid).first()
if result is None:
return create_response(message='restaurant not exist', status=411)
items = result.items()
data = {item[0]: item[1] for item in items}
sql = text('select "PID", title, time from post where "RID"=:rid')
result = db.engine.execute(sql, rid=rid)
post_list = [(row[0], row[1], row[2]) for row in result]
data['posts'] = post_list
return create_response(data, status=200)
def get_near_user_list():
args = request.args
UID = 0
distance = 0
center = []
try:
UID = args['UID']
distance = int(args['distance'])
lati = args['lati']
longi = args['longi']
except:
return create_response(message='missing required components',
status=411)
origins = str(lati) + ',' + str(longi)
sql = text('select * from mealpat_user where "UID" <> :uid')
result = db.engine.execute(sql, uid=UID)
dest = ''
i = 0
user = []
for row in result:
i += 1
dest += str(row[7]) + ',' + str(row[8]) + '|'
items = row.items()
cur_user = {item[0]: item[1] for item in items}
# find common restaurants
sql = text(
'select name from history h1, history h2, restaurant where h1."UID" =:uid1 and h2."UID"=:uid2 and h1."RID" = h2."RID" and restaurant."RID"=h1."RID"'
)
result = db.engine.execute(sql, uid1=UID, uid2=cur_user['UID'])
rows = result.fetchall()
if len(rows) == 0:
cur_user['common_restaurant'] = 'None'
else:
common_restaurant = [row[0] for row in rows]
cur_user['common_restaurant'] = common_restaurant
user.append(cur_user)
dest = dest[:-1]
url = 'https://maps.googleapis.com/maps/api/distancematrix/json?units=imperial&origins=' + origins + '&destinations=' + dest + '&key=' + map_api_key
response = requests.request('GET', url)
json_object = response.json()
return_list = []
for j in range(i):
try:
if ((json_object['rows'][0]['elements'][j]['distance']['value']) <
distance):
return_list.append(user[j])
except:
continue
return create_response(return_list, status=200)
def post_stories():
data = request.get_json()
if data.get('story_name') is not None:
new_story = row_constructor(Story, data)
else:
return create_response(status=422, message='The story_name parameter was not provided or is invalid')
db.session.add(new_story)
db.session.flush()
if data.get('poi_ids') is not None:
new_story_pois = [row_constructor(StoryPOI, story_id=new_story.id, poi_id=poi_id) for poi_id in data['poi_ids']]
db.session.add_all(new_story_pois)
db.session.commit()
story = Story.query.get(new_story.id)
return create_response(data={'story': story.to_dict()}, status=201, message='Story created')
def create_account():
request_json = request.get_json()
required_fields = ['username', 'password']
missing_fields = [
field for field in required_fields if request_json.get(field) is None
]
if len(missing_fields):
return create_response(
status=400,
message='Request json is missing the following fields: {}' \
.format(', '.join(missing_fields))
)
username = request_json.get('username')
password = request_json.get('password')
existing_user = User.query.filter_by(username=username).first()
if existing_user is not None:
return create_response(
status=400,
message='Username "{}" is already taken'.format(username))
password_fail_message = auth_utils.validate_password_requirements(password)
if password_fail_message:
return create_response(status=400, message=password_fail_message)
salt = auth_utils.generate_salt()
hashed_password = auth_utils.hash_password(password, salt)
user_add = {'username': username, 'salt': salt, 'pw_hash': hashed_password}
new_user = row_constructor(User, user_add)
db.session.add(new_user)
db.session.flush()
new_user_id = new_user.id
db.session.commit()
token = auth_tokens.generate_token()
while not auth_tokens.register_token(token, new_user_id):
token = auth_tokens.generate_token()
new_user.id = new_user_id
response_data = new_user.to_dict()
response_data.pop('pw_hash')
response_data.pop('salt')
response_data['token'] = token
return create_response(data=response_data,
status=201,
message='Successfully created account')
def get_version():
args = request.args
try:
theme = args['theme']
partner_name = args['partner_name']
product = args['product']
#TODO: result = query method by model.py
if result is None:
return create_response({version: 1}, status=200)
else:
return create_response({version: result + 1}, status=200)
except:
return create_response(
{}, status=404, message='missing components for creating new loan')
def create_map():
data = request.get_json()
fields = ['image_url', 'map_year']
missing_params = [field for field in fields if data.get(field) is None]
if len(missing_params):
message = 'Missing parameters ' + ', '.join(missing_params)
return create_response(data, 400, message)
created_map = row_constructor(Map, data)
db.session.add(created_map)
db.session.flush()
map_id = created_map.id
db.session.commit()
return create_response({'map': Map.query.get(map_id).to_dict()}, 201,
'Map created')
def find_private_chat(uid):
sql = text(
'select * from individual_chatroom where owner1=:owner or owner2=:owner'
)
result = db.engine.execute(sql, owner=uid).fetchall()
chatroom_list = []
for row in result:
owner1 = row[3]
owner2 = row[4]
new_message1 = row[5]
new_message2 = row[6]
new_message = False
target = None
if owner1 == uid:
target = owner2
new_message = new_message1
elif owner2 == uid:
target = owner1
new_message = new_message2
sql = text('select name from mealpat_user where "UID"=:source')
source_name = db.engine.execute(sql, source=target).first()[0]
chatroom = {
'source': uid,
'target': target,
'room': row[2],
'CID': row[0],
'source_name': source_name,
'new_message': new_message
}
chatroom_list.append(chatroom)
return create_response({'chatroom_list': chatroom_list})
def decorated(*args, **kwargs):
token = request.headers.get(AUTH_TOKEN_HEADER_NAME)
if not token_exists(token):
return create_response(data={'token': token},
status=401,
message='invalid authorization token')
if not is_valid_token(token):
delete_token(token)
return create_response(data={'token': token},
status=401,
message='expired authorization token')
update_token_expiration(token)
return f(*args, **kwargs)
def getAllLT():
"""
Gets all loan themes
"""
themes = Theme.query.filter_by(active=True).all()
return create_response({'loan_theme': [x.loan_theme for x in themes]},
status=200)
def home():
return create_response(
status_code=response_codes_dict['success'],
message='Welcome to the homepage'
)
