bottle.request.forms

Here are the examples of the python api bottle.request.forms taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

9 Examples 7

3 Source : snippet.py
with Apache License 2.0
from dockerizeme

def post_equipement():
    data = request.forms

    if not data:
        abort(400, 'No data received')
    entity = {}
    for k,v  in data.items():
        entity[k]=v

    if not entity.has_key('_id'):
        abort(400,'No _id specified')
    try:
        db['equipements'].save(entity)
    except ValidationError as ve:
        abort(400, str(ve))

@route('/equipements/:id', methodd='GET')

3 Source : backend.py
with MIT License
from gnstaxo

def ban(board_name):

    if f':{board_name}:' not in get_current_user(request).mod:
        return abort(403, "You are not allowed to do this.")

    form = dict(request.forms)

    reason = form.get('reason')

    user = form.get('user').strip()

    Anon.update(banned=True, ban_reason=reason, ban_date=datetime.now().replace(microsecond=0)).where(Anon.name == user).execute()

    return redirect(f'{basename}/{board_name}/mod')

@post('/  <  board_name>/unban/ < name>')

3 Source : backend.py
with MIT License
from gnstaxo

def unban(board_name, name):

    if f':{board_name}:' not in get_current_user(request).mod:
        return abort(403, "You are not allowed to do this.")

    form = dict(request.forms)

    anon = Anon.get(Anon.name == name)

    if bool(form.get("dall")):
        Post.delete().where(Post.author_id == anon.id).execute()

    if bool(form.get("unban")):
        Anon.update(banned=False, ban_reason=None, ban_date=None).where(Anon.name == name).execute()

    return redirect(f'{basename}/{board_name}/mod')

@post('/add_board')

0 Source : test_bottle.py
with BSD 2-Clause "Simplified" License
from getsentry

def test_medium_formdata_request(sentry_init, capture_events, app, get_client):
    sentry_init(integrations=[bottle_sentry.BottleIntegration()])

    data = {"foo": "a" * 2000}

    @app.route("/", method="POST")
    def index():
        import bottle

        assert bottle.request.forms["foo"] == data["foo"]
        capture_message("hi")
        return "ok"

    events = capture_events()

    client = get_client()
    response = client.post("/", data=data)
    assert response[1] == "200 OK"

    (event,) = events
    assert event["_meta"]["request"]["data"]["foo"] == {
        "": {"len": 2000, "rem": [["!limit", "x", 509, 512]]}
    }
    assert len(event["request"]["data"]["foo"]) == 512


@pytest.mark.parametrize("input_char", [u"a", b"a"])

0 Source : test_bottle.py
with BSD 2-Clause "Simplified" License
from getsentry

def test_files_and_form(sentry_init, capture_events, app, get_client):
    sentry_init(
        integrations=[bottle_sentry.BottleIntegration()], request_bodies="always"
    )

    data = {"foo": "a" * 2000, "file": (BytesIO(b"hello"), "hello.txt")}

    @app.route("/", method="POST")
    def index():
        import bottle

        assert list(bottle.request.forms) == ["foo"]
        assert list(bottle.request.files) == ["file"]
        assert not bottle.request.json
        capture_message("hi")
        return "ok"

    events = capture_events()

    client = get_client()
    response = client.post("/", data=data)
    assert response[1] == "200 OK"

    (event,) = events
    assert event["_meta"]["request"]["data"]["foo"] == {
        "": {"len": 2000, "rem": [["!limit", "x", 509, 512]]}
    }
    assert len(event["request"]["data"]["foo"]) == 512

    assert event["_meta"]["request"]["data"]["file"] == {
        "": {
            "len": -1,
            "rem": [["!raw", "x", 0, -1]],
        }  # bottle default content-length is -1
    }
    assert not event["request"]["data"]["file"]


