def POST_editor(self, id):
anime = model.get_anime(id)
episodes = model.get_episodes(id)
editorForm = self.editorForm(anime)
if not editorForm.validates():
return render.anime(anime,episodes,self.episodeForm,editorForm)
model.update_anime(id, web.input().alternativeTitle, web.input().releaseGroup, web.input().location, int(web.input().quality))
return render.anime(anime,episodes,self.episodeForm,editorForm)
def POST_skip(self, id):
anime = model.get_anime(id)
ep = model.get_episode(id, web.input().episode)
if ep.wanted == 1:
model.skipped_episode(id, web.input().episode)
return "Skipped episode %s successfully" % web.input().episode
else:
model.wanted_episode(id, web.input().episode)
return "Added episode %s successfully" % web.input().episode
def POST_skip(self, id):
anime = model.get_anime(id)
ep = model.get_episode(id, web.input().episode)
if ep.wanted == 1:
model.skipped_episode(id, web.input().episode)
return "Skipped episode %s successfully" % web.input().episode
else:
model.wanted_episode(id, web.input().episode)
return "Added episode %s successfully" % web.input().episode
def uploadImage(self):
if (len(self.request('qqfile')) > 100):
log.info("*** == %s" % type(web.input()['qqfile']))
data = web.input()['qqfile']
else:
data = web.data()
imageId = ImageServer.add(self.db, data, 'giveaminute', [100, 100])
return imageId
def POST_snatch(self, id):
anime = model.get_anime(id)
downloader = Downloader()
downloader.anime = anime
downloader.episode = web.input().episode
if (downloader.download()):
model.snatched_episode(id, web.input().episode)
return "Snatched episode %s successfully" % web.input().episode
else:
return "Couldn't snatch episode %s" % web.input().episode
def POST_snatch(self, id):
anime = model.get_anime(id)
downloader = Downloader()
downloader.anime = anime
downloader.episode = web.input().episode
if (downloader.download()):
model.snatched_episode(id, web.input().episode)
return "Snatched episode %s successfully" % web.input().episode
else:
return "Couldn't snatch episode %s" % web.input().episode
def GET(self):
inputs = web.input(id=None, num_bids=None)
web.header("Content-Type", "application/json")
try:
if not inputs.id:
raise APIRequestException("No auction ID was supplied in the 'id' parameter.")
if inputs.num_bids == None:
raise APIRequestException("No number of bids was supplied in the 'num_bids' parameter.")
# user validation
user_name = user_controller.UserController.validate_cookie()
if user_name is None:
raise APIRequestException("Not logged in!")
result = auction_controller.AuctionController.attach_autobidder(
auction_id=int(inputs.id), user_name=user_name, num_bids=inputs.num_bids
)
result = json.dumps({"result": result})
logging.debug("/auction_add_pending_bids_for_user response: {}".format(result))
return result
except APIRequestException, exception:
logging.info("/auction_add_pending_bids_for_user response to bad request: {}".format(result))
return json.dumps({"result": False, "error": unicode(exception)})
def GET(self):
inputs = web.input()
web.header("Content-Type", "application/json")
try:
## STUB ##
# TODO: fill in this stub
result = []
result.append({username: "******", price: "1.20", bidtime: "05:14:23 PM"})
result.append({username: "******", price: "1.19", bidtime: "05:14:15 PM"})
result.append({username: "******", price: "1.18", bidtime: "05:14:10 PM"})
result.append({username: "******", price: "1.17", bidtime: "05:14:09 PM"})
result.append({username: "******", price: "1.16", bidtime: "05:14:02 PM"})
result.append({username: "******", price: "1.15", bidtime: "05:13:58 PM"})
result.append({username: "******", price: "1.14", bidtime: "05:13:49 PM"})
result.append({username: "******", price: "1.13", bidtime: "05:13:42 PM"})
result.append({username: "******", price: "1.12", bidtime: "05:13:36 PM"})
result = json.dumps({"result": result})
logging.debug("/auction_recent_bids response: {}".format(result))
return result
except APIRequestException, exception:
logging.info("/auction_recent_bids response to bad request: {}".format(result))
return json.dumps({"result": False, "error": unicode(exception)})
def GET(self):
inputs = web.input(count=None)
web.header('Content-Type', 'application/json')
try:
if not inputs.count:
raise APIRequestException(
"The number of auctions to list was not provided in the 'count' parameter."
)
auctions = auction_controller.AuctionController.auctions_list_current(
inputs.count)
# Build the JSON payload
result = []
for elem in auctions:
result.append(generate_auction_dict(elem))
result = json.dumps({'result': result})
logging.debug("/auctions_list_current response: {}".format(result))
return result
except APIRequestException, exception:
logging.info(
"/auctions_list_current response to bad request: {}".format(
result))
return json.dumps({"result": False, "error": unicode(exception)})
def GET(self):
inputs = web.input(id=None)
web.header('Content-Type', 'application/json')
try:
if not inputs.id:
raise APIRequestException(
"No auction ID in the 'id' parameter.")
# user validation
user_name = user_controller.UserController.validate_cookie()
if user_name is None:
raise APIRequestException("Not logged in.")
result = auction_controller.AuctionController.cancel_autobidder(
auction_id=int(inputs.id), user_name=user_name)
result = json.dumps({'result': result})
logging.debug(
"/auction_cancel_pending_bids_for_user response: {}".format(
result))
return result
except APIRequestException, exception:
logging.info(
"/auction_cancel_pending_bids_for_user response to bad request: {}"
.format(result))
return json.dumps({"result": False, "error": unicode(exception)})
def POST(self):
data = web.input()
message = Message.Put(data.Identity, data.Content, data.RoomId)
if message:
channels = memcache.get(data.RoomId) or []
for channelId in channels:
channel.send_message(channelId, message.ToJSON())
def GET(self):
vars = web.input(name = 'web')
code = web.websafe(vars.code)
proxy_url = get_proxy_url(code)
url,port = proxy_url.split(':')
port = int(port)
return json.dumps({"code":code,"proxy_url":url,"proxy_port":port})
def POST(self, id):
i = web.input()
# assuming that the name of the hidden field is "form"
if i.form == "editor":
return self.POST_editor(id)
else:
return self.POST_snatch(id)
def GET(self):
query = web.input()
try:
nzbName = query.nzbName
except:
nzbName = None
if (process.processEpisode(query.dir, nzbName)):
return "Successfully processed episode."
return "Episode failed to process."
def GET(self):
query = web.input()
try:
nzbName = query.nzbName
except:
nzbName = None
if (process.processEpisode(query.dir, nzbName)):
return "Successfully processed episode."
return "Episode failed to process."
def POST(self):
i = web.input()
# determine which form to process based on the hidden value "form"
if i.form == "settings":
return self.POST_settings()
if i.form == "sabnzbd":
return self.POST_sabnzbd()
if i.form == "plex":
return self.POST_plex()
def parameters(self):
"""Gets a ``dict`` of request parameters"""
try:
if not web.input():
return None
except TypeError, e:
import urlparse
querystring = web.ctx.query[1:]
params = urlparse.parse_qs(querystring)
return params
def POST(self):
i = web.input()
# determine which form to process based on the hidden value "form"
if i.form == "settings":
return self.POST_settings()
if i.form == "sabnzbd":
return self.POST_sabnzbd()
if i.form == "plex":
return self.POST_plex()
def parameters(self):
"""Gets a ``dict`` of request parameters"""
try:
if not web.input():
return None
except TypeError, e:
import urlparse
querystring = web.ctx.query[1:]
params = urlparse.parse_qs(querystring)
return params
def GET(self):
xml = StringIO()
rows = web.input(rows='-1').rows
if rows != '-1':
taxonomy.write_xml(xml, taxes, _solr, rows)
else:
taxonomy.write_xml(xml, taxes)
try:
return xml.getvalue()
finally:
xml.close()
def request(self, var):
try:
if not web.input():
return None
except TypeError, e:
logging.info("##### --> [%s] POST %s, trying GET string (%s)" % (var, e, web.ctx.query))
querystring = web.ctx.query[1:]
params = dict([part.split('=') for part in querystring.split('&')])
try:
var = params[var]
except KeyError:
return None
def POST(self):
global taxes
with open(settings.taxonomy_path, 'w') as f:
try:
x = web.input(myfile={})
taxes = [taxonomy.parse_xml(x['myfile'].file)]
raise web.seeother("/static/index.html")
except Exception as e:
taxes = []
raise web.seeother("/static/index.html?%s" % e.message)
finally:
cPickle.dump(taxes, f)
map_terms()
def uploadFile(self):
"""
Handler for the /create/file endpoint. Looks for the variable named
qqfile from the request and saves it to a file on the server.
Return information about the file in a ``dict`` with keys ``id``,
``type``, and ``name``
"""
file_info = {}
# Get file from the request
if (len(self.request('qqfile')) > 100):
log.info("*** == %s" % type(web.input()['qqfile']))
file_name = ''
data = self.request('qqfile')
else:
print web.input()
file_name = self.request('qqfile')
data = web.data()
file_info['name'] = self.request('qqfile') or ''
# Get a file server wrapper
fs = S3FileServer(self.db)
# Determine whether it's an image or another type of file
media_type = file_info['type'] = self.getFileMediaType(data)
# Upload the file to the server
media_id = file_info['id'] = fs.add(data, file_name, make_unique=True)
# If it's an image, upload the thumbnails as well
if media_type == 'image':
self.saveThumbnailImage(fs, media_type, media_id, data, 'small', self.SMALL_THUMB_SIZE)
self.saveThumbnailImage(fs, media_type, media_id, data, 'medium', self.MEDIUM_THUMB_SIZE)
self.saveThumbnailImage(fs, media_type, media_id, data, 'large', self.LARGE_THUMB_SIZE)
return file_info
def GET(self):
inputs = web.input()
web.header("Content-Type", "application/json")
try:
result = user_controller.UserController.user_authenticate_cookie()
result = json.dumps({"result": result})
logging.debug("/user_authenticate_cookie response: {}".format(result))
return result
except APIRequestException, exception:
logging.info("/user_authenticate_cookie response to bad request: {}".format(result))
return json.dumps({"result": False, "error": unicode(exception)})
def request(self, var):
"""Gets the value of the request parameter named ``var``"""
try:
if not web.input():
return None
except TypeError, e:
querystring = web.ctx.query[1:]
params = dict([part.split('=') for part in querystring.split('&')])
try:
var = params[var]
except KeyError:
return None
def request(self, var):
"""Gets the value of the request parameter named ``var``"""
try:
if not web.input():
return None
except TypeError, e:
querystring = web.ctx.query[1:]
params = dict([part.split('=') for part in querystring.split('&')])
try:
var = params[var]
except KeyError:
return None
def GET(self):
inputs = web.input()
web.header('Content-Type', 'application/json')
try:
this_user = user_controller.UserController.validate_cookie()
result = user_controller.UserController.user_logout(this_user)
result = json.dumps({'result': result})
logging.debug("/user_logout response: {}".format(result))
return result
except APIRequestException, exception:
logging.info(
"/user_logout response to bad request: {}".format(result))
return json.dumps({"result": False, "error": unicode(exception)})
def GET(self):
inputs = web.input()
web.header("Content-Type", "application/json")
try:
this_user = user_controller.UserController.validate_cookie()
if not this_user:
raise APIRequestException("Not logged in!")
result = user_controller.UserController.user_info(this_user)
result = json.dumps({"result": result})
logging.debug("/user_info response: {}".format(result))
return result
except APIRequestException, exception:
logging.info("/user_info response to bad request: {}".format(result))
return json.dumps({"result": False, "error": unicode(exception)})
def POST(self):
if web.ctx.get('ip') not in allow:
return 'deny'
data = web.input()
(host, port, time, met, keys, stop) = '', 80, 50, 'ntp', '', '0'
if data.get('method'):
met = data.get('method')
if data.get('host'):
host = data.get('host')
if data.get('port'):
port = data.get('port')
if data.get('time'):
time = data.get('time')
if data.get('key'):
keys = data.get('key')
if data.get('stop'):
stop = data.get('stop')
if host == '':
return 'Host is empyt.'
if keys not in key or keys == '':
return 'Key Error.'
if stop != '0' and stop != '1':
return 'Stop Parameter error.'
ddos = DDoSAttack(host, port, time)
if stop == '1':
if ddos.stop():
return '停止任务成功'
else:
return '停止任务失败'
if met in method:
if met == 'ntp':
if ddos.ntp(thread=100):
return 'NTP 模式，攻击目标IP [{0}] 成功'.format(host)
else:
return 'NTP 模式，攻击目标IP [{0}] 失败'.format(host)
elif met == 'ssdp':
if ddos.ssdp(thread=100):
return 'SSDP 模式，攻击目标IP [{0}] 成功'.format(host)
else:
return 'SSDP 模式，攻击目标IP [{0}] 失败'.format(host)
return 'F**k.'
def GET(self):
inputs = web.input(id=None)
web.header("Content-Type", "application/json")
try:
if not inputs.id:
raise APIRequestException("No auction ID was supplied in the 'id' parameter.")
auction = auction_controller.AuctionController.auctions_status_by_ids(int(inputs.id))
result = generate_auction_dict(auction)
result = json.dumps({"result": result})
logging.debug("/auction_detail response: {}".format(result))
return result
except APIRequestException, exception:
logging.info("/auction_detail response to bad request: {}".format(result))
return json.dumps({"result": False, "error": unicode(exception)})
def GET(self):
inputs = web.input(email=None)
web.header("Content-Type", "application/json")
try:
if not inputs.email:
raise APIRequestException(
'required string parameter "email" was not passed to the server, or was an empty string'
)
result = user_controller.UserController.user_email_exists(inputs.email)
result = json.dumps({"result": result})
logging.debug("/user_email_exists response: {}".format(result))
return result
except APIRequestException, exception:
logging.info("/user_email_exists response to bad request: {}".format(result))
return json.dumps({"result": False, "error": unicode(exception)})
def GET(self):
inputs = web.input(assertion=None)
web.header("Content-Type", "application/json")
try:
this_user = user_controller.UserController.persona_login(inputs.assertion)
if this_user:
result = {"result": True, "username": this_user.username}
else:
result = {"result": False, "error": "invalid credentials"}
result = json.dumps(result)
logging.debug("/persona_login response: {}".format(result))
return result
except APIRequestException, exception:
logging.info("/persona_login response to bad request: {}".format(result))
return json.dumps({"result": False, "error": unicode(exception)})
def GET(self):
inputs = web.input(username=None)
web.header("Content-Type", "application/json")
try:
if inputs.username == None:
raise APIRequestException("no user name in the 'username' parameter")
if inputs.username == "":
raise APIRequestException("username cannot be an empty string")
result = user_controller.UserController.user_username_exists(inputs.username)
result = json.dumps({"result": result})
logging.debug("/user_username_exists response: {}".format(result))
return result
except APIRequestException, exception:
logging.info("/user_username_exists response to bad request: {}".format(result))
return json.dumps({"result": False, "error": unicode(exception)})
def POST(self):
name = web.input().name
ip = web.ctx.ip
cookieName_identity = 'identity'
cookieName_name = 'name'
identity = web.cookies().get(cookieName_identity)
browserId = ''
user = None
if identity:
user = Identity.Update(identity, name, ip, browserId)
if not user:
user = Identity.Put(name, ip, browserId)
web.setcookie(cookieName_identity, user.Id, _cookie_expire_time)
web.setcookie(cookieName_name, user.DisplayName, _cookie_expire_time)
return user.Id
def GET(self):
inputs = web.input(assertion=None)
web.header('Content-Type', 'application/json')
try:
this_user = user_controller.UserController.persona_login(
inputs.assertion)
if this_user:
result = {'result': True, 'username': this_user.username}
else:
result = {'result': False, 'error': 'invalid credentials'}
result = json.dumps(result)
logging.debug("/persona_login response: {}".format(result))
return result
except APIRequestException, exception:
logging.info(
"/persona_login response to bad request: {}".format(result))
return json.dumps({"result": False, "error": unicode(exception)})
def GET(self):
inputs = web.input(id=None)
web.header('Content-Type', 'application/json')
try:
if not inputs.id:
raise APIRequestException(
"No auction ID was supplied in the 'id' parameter.")
auction = auction_controller.AuctionController.auctions_status_by_ids(
int(inputs.id))
result = generate_auction_dict(auction)
result = json.dumps({'result': result})
logging.debug("/auction_detail response: {}".format(result))
return result
except APIRequestException, exception:
logging.info(
"/auction_detail response to bad request: {}".format(result))
return json.dumps({"result": False, "error": unicode(exception)})
def GET(self):
inputs = web.input(id=None)
web.header("Content-Type", "application/json")
try:
if not inputs.id:
raise APIRequestException("No auction ID was supplied in the 'id' parameter.")
# user validation
user = user_controller.UserController.validate_cookie()
if user is None:
raise APIRequestException("Not logged in!")
result = auction_controller.AuctionController.auction_bid(inputs.id, user.username)
result = json.dumps({"result": result})
logging.debug("/auction_bid response: {}".format(result))
return result
except APIRequestException, exception:
logging.info("/auction_bid response to bad request: {}".format(result))
return json.dumps({"result": False, "error": unicode(exception)})
def GET(self):
inputs = web.input(email=None)
web.header('Content-Type', 'application/json')
try:
if not inputs.email:
raise APIRequestException(
'required string parameter "email" was not passed to the server, or was an empty string'
)
result = user_controller.UserController.user_email_exists(
inputs.email)
result = json.dumps({'result': result})
logging.debug("/user_email_exists response: {}".format(result))
return result
except APIRequestException, exception:
logging.info(
"/user_email_exists response to bad request: {}".format(
result))
return json.dumps({"result": False, "error": unicode(exception)})
def GET(self):
inputs = web.input(ids=None)
web.header('Content-Type', 'application/json')
auction_ids = inputs.ids
try:
if not auction_ids:
raise APIRequestException(
"No auction IDs were supplied in the 'ids' parameter.")
# parse the string of IDs into a tuple of ints
sids = auction_ids.split(',')
if len(sids) > 40:
raise APIRequestException(
"Maximum of 40 auction statuses, reduce number of requested auction statuses."
)
ids = []
for sid in sids:
ids.append(int(sid))
ids = tuple(ids) # freeze the ID list
auctions = auction_controller.AuctionController.auctions_status_by_ids(
ids)
# Build the JSON payload
result = []
for elem in auctions:
result.append(generate_auction_dict(elem))
result = json.dumps({"result": result})
logging.debug("/auctions_status_by_id response: {}".format(result))
return result
except APIRequestException, exception:
logging.info(
"/auctions_status_by_id response to bad request: {}".format(
result))
return json.dumps({"result": False, "error": unicode(exception)})
def GET(self):
inputs = web.input()
web.header("Content-Type", "application/json")
try:
# TODO: check that an administrative user issued this request
auctions = auction_controller.AuctionController.auctions_list_all()
# Build the JSON payload
result = []
for elem in auctions:
result.append(generate_auction_dict(elem))
result = json.dumps({"result": result})
logging.debug("/auctions_list_all response: {}".format(result))
return result
except APIRequestException, exception:
logging.info("/auctions_list_all response to bad request: {}".format(result))
return json.dumps({"result": False, "error": unicode(exception)})
def GET(self):
inputs = web.input(username=None)
web.header('Content-Type', 'application/json')
try:
if inputs.username == None:
raise APIRequestException(
"no user name in the 'username' parameter")
if inputs.username == "":
raise APIRequestException('username cannot be an empty string')
result = user_controller.UserController.user_username_exists(
inputs.username)
result = json.dumps({'result': result})
logging.debug("/user_username_exists response: {}".format(result))
return result
except APIRequestException, exception:
logging.info(
"/user_username_exists response to bad request: {}".format(
result))
return json.dumps({"result": False, "error": unicode(exception)})
def GET(self):
inputs = web.input(count=None)
web.header("Content-Type", "application/json")
try:
if not inputs.count:
raise APIRequestException("The number of auctions to list was not provided in the 'count' parameter.")
auctions = auction_controller.AuctionController.auctions_list_current(inputs.count)
# Build the JSON payload
result = []
for elem in auctions:
result.append(generate_auction_dict(elem))
result = json.dumps({"result": result})
logging.debug("/auctions_list_current response: {}".format(result))
return result
except APIRequestException, exception:
logging.info("/auctions_list_current response to bad request: {}".format(result))
return json.dumps({"result": False, "error": unicode(exception)})
def GET(self):
inputs = web.input(ids=None)
web.header("Content-Type", "application/json")
auction_ids = inputs.ids
try:
if not auction_ids:
raise APIRequestException("No auction IDs were supplied in the 'ids' parameter.")
# parse the string of IDs into a tuple of ints
sids = auction_ids.split(",")
if len(sids) > 40:
raise APIRequestException(
"Maximum of 40 auction statuses, reduce number of requested auction statuses."
)
ids = []
for sid in sids:
ids.append(int(sid))
ids = tuple(ids) # freeze the ID list
auctions = auction_controller.AuctionController.auctions_status_by_ids(ids)
# Build the JSON payload
result = []
for elem in auctions:
result.append(generate_auction_dict(elem))
result = json.dumps({"result": result})
logging.debug("/auctions_status_by_id response: {}".format(result))
return result
except APIRequestException, exception:
logging.info("/auctions_status_by_id response to bad request: {}".format(result))
return json.dumps({"result": False, "error": unicode(exception)})
def GET(self):
inputs = web.input()
web.header('Content-Type', 'application/json')
try:
# TODO: check that an administrative user issued this request
auctions = auction_controller.AuctionController.auctions_list_all()
# Build the JSON payload
result = []
for elem in auctions:
result.append(generate_auction_dict(elem))
result = json.dumps({'result': result})
logging.debug("/auctions_list_all response: {}".format(result))
return result
except APIRequestException, exception:
logging.info(
"/auctions_list_all response to bad request: {}".format(
result))
return json.dumps({"result": False, "error": unicode(exception)})
return False
return True
def parameters(self):
"""Gets a ``dict`` of request parameters"""
try:
if not web.input():
return None
except TypeError, e:
import urlparse
querystring = web.ctx.query[1:]
params = urlparse.parse_qs(querystring)
return params
else:
return dict(web.input().items())
def request(self, var):
"""Gets the value of the request parameter named ``var``"""
try:
if not web.input():
return None
except TypeError, e:
querystring = web.ctx.query[1:]
params = dict([part.split('=') for part in querystring.split('&')])
try:
var = params[var]
except KeyError:
return None
def params(name):
aname = "%s[]" % name
p = {aname: []}
for x in getattr(web.input(**p), aname):
yield x
return False
return True
def parameters(self):
"""Gets a ``dict`` of request parameters"""
try:
if not web.input():
return None
except TypeError, e:
import urlparse
querystring = web.ctx.query[1:]
params = urlparse.parse_qs(querystring)
return params
else:
return dict(web.input().items())
def request(self, var):
"""Gets the value of the request parameter named ``var``"""
try:
if not web.input():
return None
except TypeError, e:
querystring = web.ctx.query[1:]
params = dict([part.split('=') for part in querystring.split('&')])
try:
var = params[var]
except KeyError:
return None
def GET(self, fn):
if fn == "taxonomies":
# return taxonomy list
return json.dumps([{
'value': x[0],
'label': str(x[1])
} for x in enumerate(taxes)])
if fn == "taxonomy":
# return taxonomy data, and possibly create/rename/delete a taxonomy
tax_idx = web.input(value=None).value
name = web.input(name=None).name
remove = web.input(remove=False).remove
if tax_idx is None:
if name is None or remove is not False:
return json.dumps({"error": "no taxonomy index specified"})
# create a new taxonomy with specified name
for t in taxes:
if t.name == name:
return json.dumps({
"error":
"a taxonomy with that name already exists"
})
term = taxonomy.Term(name)
taxes.append(term)
term_map["term%s" % term.uid] = term
commit()
return json.dumps({"value": len(taxes) - 1})
try:
tax_idx = int(tax_idx)
except ValueError:
return json.dumps({
"error":
"invalid taxonomy index specified - not an integer"
})
if tax_idx < 0 or tax_idx >= len(taxes):
return json.dumps(
{"error": "invalid taxonomy index specified"})
if remove is not False:
if name is not None:
return json.dumps(
{"error": "name specified for taxonomy removal"})
# delete taxonomy
del taxes[tax_idx]
map_terms()
commit()
return json.dumps({})
if name is not None:
# rename taxonomy
for t in taxes:
if t.name == name:
return json.dumps({
"error":
"a taxonomy with that name already exists"
})
taxes[tax_idx].name = name
commit()
return json.dumps({"value": tax_idx})
# default - fetch taxonomy data
return json.dumps([taxes[tax_idx].for_jtree(_solr)])
if fn == "keywords":
# return keywords for a taxonomy term
term_id = web.input(id=None).id
if term_id is None:
return json.dumps({"error": "no term id specified"})
term = term_map[term_id]
return json.dumps([{
"data": [k],
"metadata": p
} for k, p in term.iter_clues()])
if fn == "documents":
# return documents matching a node (category) (and add/remove a keyword?)
term_id = web.input(id=None).id
if term_id is None:
return json.dumps({"error": "no term id specified"})
term = term_map[term_id]
change = False
for add in params("add"):
term.set_clue(add)
change = True
for remove in params("remove"):
term.delete_clue(remove)
change = True
for toggle in params("toggle"):
term.toggle_clue(toggle)
change = True
if change:
commit()
numFound, docs = taxonomy.get_docs_for_category(_solr, term)
return json.dumps({
"docs": [{
"data": doc
} for doc in docs],
"count": numFound
})
if fn == "suggestions":
# return suggested keywords based on matching documents
term_id = web.input(id=None).id
if term_id is None:
return json.dumps({"error": "no term id specified"})
term = term_map[term_id]
clues = []
for x, _ in term.iter_clues():
clues.append(x)
clues.extend(x.split(' '))
clues = [clue.lower() for clue in clues]
doc_ids = [
x for x in taxonomy.get_doc_ids_for_category(_solr, term)
]
keywords = taxonomy.suggest_keywords(_solr, doc_ids, clues, 7)
return json.dumps([{
"data": [k],
"metadata": True
} for k in keywords])
if fn == "document":
doc_id = web.input(id=None).id
doc = _solr.query(doc_id=doc_id).execute()[0]
ranked = [{
"data": [x[0].uid, str(x[0]),
str(int(x[1] * 10000))]
} for x in taxonomy.classify_doc(doc["text"], taxes)[:18]]
return json.dumps({
"title": doc["title"],
"ranked": ranked,
"text": doc["text"]
})
if fn == "category":
# rename/create/remove a category
category_id = web.input(id=None).id
parent_id = web.input(parent_id=None).parent_id
name = web.input(name=None).name
if category_id is not None:
if category_id not in term_map:
return json.dumps(
{"error": "no such category: %s" % category_id})
category = term_map[category_id]
else:
category = None
if category is not None:
if name is not None:
# rename category
category.name = name
else:
# remove category
category.parent.children.remove(category)
del term_map[category_id]
else:
if name is None:
return json.dumps(
{"error": "no name or category id specified"})
elif parent_id is None:
return json.dumps({"error": "no parent id specified"})
elif parent_id not in term_map:
return json.dumps(
{"error": "no such category: %s" % parent_id})
else:
# create category
parent = term_map[parent_id]
child = parent.create_child(name)
term_map["term%s" % child.uid] = child
commit()
return json.dumps({"id": "term%s" % child.uid})
commit()
return json.dumps({})
raise Exception("No such AJAX function: %s" % fn)
return web.SeeOther(url)
def json(self, obj):
web.header("Content-Type", "application/json")
out = json.dumps(obj)
return out.encode('utf-8')
def stream_json(self,obj):
logging.info("yielding some json")
yield json.dumps(obj)
def request(self, var):
try:
if not web.input():
return None
except TypeError, e:
logging.info("##### --> [%s] POST %s, trying GET string (%s)" % (var, e, web.ctx.query))
querystring = web.ctx.query[1:]
params = dict([part.split('=') for part in querystring.split('&')])
try:
var = params[var]
except KeyError:
return None
else:
var = web.input()[var] if hasattr(web.input(), var) else None
if type(var) is str or type(var) is unicode:
var = util.strip_html(var)
var = var.strip()
if len(var) == 0: return None
var = util.make_unicode(var)
return var
def GET(self):
inputs = web.input()
web.header('Content-Type', 'application/json')
try:
## STUB ##
# TODO: fill in this stub
result = []
result.append({
username: '******',
price: '1.20',
bidtime: '05:14:23 PM'
})
result.append({
username: '******',
price: '1.19',
bidtime: '05:14:15 PM'
})
result.append({
username: '******',
price: '1.18',
bidtime: '05:14:10 PM'
})
result.append({
username: '******',
price: '1.17',
bidtime: '05:14:09 PM'
})
result.append({
username: '******',
price: '1.16',
bidtime: '05:14:02 PM'
})
result.append({
username: '******',
price: '1.15',
bidtime: '05:13:58 PM'
})
result.append({
username: '******',
price: '1.14',
bidtime: '05:13:49 PM'
})
result.append({
username: '******',
price: '1.13',
bidtime: '05:13:42 PM'
})
result.append({
username: '******',
price: '1.12',
bidtime: '05:13:36 PM'
})
result = json.dumps({'result': result})
logging.debug("/auction_recent_bids response: {}".format(result))
return result
except APIRequestException, exception:
logging.info(
"/auction_recent_bids response to bad request: {}".format(
result))
return json.dumps({"result": False, "error": unicode(exception)})
