def write_error(self, status_code, **kwargs):
try:
stats.request(str(get_ip(self.request)))
except:
error("Errored while handling request IP -- still served...")
self.render("pages/error.html",
message=httplib.responses[status_code],
error=status_code)
def get(self):
try:
req_resp = stats.request(str(get_ip(self.request)))
say("Received STATS request (" + req_resp + ")")
except:
error("Errored while handling request IP -- still served...")
self.render("pages/stats.html",
countries=stats.top_countries(),
last_restart=stats.time(),
devices=stats.unique_devices(),
total_requests=stats.requests,
requests_per_second=stats.requests_per_second())
def write_tweet(account, tweet, data, overwrite=True):
if (not overwrite) and os.path.exists(
"database/" + str(account) + "/tweets/" + str(tweet) + ".json"
): # if tweet already written and overwrite = false, do not write to file
return False
if not is_account(account):
error("Cannot write tweet to an account that does not exist!",
detail="Tweet = " + str(tweet) + ", account = " + str(account) +
".")
return
if not os.path.isdir("database/" + str(account) + "/tweets"):
os.mkdir("database/" + str(account) + "/tweets")
with open("database/" + str(account) + "/tweets/" + str(tweet) + ".json",
"w") as tweet_file:
json.dump(data, tweet_file)
return True
def get(self):
try:
req_resp = stats.request(str(get_ip(self.request)))
except:
error("Errored while handling request IP -- still served...")
say("Received INDEX request (" + req_resp + ")")
flash = flashes.get_latest_flashes(1)[0]
flash['text'] = tornado.escape.xhtml_unescape(flash['text'])
time = str(flash['time'])
if isinstance(flash['time'], basestring):
time = arrow.Arrow.strptime(
flash['time'], "%a %b %d %H:%M:%S +0000 %Y").humanize()
elif isinstance(flash['time'], datetime.datetime):
time = arrow.get(flash['time']).humanize()
self.render("pages/index.html", flash=flash, time=time)
def _push_notification_to_subscribers(subscriptions, data):
userio.say("Sending notification to " + str(subscriptions.count()) +
" subscribers in a new thread...")
for subscription in subscriptions:
try:
webpush(
subscription_info=subscription,
data=data,
vapid_private_key=configuration.
get_vapid_public_private_key_pair()[1],
vapid_claims=VAPID_CLAIMS,
#gcm_key=configuration.get_gcm_key(),
)
except Exception as e:
userio.error(" ...unable to send notification: " + str(e))
db.subscriptions.remove(subscription)
userio.say(" ...removed subscription!")
userio.ok("Finished sending notification.")
thread.exit()
def full_pass(account):
if not databasehandler.is_account(account):
error("Cannot scan account that doesn't exist!",
detail="Offending account is " + str(account))
else:
# pull all the tweet ids from the database
archived_ids = databasehandler.get_tweets(account)
# pull all the tweets from Twitter
available_tweets = twitterhandler.get_all_tweets(account)
available_ids = [tweet["id"] for tweet in available_tweets]
deleted_candidates = [
idz for idz in archived_ids if int(idz) not in available_ids
]
ok("Found " + str(len(deleted_candidates)) + " deletion candidates...")
deleted = []
for candidate in deleted_candidates:
if not twitterhandler.does_status_exist(candidate):
ok("Tweet " + str(candidate) + " has been deleted!")
deleted.append(candidate)
ok("Found " + str(len(deleted)) + " deleted tweets!")
# also write the new tweets to the database
pushed = 0
for tweet in available_tweets:
if databasehandler.write_tweet(account,
tweet["id"],
tweet,
overwrite=False):
pushed += 1
# and mark the deleted tweets as deleted
for tweet_id in deleted:
tweet = databasehandler.get_tweet(account, tweet_id)
tweet["deleted"] = True
databasehandler.write_tweet(account, tweet_id, tweet)
ok("Also pushed " + str(pushed) + " new tweets to the database.")
return deleted
def on_status(self, status):
try:
say("Detected flash...")
if configuration.is_following(status.user.screen_name):
say("...from a relevant source!")
url = None
if 'urls' in status.entities and len(
status.entities['urls']) > 0:
url = status.entities['urls'][0]["expanded_url"]
flash = generate_flash(
status.text, url,
configuration.get_name(status.user.screen_name), status.id,
status.created_at,
configuration.get_channel(status.user.screen_name))
push_flash(flash)
ok("Detected and pushed flash: " + str(flash))
else:
say("...from an irrelevant source.")
except Exception as e:
error("Encountered an exception while processing a flash: " +
str(e))
return True
def get(self):
try:
req_resp = stats.request(str(get_ip(self.request)))
except:
error("Errored while handling request IP -- still served...")
say("Received INDEX request (" + req_resp + ")")
alerts = flashes.get_latest_flashes(3)
for flash in alerts:
flash['text'] = tornado.escape.xhtml_unescape(flash['text'])
if isinstance(flash['time'],
basestring) and "+0000" in flash['time']:
flash['time'] = arrow.Arrow.strptime(
flash['time'], "%a %b %d %H:%M:%S +0000 %Y").humanize()
if isinstance(flash['time'], datetime.datetime):
flash['time'] = arrow.get(flash['time']).humanize()
self.render("pages/index.html",
flashes=alerts,
countries=stats.top_countries(),
last_restart=stats.time(),
devices=stats.unique_devices(),
total_requests=stats.requests,
requests_per_second=str(stats.requests_per_second())[:5])
def get(self):
try:
req_resp = stats.request(str(get_ip(self.request)))
say("Received API request (" + req_resp + ")")
except:
error("Errored while handling request IP -- still served...")
self.set_header("Content-Type", "application/json")
latest = -1
try:
latest = int(self.get_argument('latest'))
except:
pass # no latest flash specified
data = {
"server":
"LibreNews Central",
"channels": [k[2] for k in configuration.get_accounts()],
"latest": [
flash for flash in flashes.get_latest_flashes(25)
if int(flash['id']) > int(latest)
]
}
self.write(
unicode(json.dumps(data, sort_keys=True, separators=(',', ':'))))
def get(self):
try:
stats.request(str(get_ip(self.request)))
except:
error("Errored while handling request IP -- still served...")
self.render("pages/error.html", message="Page not found", error="404")
def on_error(self, status):
error("Encountered an error while processing a status: " + str(status))
if status == 420:
# returning False in on_data disconnects the stream
return False
return True
