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' )