@pytest.mark.parametrize(

0 Source : backend.py
with MIT License
from gnstaxo

def delete_post(board_name):

    current_user = get_current_user(request)

    board = Board.get(Board.name == board_name)
    form = dict(request.forms)

    if bool(form.get('report')):
        reason = form.get('report')
        report_reasons = loads(config['reports.reasons'])
        if reason not in report_reasons: return redirect(f'{basename}/{board_name}/')
        for refnum in list(form)[:-1]:
            report = Report(reason=reason, refnum=refnum, board=board, date=datetime.now().replace(microsecond=0))
            report.save()
    else:
        for refnum in form:
            thread = board.posts.where(Post.refnum == refnum).get()
            if (thread.author == current_user or
                f':{board_name}:' in current_user.mod):

                remove_textual_refs(board, thread)
                
                if thread.image: remove_media(thread.image)

                if not thread.is_reply:

                    for reply in board.posts.where(Post.replyrefnum == thread.refnum):

                        if reply.image: remove_media(reply.image)
                        reply.delete_instance()

                thread.delete_instance()
                Report.delete().where(refnum == thread.refnum).execute()

    redirect(f'{basename}/{board_name}/')

@post('/  <  board_name>/ban')

0 Source : app.py
with MIT License
from microsoft

    def _initBottle(self):

        @self.app.route('/login')
        def show_login_page():
            return static_file('loginScreen.html', root=os.path.join(self.staticDir, 'templates'))

        
        @self.app.route('/doLogin', method='POST')
        @self.app.route('/  <  project>/doLogin', method='POST')
        def do_login(project=None):
            # check provided credentials
            try:
                username = html.escape(self._parse_parameter(request.forms, 'username'))
                password = self._parse_parameter(request.forms, 'password')

                # check if session token already provided; renew login if correct
                sessionToken = self.middleware.decryptSessionToken(username, request)
                #request.get_cookie('session_token', secret=self.config.getProperty('Project', 'secret_token'))
                if sessionToken is not None:
                    sessionToken = html.escape(sessionToken)

                sessionToken, _, expires = self.middleware.login(username, password, sessionToken)
                
                response.set_cookie('username', username, path='/')   #, expires=expires, same_site='strict')
                self.middleware.encryptSessionToken(username, response)
                # response.set_cookie('session_token', sessionToken, httponly=True, path='/', secret=self.config.getProperty('Project', 'secret_token'))    #, expires=expires, same_site='strict')

                return {
                    'expires': expires.strftime('%H:%M:%S')
                }

            except Exception as e:
                abort(403, str(e))
        

        @self.app.route('/loginCheck', method='POST')
        @self.app.route('/ < project>/loginCheck', method='POST')
        def loginCheck(project=None):
            try:
                username = request.get_cookie('username')
                if username is None:
                    username = self._parse_parameter(request.forms, 'username')
                username = html.escape(username)

                sessionToken = self.middleware.decryptSessionToken(username, request)
                # sessionToken = html.escape(request.get_cookie('session_token', secret=self.config.getProperty('Project', 'secret_token')))

                _, _, expires = self.middleware.getLoginData(username, sessionToken)
                
                response.set_cookie('username', username, path='/')   #, expires=expires, same_site='strict')
                self.middleware.encryptSessionToken(username, response)
                # response.set_cookie('session_token', sessionToken, httponly=True, path='/', secret=self.config.getProperty('Project', 'secret_token'))    #, expires=expires, same_site='strict')
                return {
                    'expires': expires.strftime('%H:%M:%S')
                }

            except Exception as e:
                abort(401, str(e))


        @self.app.route('/logout', method='GET')        
        @self.app.route('/logout', method='POST')
        @self.app.route('/ < project>/logout', method='GET')        
        @self.app.route('/ < project>/logout', method='POST')
        def logout(project=None):
            try:
                username = html.escape(request.get_cookie('username'))
                sessionToken = self.middleware.decryptSessionToken(username, request)
                self.middleware.logout(username, sessionToken)
                response.set_cookie('username', '', path='/', expires=0)   #, expires=expires, same_site='strict')
                response.set_cookie('session_token', '',
                            httponly=True, path='/', expires=0)
                # self.middleware.encryptSessionToken(username, response)
                # response.set_cookie('session_token', sessionToken, httponly=True, path='/', secret=self.config.getProperty('Project', 'secret_token'))    #, expires=expires, same_site='strict')

                # send redirect
                response.status = 303
                response.set_header('Location', self.indexURI)
                return response

            except Exception as e:
                abort(403, str(e))


        @self.app.route('/ < project>/getPermissions', method='POST')
        def get_user_permissions(project):
            try:
                try:
                    username = html.escape(request.get_cookie('username'))
                except:
                    username = None
                if not self.checkAuthenticated(project=project):
                    abort(401, 'not permitted')

                return {
                    'permissions': self.middleware.getUserPermissions(project, username)
                }
            except:
                abort(400, 'bad request')


        @self.app.route('/getUserNames', method='POST')
        @self.app.route('/ < project>/getUserNames', method='POST')
        def get_user_names(project=None):
            if project is None:
                try:
                    project = request.json['project']
                except:
                    # no project specified (all users); need be superuser for this
                    project = None

            if self.checkAuthenticated(project, admin=True, superuser=(project is None), extend_session=True):
                return {
                    'users': self.middleware.getUserNames(project)
                }

            else:
                abort(401, 'forbidden') 


        @self.app.route('/doCreateAccount', method='POST')
        def createAccount():
            #TODO: make secret token match
            try:
                username = html.escape(self._parse_parameter(request.forms, 'username'))
                password = self._parse_parameter(request.forms, 'password')
                email = html.escape(self._parse_parameter(request.forms, 'email'))

                sessionToken, _, expires = self.middleware.createAccount(
                    username, password, email
                )

                response.set_cookie('username', username, path='/')   #, expires=expires, same_site='strict')
                self.middleware.encryptSessionToken(username, response)
                # response.set_cookie('session_token', sessionToken, httponly=True, path='/', secret=self.config.getProperty('Project', 'secret_token'))    #, expires=expires, same_site='strict')
                return {
                    'expires': expires.strftime('%H:%M:%S')
                }

            except Exception as e:
                abort(403, str(e))


        @self.app.route('/createAccount')
        def showNewAccountPage():
            # check if token is required; if it is and wrong token provided, show login screen instead
            try:
                targetToken = html.escape(self.config.getProperty('UserHandler', 'create_account_token'))
            except:
                # no secret token defined
                targetToken = None
            if targetToken is not None and not(targetToken == ''):
                try:
                    providedToken = html.escape(request.query['t'])
                    if providedToken == targetToken:
                        response = static_file('templates/newAccountScreen.html', root=self.staticDir)
                    else:
                        response = redirect('/login')
                except:
                    response = redirect('/login')
            else:
                # no token required
                response = static_file('templates/newAccountScreen.html', root=self.staticDir)
            response.set_header('Cache-Control', 'public, max-age=0')
            return response


        @self.app.route('/loginScreen')
        def showLoginPage():
            return static_file('templates/loginScreen.html', root=self.staticDir)


        @self.app.route('/accountExists', method='POST')
        def checkAccountExists():
            username = ''
            email = ''
            try:
                username = html.escape(self._parse_parameter(request.forms, 'username'))
            except: pass
            try:
                email = html.escape(self._parse_parameter(request.forms, 'email'))
            except: pass
            try:
                return { 'response': self.middleware.accountExists(username, email) }
            except Exception as e:
                abort(401, str(e))


        @self.app.get('/getAuthentication')
        @self.app.post('/getAuthentication')
        def getAuthentication():
            if not self.checkAuthenticated():
                return { 'authentication': {
                        'canCreateProjects': False,
                        'isSuperUser': False
                    }
                }
            try:
                username = html.escape(request.get_cookie('username'))

                # optional: project
                if 'project' in request.query:
                    project = html.escape(request.query['project'])
                else:
                    project = None

                return { 'authentication': self.middleware.getAuthentication(username, project) }

            except:
                return { 'authentication': {
                        'canCreateProjects': False,
                        'isSuperUser': False
                    }
                }


        @self.app.post('/setPassword')
        def setPassword():
            '''
                Routine for super users to set the password of
                a user.
            '''
            if self.checkAuthenticated(superuser=True):
                try:
                    data = request.json
                    username = data['username']
                    password = data['password']
                    result = self.middleware.setPassword(username, password)
                    return result

                except Exception as e:
                    return {
                        'success': False,
                        'message': str(e)
                    }
            else:
                abort(404, 'not found')


        @self.app.get('/v')
        def userVerify():
            '''
                Reserve for future implementations that require
                unauthorized but token-protected user services.
            '''
            abort(404, 'not found')


    def checkAuthenticated(self, project=None, admin=False, superuser=False, canCreateProjects=False, extend_session=False, return_all=False):

0 Source : bsc.py
with MIT License
from NASA-AMMOS

    def _add_logger_by_name(self, name):
        """Handles POST requests for adding a new logger.

        Expects logger configuration to be passed in the request's query string.
        The logger name is included in the URL and the address components and
        connection type should be included as well. The loc attribute is
        defaulted to "localhost" when making the socket connection if not
        defined.

        loc = IP / interface
        port = port / protocol
        conn_type = udp or ethernet

        Raises:
            ValueError:
                if the port or connection type are not supplied.
        """
        data = dict(request.forms)
        loc = data.pop("loc", "")
        port = data.pop("port", None)
        conn_type = data.pop("conn_type", None)

        if not port or not conn_type:
            e = "Port and/or conn_type not set"
            raise ValueError(e)
        address = [loc, int(port)]

        if "rotate_log" in data:
            data["rotate_log"] = True if data == "true" else False

        if "rotate_log_delta" in data:
            data["rotate_log_delta"] = int(data["rotate_log_delta"])

        self._logger_manager.add_logger(name, address, conn_type, **data)

    def _stop_logger_by_name(self, name):

0 Source : app.py
with Apache License 2.0
from wetneb

def jsonp(view):
    """
    Decorator for views that return JSON
    """
    def wrapped(*posargs, **kwargs):
        args = {}
        # if we access the args via get(),
        # we can get encoding errors...
        for k in request.forms:
            args[k] = getattr(request.forms, k)
        for k in request.query:
            args[k] = getattr(request.query, k)
        callback = args.get('callback')
        status_code = 200
        try:
            result = view(args, *posargs, **kwargs)
        except (KeyError) as e:#ValueError, AttributeError, KeyError) as e:
            import traceback, sys
            traceback.print_exc(file=sys.stdout)
            result = {'status':'error',
                    'message':'invalid query',
                    'details': str(e)}
            status_code = 403
        if callback:
            result = '%s(%s);' % (callback, json.dumps(result))

        if status_code == 200:
            return result
        else:
            abort(status_code, result)

    return wrapped


@route('/api/annotate', method=['GET','POST'])