Python reqparse.RequestParser类代码示例

class UserCreate(Resource):
    def __init__(self):
        self.reqparse = RequestParser()
        self.reqparse.add_argument(
            'user',
            type = username,
            required = True,
            location = 'json'
        )
        self.reqparse.add_argument(
            'key',
            type = pubkey,
            required = True,
            location = 'json'
        )
        super(UserCreate, self).__init__()

    def post(self):
        args = self.reqparse.parse_args()

        try:
            p.add_user(
                username=str(args['user']),
                pubkey=args['key'],
                hostname='va1.hashbang.sh'
            )
        except ldap.SERVER_DOWN:
            return { 'message': 'Unable to connect to LDAP server'}, 400
        except ldap.ALREADY_EXISTS:
            return { 'message': 'User already exists'}, 400
        except:
            sys.stderr.write("Unexpected Error: %s\n" % sys.exc_info()[0])
            return { 'message': 'User creation script failed'}, 400

        return {'message': 'success'}

 def post(self):
     # parse incoming POST data
     reqparse = RequestParser()
     reqparse.add_argument('blob', type=str, location='json')
     data = reqparse.parse_args()
     if not data.blob:
         return self.argument_required('blob')
     # encode content as bytestring
     tmp = base64.b64decode(data.blob)
     # calculate sha1 digest
     digest = hashlib.sha1(tmp).hexdigest()
     # write into temp file
     f = TemporaryFile()
     _ = f.write(tmp)
     f.flush()
     _ = f.seek(0)
     # upload blob
     created = self.blob_container.put(f, digest=digest)
     # response json and status code
     code = created and 201 or 409
     response = dict(
         digest = digest,
         url = '/image/{0}'.format(digest)
     )
     return response, code

 def concrete_backend():
     parser = RequestParser()
     for argument in arguments:
         parser.args.append(argument)
     user, created = func(parser.parse_args())
     current_app.db.session.commit()
     login_user(user)
     return user, created

 def get_one(self, id):
     parser = RequestParser()
     # Look only in the querystring
     parser.add_argument('user', location='args', default=None)
     args = parser.parse_args(request)
     dao = TimerDAO()
     timer = dao.get(id)
     as_dict = TimerFormatter().model_to_dict(timer)
     resp = jsonify(as_dict)
     return resp

class Set(Resource):

    def __init__(self):
        super(Set, self).__init__()
        self.__mParser = RequestParser()
        self.__mParser.add_argument('bus_id', type=str, required=True)
        self.__mParser.add_argument('address', type=str, required=True)
        self.__mParser.add_argument('value', type=str, required=True)
        self.__mParser.add_argument('cmd', type=str)

    def get(self):
        lStatus = 'ok'
        lArgs = self.__mParser.parse_args()
        lBusId = int(lArgs['bus_id'], 0)
        lAddress = int(lArgs['address'], 0)
        lValue = int(lArgs['value'], 0)
        lBus = SMBus(lBusId)

        try:
            if lArgs['cmd'] is None:
                lBus.write_byte(lAddress, lValue)
            else:
                lCommand = int(lArgs['cmd'], 0)
                lBus.write_byte_data(lAddress, lCommand, lValue)
        except IOError, pExc:
            lStatus = "Error writing data: " + str(pExc)

        return {
            'bus_id': lBusId,
            'address': lAddress,
            'cmd': lCommand,
            'value': lValue,
            'status': lStatus
            }

 def put(self, id):
     reqparse = RequestParser()
     reqparse.add_argument('text', type=str, location='json')
     data = reqparse.parse_args()
     if not data.text:
         return self.argument_required('text')
     self.cursor.execute("""
         UPDATE {}
         SET text = ?
         WHERE id = ?
     """.format(self.__table__), (data.text, id))
     self.refresh_table()
     return self.get(id)

 def delete(self, url):
     parser = RequestParser()
     parser.add_argument(arg_token)
     args = parser.parse_args()
     if not args['token']:
         return error('notoken'), 403
     user = User.query.filter_by(token=args['token']).first()
     if not user:
         return error('wrongtoken'), 403
     res = do_delete_image(user, url)
     if res == 'success':
         return {'status': 'success'}
     else:
         return error(res), 403

 def __init__(self):
     super(Set, self).__init__()
     self.__mParser = RequestParser()
     self.__mParser.add_argument('bus_id', type=str, required=True)
     self.__mParser.add_argument('address', type=str, required=True)
     self.__mParser.add_argument('value', type=str, required=True)
     self.__mParser.add_argument('cmd', type=str)

    def put(self, id):
        """Update tags for a score"""
        parser = RequestParser()
        parser.add_argument('tags', type=str, required=True)
        args = parser.parse_args()

        q = db.session.query
        score = q(models.Score).get(id)

        tag_names = [t.strip() for t in args.tags.split(',')]

        score.tags = _process_tags(tag_names, score.user_id)
        db.session.commit()
        score = q(models.Score).get(id)
        result = ScoreSerializer(score).data
        return {'result': result}

