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
3
Source : snippet.py
with Apache License 2.0
from dockerizeme
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
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
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
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
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
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
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
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
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'])