def prepare_response(self, content, status_code, content_type, headers):
response = HTTPResponse(content_type=content_type)
response.write(content)
response.status_code = status_code
for name, value in headers.iteritems():
response.headers.append((name, value))
return response
def simple_template_response(template, extra_data=None):
extra_data = extra_data or {}
template_handler = get_template_handler()
response = HTTPResponse()
response.write(template_handler(template, extra_data))
return response
def post(self):
try:
form = self.request.form
code = form['code'][0]
except:
return bad_request_with_detail(
'No data posted, or data in incorrect format')
params = {
"grant_type": "authorization_code",
"redirect_uri": config.SPOTIFY_CALLBACK_URL,
"code": code
}
token_response = requests.post(config.SPOTIFY_TOKEN_ENDPOINT,
data=params,
headers=auth_header,
verify=True)
response = HTTPResponse()
response.content_type = 'application/json'
response.status_code = token_response.status_code
if token_response.status_code == 200:
json_response = token_response.json()
refresh_token = json_response["refresh_token"]
encrypted_token = crypt.encrypt(refresh_token)
json_response["refresh_token"] = encrypted_token
response_body = json.dumps(json_response)
response.write(response_body)
else:
response.write_bytes(token_response.content)
return response
def upload(request):
#print 'form:', request.form
#print 'uploaded:', request.files
response = HTTPResponse()
# check data integrity:
if request.files.get('data') and request.form.get('crc'):
storage = request.files.get('data')[0] # raw object
crc = request.form.get('crc')[0] # crc for compressed content
if str(zlib.crc32(storage.value)) == crc: # check integrity
# return file save result
content = zlib.decompress(storage.value)
# write to file here
savefile = storage.filename if storage.filename else (
datetime.now().strftime('%Y%m%d%H%M%S') +
str(random.randint(0, 100)) + '.html')
fout = open(os.path.join(conf.get('upload_dir'), savefile), 'w')
fout.write(content)
fout.close()
response.write(conf.get('upload_url_prefix') + savefile)
else:
return bad_request()
else:
# bad request
return bad_request()
return response
def testdynamiccomponent(request):
resp = HTTPResponse()
resp.write(
etree.tostring(
etree.XML(
parse_dynamic_content_xml(
os.path.join(TEMPLATES_FOLDER, 'basexml/test.xml'),
{}))).decode('utf-8'))
return resp
def process(self,
url=None,
method='GET',
data=None,
environ=None,
secure=False,
content_type='html',
route_name=None,
encoding='UTF-8'):
content_type_to_http_protocol_content_types = {
'html': 'text/html; charset={}'.format(encoding),
'json': 'application/json; charset={}'.format(encoding)
}
original_content_type = content_type
content_type = content_type_to_http_protocol_content_types[
content_type]
if route_name:
url = router.path_for(route_name)
if url is None:
raise ValueError(
'Please provide correct url for request or proper route_name')
data = data or {}
method = method.upper()
response = HTTPResponse()
r = self._base_environ()
r.update({
'PATH_INFO': url,
'REQUEST_METHOD': str(method),
'SERVER_PORT': str('443') if secure else str('80'),
'wsgi.url_scheme': str('https') if secure else str('http'),
})
if method in ('POST', 'PUT'):
formatter = get_formatter_for(original_content_type)
data = formatter.format(data).encode(encoding)
r.update({
'CONTENT_LENGTH': len(data),
'CONTENT_TYPE': str(content_type),
'wsgi.input': FakePayload(data),
})
elif method == 'GET':
# WSGI requires latin-1 encoded strings.
r['QUERY_STRING'] = bytes(parse.urlencode(data),
'iso-8859-1').decode()
r.update(environ or {})
def wsgi_response_handler(response, status_string, headers):
response.content_type = [
header[1] for header in headers
if header[0].lower() == 'content-type'
].pop()
response.status_code = HTTP_STATUS_STRING_TO_CODE[status_string]
response.headers = headers
output = application(r, partial(wsgi_response_handler, response))
response.buffer = output
return response
def get(self):
fortunes = db_session.query(Fortune).all()
fortunes.append(Fortune(id=0, message="Additional fortune added at request time."))
fortunes.sort(key=attrgetter("message"))
template = template_engine.get_template("fortune.html")
template_html = template.render({"fortunes": fortunes})
response = HTTPResponse()
response.write(template_html)
return response
def datatoZigBee(request):
response = HTTPResponse()
try:
id= int(request.get_param('id'))
data=request.get_param('data').encode("ascii")
addr=dictionary[id]['addr']
addr_long=dictionary[id]['addr_long']
sendToZigBee(addr_long, addr, data)
except Exception as e:
print ("Error enviando datos "+ str(e))
response.status_code = 401
return response
def get(self, skip_body=False):
mime_type, encoding = mimetypes.guess_type(self.filepath)
response = HTTPResponse(mime_type or 'plain/text', encoding)
if not skip_body:
response.headers.append(HTTP_HEADER_ACCEPT_RANGE_NONE)
file = open(self.filepath, 'rb')
try:
response.write_bytes(file.read())
finally:
file.close()
return response
def get(self):
fortunes = db_session.query(Fortune).all()
fortunes.append(Fortune(id=0, message="Additional fortune added at request time."))
fortunes.sort(key=attrgetter("message"))
engine = Engine(loader=FileLoader(["views"]), extensions=[CoreExtension()])
template = engine.get_template("fortune.html")
for f in fortunes:
f.message = bleach.clean(f.message)
template_html = template.render({"fortunes": fortunes})
response = HTTPResponse()
response.write(template_html)
return response
def handler(request):
if self.challenge_key not in request.query:
return bad_request()
challenge_code = last_item_adapter(
request.query)[self.challenge_key]
turing_number = ''.join(random.sample(self.chars, self.max_chars))
if not self.cache.set(self.prefix + challenge_code,
(int(time()), turing_number),
self.timeout, self.namespace):
return bad_request()
response = HTTPResponse(content_type)
self.image(turing_number).save(
FileAdapter(response), format, **options)
return response
def post(self):
"""
Handle HTTP POST.
"""
method = self.get_method()
body = self.get_body()
# TODO handle method exception.
result = method(**body)
payload = self.encoder.encode(result)
response = HTTPResponse(content_type="application/json")
response.status_code = 200
response.write(payload)
return response
def welcome(request):
message, error = '', ''
if request.method == 'POST':
errors = {}
if not captcha.validate(request, errors, gettext=lambda s: s):
error = errors['turing_number'][-1]
else:
message = 'Well done!'
challenge_code = captcha.get_challenge_code(request)
response = HTTPResponse()
response.write("""
<html><head><style>
span {color: green;}
span.error {color:red;}
input[type=text] {width:200;text-transform: uppercase;}
#captcha {display:block; width:200; height:75}
</style></head><body>
<html><body>
<h2>Captcha Verification: wheezy.http demo</h2>
<span><b>%s</b></span>
<form method="post">
<p>Please enter the text from image:</p>
<p>
<label for="turing_number">
<img id="captcha" src="/captcha.jpg?c=%s" />
<input type="hidden" name="c" value="%s" />
</label>
<input id="turing_number" name="turing_number" type="text"
maxlength="4" autocomplete="off" />
<span class="error">%s</span>
</p>
<p><input type="submit" value="Verify"></p>
</form>
<script>
window.onload=function()
{
c = document.getElementById('captcha');
c.onclick = function() {
this.src=this.src.replace(/&r=\d+/g,'') + '&r=' + \
Math.floor(Math.random() * 100 + 1);
};
}
</script>
</body></html>
""" % (message, challenge_code, challenge_code, error))
return response
def wrap_request(self, request, *args, **kwargs):
'''
Prepares data and pass control to `restea.Resource` object
:returns: :class: `wheezy.http.HTTPResponse`
'''
data_format, kwargs = self._get_format_name(kwargs)
formatter = formats.get_formatter(data_format)
resource = self._resource_class(
WheezyRequestWrapper(request), formatter
)
res, status_code, content_type = resource.dispatch(*args, **kwargs)
response = HTTPResponse(
content_type=content_type,
)
response.write(res)
response.status_code = status_code
return response
def post(self):
try:
form = self.request.form
encrypted_token = form['refresh_token'][0]
token = crypt.decrypt(encrypted_token)
except:
return bad_request_with_detail(
'No data posted, or data in incorrect format')
params = {"grant_type": "refresh_token", "refresh_token": token}
token_response = requests.post(config.SPOTIFY_TOKEN_ENDPOINT,
data=params,
headers=auth_header,
verify=True)
response = HTTPResponse()
response.content_type = 'application/json'
response.status_code = token_response.status_code
response.write_bytes(token_response.content)
return response
def _error_response(self, request, error):
resp = HTTPResponse()
resp.status_code = ERROR_STATUS_CODE
resp.write_bytes(json.dumps({'error': error}))
return resp
def get(self):
response = HTTPResponse()
quote = {'message': 'Hello, World!'}
response.write(json.dumps(quote))
return response
def get(self):
response = HTTPResponse()
response.write('Hello,World~~get')
return response
def get(self):
response = HTTPResponse()
response.write(PING_MESSAGE.format(app='wheezyweb'))
return response
def plaintext(request):
response = HTTPResponse()
response.headers = [("Content-Type", "text/plain; charset=UTF-8")]
response.write("Hello, world!")
return response
def json_view(request):
response = HTTPResponse()
json_data = {"message": "Hello, World!"}
data = json.dumps(json_data)
response.write(data)
return response
def get(self):
response = HTTPResponse()
response.write('Hello World!')
return response
def data(request):
id= int(request.get_param('id'))
data=get_data(id)
response = HTTPResponse()
response.write(json.dumps(data))
return response
def get_id(request):
global sink_info
response = HTTPResponse()
response.write(json.dumps(sink_info))
return response
def nodes(request):
dic=get_nodes()
response = HTTPResponse()
response.write(json.dumps(dic))
return response
def test(request):
response = HTTPResponse()
response.write('<html><body>Hello World</body></html>')
return response
def welcome(request):
response = HTTPResponse()
response.write('Server is up!')
return response
def welcome(request):
response = HTTPResponse()
response.write('Hello World!')
return response
def get(self):
response = HTTPResponse()
response.write('hello world')
return response
def get(self):
response = HTTPResponse(content_type="application/json; charset=UTF-8")
response.write(ujson.dumps({"test": True}))
return response