class Get(Resource):

    def __init__(self):
        super(Get, self).__init__()
        self.__mParser = RequestParser()
        self.__mParser.add_argument('bus_id', type=str, required=True)
        self.__mParser.add_argument('address', type=str, required=True)
        self.__mParser.add_argument('cmd', type=str)

    def get(self):
        lStatus = "ok"
        lCommand = ""
        lValue = ""
        lArgs = self.__mParser.parse_args()
        lBusId = int(lArgs['bus_id'], 0)
        lBus = SMBus(lBusId)

        lAddress = int(lArgs['address'], 0)
        try:
            if lArgs['cmd'] is None:
                lValue = lBus.read_byte(lAddress)
            else:
                lCommand = int(lArgs['cmd'], 0)
                lValue = lBus.read_byte_data(lAddress, lCommand)
        except IOError, pExc:
            lStatus = "Error reading from bus: " + str(pExc)

        return {
            'bus_id': lBusId,
            'address': lAddress,
            'cmd': lCommand,
            'value': lValue,
            'status': lStatus
            }

    def wrapper(inst, *args, **kwargs):

        header_parser = RequestParser()
        header_parser.add_argument(User.Fields.USERNAME,
                                   type=str,
                                   required=True,
                                   location='headers',
                                   help='username needs to be present in header')

        header_parser.add_argument(User.Fields.PASSWORDHASH,
                                   type=str,
                                   required=True,
                                   location='headers',
                                   help='password hash needs to be present in header')

        headers = header_parser.parse_args()

        request._username = headers[User.Fields.USERNAME]
        request._passwordhash = headers[User.Fields.PASSWORDHASH]

        user = UserOperations.find_user_with_passwordhash(
            request._username,
            request._passwordhash
        )

        if not user:
            cors_headers = {
                'Access-Control-Allow-Origin': '*'
            }

            return "Cannot authenticte user", 401, cors_headers
            # raise UserException("Could not authenticate user")

        return func(inst, *args, **kwargs)

    def get(self):

        params_parser = RequestParser()

        params_parser.add_argument(User.Fields.NAME,
                            type=str,
                            required=False,
                            location='args')

        params_parser.add_argument(User.Fields.SETTINGS,
                            type=str,
                            required=False,
                            location='args')

        fields = params_parser.parse_args()

        name = fields.get(User.Fields.NAME, None)
        settings = fields.get(User.Fields.SETTINGS, None)

        d = dict()
        if name is not None:
            d[User.Fields.NAME] = name
        if settings is not None:
            d[User.Fields.SETTINGS] = settings


        updated_user = UserOperations.update_user(
            request._username, request._passwordhash, d
        )

        user_dict = User.encode(updated_user)
        user_dict = remove_id_from_user_dict(user_dict)
        return user_dict, 200

    def get(self, soknad_id=None):
        if soknad_id:
            soknad = self.soknad_resource.get(soknad_id)
            ExternalResourceHelper.load_organisation(soknad)
            ExternalResourceHelper.load_persons([soknad])
            ExternalResourceHelper.load_users([soknad])
            return output_pdf(soknad, 200, template=u"pdf/soknad.html")
            # return output_csv(soknad, 200, fieldname_mapping=get_fieldname_mapping(), fields_to_ignore=get_fields_to_ignore())
        else:
            parser = RequestParser()
            parser.add_argument("id", type=int, action="append", required=True)
            args = parser.parse_args()
            soknader = self.soknad_resource.get()
            soknader = [s for s in soknader if s["id"] in args["id"]]

            ExternalResourceHelper.load_organisations(soknader)
            ExternalResourceHelper.load_persons(soknader)
            ExternalResourceHelper.load_users(soknader)

            return output_csv(
                soknader, 200, fieldname_mapping=get_fieldname_mapping(), fields_to_ignore=get_fields_to_ignore()
            )

 def __init__(self):
     self.reqparse = RequestParser()
     self.reqparse.add_argument(
         'user',
         type = username,
         required = True,
         location = 'json'
     )
     self.reqparse.add_argument(
         'key',
         type = pubkey,
         required = True,
         location = 'json'
     )
     super(UserCreate, self).__init__()

 def post(self):
     parser = RequestParser()
     parser.add_argument(arg_token)
     parser.add_argument('file', type=FileStorage, location='files')
     parser.add_argument('desc', type=unicode, location='form')
     args = parser.parse_args()
     f = args['file']
     user = args['token']
     if user:
         user = User.query.filter_by(token=user).first()
         if not user:
             return error('wrongtoken'), 403
     if not f:
         return error('imagenotattached'), 400
     upload = do_upload_image(user, f, args['desc'])
     if isinstance(upload, str):
         return error(upload), 403
     else:
         return success({'url': {'part': upload.url, 'page': BASE_URL % upload.url, 'direct': upload.direct_url}}), 201