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 _validate_params(cls, conntype, user):
"""
"""
mandatory_params = (
CONNECTION_TYPE_MAPPING[conntype]['mandatory_params'])
# checking for mandatory parameters
missing_mandatory_params = (
[k for k in mandatory_params
if request.json.get(k) in (None, '')])
if missing_mandatory_params:
return (False, build_error_dict([
'Field "%s" not specified.' % field
for field in missing_mandatory_params]))
# validate user id value
if not (User.query.filter(and_(
User.is_active,
User.id != user.id,
User.id == request.json.get('user_id'))).first()):
return (False, build_error_dict([
'Invalid "user_id" value.']))
# preparing param dict
params = dict(
description=request.json.get('description'),
text=request.json.get('text'),
user_from_id=user.id,
user_to_id=request.json.get('user_id'))
return (True, params)
def validate_reference(cls, user):
"""
Expected form:
{"description": str, "other_user_id": int,
"friendship_level"}
"""
success, params = cls._validate_params('references', user)
if not success:
return (success, params)
# validate friendship level value
if not Reference.validate_reference_type(
request.json.get('reference_type')):
return (False, build_error_dict(
['Invalid "reference_type" value.']))
# preparing param dict
params.update(dict(
description='reference',
type_status=request.json.get('reference_type'),
flags=filter(None,
[request.json.get('reference_type')])))
return (True, params)
def validate_friendship(cls, user):
"""
Expected form:
{"description": str, "other_user_id": int,
"friendship_level"}
"""
success, params = cls._validate_params('friendships', user)
if not success:
return (success, params)
# validate friendship level value
if not FriendshipConnection.validate_friendship_level(
request.json.get('friendship_level')):
return (False, build_error_dict(
['Invalid "friendship_level" value.']))
# preparing param dict
params.update(dict(
text=request.json.get('description'),
type_status='pending',
flags=filter(None,
[request.json.get('friendship_level', 'friend')])))
return (True, params)
def validate(cls, user):
param_errors = []
params = dict(
title=request.json.get("title"),
description=request.json.get("description"),
scheduled_from=datetime_from_json(request.json.get("scheduled_from")),
creator_id=user.id,
location=request.json.get("location"),
city_id=request.json.get("city_id"),
)
missing_params = [k for k, v in params.iteritems() if v in ["", None]]
param_errors = ['Field "%s" not specified.' % k for k in missing_params]
optional_params = dict(scheduled_until=datetime_from_json(request.json.get("scheduled_until")))
params.update(optional_params)
# city must exist
if params.get("city_id") and not City.query.filter_by(id=params["city_id"]).first():
param_errors.append('Invalid "city_id" value.')
# can't create activities less than one hour in advance
datetime_max = datetime.now() + timedelta(hours=1)
if params.get("scheduled_from") and params["scheduled_from"] < datetime_max:
param_errors.append('Invalid "scheduled_from" value.')
if params.get("scheduled_until") and params["scheduled_until"] < datetime_max:
param_errors.append('Invalid "scheduled_until" value.')
if param_errors: # in case of errors
return (False, build_error_dict(param_errors))
return (True, params)
def post(self):
"""
Creates a new account.
"""
# TODO: improved password handling?
params = dict(
first_name=request.json.get('first_name'),
last_name=request.json.get('last_name'),
birth_date=request.json.get('birth_date'),
email=request.json.get('email'),
gender=request.json.get('gender'),
username=request.json.get('username'),
password=request.json.get('password'))
optional_params = dict(
city_id=request.json.get('city_id'))
missing_fields = [k for (k, v) in params.iteritems() if not v]
if missing_fields:
return (jsonify(build_error_dict([
'No value specified for "%s".' % field
for field in missing_fields])), 400, [])
params.update(optional_params)
user = User(**params)
user.save(commit=True)
return UserByIDHandler._get(user)
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 _validate_message(cls, user, param_extend={}):
"""
Expected form:
{"subject": str, "text": str, "recipient_list_ids": [int*]}
"""
request_json = json_loads(request.data)
# recipient list validation
recipient_list_objects = User.query.filter(and_(
User.id.in_(request_json.get('recipient_list_ids')),
User.id != user.id,
User.is_active)).all()
recipient_list_ids = [o.id for o in recipient_list_objects]
# param dict built here
params = dict(
# mandatory params here
subject=request_json.get('subject'),
sender_id=user.id,
text=request_json.get('text'),
recipient_list_ids=recipient_list_ids,
# optional values here
message_status=request_json.get('message_status'),
reply_to_id=request_json.get('reply_to_id'))
params.update(param_extend)
# checking for mandatory parameters
resp = cls.validate_values(params)
errors = (
resp['errors.mandatory'] + resp['errors.type'] +
resp['errors.other'])
if errors:
return (False, build_error_dict(errors))
# preparing the full param dict to be returned
for (k, v) in params.items():
if v in (None, '', u''):
del params[k]
# success!
return (True, params)
def post(self, loctype):
if loctype not in LOCATION_TYPE_MAPPING:
return ('TYPE', '400', [])
location_class = LOCATION_TYPE_MAPPING[loctype]
params = dict(
name=request.json.get('name'),
country_id=request.json.get('country_id'),
latitude=request.json.get('latitude'),
longitude=request.json.get('longitude'))
optional_params = dict(
rating=request.json.get('rating'),
timezone=request.json.get('timezone'),
slug=request.json.get('slug'),
wikiname=request.json.get('wikiname'))
missing_vals = [(k, v) for (k, v) in params.iteritems()
if v in (None, '')]
if missing_vals:
error_dict = build_error_dict([
'"%s" not specified' % k for (k, _) in missing_vals])
return (jsonify(error_dict), 400, [])
params.update(optional_params)
params['coordinates'] = WKTSpatialElement(
'POINT(%s %s)' % (
params.get('latitude'),
params.get('longitude')))
del params['latitude']
del params['longitude']
location = location_class(**params)
location.save(commit=True)
return LocationByIDHandler._get(loctype, location)
