def createBoard(user_id):
print "Inside the creating board %s" %user_id
jsonBody=request.body.read()
jsonObj=json.loads(jsonBody)
for key in sorted(request.forms.iterkeys()):
print "%s=%s" % (key, request.forms[key])
if(db.isvaliduser(user_id)):
print "Creating board for user -> " + user_id
id = random.randint(1, 100)
board._board_id = id
print str(board._board_id) + "\n"
board._board_name = jsonObj['boardname'] # request.forms.get('boardName')
print "BoardName: " + board._board_name
board._userId = user_id
new_board = db.insertBoard(board)
response.set_header("content-type","application/json")
response.body = new_board
print "***Response returned is:\n"
print response.status
print response.body
print "\n***"
return response
else:
return erroruser()
def get_cal():
"""
Test of the Calendar class via API.
Path: GET /cal
"""
response.set_header('Content-Type', 'application/json')
return Calendar(config).get_events()
def check_refer_redirect(self):
referer = request.headers.get('Referer')
if not referer:
return
host = request.headers.get('Host')
if host not in referer:
return
inx = referer[1:].find('http')
if not inx:
inx = referer[1:].find('///')
if inx > 0:
inx + 1
if inx < 0:
return
url = referer[inx + 1:]
host = referer[:inx + 1]
orig_url = request.urlparts.path
if request.urlparts.query:
orig_url += '?' + request.urlparts.query
full_url = host + urljoin(url, orig_url)
response.status = 302
response.set_header('Location', full_url)
return True
def resolve_meokanal_item(aid, idx):
"""Resolves a MEO Kanal item to a load balancer URI, ensuring freshness."""
link = alc.resolve_meo_item(aid, idx)
log.error(link)
response.status = 301
response.set_header("Location", link)
def getrandom():
print 'rand??'
print 'getrandom req...'
obj = get_bbbblinken_json()
print 'got object'
candidates = []
for child in obj['data']['children']:
c = child['data']
if c['is_self']:
continue
candidates.append(c)
#urls.append(show_url(c['url']))
winner = random.choice(candidates)
url = show_url(winner['url'])
print url
response.set_header('Content-Type', 'application/javascript')
output = {}
output['code'] = js_code(url)
output['url'] = url
output['name'] = winner['title']
return json.dumps(output)
def get_handicappers():
response.set_header('Content-Type', 'application/json')
prefix = get_prefix(request)
result = [{'id': 1, 'name': 'Frank'}, {'id': 2, 'name': 'Martin'}, {'id': '3', 'name': 'Jason'}]
return json.dumps(result) #'[' + ',\n'.join(result) + ']'
def permanent(euid):
location = 'http://lorempixel.com/100/100/'
response.set_header('Location', location)
response.status = 301
return 'Moved Permanently'
def _output(content):
"""Output the content in the datastore as a HTTP Response"""
serve = True
# check modifications and etag
if "If-Modified-Since" in request.headers:
last_seen = datetime.datetime.strptime(request.headers["If-Modified-Since"], HTTP_DATE_FMT)
if last_seen >= content.modified.replace(microsecond=0):
serve = False
if "If-None-Match" in request.headers:
etags = [x.strip('" ') for x in request.headers["If-None-Match"].split(",")]
if content.etag in etags:
serve = False
headers = {}
if content.content_type:
headers["Content-Type"] = content.content_type
last_modified = content.modified.strftime(HTTP_DATE_FMT)
headers["Last-Modified"] = last_modified
headers["ETag"] = '"%s"' % (content.etag,)
for header in content.headers:
key, value = header.split(":", 1)
headers[key] = value.strip()
if serve:
response.body = content.body
for key, value in headers.iteritems():
response.set_header(key, value)
response.content_type = content.content_type
response.status = int(content.status)
else:
response.status = 304
return response
def doGetCaseResultLog(sid, tid):
"""
URL:/test/caseresult/<sid>/<tid>/log
TYPE:http/POST
Get detail of a test case result by sid&tid
@type sid:string
@param sid:the id of test session
@type tid: string
@param tid: the id of case result
@type data:JSON
@param data:{'token':(string)value}
@rtype: JSON
@return:ok-{'results':{'sid':(string)value,'tid':(string)value,'casename':(string)value,'starttime':(string)value,'endtime':(string)value,'result':(string)value ['Pass'/'Fail'/'Error'],'log':(GridFsId)value,'snapshots':(arrary of GridFsId)}}
error-{'errors':{'code':value,'msg':(string)info}}
"""
content_type = request.headers.get("Content-Type")
if not (content_type):
# return {'errors':{'code':500, 'msg':'Missing Content-Type'}}
# else:
json = request.json
if not json is None:
token = json["token"]
else:
token = "1122334455667788"
record_id = sid + "_" + tid
response.set_header("Content-Type", "application/x-download")
response.set_header("Content-Disposition", "attachment; filename=log_" + record_id + ".zip", True)
return getTestCaseLog(token, sid, tid)
def home(query=None):
response.set_header("Server", "GIF.CL.IT")
response.set_header("Cache-Control", "no-cache, Expires=-1")
vhost = request.urlparts.netloc.split('.')[0]
if query == 'random':
query = random_line(open('/usr/share/dict/words', 'r'))
if vhost != 'gif':
query = vhost
if query is None or query == 'about':
with open('USAGE.TXT', 'r') as f:
return "<pre>" + ''.join(f.readlines()) + "</pre>"
request_uri = ROOT_URI + '?$format=json&Query=' + quote_plus("'"+query+" gif'")
data = requests.get(request_uri, auth=(ACCT_KEY, ACCT_KEY))
data = json.loads(data.text)['d']['results']
max_attempts = len(data)-1
attempts = 0
serp_idx = 0
good_image = False
try:
while not good_image:
if data[serp_idx]['ContentType'] == "image/animatedgif" and \
data[serp_idx]['Width'] >= 250 and \
data[serp_idx]['Height'] >= 250 and \
data[serp_idx]['FileSize'] >= 250000:
good_image = True
else:
serp_idx = serp_idx + 1
if attempts > max_attempts:
raise
except Exception:
return "Unable to reticulate splines"
return '<img style="margin:0;position:absolute;top:0;left:0;" src="' + data[serp_idx]['MediaUrl'] + '" />'
def proxy_influx_query(path):
"""
Capture the query events comming from Grafana.
Investigate the query and replace the measurement name with a Retention Policy measurement name if possible.
Send out the (modified or unmodified) query to Influx and return the result
"""
forward_url = CONFIG['influxdb_http'] # The local influx host
params = dict(request.query) # get all query parameters
try:
params['q'] = modify_query(params, rp_db_map)
except Exception as e:
print "EXC:", e
pass
headers = request.headers
cookies = request.cookies
r = requests.get(url=forward_url +'/'+ path, params=params, headers=headers, cookies=cookies, stream=True) # get data from influx
if r.status_code == 200:
for key, value in dict(r.headers).iteritems():
response.set_header(key, value)
for key, value in dict(r.cookies).iteritems():
response.cookies[key] = value
pass
else:
abort(r.status_code, r.reason) # NOK, return error
return r.raw
def paste():
isBrowser = False
text = request.forms.get(app.config["POST_FIELD"])
if not text:
text = request.forms.get("browser_text")
isBrowser = True
if not text:
response.status = 400
return 'No data\n'
try:
storage = Storage (app.config)
hashname = storage.store (text)
redirect = '{0}/{1}'.format(app.config["URL"], hashname)
if isBrowser:
response.status = 303
syntax = request.forms.get("syntax", "")
if nameRe.match (syntax):
redirect += "?"+syntax
response.set_header ('Location', redirect)
else:
storage.markviewed (hashname)
return redirect+"\n"
except Exception as ex:
logging.error(ex)
response.status = 400
return 'Bad request\n'.format(ex)
def get_current_time():
cur_time = re.sub(r'\.[0-9]*$', '+08:00', datetime.isoformat(datetime.now()))
print('>> current-time: %s' % cur_time)
response.set_header('Cache-Control', 'no-cache')
response.content_type = 'application/json'
return { 'status': 'OK', 'time': cur_time }
def index(office):
response.set_header('Access-Control-Allow-Origin','*')
response.set_header('Content-type','text/xml')
ip = offices[office]['ip']
vctype = offices[office]['type']
req = requests.get('http://%s/status.xml' % ip,auth=auth)
return req.content
def view_edit(name=None):
"""edit or creates a new page
.. note:: this is a bottle view
if no page name is given, creates a new page.
Keyword Arguments:
:name: (str) -- name of the page (OPTIONAL)
Returns:
bottle response object
"""
response.set_header('Cache-control', 'no-cache')
response.set_header('Pragma', 'no-cache')
filename = get_filename(name)
if os.path.exists(filename):
file_handle = open(filename, 'r', encoding='utf-8')
content = file_handle.read()
else:
content = get_default_view(name)
return template('edit',
type="edit",
name=get_id(name),
breadcrumbs=get_breadcrumbs(name),
content=content)
def track(id):
details = Tracker().track(id)
if details != None:
response.set_header('Content-Type', 'application/json')
return json.dumps(details, cls=DateTimeEncoder, sort_keys=True, indent=4, separators=(',', ': '))
else:
abort(404, 'Consignment details not Found')
def view_history(name, gitref):
"""serve a page name from git repo (an old version of a page)
.. note:: this is a bottle view
* this is a GET only method : you can not change a committed page
Keyword Arguments:
:name: (str) -- name of the rest file (without the .rst extension)
:gitref: (str) -- hexsha of the git commit to look into
Returns:
bottle response object or 404 error page
"""
response.set_header('Cache-control', 'no-cache')
response.set_header('Pragma', 'no-cache')
content = read_committed_file(gitref, name + '.rst')
if content:
html_body = publish_parts(content,
writer=HisWriter(),
settings=None,
settings_overrides=None)['html_body']
history = commit_history(name + '.rst')
return template('page',
type="history",
name=name,
extended_name=None,
is_repo=check_repo(),
history=history,
gitref=gitref,
content=html_body)
else:
return abort(404)
def aggregate_discursos(word):
response.set_header('Content-Type', 'application/json')
response.set_header('Access-Control-Allow-Origin', '*')
entity = db['discursos'].find({ "keywords" : word}, { "integra" : 1, "orador_nome" : 1, "orador_uf" : 1, "orador_partido" : 1 })
discursos = {}
for d in entity:
discurso_stripped = ''
for line in d['integra'].split('\n'):
try:
line.index(word)
discurso_stripped = discurso_stripped + line + "\n"
except:
pass
deputado = d['orador_nome']+d['orador_partido']+d['orador_uf']
if discursos.has_key(deputado):
discursos[deputado]['discursos'].append(discurso_stripped)
else:
discursos[deputado] = {}
discursos[deputado]['orador_nome'] = d['orador_nome']
discursos[deputado]['orador_uf'] = d['orador_uf']
discursos[deputado]['orador_partido'] = d['orador_partido']
discursos[deputado]['discursos'] = [discurso_stripped]
resposta = []
for d in discursos:
tmp = discursos[d]
tmp["id"] = d
resposta.append(tmp)
resposta = json.dumps(resposta, default=json_util.default)
if not entity:
abort(404, 'No document with id %s' % query)
return resposta
def upload():
metainfo_file = request.files.get("metainfo-file")
swarm = Swarm.from_metainfo_file(metainfo_file.file, metainfo_file.filename)
response.set_header("Content-Type", "application/x-bittorrent")
response.set_header("Content-Disposition",
"filename={name}.torrent".format(name=swarm.name()))
return swarm.to_metainfo()
def wrapper(*args, **kwargs):
def expire(when):
for t in [k for k in _times.keys()]:
if (when - t) > timeout:
del(_cache[_times[t]])
del(_times[t])
now = time.time()
try:
item = _cache[request.urlparts]
if 'If-Modified-Since' in request.headers:
try:
since = time.mktime(email.utils.parsedate(request.headers['If-Modified-Since']))
except:
since = now
if item['mtime'] >= since:
expire(now)
abort(304,'Not modified')
for h in item['headers']:
response.set_header(str(h), item['headers'][h])
body = item['body']
response.set_header('X-Source', 'Worker Cache')
except KeyError:
body = callback(*args, **kwargs)
item = {
'body': body,
'headers': response.headers,
'mtime': int(now)
}
_cache[request.urlparts] = item
_times[now] = request.urlparts
expire(now)
return body
def master_json(self):
ret = {"status": "OK",
"body": self.helper_get_master_struct()
}
response.set_header('Cache-Control', 'No-store')
return json.dumps(ret)
def random_image(db):
'''
Returns a random image from the database. This is MySQL-specific at the moment.
'''
image = db.query(Image).order_by(func.rand()).first()
response.set_header('Content-Type', 'image/%s' % image.filetype)
return str(image.data)
def view_quick_save_page(name=None):
"""quick save a page
.. note:: this is a bottle view
* this view must be called with the PUT method
write the new page content to the file, and not not commit or redirect
Keyword Arguments:
:name: (str) -- name of the rest file (without the .rst extension)
Returns:
bottle response object (200 OK)
"""
response.set_header('Cache-control', 'no-cache')
response.set_header('Pragma', 'no-cache')
if request.method == 'PUT':
if name is None:
# new file
if len(request.forms.filename) > 0:
name = request.forms.filename
if name is not None:
filename = "{0}.rst".format(name)
file_handle = open(filename, 'w')
content = request.body.read()
content = content.decode('utf-8')
file_handle.write(content.encode('utf-8'))
file_handle.close()
return "OK"
else:
return abort(404)
def paper_summary_bets(strategy_id):
bets = list(db[PAPER_BETS].find({'strategy_id': ObjectId(strategy_id)}, fields={'_id': 0}))
for bet in bets:
bet['strategy_id'] = str(bet['strategy_id'])
json_bets = json.dumps(bets, default=to_json)
response.set_header('Content-Type', 'text/html')
return template('templates/paper-bets', json_bets=json_bets)
def picture(name):
rows=session.query(People).filter(People.name==name)
if rows:
response.set_header('content_type', 'image/jpeg')
return rows[0].picture
else:
raise bottle.HTTPError(500,'No picture')
def nocacheheaders(euid):
location = 'http://lorempixel.com/100/100/'
response.set_header('Location', location)
response.status = 302
return 'Found'
def service(self):
base = self.getBaseUrl()
response.set_header('Content-type', 'text/xml')
ret = ''
ret += "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>"
ret += "\n<TileMapService version=\"1.0.0\" services=\"%s\">" % (base,)
ret += "\n\t<Title>%s v%s</Title>" % (self.server_name, self.server_version)
ret += "\n\t<Abstract />"
ret += "\n\t<TileMaps>"
for dbfile in glob.glob('*.mbtiles'):
if not os.path.isfile(dbfile):
continue
try:
db = sqlite3.connect(dbfile)
params = self.readparams(db)
name = htmlspecialchars(params['name'])
identifier = dbfile.replace('.mbtiles', '')
ret += ('\n\t\t<TileMap title="%s" srs="OSGEO:41001" ' +
'profile="global-mercator" href="%s1.0.0/%s" />'
) % (name, base, identifier)
except sqlite3.DatabaseError:
pass
ret += "\n\t</TileMaps>"
ret += "\n</TileMapService>"
return ret
def get_image(md5sum):
'''
Returns the image from the database.
'''
image = db.images.find_one({'md5': md5sum})
response.set_header('Content-Type', 'image/%s' % image['filetype'])
return str(image['data'])
def api():
log.debug('Handling request for {0}.'.format(request.fullpath))
# these are really basic, don't check much
function = request.query.t or pynab.api.api_error(200)
for r, func in pynab.api.functions.items():
# reform s|search into ^s$|^search$
# if we don't, 's' matches 'caps' (s)
r = '|'.join(['^{0}$'.format(r) for r in r.split('|')])
if re.search(r, function):
dataset = dict()
dataset['get_link'] = get_link
data = func(dataset)
output_format = request.query.o or 'xml'
if output_format == 'xml':
# return as xml
response.set_header('Content-type', 'application/rss+xml')
return data
elif output_format == 'json':
# bottle auto-converts into json
return xmltodict.parse(data)
else:
return pynab.api.api_error(201)
# didn't match any functions
return pynab.api.api_error(202)
def get(name=None):
query = {}
if name is not None:
query['name'] = name
response.set_header('Content-Type', 'application/json')
return json.dumps(list(db.phrases.find(query)), default=default)
def events_json():
'''
much like http://localhost:9200/anthracite/event/_search?q=*:*&pretty=true
but: displays only the actual events, not index etc, they are sorted, and uses unix timestamps
'''
response.set_header("Access-Control-Allow-Origin", "*")
response.set_header("Access-Control-Allow-Credentials", "true")
response.set_header("Access-Control-Allow-Methods", "OPTIONS, GET, POST")
response.set_header(
"Access-Control-Allow-Headers",
"Content-Type, Depth, User-Agent, X-File-Size, X-Requested-With, If-Modified-Since, X-File-Name, Cache-Control"
)
return {"events": backend.get_events_raw()}
def short():
fortune = subprocess.run (
['fortune', '-s'],
stdout = subprocess.PIPE,
).stdout.decode()
r = res()
r.get('collection').update (dict (
items = [
dict (
href = mk_url ('/'),
data = [
dict (name = 'fortune', value = fortune)
],
)
],
))
response.set_header ('Content-Type', 'application/vnd.collection+json')
return json.dumps (r)
def disk_create(hypervisor, host, guest_id):
"""
Create a disk for a given guest
::
POST /:hypervisor/:host/guests/:guest_id/disks
"""
response.content_type = "application/json"
manager = create_manager(hypervisor, host)
data = request.body.readline()
if not data:
abort(400, 'No data received')
data = json.loads(data)
disk = manager.disk_create(guest_id, data)
location = "/%s/%s/guests/%s/disks/%s" % (hypervisor, host, guest_id,
disk["id"])
response.set_header("Location", location)
return json.dumps(disk)
def snapshot_create(hypervisor, host, guest_id):
"""
Create a snapshot for a given guest
::
POST /:hypervisor/:host/guests/:guest_id/snapshots
"""
response.content_type = "application/json"
manager = create_manager(hypervisor, host)
data = request.body.readline()
if not data:
abort(400, 'No data received')
data = json.loads(data)
snapshot = manager.snapshot_create(guest_id, data.get('name'))
location = "/%s/%s/guests/%s/snapshots/%s" % (hypervisor, host, guest_id,
snapshot["id"])
response.set_header("Location", location)
return json.dumps(snapshot)
def proxy_request():
""" Called from a bottle request context.
Proxies the call transparently to the graphite server.
"""
url = config.graphite_url + request.path + '?' + request.query_string
if request.method == 'POST':
r = requests.post(url,
data=request.body.read(),
headers=request.headers,
stream=True)
else:
r = requests.get(url, headers=request.headers, stream=True)
# Relay headers intact
for k, v in r.headers.items():
if not is_hop_by_hop(k):
response.set_header(k, v)
response.status = r.status_code
return r.raw.read()
def wrapper(*args, **kwargs):
response.set_header("Access-Control-Allow-Origin", "*")
response.set_header("Content-Type", "application/json")
response.set_header("Access-Control-Allow-Methods",
"GET, POST, OPTIONS")
response.set_header("Access-Control-Allow-Headers",
"Access-Control-Allow-Origin, Content-Type")
# skip the function if it is not needed
if request.method == 'OPTIONS':
return
return func(*args, **kwargs)
def check_auth(self):
user, password = request.auth or (None, None)
if user is None or password is None:
response.set_header('WWW-Authenticate', 'Basic realm="private"')
raise BasicAuthenticationError
credentials = {
"user": user,
"password": password
}
with self.cache_user_password_lock:
if (user, password) in self.cache_user_password:
return user
try:
self.users.check_credentials(credentials)
with self.cache_user_password_lock:
self.cache_user_password[(user, password)] = user
return user
except AuthenticationError:
response.set_header('WWW-Authenticate', 'Basic realm="private"')
raise BasicAuthenticationError
def getTotalUploaders():
response.set_header("Access-Control-Allow-Origin", "*")
db = sqlite3.connect(Settings.MONITOR_DB)
uploaders = collections.OrderedDict()
limit = request.GET.get('limit', '20').strip()
query = """SELECT name, SUM(hits) AS total
FROM uploaders
GROUP BY name
ORDER BY total DESC
LIMIT """ + limit
results = db.execute(query)
for row in results:
uploaders[row[0].encode('utf8')] = row[1]
db.close()
return simplejson.dumps(uploaders)
def callback():
response.set_header('Content-Type', 'application/json; charset=utf-8')
lat = request.query.lat
lon = request.query.lon
if lat is None or lon is None:
return "{'error': 'both lat and lon parameters are required'}"
try:
lat = float(lat)
lon = float(lon)
except:
return "{'error': 'both lat and lon must be numbers'}"
result = polyPoint(lat, lon)
if result is False:
return "{'error': 'unknown location'}"
return json.dumps(result, ensure_ascii=False)
def save_posto():
"""
Processa o POST para salvar um novo registro de posto
"""
# Le o parametro api_key, enviado no POST
api_key = request.forms.api_key
if not api_key:
return abort(code=401, text="Unauthorized. API Key is mandatory")
# Busca um usuario pela chave da API passado no POST
usuario = Usuario.get(Usuario.api_key == api_key)
if not usuario:
return abort(code=401, text="Unauthorized. Invalid API Key")
# Le o parametro nome, enviado no POST
nome = request.forms.name
if not nome:
return abort(code=400, text="Bad Request. Field \"name\" is required")
# Le o parametro latitude, enviado no POST
latitude = request.forms.latitude
if not latitude:
return abort(code=400,
text="Bad Request. Field \"latitude\" is required")
# Le o parametro longitude, enviado no POST
longitude = request.forms.longitude
if not longitude:
return abort(code=400,
text="Bad Request. Field \"longitude\" is required")
posto = Posto(nome=nome, latitude=latitude, longitude=longitude)
posto.save()
last_id = get_last_id(table='posto')
response.set_header('Content-Type', 'text/plain')
response.status = 201
response.body = "/postos/%d" % last_id
return response
def view_edit(name=None):
"""Edit or creates a new page.
.. note:: this is a bottle view
if no page name is given, creates a new page.
Keyword Arguments:
:name: (str) -- name of the page (OPTIONAL)
Returns:
bottle response object
"""
response.set_header('Cache-control', 'no-cache')
response.set_header('Pragma', 'no-cache')
if name is None:
# new page
return template('edit',
type="edit",
name=name,
extended_name=None,
is_repo=check_repo(),
history=[],
gitref=None,
today=datetime.datetime.now().strftime("%Y%m%d"),
content="")
else:
files = glob.glob("{0}.rst".format(name))
if len(files) > 0:
file_handle = open(files[0], 'r')
return template('edit',
type="edit",
name=name,
extended_name=None,
is_repo=check_repo(),
history=[],
gitref=None,
today=datetime.datetime.now().strftime("%Y%m%d"),
content=file_handle.read())
else:
return abort(404)
def getprimarycolor():
response.headers['Access-Control-Allow-Origin'] = '*'
response.content_type = "text/plain"
response.set_header("Cache-Control", "public, max-age=600")
url = request.query["url"] # pylint: disable=unsubscriptable-object
filecache = ""
filename = "files/" + url.split("/")[len(url.split("/")) - 1]
if "/api/v1/getbanner" in url:
filename = "banners/" + url.split("/")[len(url.split("/")) -
1] + ".jpg"
if os.path.exists("filecache"):
f = open("filecache", "r")
x = f.readlines()
f.close()
for i in x:
if i.split("#")[0] == filename:
filecache = i.split("#")[1]
if not filecache == "":
return filecache
else:
if not "/api/v1/getbanner" in url:
subprocess.Popen(["wget", "-O", filename, url],
shell=False).wait()
color_thief = ColorThief(filename)
dominant_color = color_thief.get_color()
x = str(dominant_color).replace("(",
"").replace(" ",
"").replace(")", "")
f = open("filecache", "a+")
f.write(filename + "#" + x + "\n")
return x
else:
if not "/api/v1/getbanner" in url:
subprocess.Popen(["wget", "-O", filename, url], shell=False).wait()
color_thief = ColorThief(filename)
dominant_color = color_thief.get_color()
x = str(dominant_color).replace("(", "").replace(" ",
"").replace(")", "")
f = open("filecache", "a+")
f.write(filename + "#" + x + "\n")
return x
def topic_json(k, topic_no, N=40):
etag = _generate_etag(self.v[k])
#Check for an "If-None-Match" in the request
if request.get_header('If-None-Match', '') == etag:
response.status = 304
return "Not Modified"
if k not in self.topic_range:
response.status = 400 # Not Found
return "No model for k = {}".format(k)
#response.set_header('Cache-Control', 'max-age=120')
response.set_header('Etag', etag)
response.content_type = 'application/json; charset=UTF8'
try:
N = int(request.query.n)
except:
pass
if N > 0:
data = self.v[k].dist_top_doc([topic_no])[:N]
else:
data = self.v[k].dist_top_doc([topic_no])[N:]
data = reversed(data)
docs = [doc for doc, prob in data]
doc_topics_mat = self.v[k].doc_topics(docs)
docs = self.get_docs(docs, id_as_key=True)
js = []
for doc_prob, topics in zip(data, doc_topics_mat):
doc, prob = doc_prob
struct = docs[doc]
struct.update({'prob': float(1 - prob),
'topics': dict([(text(t), float(p)) for t, p in topics])})
js.append(struct)
return json.dumps(js)
def put_one(url_params, db):
# get & check the json from the body
while True:
try:
item = request.json
if item is None:
raise ValueError
if not item.viewkeys() & {
'model', 'brand', 'image', 'screensize', 'os'
}:
raise ValueError
if not is_float(item['screensize']):
raise ValueError
if not is_integer(url_params):
raise KeyError
else:
break
except ValueError:
# send 400, when incorrect json
abort(400,
"Incorrect JSON (also make sure screensize is a number)")
except KeyError:
# send 400, when id is not an integer
abort(400, "Id is not an integer")
# go do sQl
db.execute(
"""UPDATE phones
SET brand=?, model=?, os=?, image=?,
screensize=? WHERE id=?""",
(item['brand'], item['model'], item['os'], item['image'],
item['screensize'], url_params))
# set headers for response
response.content_type = 'application/json'
response.set_header('Content-Language', 'en')
# return a response
model = item.get('model')
brand = item.get('brand')
responsJ = {"Updated": "item", "model": model, "brand": brand}
return json.dumps(responsJ)
def wrapper(*args, **kwargs):
config = Config()
if self.name in route.skiplist:
return callback(*args, **kwargs)
try:
data = callback(*args, **kwargs)
# catch validation errors from the controller
except (BaseError, ValidationError, ConnectionError, Exception) as e:
# create a standardized error object
data = {
'opstat': 'error'
}
if hasattr(e, 'message') and e.message:
data['error'] = e.message
elif hasattr(e, 'msg') and e.msg:
data['error'] = e.msg
else:
data['error'] = unicode(e)
if hasattr(e, 'fields') and isinstance(e.fields, dict):
data['fields'] = e.fields
if hasattr(e, 'returned') and isinstance(e.returned, dict):
data['response'] = e.returned
if not isinstance(e, ValidationError):
Log.get_instance().exception(
"Error tracked: \Request: %s\nMessage: %s\nFields: %s\nResponse: %s" % (
request,
e.message,
getattr(e, 'fields', None),
getattr(e, 'response', None)
)
)
# return server error response
response.status = 500
if config.debug is True:
data['traceback'] = traceback.format_exc()
response.set_header('Content-Type', 'application/json')
return json.dumps(data)
def gen():
global pdf
global pdf_key
global pdf_name
print("gen")
del pdf
pdf = io.BytesIO()
profil = {}
for (k, v) in request.params.allitems():
if (k == 'raisons'):
profil['RAISONS'] = [v]
else:
profil[k.upper()] = v
if ('AUTO' in profil):
if ('FAIT_LE' in profil):
del profil['FAIT_LE']
del profil['FAIT_H']
del profil['FAIT_M']
del profil['SORT_LE']
del profil['SORT_H']
del profil['SORT_M']
pdf.seek(0)
pdf.write(make_attestation(profil).read())
print(type(pdf))
pdf_name = "attestation-%s.pdf" % make_pdf_name(profil)
pdf_key = "%s.pdf" % uuid.uuid4().hex
if request.headers.get('X-Requested-With') == 'XMLHttpRequest':
return pdf_key
else:
response.set_header('Content-type', 'application/pdf')
response.set_header("Content-Disposition",
"attachment; filename=%s" % pdf_name)
response.content_length = len(pdf.getvalue())
pdf.seek(0)
return pdf.getvalue()
def agregarRegistro():
response.set_header('Content-Type', 'application/json')
if not request.json:
return '{"R":400,"D":"Cuerpo Vacio"}'
if not 'personas' in request.json:
return '{"R":400,"D":"No hay personas"}'
if not str(request.json['personas']).isnumeric():
return '{"R":400,"D":"personas no es un número"}'
#Si llega aqui es que si hay personas
con_bd = sqlite3.connect('database.sqlite')
cursor_principal = con_bd.cursor()
SQL = "insert into registro values (?, datetime('now'))"
cursor_principal.execute(SQL, (request.json['personas'], ))
con_bd.commit()
cursor_principal.close()
con_bd.close()
a = {"R": 201}
return json.dumps(a)
def get_url_upload():
import json
# url = request.forms.get('url') 获取用户为文件定义的名字,一定要发布出去才可以使用
response.set_header('Access-Control-Allow-Origin','*')
data = eval((request.body.readlines()[0]).decode('utf8'))
import requests
page = requests.get(data['url'] , headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'})
page.encoding = 'utf8'
f = page.text
md5 = hashlib.md5()
md5.update(data['url'].encode('utf'))
filename = md5.hexdigest()
ans = analyse.crawl_sample(filename , f , 1)
ans['grade'] = data['grade']
print(ans['grade'])
number_reader = -1
if ans != None :
# 获得了对应文章的标签属性 , ans是一个含有grade但是没有number_reader的字典
number_reader = get_result(ans)
# 发送信号单元
return json.dumps({'result': int(number_reader)} , ensure_ascii = False , skipkeys = True)
def index():
response.headers['Access-Control-Allow-Origin'] = '*'
response.headers['Access-Control-Allow-Methods'] = 'PUT, GET, POST, DELETE, OPTIONS'
response.headers['Access-Control-Allow-Headers'] = 'Origin, Accept, Content-Type, X-Requested-With, X-CSRF-Token'
command = "none"
if request.method == 'POST':
command = request.POST['command']
print(command)
arduino_command = None
if(command):
print(command+"\n")
ser.write(command.encode()+"\n")
response.set_header('Access-Control-Allow-Origin', '*')
result = "ok: "+command
return result
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
def get_log(self,record_id):
'''
Get log file for report.
'''
##print 'querylog()'
#db=self.getDB()
report=self.db["report_data"]
record=report.find_one({"_id":int(record_id)});
if not record:
abort(400,'No record found!')
elif ("log" not in record):
abort(400,"No log file!")
else:
#fs=self.getfs()
if not self.fs.exists(record['log']):
abort(400,'File not found!')
else:
log=self.fs.get(record['log'])
response.set_header('Content-Type','application/x-download')
response.set_header('Content-Disposition','attachment; filename=log_'+record_id+'.zip',True)
return log
def links(n):
try:
n = int(n)
except:
n = None
if n == 1:
response.set_header('Link',
'</links/2>; rel="next", </links/3>; rel="last"')
elif n == 2:
response.set_header(
'Link',
'</links/3>; rel="next", </links/3>; rel="last", </links/1>; rel="prev", </links/1>; rel="first"'
)
elif n == 3:
response.set_header('Link',
'</links/1>; rel="prev", </links/1>; rel="first"')
elif n is None:
response.set_header('Link', '</links/none>; rel="self"')
else:
response.set_header('Link', '</links/1>')
return normal_formsdict()
def tag_create(hypervisor, host, guest_id):
"""
Create a new tag for a given guest
::
POST /:hypervisor/:host/guests/:guest_id/tags
"""
response.content_type = "application/json"
manager = create_manager(hypervisor, host)
data = request.body.readline()
if not data:
abort(400, 'No data received')
data = json.loads(data)
tag = manager.tag_create(guest_id, data.get('name'))
#TODO: Should we return the Location for the first tag?
location = "/%s/%s/guests/%s/tags/%s" % (hypervisor, host, guest_id,
tag[0])
response.set_header("Location", location)
return json.dumps(tag)
def hit_list():
try:
response.set_header("Access-Control-Allow-Origin", "*")
stub_day = str(request.query.day)
page = int(request.query.page)
model = str(request.query.model)
status = str(request.query.status)
symbol = str(request.query.symbol)
size = int(request.query.size)
retlist = mysql_client.query_stock_hit_page_list(
symbol, status, model, page)
total = mysql_client.query_stock_hit_page_count() * size
#封装当前价格
if retlist != None and len(retlist) > 0:
retlist = compose_cur_prices(retlist)
return '{"total":' + str(
total) + ', "msg":"success", "res":' + json.dumps(
retlist, cls=DateEncoder) + '}'
return '{"total":20, "msg":"success", "res":[]}'
except Exception, e:
traceback.print_exc()
def query_paginate(resources, arguments):
"""Return the resources paginated
Args:
resources(list): List to paginate
arguments(FormsDict): query arguments
Returns:
list: Paginated resource (asc or desc)
"""
if '_page' not in arguments:
return resources
page = int(arguments['_page'])
limit = 10 if '_limit' not in arguments else int(arguments['_limit'])
chunk_data = list(chunk_list(resources, limit))
results = chunk_data[page - 1]
link_header = build_link_header(request, page, len(chunk_data))
response.set_header("Link", link_header)
return results
def get_nfo(dataset=None):
if auth():
id = request.query.guid or None
if id:
with db_session() as db:
release = db.query(Release).join(NFO).filter(
Release.id == id).first()
if release:
data = release.nfo.data
response.set_header('Content-type', 'application/x-nfo')
response.set_header(
'Content-Disposition',
'attachment; filename="{0}"'.format(
release.search_name.replace(' ', '_') + '.nfo'))
return gzip.decompress(data)
else:
return api_error(300)
else:
return api_error(200)
else:
return api_error(100)
def sync(start_id, count):
'''
Data sync interface for other database.Should be invoked locally.
Paramenters:
startid=id(start from 1)
count=count
Return:
Headers:
Content-Type:application/json
Body:
A json array and every element in the array is a json document.
array:[{},{}]
document:{_id,category,type,name,info,occur_time,receive_time,uuid,sys_info:{}}
'''
brstore_url = brconfig.BRSTORE + "/record/sync?startid=%d&count=%d" % (
start_id, count)
data = json.loads(access(brstore_url))
response.set_header("Content-Type", "application/json")
return data
def raw_access(url, headers=None, data=None):
req = urllib2.Request(url)
if data != None:
req.add_data(data)
if headers != None:
for key in headers:
req.add_header(key, headers[key])
req.add_header("x-user", "brquery")
req.add_header("x-password", "Redis123")
f = urllib2.urlopen(req)
m = f.info()
contentType = m.getheader("Content-Type")
response.set_header("Content-Type", contentType)
if contentType == "application/x-download":
d = m.getheader("Content-Disposition")
if d != None:
response.set_header("Content-Disposition", d)
return f
else:
return f.readline()
def getTotalSchemas():
response.set_header("Access-Control-Allow-Origin", "*")
db = mariadb.connect(user=Settings.MONITOR_DB['user'],
password=Settings.MONITOR_DB['password'],
database=Settings.MONITOR_DB['database'])
schemas = collections.OrderedDict()
query = """SELECT `name`, SUM(`hits`) AS `total`
FROM `schemas`
GROUP BY `name`
ORDER BY `total` DESC"""
results = db.cursor()
results.execute(query)
for row in results:
schemas[str(row[0])] = row[1]
db.close()
return simplejson.dumps(schemas)
def upload():
response.set_header("Access-Control-Allow-Origin", "*")
try:
# Body may or may not be compressed.
message_body = get_decompressed_message()
except zlib.error as exc:
# Some languages and libs do a crap job zlib compressing stuff. Provide
# at least some kind of feedback for them to try to get pointed in
# the correct direction.
response.status = 400
logger.error("gzip error with %s: %s" %
(get_remote_address(), exc.message))
return exc.message
except MalformedUploadError as exc:
# They probably sent an encoded POST, but got the key/val wrong.
response.status = 400
logger.error("Error to %s: %s" % (get_remote_address(), exc.message))
return exc.message
statsCollector.tally("inbound")
return parse_and_error_handle(message_body)
