+import logging
+import pyramid.httpexceptions
import re
from colorsys import rgb_to_hls, hls_to_rgb
from cgi import escape as html_escape
-from datetime import datetime
+from datetime import datetime, timedelta
+from decimal import Decimal
+from collections import namedtuple
+from xonstat.d0_blind_id import d0_blind_id_verify
+
+
+log = logging.getLogger(__name__)
+
# Map of special chars to ascii from Darkplace's console.c.
_qfont_table = [
'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
'x', 'y', 'z', '{', '|', '}', '~', '<',
-
+
'<', '=', '>', '#', '#', '.', '#', '#',
'#', '#', ' ', '#', ' ', '>', '.', '.',
'[', ']', '0', '1', '2', '3', '4', '5',
if qstr == None:
qstr = ''
return _all_colors.sub('', qstr)
-
-
+
+
def hex_repl(match):
- # Convert hex to 8 bits and to 0.0-1.0 scale
- r = int(match.group(1) * 2, 16) / 255.
- g = int(match.group(2) * 2, 16) / 255.
- b = int(match.group(3) * 2, 16) / 255.
+ """Convert Darkplaces hex color codes to CSS rgb.
+ Brighten colors with HSL light value less than 50%"""
+
+ # Extend hex char to 8 bits and to 0.0-1.0 scale
+ r = int(match.group(1) * 2, 16) / 255.0
+ g = int(match.group(2) * 2, 16) / 255.0
+ b = int(match.group(3) * 2, 16) / 255.0
+
+ # Check if color is too dark
hue, light, satur = rgb_to_hls(r, g, b)
if light < _contrast_threshold:
light = _contrast_threshold
- # Get new rgb in 0-255 scale
- r, g, b = tuple([int(round(255 * i)) for i in hls_to_rgb(hue, light, satur)])
- return '<span style="color:rgb({0},{1},{2})">'.format(r, g, b)
+ r, g, b = hls_to_rgb(hue, light, satur)
+
+ # Convert back to 0-255 scale for css
+ return '<span style="color:rgb(%d,%d,%d)">' % (255 * r, 255 * g, 255 * b)
+
+
+def html_colors(qstr='', limit=None):
+ qstr = html_escape(qfont_decode(qstr))
+ qstr = qstr.replace('^^', '^')
+ if limit is not None and limit > 0:
+ qstr = limit_printable_characters(qstr, limit)
-def html_colors(qstr=''):
- qstr = html_escape(qfont_decode(qstr).replace('^^', '^'))
html = _dec_colors.sub(lambda match: _dec_spans[int(match.group(1))], qstr)
html = _hex_colors.sub(hex_repl, html)
return html + "</span>" * len(_all_colors.findall(qstr))
+def limit_printable_characters(qstr, limit):
+ # initialize assuming all printable characters
+ pc = [1 for i in range(len(qstr))]
+
+ groups = _all_colors.finditer(qstr)
+ for g in groups:
+ pc[g.start():g.end()] = [0 for i in range(g.end() - g.start())]
+
+ # printable characters in the string is less than or equal to what was requested
+ if limit >= len(qstr) or sum(pc) <= limit:
+ return qstr
+ else:
+ sumpc = 0
+ for i,v in enumerate(pc):
+ sumpc += v
+ if sumpc == limit:
+ return qstr[0:i+1]
+
+
def page_url(page):
return current_route_url(request, page=page, _query=request.GET)
def pretty_date(time=False):
- """
- Get a datetime object or a int() Epoch timestamp and return a
- pretty string like 'an hour ago', 'Yesterday', '3 months ago',
- 'just now', etc
- """
- now = datetime.now()
+ '''Returns a human-readable relative date.'''
+ now = datetime.utcnow()
if type(time) is int:
diff = now - datetime.fromtimestamp(time)
elif isinstance(time,datetime):
- diff = now - time
+ diff = now - time
elif not time:
+ print "not a time value"
diff = now - now
- second_diff = diff.seconds
- day_diff = diff.days
-
- if day_diff < 0:
- return ''
-
- if day_diff == 0:
- if second_diff < 10:
- return "just now"
- if second_diff < 60:
- return str(second_diff) + " seconds ago"
- if second_diff < 120:
- return "a minute ago"
- if second_diff < 3600:
- return str( second_diff / 60 ) + " minutes ago"
- if second_diff < 7200:
- return "an hour ago"
- if second_diff < 86400:
- return str( second_diff / 3600 ) + " hours ago"
- if day_diff == 1:
- return "Yesterday"
- if day_diff < 7:
- return str(day_diff) + " days ago"
- if day_diff < 31:
- if day_diff/7 == 1:
- return "a week ago"
- else:
- return str(day_diff/7) + " weeks ago"
- if day_diff < 365:
- if day_diff/30 == 1:
- return "a month ago"
- else:
- return str(day_diff/30) + " months ago"
+
+ dim = round(diff.seconds/60.0 + diff.days*1440.0)
+
+ if dim == 0:
+ return "less than a minute ago"
+ elif dim == 1:
+ return "1 minute ago"
+ elif dim >= 2 and dim <= 44:
+ return "{0} minutes ago".format(int(dim))
+ elif dim >= 45 and dim <= 89:
+ return "about 1 hour ago"
+ elif dim >= 90 and dim <= 1439:
+ return "about {0} hours ago".format(int(round(dim/60.0)))
+ elif dim >= 1440 and dim <= 2519:
+ return "1 day ago"
+ elif dim >= 2520 and dim <= 43199:
+ return "{0} days ago".format(int(round(dim/1440.0)))
+ elif dim >= 43200 and dim <= 86399:
+ return "about 1 month ago"
+ elif dim >= 86400 and dim <= 525599:
+ return "{0} months ago".format(int(round(dim/43200.0)))
+ elif dim >= 525600 and dim <= 655199:
+ return "about 1 year ago"
+ elif dim >= 655200 and dim <= 914399:
+ return "over 1 year ago"
+ elif dim >= 914400 and dim <= 1051199:
+ return "almost 2 years ago"
else:
- if day_diff/365 == 1:
- return "a year ago"
+ return "about {0} years ago".format(int(round(dim/525600.0)))
+
+def datetime_seconds(td):
+ return float(td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6
+
+def to_json(data):
+ if not type(data) == dict:
+ # assume it's a named tuple
+ data = data._asdict()
+ result = {}
+ for key,value in data.items():
+ if value == None:
+ result[key] = None
+ elif type(value) in [bool,int,long,float,complex,str]:
+ result[key] = value
+ elif type(value) == unicode:
+ result[key] = value.encode('utf-8')
+ elif type(value) == Decimal:
+ result[key] = float(value)
+ elif type(value) == datetime:
+ result[key] = value.strftime('%Y-%m-%dT%H:%M:%SZ')
+ elif type(value) == timedelta:
+ result[key] = datetime_seconds(value)
else:
- return str(day_diff/365) + " years ago"
+ result[key] = to_json(value.to_dict())
+ return result
+
+
+def is_leap_year(today_dt=None):
+ if today_dt is None:
+ today_dt = datetime.utcnow()
+
+ if today_dt.year % 400 == 0:
+ leap_year = True
+ elif today_dt.year % 100 == 0:
+ leap_year = False
+ elif today_dt.year % 4 == 0:
+ leap_year = True
+ else:
+ leap_year = False
+
+ return leap_year
+
+
+def is_cake_day(create_dt, today_dt=None):
+ cake_day = False
+
+ if today_dt is None:
+ today_dt = datetime.utcnow()
+
+ # cakes are given on the first anniversary, not the actual create date!
+ if datetime.date(today_dt) != datetime.date(create_dt):
+ if today_dt.day == create_dt.day and today_dt.month == create_dt.month:
+ cake_day = True
+
+ # leap year people get their cakes on March 1
+ if not is_leap_year(today_dt) and create_dt.month == 2 and create_dt.day == 29:
+ if today_dt.month == 3 and today_dt.day == 1:
+ cake_day = True
+
+ return cake_day
+
+
+def verify_request(request):
+ """Verify requests using the d0_blind_id library"""
+
+ # first determine if we should be verifying or not
+ val_verify_requests = request.registry.settings.get('xonstat.verify_requests', 'true')
+ if val_verify_requests == "true":
+ flg_verify_requests = True
+ else:
+ flg_verify_requests = False
+
+ try:
+ (idfp, status) = d0_blind_id_verify(
+ sig=request.headers['X-D0-Blind-Id-Detached-Signature'],
+ querystring='',
+ postdata=request.body)
+
+ log.debug('\nidfp: {0}\nstatus: {1}'.format(idfp, status))
+ except:
+ idfp = None
+ status = None
+
+ if flg_verify_requests and not idfp:
+ log.debug("ERROR: Unverified request")
+ raise pyramid.httpexceptions.HTTPUnauthorized("Unverified request")
+
+ return (idfp, status)