def get(self):
user = self.GetCurrentUser()
if (not user):
self.respondWithDictionaryAsJSON({"error":"please authenticate by setting the Authorization header to your API key"})
return
cursor = self.request.get("cursor")
if cursor:
cursor = cursor
else:
cursor = None
comments = db.GqlQuery("select * from Comment order by posted_at desc")
if cursor:
comments.with_cursor(start_cursor=cursor)
results = []
for c in comments:
try:
results.append({"id":c.key().id(),
"user":c.user.email(),
"subject":c.subject,
"body":c.body,
"radar":c.radar.number,
"posted_at":str(c.posted_at),
"is_reply_to":c.is_reply_to and c.is_reply_to.key().id() or None})
except Exception:
None
if len(results) == 100:
break
response = {"result":results, "cursor":comments.cursor()}
apiresult = simplejson.dumps(response)
self.respondWithText(apiresult)
def get(self):
page = self.request.get("page")
if page:
page = int(page)
else:
page = 1
count = self.request.get("count")
if count:
count = int(count)
else:
count = 100
comments = db.GqlQuery("select * from Comment order by posted_at desc").fetch(count,(page-1)*count)
result = []
for c in comments:
try:
commentInfo = {
"id":c.key().id(),
"user":c.user.email(),
"subject":c.subject,
"body":c.body,
"radar":c.radar.number,
"created":str(c.posted_at),
}
if c.is_reply_to:
commentInfo["is_reply_to"] = c.is_reply_to.key().id()
result.append(commentInfo)
except Exception:
None # we'll get here if the corresponding radar was deleted
response = {"result":result}
apiresult = simplejson.dumps(response)
self.respondWithText(apiresult)
def get(self):
user = self.GetCurrentUser()
if (not user):
self.respondWithDictionaryAsJSON({"error":"please authenticate by setting the Authorization header to your API key"})
return
cursor = self.request.get("cursor")
if cursor:
cursor = cursor
else:
cursor = None
radars = db.GqlQuery("select * from Radar order by modified desc")
if cursor:
radars.with_cursor(start_cursor=cursor)
results = []
for r in radars:
results.append({"id":r.key().id(),
"title":r.title,
"number":r.number,
"user":r.user.email(),
"status":r.status,
"description":r.description,
"resolved":r.resolved,
"product":r.product,
"classification":r.classification,
"reproducible":r.reproducible,
"product_version":r.product_version,
"created":str(r.created),
"modified":str(r.modified),
"originated":r.originated})
if len(results) == 100:
break
response = {"result":results, "cursor":radars.cursor()}
apiresult = simplejson.dumps(response)
self.respondWithText(apiresult)
def get(self):
m = PAGE_PATTERN.match(self.request.path)
if m:
number = m.group(1)
if (int(number) > 500):
self.error(404)
self.respondWithText('Not found')
return
if (int(number) > 1):
showprev = int(number)-1
else:
showprev = None
shownext = int(number)+1
pagename = "page" + number
biglist = memcache.get(pagename)
if biglist is None:
radars = db.GqlQuery("select * from Radar order by number_intvalue desc").fetch(PAGESIZE,(int(number)-1)*PAGESIZE)
if len(radars) > 0:
path = os.path.join(os.path.dirname(__file__), os.path.join('templates', 'biglist.html'))
biglist = template.render(path, {'radars':radars})
memcache.add(pagename, biglist, 3600) # one hour, but we also invalidate on edits and adds
else:
biglist = "<p>That's all.</p>"
self.respondWithTemplate('page.html', {'pagenumber':number, 'shownext':shownext, 'showprev':showprev, "biglist": biglist})
else:
self.respondWithText('invalid page request')
def get(self):
user = users.GetCurrentUser()
if (not user):
self.respondWithTemplate('please-sign-in.html', {'action': 'view your Radars'})
else:
radars = db.GqlQuery("select * from Radar where user = :1 order by number_intvalue desc", user).fetch(1000)
self.respondWithTemplate('radar-list.html', {"radars": radars})
def get(self):
page = self.request.get("page")
if page:
page = int(page)
else:
page = 1
count = self.request.get("count")
if count:
count = int(count)
else:
count = 100
apiresult = memcache.get("apiresult")
if apiresult is None:
radars = db.GqlQuery("select * from Radar order by number_intvalue desc").fetch(count,(page-1)*count)
response = {"result":
[{"id":r.key().id(),
"classification":r.classification,
"created":str(r.created),
"description":r.description,
"modified":str(r.modified),
"number":r.number,
"originated":r.originated,
"parent":r.parent_number,
"product":r.product,
"product_version":r.product_version,
"reproducible":r.reproducible,
"resolved":r.resolved,
"status":r.status,
"title":r.title,
"user":r.user.email()}
for r in radars]}
apiresult = simplejson.dumps(response)
#memcache.add("apiresult", apiresult, 600) # ten minutes, but we also invalidate on edits and adds
self.respondWithText(apiresult)
def get(self):
page = self.request.get("page")
if page:
page = int(page)
else:
page = 1
comments = db.GqlQuery(
"select * from Comment order by posted_at desc").fetch(
100, (page - 1) * 100)
result = []
for c in comments:
try:
result.append({
"id":
c.key().id(),
"user":
c.user.email(),
"subject":
c.subject,
"body":
c.body,
"radar":
c.radar.number,
"is_reply_to":
c.is_reply_to and c.is_reply_to.key().id() or ""
})
except Exception:
None
response = {"result": result}
apiresult = simplejson.dumps(response)
self.respondWithText(apiresult)
def get(self):
biglist = memcache.get("biglist")
if biglist is None:
radars = db.GqlQuery("select * from Radar order by number_intvalue desc").fetch(100)
path = os.path.join(os.path.dirname(__file__), os.path.join('templates', 'biglist.html'))
biglist = template.render(path, {'radars':radars})
memcache.add("biglist", biglist, 3600) # one hour, but we also invalidate on edits and adds
self.respondWithTemplate('index.html', {"biglist": biglist})
def get(self):
page = self.request.get("page")
if page:
page = int(page)
else:
page = 1
apiresult = memcache.get("apiresult")
if apiresult is None:
radars = db.GqlQuery("select * from Radar order by number desc").fetch(100,(page-1)*100)
response = {"result":[r.key().id() for r in radars]}
apiresult = simplejson.dumps(response)
self.respondWithText(apiresult)
def post(self):
user = self.GetCurrentUser()
if (not user):
self.respondWithTemplate('please-sign-in.html',
{'action': 'add Radars'})
else:
title = self.request.get("title")
number = self.request.get("number")
status = self.request.get("status")
description = self.request.get("description")
resolved = self.request.get("resolved")
product = self.request.get("product")
classification = self.request.get("classification")
reproducible = self.request.get("reproducible")
product_version = self.request.get("product_version")
originated = self.request.get("originated")
radar = Radar(title=title,
number=number,
number_intvalue=int(number),
status=status,
user=user,
description=description,
resolved=resolved,
product=product,
classification=classification,
reproducible=reproducible,
product_version=product_version,
originated=originated,
created=datetime.datetime.now(),
modified=datetime.datetime.now())
radar.put()
memcache.flush_all()
# tweet this.
if 1:
#tweet = ("[rdar://%s] %s: %s" % (number, radar.username(), title))
tweet = ("http://openradar.me/%s %s: %s" %
(number, radar.username(), title))
tweet = tweet[0:140]
secrets = db.GqlQuery("select * from Secret where name = :1",
"retweet").fetch(1)
if len(secrets) > 0:
secret = secrets[0].value
form_fields = {"message": tweet, "secret": secret}
form_data = urllib.urlencode(form_fields)
try:
result = fetch(
"http://sulfur.neontology.com/retweet.php",
payload=form_data,
method=POST)
except Exception:
None # let's not worry about downstream problems
self.redirect("/myradars")
def get(self):
username = self.request.get("user")
user = users.User(username)
searchlist = ""
if user:
query = db.GqlQuery("select * from Radar where user = :1 order by number desc", user)
radars = query.fetch(100)
if len(radars) > 0:
path = os.path.join(os.path.dirname(__file__), os.path.join('../templates', 'biglist.html'))
searchlist = template.render(path, {'radars':radars})
self.respondWithTemplate('byuser.html', {"radarlist": searchlist})
else:
self.respondWithText('unknown user')
def get(self):
user = self.GetCurrentUser()
if (not user):
self.respondWithDictionaryAsJSON({
"error":
"please authenticate by setting the Authorization header to your API key (http://www.openradar.me/apikey)"
})
return
page = self.request.get("page")
if page:
page = int(page)
else:
page = 1
if page > 10:
self.respondWithText("")
return
count = self.request.get("count")
if count:
count = int(count)
else:
count = 100
apiresult = memcache.get("apiresult")
if apiresult is None:
radars = db.GqlQuery(
"select * from Radar order by number_intvalue desc").fetch(
count, (page - 1) * count)
response = {
"result": [{
"id": r.key().id(),
"classification": r.classification,
"created": str(r.created),
"description": r.description,
"modified": str(r.modified),
"number": r.number,
"originated": r.originated,
"parent": r.parent_number,
"product": r.product,
"product_version": r.product_version,
"reproducible": r.reproducible,
"resolved": r.resolved,
"status": r.status,
"title": r.title,
"user": r.user.email()
} for r in radars]
}
apiresult = simplejson.dumps(response)
#memcache.add("apiresult", apiresult, 600) # ten minutes, but we also invalidate on edits and adds
self.respondWithText(apiresult)
def get(self):
user = self.GetCurrentUser()
if (not user):
self.respondWithDictionaryAsJSON({
"error":
"please authenticate by setting the Authorization header to your API key (http://www.openradar.me/apikey)"
})
return
page = self.request.get("page")
if page:
page = int(page)
else:
page = 1
if page > 10:
self.respondWithText("")
return
count = self.request.get("count")
if count:
count = int(count)
else:
count = 100
comments = db.GqlQuery(
"select * from Comment order by posted_at desc").fetch(
count, (page - 1) * count)
result = []
for c in comments:
try:
commentInfo = {
"id": c.key().id(),
"user": c.user.email(),
"subject": c.subject,
"body": c.body,
"radar": c.radar.number,
"created": str(c.posted_at),
}
if c.is_reply_to:
commentInfo["is_reply_to"] = c.is_reply_to.key().id()
result.append(commentInfo)
except Exception:
None # we'll get here if the corresponding radar was deleted
response = {"result": result}
apiresult = simplejson.dumps(response)
self.respondWithText(apiresult)
def get(self):
comments = db.GqlQuery(
"select * from Comment order by posted_at desc").fetch(20)
self.respondWithTemplate('comments-recent.html',
{"comments": comments})
