def patch(self, conntype, id):
if conntype not in CONNECTION_TYPE_MAPPING:
return ('TYPE', 400, [])
conn_dict = CONNECTION_TYPE_MAPPING[conntype]
conn_class = conn_dict['class']
conn = self._get_instance(conntype, id)
if not isinstance(conn, conn_class):
# error
return conn
logged_user = get_logged_user()
if conntype == 'friendships':
type_status = request.json.get('type_status')
if type_status:
# pending status can be changed only by the other counterpart
# (to be improved yet)
if (conn.type_status['current'] == 'pending' and
conn.user_from_id == logged_user.id):
return ('UNAUTHORIZED', 405, [])
try:
make_transition(conn, 'type_status', type_status)
except StateValueError:
return (jsonify(build_error_dict([
'Invalid "type_status" value.'])), 400, [])
except StateTransitionError:
return (jsonify(build_error_dict([
'Invalid "type_status" transition.'])), 400, [])
return jsonify(conn.serializer_func(logged_user))
def _get(cls, conntype, conn):
logged_user = get_logged_user()
if not conn:
return ('NOT FOUND', 404, [])
this_conn = cls._get_instance(conntype, conn)
if isinstance(this_conn, tuple):
return this_conn
return jsonify(this_conn.serializer_func(logged_user))
def post(self):
logged_user = get_logged_user()
success, params = self.validate(logged_user)
if not success:
return (jsonify(params), 400, [])
activity = Activity(**params)
activity.save(commit=True)
activity.set_user_rsvp(logged_user, "yes")
return ActivityByIDHandler._get(activity)
def get(self, direction, msgtype):
user = get_logged_user()
if msgtype not in MESSAGE_TYPE_MAPPING:
return ('TYPE', 400, [])
try:
msg_list = filter_by_direction(msgtype, direction, user)
except ValueError:
return ('DIRECTION', 400, [])
resp = [msg.serialized_func(user) for msg in msg_list]
return jsonify(resp)
def patch(self, direction, msgtype, id):
user = get_logged_user()
request_json = json_loads(request.data)
if msgtype not in MESSAGE_TYPE_MAPPING:
return ('TYPE', 400, [])
msg_dict = MESSAGE_TYPE_MAPPING[msgtype]
msg_notification_class = msg_dict['notification_class']
if direction == 'out': # PATCH op is allowed only for incoming msgs
return ('FORBIDDEN', 403, [])
elif direction != 'in': # Invalid direction value
return ('DIRECTION', 400, [])
msg_list = filter_by_direction(
msgtype, 'in', user, additional_filters={'id': id})
if not msg_list:
return ('NOT FOUND', 404, [])
msg = msg_list[0]
added_flags, removed_flags = (
request_json.get('flags_in'),
request_json.get('flags_out'))
msg.change_flags(added_flags, removed_flags)
msg_notification = msg.get_notification(user)
errors = []
try:
msg_notification.change_status(request_json.get('message_status'))
except ValueError: # Invalid transition
errors.append('Invalid "message_status" value.')
if msgtype == 'hospitality_request':
request_status = request_json.get('request_status')
if (request_status and
((direction == 'out' and request_status == 'canceled')
or direction == 'in' and msg.status != 'canceled')):
try:
msg.change_status(request_status)
except ValueError: # Invalid transition
errors.append('Invalid "request_status" value.')
if errors: # Errors found, returns error structure
return (jsonify(build_error_dict(errors)), 400, [])
# in case of success, returns the updated message serialization
msg.save()
msg_notification.save(commit=True)
return jsonify(msg.serialized_func(user))
def get(self, conntype):
user = get_logged_user()
if conntype not in CONNECTION_TYPE_MAPPING:
return ('TYPE', '400', [])
conn_dict = CONNECTION_TYPE_MAPPING[conntype]
conn_class = conn_dict['class']
conn_list = conn_class.query.filter(or_(
conn_class.user_from_id == user.id,
conn_class.user_to_id == user.id)).all()
resp = [conn.serializer_func(user) for conn in conn_list]
return jsonify(resp)
def post(self, direction, msgtype):
user = get_logged_user()
if direction != 'out':
return ('NOT ALLOWED', 403, [])
logged_user = get_logged_user()
if msgtype not in MESSAGE_TYPE_MAPPING:
return ('TYPE', 400, [])
msg_dict = MESSAGE_TYPE_MAPPING[msgtype]
msg_class, msg_validator = (
msg_dict['class'],
getattr(self, msg_dict['validator']))
success, param_dict = getattr(
self, msg_dict['validator'])(logged_user)
if not success:
return (jsonify(param_dict), 400, [])
msg = msg_class(**param_dict)
msg.send_to(*msg.recipient_list)
return jsonify(msg.serialized_func(user))
def get(self, direction, msgtype, id):
user = get_logged_user()
if msgtype not in MESSAGE_TYPE_MAPPING:
return ('TYPE', 400, [])
try:
msg_list = filter_by_direction(
msgtype, direction, user, additional_filters={'id': id})
except ValueError:
return ('DIRECTION', 400, [])
if not msg_list:
return ('NOT FOUND', 404, [])
msg = msg_list[0]
return jsonify(msg.serialized_func(user))
def post(self, conntype):
logged_user = get_logged_user()
if conntype not in CONNECTION_TYPE_MAPPING:
return ('TYPE', '400', [])
conn_dict = CONNECTION_TYPE_MAPPING[conntype]
conn_class, conn_validator = (
conn_dict['class'],
getattr(self, conn_dict['validator']))
success, param_dict = getattr(
self, conn_dict['validator'])(logged_user)
if not success:
return (jsonify(**param_dict), 400, [])
conn = conn_class(**param_dict)
conn.save(commit=True)
return jsonify(conn.serializer_func(logged_user))
def get(self, loctype):
logged_user = get_logged_user()
if loctype not in LOCATION_TYPE_MAPPING:
return ('TYPE', '400', [])
location_class = LOCATION_TYPE_MAPPING[loctype]
#loc_query = location_class.query
#if logged_user:
# make_point = lambda c: func.ST_SetSRID(
# func.ST_Point(c.x, c.y), 4326)
# loc_query = loc_query.filter(
# func.ST_Distance_Sphere(
# make_point(location_class.coordinates),
# make_point(logged_user.city.coordinates)) < 100000)
fields = parse_search_fields()
fields['query_field'] = 'name'
resp = search.query(location_class, **fields)
return jsonify([obj.serialized for _, obj in resp])
def post(self):
"""
Create new group.
{
"title": str,
"description": str,
^"city_id": int,
^"minorlocality_id": int,
^"parent_group_id": int}
"""
user = get_logged_user()
params = dict(
title=request.json.get('title'),
creator_id=user.id)
optional_params = dict(
description=request.json.get('description'),
city_id=request.json.get('city_id'),
minorlocality_id=request.json.get('minorlocality_id'),
parent_group_id=request.json.get('parent_group_id'))
if not all([v not in (None, '') for v in params.itervalues()]):
return (jsonify(error=True), 400, [])
if (optional_params['city_id'] is None and
optional_params['minorlocality_id'] is not None):
return (jsonify(error=True), 400, [])
if (optional_params['parent_group_id'] is not None):
parent_group = Group.query.filter_by(
id=optional_params['parent_group_id']).first()
if not parent_group:
return (jsonify(error=True), 400, [])
elif parent_group.city_id != optional_params['city_id']:
return (jsonify(error=True), 400, [])
params.update(optional_params)
group = Group(**params)
group.save(commit=True)
return GroupByIDHandler._get(group)
def _get_instance(cls, conntype, conn_or_id):
logged_user = get_logged_user()
conn_dict = CONNECTION_TYPE_MAPPING[conntype]
conn_class = conn_dict['class']
if isinstance(conn_or_id, conn_class):
conn = conn_or_id
else:
conn = conn_class.query.filter_by(id=conn_or_id).first()
if not conn:
return ('NOT FOUND', 404, [])
conn = conn_class.query.filter(or_(
conn_class.user_from_id == logged_user.id,
conn_class.user_to_id == logged_user.id)).filter(
conn_class.id == conn.id).first()
if not conn:
return ('UNAUTHORIZED', 405, [])
return conn
def patch(self):
user = get_logged_user()
if not user:
return ('NOT AUTHENTICATED', 401, [])
return UserByIDHandler._patch(user)
def fn2(cls, user, *args, **kwargs):
logged_user = get_logged_user()
if user.id != logged_user.id:
return ('', 401, [])
else:
return fn(cls, user, *args, **kwargs)
