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)