def compare_ua(self, ua):
# TODO: Validate this code.
if ua == self.ua:
return True
old_ua = httpagentparser.detect(self.ua)
new_ua = httpagentparser.detect(ua)
keys = {"os": ["version", "name"], "browser": ["version", "name"]}
if "os" in old_ua and "os" in new_ua:
if old_ua["os"] != new_ua["os"]:
return False
if "browser" in old_ua and "browser" in new_ua:
ou = old_ua["browser"]
nu = new_ua["browser"]
if ou.get("name") != nu.get("name"):
return False
if ou.get("version") == nu.get("version"):
return True
try:
ou_v = LooseVersion(ou.get("version"))
nu_v = LooseVersion(nu.get("version"))
except AttributeError:
return False # Something fishy with version strings
if nu_v < ou_v:
return False # downgraded browser version
return True
def index(request):
"""if student, redirect them to timesheet. if faculty allow this page
"""
if "next" in request.GET and request.GET["next"] != "/":
return HttpResponseRedirect(request.GET["next"])
if request.user.is_staff:
try:
# Warn users of IE and Firefox < 4.0 they are not supported
ua = request.META["HTTP_USER_AGENT"]
browser_name = httpagentparser.detect(ua)["browser"]["name"]
browser_version = httpagentparser.detect(ua)["browser"]["version"]
if browser_name == "Microsoft Internet Explorer":
messages.warning(
request,
mark_safe(
"Warning Internet Explorer is not supported on the admin site. If you "
"have any trouble, try using a standards compliant browser such as Firefox, Chrome, Opera, or Safari."
),
)
except:
pass
return HttpResponseRedirect("/sis/dashboard")
elif request.user.groups.filter(Q(name="students")).count() > 0:
return student_redirect(request)
elif request.user.groups.filter(name="family").count() > 0:
return family_redirect(request)
elif request.user.groups.filter(Q(name="company")).count() > 0:
from ecwsp.work_study.views import supervisor_dash
return supervisor_dash(request)
else:
return render_to_response(
"base.html", {"msg": "Not authorized", "request": request}, RequestContext(request, {})
)
def my_homepage(request):
data = request.META.get('HTTP_USER_AGENT', 'unknown')
if data == 'unknown':
data = False
else:
browser, os = httpagentparser.detect(data)['browser']['name'], httpagentparser.detect(data)['os']['name']
return render(request, 'myhomepage.html', {'data':data, 'browser': browser, 'os':os})
def index(request):
"""if student, redirect them to timesheet. if faculty allow this page
"""
if 'next' in request.GET and request.GET['next'] != "/":
return HttpResponseRedirect(request.GET['next'])
if request.user.is_staff:
try:
# Warn users of IE and Firefox < 4.0 they are not supported
ua = request.META['HTTP_USER_AGENT']
browser_name = httpagentparser.detect(ua)['browser']['name']
browser_version = httpagentparser.detect(ua)['browser']['version']
if browser_name == "Microsoft Internet Explorer":
messages.warning(request,
mark_safe('Warning Internet Explorer is not supported on the admin site. If you ' \
'have any trouble, try using a standards compliant browser such as Firefox, Chrome, Opera, or Safari.'))
elif browser_name == "Firefox" and int(browser_version.split('.')[0]) < 6:
messages.warning(request, 'Warning, your version of Firefox is out of date. Please upgrade.')
except:
pass
return HttpResponseRedirect('/sis/dashboard')
elif request.user.groups.filter(Q(name='students')).count() > 0:
return student_redirect(request)
elif request.user.groups.filter(name='family').count() > 0:
return family_redirect(request)
elif request.user.groups.filter(Q(name='company')).count() > 0:
from ecwsp.work_study.views import supervisor_dash
return supervisor_dash(request)
else:
return render_to_response('base.html', {'msg': "Not authorized", 'request': request,}, RequestContext(request, {}))
def test_harass(self):
then = time.time()
for agent, simple_res, res in data * self.harass_repeat:
detect(agent)
time_taken = time.time() - then
no_of_tests = len(self.data) * self.harass_repeat
print "\nTime taken for %s detecttions: %s" % (no_of_tests, time_taken)
print "Time taken for single detecttion: ", time_taken / (len(self.data) * self.harass_repeat)
def process(arr):
global _default_index
if _default_index is None:
for i, x in enumerate(arr):
t = httpagentparser.detect(x)
if t:
_default_index = i
break
else:
t = httpagentparser.detect(arr[_default_index])
# {'os': {'name': 'Linux'},
# 'browser': {'version': '5.0.307.11', 'name': 'Chrome'}}
if t:
add(t)
def detect_browser (self):
if self.user_agent:
for client in EMAIL_CLIENTS:
if client[0] in self.user_agent:
self.email_client = client[1]
break
b = httpagentparser.detect(self.user_agent)
if 'dist' in b and 'name' in b['dist']:
self.browser_os = b['dist']['name']
elif 'os' in b and 'name' in b['os']:
self.browser_os = b['os']['name']
if 'browser' in b:
if 'name' in b['browser']:
self.browser_name = b['browser']['name']
if 'version' in b['browser']:
try:
self.browser_version = int(b['browser']['version'].split('.')[0])
except:
pass
if self.referer:
for client in WEB_CLIENTS:
if client[0] in self.referer:
self.email_client = client[1]
break
def send_auditlog_record(line):
global failcount, queuelength
with countlock:
queuelength -= 1
# Invalid json input is not an error we can handle
msg = json.loads(line)
task = msg['event']
user = msg['user']
if task == "User Access":
action = user
else:
action = msg.get('action') or '|'.join(msg.get(x) for x in ('study', 'subset1', 'subset2', 'analysis', 'query', 'facetQuery', 'clientId') if msg.get(x))
args = dict(action = action,
application = msg['program'],
appVersion = msg['programVersion'],
user = user,
task = task,
)
if msg['userAgent']:
args['browser'] = '<unknown browser>'
browser = httpagentparser.detect(msg['userAgent']).get('browser')
if browser:
args['browser'] = browser['name'] + ' ' + browser['version']
fullurl = URL + '?' + urllib.parse.urlencode(args)
#print(fullurl)
try:
#raise Exception('testing')
urllib.request.urlopen(Request(fullurl, method='POST'), timeout=TIMEOUT).readall()
except Exception as exc:
with countlock:
failcount += 1
log.error("{e}, url: {url}".format(e=' '.join(str(e) for e in exc.args), url=fullurl))
def check_user_agent(user_agent, requirements):
import httpagentparser
from pkg_resources import parse_version
if not user_agent:
return True
if not requirements:
return True
if type(user_agent) == dict:
parsed = user_agent
else:
parsed = httpagentparser.detect(user_agent)
if "browser" not in parsed:
return True
if "name" not in parsed["browser"]:
return True
if "version" not in parsed["browser"]:
return True
user_browser = parsed["browser"]["name"].lower()
user_browser_version = parsed["browser"]["version"]
for browser, browser_version in requirements:
if not browser_version:
return False
if user_browser == browser.lower():
if cmp(parse_version(browser_version), parse_version(user_browser_version)) <= 0:
return True
return False
def make_entry(x):
a = Access ( ip = x.group('ip'),
uri = x.group('uri'),
time = apachetime( x.group('time') ),
status_code = int( x.group('status_code') ),
referral = x.group('referral'),
agentString = x.group('agent'),
bytes = int( x.group('bytes') ),
)
if x.group('agent') is not None:
agentInfo = httpagentparser.detect( x.group('agent') )
if 'flavor' in agentInfo:
a['os'] = agentInfo['flavor'].keys()[0]
a['osVersion'] = agentInfo['flavor'][a['os']]['version']
if 'browser' in agentInfo:
a['browser'] = agentInfo['browser'].keys()[0]
a['browserVersion'] = agentInfo['browser'][a['browser']]['version']
if 'bot' in agentInfo:
a['bot'] = agentInfo['bot'].keys()[0]
a['botVersion'] = agentInfo['bot'][a['bot']]['version']
if 'rss_reader' in agentInfo:
a['rssReader'] = agentInfo['rss_reader'].keys()[0]
a['rssReaderVersion'] = agentInfo['rss_reader'][a['rssReader']]['version']
return a
def process_request(self, request):
self._clear_cookie = False
if is_media_request(request):
return None
if "HTTP_USER_AGENT" not in request.META:
return None
if not hasattr(settings, "BADBROWSER_REQUIREMENTS"):
return None # no requirements have been setup
if request.path[-20:] == reverse("django-badbrowser-ignore")[-20:]:
# Allow through any requests for the ignore page
return None
user_agent = request.META["HTTP_USER_AGENT"]
parsed_user_agent = httpagentparser.detect(user_agent)
# Set the browser information on the request object
request.browser = parsed_user_agent
if check_user_agent(parsed_user_agent, settings.BADBROWSER_REQUIREMENTS):
self._clear_cookie = True
return None # continue as normal
else:
if self._user_ignored_warning(request):
return None
from views import unsupported
return unsupported(request)
def process_request(self, request):
self._clear_cookie = False
if request.path.startswith(settings.MEDIA_URL):
# no need to test media requests (which sometimes come via
# via django during development)
return None
if "HTTP_USER_AGENT" not in request.META:
return None
user_agent = request.META["HTTP_USER_AGENT"]
parsed_user_agent = httpagentparser.detect(user_agent)
# Set the browser information on the request object
request.browser = parsed_user_agent
if not hasattr(settings, "BADBROWSER_REQUIREMENTS"):
return None # no requirements have been setup
if request.path == reverse("django-badbrowser-ignore"):
# Allow through any requests for the ignore page
return None
if check_user_agent(parsed_user_agent, settings.BADBROWSER_REQUIREMENTS):
self._clear_cookie = True
return None # continue as normal
else:
if self._user_ignored_warning(request):
return None
from django_badbrowser.views import unsupported
return unsupported(request)
def get_readable_ua(self):
""" Returns user-agent in readable format """
data = httpagentparser.detect(self.ua)
browser = None
os = None
if "browser" in data and "name" in data["browser"]:
browser = data["browser"]["name"]
if "dist" in data and "name" in data["dist"]:
if "version" in data["dist"]:
os = "%s (%s)" % (data["dist"]["name"], data["dist"]["version"])
else:
os = data["dist"]["name"]
elif "platform" in data and "name" in data["platform"]:
if "version" in data["platform"]:
os = "%s (%s)" % (data["platform"]["name"], data["platform"]["version"])
else:
os = data["platform"]["name"]
elif "os" in data and "name" in data["os"]:
os = data["os"]["name"]
if browser:
if os:
return "%s on %s" % (browser, os)
else:
return "%s on unknown platform" % (browser)
return self.ua
def browser(request):
"""
Adds browser-related context variables to the context.
This adds in context a ``browser`` key wich is a dict:
- name: name of the browser.
- version: full version of the browser.
- outdated: specify if browser is outdated so unsupported.
- major_version: the browser major version (None if not available).
"""
import httpagentparser
if request.META.get('HTTP_USER_AGENT'):
br = httpagentparser.detect(request.META['HTTP_USER_AGENT'])['browser']
if isinstance(br, dict):
br['major_version'] = None
br['outdated'] = False
try:
# Try to get the major version (does not work all the time ;-) )
br['major_version'] = int(br['version'].split('.')[0])
except:
# Forget the major browser version
pass
# Mark outdated browsers
if "internet explorer" in br['name'].lower() \
and br['major_version'] \
and br['major_version'] < 9:
br['outdated'] = True
return {'browser': br}
else:
return {'browser': None}
def user_agents(query, limit):
c = Counter(pv.headers.get('User-Agent') for pv in query)
ua_dict = {}
for key, count in c.most_common(limit):
ua = httpagentparser.detect(key)
ua_dict[ua['browser']['name']] = count
return ua_dict
def check_user_agent(user_agent, requirements):
if not user_agent:
return True
if not requirements:
return True
if type(user_agent) == httpagentparser.Result or type(user_agent) == dict:
parsed = user_agent
else:
parsed = httpagentparser.detect(user_agent)
if "browser" not in parsed:
return True
if "name" not in parsed["browser"]:
return True
if "version" not in parsed["browser"]:
return True
user_browser = parsed["browser"]["name"].lower()
user_browser_version = parsed["browser"]["version"]
for browser, browser_version in requirements:
if user_browser == browser.lower():
if not browser_version:
return False
if parse_version(browser_version) > parse_version(user_browser_version):
return False
return True
def checkBrowserCompatible(request):
to_return = True
cookie = request.COOKIES.get('atyourownrisk')
if cookie:
if cookie == 'yes':
return True
user_agent = request.META.get('HTTP_USER_AGENT')
if user_agent:
parsed = httpagentparser.detect(user_agent)
browser = parsed.get('browser')
if browser:
browser_name = browser.get('name')
if browser_name == "Microsoft Internet Explorer":
try:
version = float(browser.get('version'))
if version < 9.0:
to_return = False
except ValueError as e:
to_return = False
if not to_return:
browser_logger.debug('useragent: ' + str(user_agent))
return to_return
def is_supports_webp(request):
if "webp" in request.META.get("HTTP_ACCEPT", ""):
return True
data = httpagentparser.detect(request.META.get("HTTP_USER_AGENT"))
if "browser" in data and data["browser"]["name"] in WEBP_VALID_BROWSERS:
return True
return False
def policy_is_valid_policy_system(self, fileid, user_agent):
self.get_file_query(fileid)
parser = httpagentparser.detect(user_agent)
if 'os' not in parser or 'name' not in parser['os']:
return True
q = self.session.query(FileOSBlocked).filter_by(fileid=fileid).filter_by(system=parser['os']['name']).all()
return len(q) == 0
def parse_browser(user_agent_string):
browser = httpagentparser.detect(user_agent_string)
return [
browser['os']['name'],
browser['browser']['name'],
browser['browser']['version'],
]
def is_mobile():
useragent = httpagentparser.detect(request.user_agent.string)
if useragent.get('dist', {}).get('name', '').lower() in ['ipad', 'iphone',
'android']:
return True
else:
return False
def login(self, user, new=False):
ua = self.request.headers.get('User-Agent', '')
ip = self.request.remote_addr or ''
auth = None
if not new:
auth = user.getAuth(ua)
if auth:
# note that this triggers the last login auto update
auth.ip = ip
auth.put()
else:
parsed = httpagentparser.detect(ua)
os = browser = device = ''
if 'os' in parsed:
# shows up as Linux for Android, Mac OS for iOS
os = parsed['os']['name']
if 'browser' in parsed:
browser = parsed['browser']['name']
if 'dist' in parsed:
# "dist" stands for "distribution" - like Android, iOS
device = parsed['dist']['name']
auth = model.Auth(user_agent=ua, os=os, browser=browser, device=device, ip=ip, parent=user.key)
auth.put()
self.session['auth_key'] = auth.key.urlsafe()
self.redirect("/home")
def index(request, place_id=None):
# Load app config settings
config = get_shareabouts_config(settings.SHAREABOUTS.get("CONFIG"))
config.update(settings.SHAREABOUTS.get("CONTEXT", {}))
# Get initial data for bootstrapping into the page.
dataset_root = settings.SHAREABOUTS.get("DATASET_ROOT")
if dataset_root.startswith("file:"):
dataset_root = request.build_absolute_uri(reverse("api_proxy", args=("",)))
api = ShareaboutsApi(dataset_root=dataset_root)
# Get the content of the static pages linked in the menu.
pages_config = config.get("pages", [])
pages_config_json = json.dumps(pages_config)
# The user token will be a pair, with the first element being the type
# of identification, and the second being an identifier. It could be
# 'username:mjumbewu' or 'ip:123.231.132.213', etc. If the user is
# unauthenticated, the token will be session-based.
if "user_token" not in request.session:
t = int(time.time() * 1000)
ip = request.META["REMOTE_ADDR"]
unique_string = str(t) + str(ip)
session_token = "session:" + hashlib.md5(unique_string).hexdigest()
request.session["user_token"] = session_token
request.session.set_expiry(0)
user_token_json = u'"{0}"'.format(request.session["user_token"])
# Get the browser that the user is using.
user_agent_string = request.META.get("HTTP_USER_AGENT", "")
if user_agent_string:
user_agent = httpagentparser.detect(user_agent_string)
user_agent_json = json.dumps(user_agent)
else:
# If no user agent is specified, stub a generic one in.
user_agent_json = json.dumps(
{"os": {"name": ""}, "browser": {"name": "", "version": None}, "platform": {"name": "", "version": None}}
)
place = None
if place_id and place_id != "new":
place = api.get("places/" + place_id)
if place:
place = json.loads(place)
context = {
"config": config,
"user_token_json": user_token_json,
"pages_config": pages_config,
"pages_config_json": pages_config_json,
"user_agent_json": user_agent_json,
# Useful for customized meta tags
"place": place,
"API_ROOT": api.root,
"DATASET_ROOT": api.dataset_root,
}
return render(request, "index.html", context)
def index(request, place_id=None):
# Load app config settings
config = get_shareabouts_config(settings.SHAREABOUTS.get('CONFIG'))
config.update(settings.SHAREABOUTS.get('CONTEXT', {}))
# Get initial data for bootstrapping into the page.
api = ShareaboutsApi(dataset_root=request.build_absolute_uri(reverse('api_proxy', args=('',))))
# Get the content of the static pages linked in the menu.
pages_config = config.get('pages', [])
pages_config_json = json.dumps(pages_config)
# The user token will be a pair, with the first element being the type
# of identification, and the second being an identifier. It could be
# 'username:mjumbewu' or 'ip:123.231.132.213', etc. If the user is
# unauthenticated, the token will be session-based.
if 'user_token' not in request.session:
t = int(time.time() * 1000)
ip = request.META['REMOTE_ADDR']
unique_string = str(t) + str(ip)
session_token = 'session:' + hashlib.md5(unique_string).hexdigest()
request.session['user_token'] = session_token
request.session.set_expiry(0)
user_token_json = u'"{0}"'.format(request.session['user_token'])
# Get the browser that the user is using.
user_agent_string = request.META.get('HTTP_USER_AGENT', '')
if user_agent_string:
user_agent = httpagentparser.detect(user_agent_string)
user_agent_json = json.dumps(user_agent)
else:
# If no user agent is specified, stub a generic one in.
user_agent_json = json.dumps({
"os": {"name": ""},
"browser": {"name": "", "version": None},
"platform": {"name": "", "version": None}
})
place = None
if place_id and place_id != 'new':
place = api.get('places/' + place_id)
if place:
place = json.loads(place)
context = {'config': config,
'user_token_json': user_token_json,
'pages_config': pages_config,
'pages_config_json': pages_config_json,
'user_agent_json': user_agent_json,
# Useful for customized meta tags
'place': place,
'API_ROOT': api.root,
'DATASET_ROOT': api.dataset_root,
}
return render(request, 'index.html', context)
def _check_by_user_agent(user_agent):
""" Checks if the client accepts checking the given user_agent """
if user_agent:
data = httpagentparser.detect(user_agent)
if 'browser' in data:
return data['browser']['name'] in WEBP_VALID_BROWSERS
return False
def handle_error(request, response, exception):
exc_type, exc_value, exc_tb = sys.exc_info()
c = {
'exception': str(exception),
'url': request.url,
}
if request.app.config.get('send_mail_developer') is not False:
# send email
subject = "[{}] ERROR {}".format(request.app.config.get('environment').upper(),
request.app.config.get('app_name'))
lines = traceback.format_exception(exc_type, exc_value, exc_tb)
ua = httpagentparser.detect(request.user_agent)
_os = ua.has_key('flavor') and 'flavor' or 'os'
operating_system = str(ua[_os]['name']) if "name" in ua[_os] else "-"
if 'version' in ua[_os]:
operating_system += ' ' + str(ua[_os]['version'])
if 'dist' in ua:
operating_system += ' ' + str(ua['dist'])
browser = str(ua['browser']['name']) if 'browser' in ua else "-"
browser_version = str(ua['browser']['version']) if 'browser' in ua else "-"
message = '<strong>Application ID:</strong> ' + app_identity.get_application_id() + "<br />" + \
'<strong>Application Version:</strong> ' + os.environ['CURRENT_VERSION_ID'] + "<br />" + \
'<hr><strong>User Agent:</strong> ' + str(request.user_agent) + "<br />" + \
'<strong>IP Address:</strong> ' + str(request.remote_addr) + "<br />" + \
'<strong>Operating System:</strong> ' + str(operating_system) + "<br />" + \
'<strong>Browser:</strong> ' + str(browser) + "<br />" + \
'<strong>Browser Version:</strong> ' + str(browser_version) + "<br />" + \
'<hr><strong>Error Type:</strong> ' + exc_type.__name__ + "<br />" + \
'<strong>Description:</strong> ' + c['exception'] + "<br />" + \
'<strong>Method:</strong> ' + str(os.environ['REQUEST_METHOD']) + "<br />" + \
'<strong>URL:</strong> ' + c['url'] + "<br />" + \
'<strong>Referer:</strong> ' + str(request.referer) + "<br />" + \
'<strong>Traceback:</strong> <br />' + '<br />'.join(lines)
if c['exception'] is not 'Error saving Email Log in datastore':
email_url = webapp2.uri_for('taskqueue-send-email')
for dev in request.app.config.get('developers'):
taskqueue.add(url=email_url, params={
'to': dev[1],
'subject': subject,
'body': message,
'sender': request.app.config.get('contact_sender'),
})
status_int = hasattr(exception, 'status_int') and exception.status_int or 500
template = request.app.config.get('error_templates')[status_int]
t = jinja2.get_jinja2(app=webapp2.get_app()).render_template(template, **c)
logging.error("Error {}: {}".format(status_int, exception))
response.write(t)
response.set_status(status_int)
def __init__(self, **kvs):
super(Context, self).__init__()
self.device_id = kvs.get(u'device_id', u'')
self.borqs_id = kvs.get(u'borqs_id', u'')
self.google_ids = split2(kvs.get(u'google_ids', u''), u',')
self.locale = kvs.get(u'locale', u'')
self.ip = kvs.get(u'ip', u'')
self.user_agent = kvs.get(u'user_agent', u'')
self._parsed_user_agent = httpagentparser.detect(self.user_agent)
def ua_det_browser(user_agent):
try:
details = httpagentparser.detect(str(user_agent))
if 'browser' in details:
return details['browser']['name']
else:
return None
except:
return None
def browser_detection(event):
if not(event.request.session.has_key('browserdetection')) or event.request.session.get('browserdetection') == None:
browser = detect(event.request.user_agent, fill_none=True)
try:
if browser['platform']['name'] in ['iOS', 'BlackBerry', 'Android']:
event.request.session['browserdetection'] = 'mobile'
else:
event.request.session['browserdetection'] = 'normal'
except KeyError:
event.request.session['browserdetection'] = 'normal'
def get_template(self):
"""
iPhone user agent is
Mozilla/5.0 (iPhone; U; CPU iPhone OS 3_1_2 like Mac OS X; en-us) AppleWebKit/528.18 (KHTML, like Gecko) Version/4.0 Mobile/7D11 Safari/528.16
"""
agent = httpagentparser.detect(cherrypy.request.headers['User-Agent'])
is_ios = agent.get('dist', {}).get('name', None) in ['iPhone', 'IPad']
template_type = 'iweb' if is_ios else ''
template_text = globals().get(template_type+'_template', default_template)
template = genshi.template.MarkupTemplate(template_text)
return template
def log_auth(cls, request, confirm_method=''):
ip_address = get_ip(request)
user_agent = request.META.get('HTTP_USER_AGENT')
if user_agent is not None:
parser = detect(user_agent)
browser = parser.get('browser', {})
user_agent = "%s, %s %s" % (
parser.get('platform', {}).get('name', ""),
browser.get('name', ""), browser.get('version', ""))
cls.objects.create(
user=request.user, ip=ip_address, geo=get_geo(ip_address),
agent=user_agent, confirm_method=confirm_method
)
def index(request, default_place_type):
# Load app config settings
config = get_shareabouts_config(settings.SHAREABOUTS.get('CONFIG'))
config.update(settings.SHAREABOUTS.get('CONTEXT', {}))
# Get initial data for bootstrapping into the page.
api = ShareaboutsApi(root=settings.SHAREABOUTS.get('DATASET_ROOT'))
# Handle place types in case insensitive way (park works just like Park)
lower_place_types = [k.lower() for k in config['place_types'].keys()]
if default_place_type.lower() in lower_place_types:
validated_default_place_type = default_place_type
else:
validated_default_place_type = ''
# TODO These requests should be done asynchronously (in parallel).
places_json = api.get('places', default=u'[]')
# Get the content of the static pages linked in the menu.
pages_config = config.get('pages', [])
pages_config_json = json.dumps(pages_config)
# The user token will be a pair, with the first element being the type
# of identification, and the second being an identifier. It could be
# 'username:mjumbewu' or 'ip:123.231.132.213', etc. If the user is
# unauthenticated, the token will be session-based.
if 'user_token' not in request.session:
t = int(time.time() * 1000)
ip = request.META['REMOTE_ADDR']
unique_string = str(t) + str(ip)
session_token = 'session:' + hashlib.md5(unique_string).hexdigest()
request.session['user_token'] = session_token
request.session.set_expiry(0)
user_token_json = u'"{0}"'.format(request.session['user_token'])
# Get the browser that the user is using.
user_agent_string = request.META['HTTP_USER_AGENT']
user_agent = httpagentparser.detect(user_agent_string)
user_agent_json = json.dumps(user_agent)
context = {
'places_json': places_json,
'config': config,
'user_token_json': user_token_json,
'pages_config_json': pages_config_json,
'user_agent_json': user_agent_json,
'default_place_type': validated_default_place_type,
}
return render(request, 'index.html', context)
def get(self):
QfileLoc = self.request.get("fl")
QlineNo = self.request.get("ln")
QerrMsg = self.request.get("err")
QinfoMsg = self.request.get("info")
QUA = os.environ['HTTP_USER_AGENT']
try:
QOSName = httpagentparser.detect(QUA)['os']['name']
except:
QOSName = "Unknown"
try:
QOSVer = httpagentparser.detect(QUA)['os']['version']
except:
QOSVer = "Unknown"
try:
QBrowserName = httpagentparser.detect(QUA)['browser']['name']
except:
QBrowserName = "Unknown"
try:
QBrowserVer = httpagentparser.detect(QUA)['browser']['version']
except:
QBrowserVer = "Unknown"
QIP = os.environ['REMOTE_ADDR']
o = urlparse.urlsplit(self.request.get("sn"))
QserverName = o.scheme + "://" + o.netloc
QserverPath = o.path
if o.query != "":
QserverPath += "?" + o.query
if o.fragment != "":
QserverPath += "#" + o.fragment
Qguid = self.request.get("ui")
Qi = self.request.get("i")
storeLog = LogErr(serverName=QserverName, serverPath=QserverPath, fileLoc=QfileLoc, lineNo=QlineNo, errMsg=QerrMsg, infoMsg=QinfoMsg, IP=QIP, UA=QUA, OSName=QOSName, OSVer=QOSVer, BrowserName=QBrowserName, BrowserVer=QBrowserVer, guid=Qguid)
try:
storeLog.put()
errMsg = ""
except CapabilityDisabledError, err:
errMsg = "// AppEngine is in read-only mode at the moment: " + err + "\n"
def __init__(self, client_id, user_agent):
self.client_id = client_id
self.create_datetime = int(time.time())
self.last_datetime = self.create_datetime
self.user_agent = user_agent
agent_data = httpagentparser.detect(user_agent)
os_data = agent_data.get("os") or {}
self.user_os_name = os_data.get("name")
self.user_os_version = os_data.get("version")
browser_data = agent_data.get("browser") or {}
self.user_browser_name = browser_data.get("name")
self.user_browser_version = browser_data.get("version")
self.bot = agent_data.get("bot")
def parse_agent(ua):
agent_summary = {}
parsed = httpagentparser.detect(ua)
for attr in ("browser", "os", "platform"):
d = parsed.get(attr)
if d:
for subattr in ("name", "version"):
if subattr in d:
key = "%s_%s" % (attr, subattr)
agent_summary[key] = d[subattr]
agent_summary['bot'] = parsed.get('bot')
return agent_summary
def index(request, place_id=None):
# Load app config settings
config = get_shareabouts_config(settings.SHAREABOUTS.get('CONFIG'))
config.update(settings.SHAREABOUTS.get('CONTEXT', {}))
# Get initial data for bootstrapping into the page.
api = ShareaboutsApi(dataset_root=settings.SHAREABOUTS.get('DATASET_ROOT'))
# Get the content of the static pages linked in the menu.
pages_config = config.get('pages', [])
pages_config_json = json.dumps(pages_config)
# The user token will be a pair, with the first element being the type
# of identification, and the second being an identifier. It could be
# 'username:mjumbewu' or 'ip:123.231.132.213', etc. If the user is
# unauthenticated, the token will be session-based.
if 'user_token' not in request.session:
t = int(time.time() * 1000)
ip = request.META['REMOTE_ADDR']
unique_string = str(t) + str(ip)
session_token = 'session:' + hashlib.md5(unique_string).hexdigest()
request.session['user_token'] = session_token
request.session.set_expiry(0)
user_token_json = u'"{0}"'.format(request.session['user_token'])
# Get the browser that the user is using.
user_agent_string = request.META['HTTP_USER_AGENT']
user_agent = httpagentparser.detect(user_agent_string)
user_agent_json = json.dumps(user_agent)
place = None
if place_id:
place = api.get('places/' + place_id)
if place:
place = json.loads(place)
context = {
'config': config,
'user_token_json': user_token_json,
'pages_config': pages_config,
'pages_config_json': pages_config_json,
'user_agent_json': user_agent_json,
# Useful for customized meta tags
'place': place,
'API_ROOT': api.root,
'DATASET_ROOT': api.dataset_root,
}
return render(request, 'index.html', context)
def _aggregate_stats(row):
request_host = row['RequestHost']
stats = host_stats.setdefault(request_host,
collections.defaultdict(int))
metadata = host_metadata.setdefault(row['RequestHost'], {})
stats['total-requests'] += 1
status_code = row['DownstreamStatus']
stats[f'status-{status_code}'] += 1
duration_seconds = int(row['Duration']) / 1000000000
if duration_seconds > 10:
duration_tag = 'more_then_10s'
elif duration_seconds > 5:
duration_tag = 'more_then_5s'
elif duration_seconds > 3:
duration_tag = 'more_then_3s'
else:
duration_tag = None
if duration_tag:
stats[f'duration-{duration_tag}'] += 1
start_time = row['StartUTC']
if not metadata.get('first-start-time'
) or metadata['first-start-time'] > start_time:
metadata['first-start-time'] = start_time
if not metadata.get(
'last-start-time') or metadata['last-start-time'] < start_time:
metadata['last-start-time'] = start_time
referer = row['request_Referer']
referer = referer.strip() if referer else None
if not referer:
referer_tag = None
elif referer.startswith(f'https://{request_host}'):
referer_tag = 'self'
else:
referer_tag = 'external'
if referer_tag:
stats[f'referer-{referer_tag}'] += 1
user_agent = row['request_User-Agent']
try:
user_agent = httpagentparser.detect(user_agent)
user_agent_os = user_agent.get('os', {}).get('name')
user_agent_browser = user_agent.get('browser', {}).get('name')
except Exception:
user_agent_os, user_agent_browser = None, None
if user_agent_os:
stats[f'ua-os-{user_agent_os}'] += 1
if user_agent_browser:
stats[f'ua-browser-{user_agent_browser}'] += 1
[all_stats_keys.add(k) for k in stats]
[all_metadata_keys.add(k) for k in metadata]
return row
def session_created(event):
"""
On first connect, log the devices user agent
"""
# Quick hack to prevent flooding of event logs for
# - Users with cookies turned off (hopefully not to many of these in the real world).
# - Test users that create a new request every time.
ip = event.request.environ.get('REMOTE_ADDR')
if ip in known_ip_address:
return
known_ip_address.add(ip)
event.request.log_event(device=httpagentparser.detect(
event.request.environ.get('HTTP_USER_AGENT')), )
def login():
if flask.request.method == "POST":
vm = LoginViewModel()
if not vm.email or not vm.password:
return {"error": "You have not filled your credentials properly"}
user = user_service.validate_user(vm.email, vm.password)
if not user:
today = date.today() # gets the date of the login attempt
time = datetime.now() # gets the time of the login attempt
current_time = time.strftime(
"%H:%M:%S") # formats the time in a specific format
hostname = socket.gethostname(
) # gets the hostname of the attacker
ip_address = socket.gethostbyname(
hostname) # gets the ip address of the attacker
agent = request.environ.get('HTTP_USER_AGENT')
browser = httpagentparser.detect(
agent) # gets the browser of the attacker
if not browser:
browser = agent.split('/')[0]
else:
browser = browser['browser']['name']
log_DateTime = str(today) + " " + str(current_time)
log_Account = vm.email
log_AttemptedPassword = vm.password
log_HostName = hostname
log_IPAddress = ip_address
log_browser = browser
log_OS = platform.system(
) # gets the operating system of the attacker
log_service.createLog(log_DateTime, log_Account,
log_AttemptedPassword, log_HostName,
log_IPAddress, log_browser, log_OS)
f = open("loginLog.txt", "a")
f.write("FAILED LOGIN ATTEMPT FOR " + vm.email + " at " +
str(today) + " " + str(current_time) + " with password: "******"\n")
f.close()
return {"error": "You have entered an invalid email or password"}
if user:
login_user(user)
resp = flask.redirect('/accounts')
cookie_auth.set_auth(resp, current_user.id)
return resp
def login(self, user, new=False, remember=False):
ua = self.request.headers.get('User-Agent', '')
if ua.startswith('Tornado'):
# this is a change in tornado 6.1 - instead of returning nothing if the user agent is missing
# they put in a defualt like "Tornado/6.1" - but we want to try to detect this
ua = None
ip = self.request.remote_ip or ''
# reject a login attempt without a user agent or IP address
if not ua or not ip:
return self.renderJSON({'errors': 'Invalid client.'})
auth = None
if not new:
auth = user.getAuth(ua)
if auth:
# note that we want to save this even if it isn't different because it updates the last modified
auth.ip = ip
auth.save()
else:
parsed = httpagentparser.detect(ua)
os = browser = device = ''
if 'os' in parsed:
# shows up as Linux for Android, Mac OS for iOS
os = parsed['os']['name']
if 'browser' in parsed:
browser = parsed['browser']['name']
if 'dist' in parsed:
# "dist" stands for "distribution" - like Android, iOS
device = parsed['dist']['name']
auth = model.Auth(user_agent=ua,
os=os,
browser=browser,
device=device,
ip=ip,
account=user)
auth.save()
expires_days = remember and AUTH_EXPIRES_DAYS or None
self.set_secure_cookie('auth_key',
auth.slug,
expires_days=expires_days,
domain=HOST,
httponly=True,
samesite='strict',
secure=not self.debug)
self.redirect("/home")
def jserror(request):
agent = request.META.get('HTTP_USER_AGENT', None)
os = browser_name = browser_version = bot = TAG_UNKNOWN
if agent:
parsed_agent = httpagentparser.detect(agent)
bot = parsed_agent.get('bot', False)
if 'os' in parsed_agent:
os = parsed_agent['os'].get('name', TAG_UNKNOWN)
if 'browser' in parsed_agent:
browser_version = parsed_agent['browser'].get(
'version', TAG_UNKNOWN)
browser_name = parsed_agent['browser'].get('name', TAG_UNKNOWN)
url = request.POST.get('page', None)
domain = None
if url:
path = urlparse(url).path
if path:
domain = get_domain_from_url(path)
domain = domain or '_unknown'
metrics_counter('commcare.jserror.count',
tags={
'os': os,
'browser_version': browser_version,
'browser_name': browser_name,
'url': sanitize_url(url),
'bot': bot,
'domain': domain,
})
notify_error(message=f'[JS] {request.POST.get("message")}',
details={
'message': request.POST.get('message'),
'domain': domain,
'page': url,
'file': request.POST.get('file'),
'line': request.POST.get('line'),
'stack': request.POST.get('stack'),
'meta': {
'os': os,
'browser_version': browser_version,
'browser_name': browser_name,
'bot': bot,
}
})
return HttpResponse('')
def get_tag_values(self, event):
http = event.interfaces.get('sentry.interfaces.Http')
if not http:
return []
if not http.headers:
return []
if 'User-Agent' not in http.headers:
return []
ua = httpagentparser.detect(http.headers['User-Agent'])
if not ua:
return []
result = self.get_tag_from_ua(ua)
if not result:
return []
return [result]
def index(request):
"""if student, redirect them to timesheet. if faculty allow this page
"""
if 'next' in request.GET and request.GET['next'] != "/":
return HttpResponseRedirect(request.GET['next'])
if request.user.is_staff:
try:
# Warn users of IE and Firefox < 4.0 they are not supported
ua = request.META['HTTP_USER_AGENT']
browser_name = httpagentparser.detect(ua)['browser']['name']
browser_version = httpagentparser.detect(ua)['browser']['version']
if browser_name == "Microsoft Internet Explorer":
messages.warning(request,
mark_safe('Warning Internet Explorer is not supported on the admin site. If you ' \
'have any trouble, try using a standards compliant browser such as Firefox, Chrome, Opera, or Safari.'))
elif browser_name == "Firefox" and int(
browser_version.split('.')[0]) < 6:
messages.warning(
request,
'Warning, your version of Firefox is out of date. Please upgrade.'
)
except:
pass
return HttpResponseRedirect('/admin')
elif request.user.groups.filter(Q(name='students')).count() > 0:
return student_redirect(request)
elif request.user.groups.filter(name='family').count() > 0:
return family_redirect(request)
elif request.user.groups.filter(Q(name='company')).count() > 0:
from ecwsp.work_study.views import supervisor_dash
return supervisor_dash(request)
else:
return render_to_response('base.html', {
'msg': "Not authorized",
'request': request,
}, RequestContext(request, {}))
def show_hit(request, hit_id):
h = get_object_or_404(Hit, pk=hit_id)
#template_name = h.jobs.all()[0].__class__.__name__ + ".html"
template_name = '%s.html' % h.template
print 'template_name:', template_name
try:
useragent = httpagentparser.detect(request.META["HTTP_USER_AGENT"])
except KeyError:
useragent = {'os': {'name': 'Unknown'}}
try:
ip = request.META["HTTP_X_FORWARDED_FOR"]
except KeyError:
ip = '0.0.0.0'
try:
if False:
#country_response = requests.get("http://api.hostip.info/country.php?ip=%s" % ip, timeout=3)
country_response = requests.get("https://freegeoip.net/json/%s" % ip, timeout=4)
country = (country_response.json())['country_code']
else:
country = "GeoLocation Disabled"
except requests.Timeout:
print("ERROR: THE GEOLOCATION API TIMED OUT")
country = "Unknown"
worker_id = request.GET.get("workerId", 'unknown')
#print("Worker: %s\t country: %s"%(worker_id,country))
examples_search = os.path.join(settings.STATIC_DOC_ROOT, 'examples', h.template, '*.png')
examples = []
for example_path in glob.glob(examples_search):
filename = os.path.basename(example_path)
examples.append('%s/static/examples/%s/%s' % (settings.URL_PATH, h.template, filename))
return render(request, template_name, context={
"hit": h,
"assignment": request.GET.get("assignmentId", default_assignment_id),
"worker_id": worker_id,
"forbidden": worker_id in [worker.turk_id for worker in h.forbidden_workers.all()],
"os": useragent["os"]["name"],
#"browser": useragent["browser"]["name"] + " " + useragent["browser"]["version"],
"browser": 'buggy',
"country": country,
"ip": ip,
"path": settings.URL_PATH,
"example_urls": examples,
})
def add_show(request):
error_message = None
data = ipapi.location(output='json')
# print(data)
# print(request.get_host())
# print(socket.gethostname())
# user.ipaddress = get_ip(request)
# print(user.ipaddress)
# ipaddress=get_ip(request)
# print(request.build_absolute_uri())
# print(request.META['HTTP_USER_AGENT'])
# print(request.headers)
# Only find the user agent in (request.headers)
# print(request.headers['User-Agent'])
agent = request.environ.get('HTTP_USER_AGENT')
browser = httpagentparser.detect(agent)
os = platform.system()
if not browser:
browser = agent.split('/')[0]
else:
browser = browser['browser']['name']
if request.method == 'POST':
form = StudentRegistration(request.POST)
if form.is_valid():
nm = form.cleaned_data['name']
em = form.cleaned_data['email']
pw = form.cleaned_data['password']
reg = User2(name=nm, email=em, password=pw)
reg.save()
form = StudentRegistration()
else:
form = StudentRegistration()
stud = User2.objects.all()
context = {
'form': form,
'stu': stud,
'browser': browser,
'os': os,
'data': data,
}
return render(request, 'enroll/addandshow.html', context)
def get_pixel(event, context):
"""
Ingest data and return a 1x1 gif pixel
"""
# print the full event in CloudWatch for debugging purposes
print('raw_event: '+json.dumps(event))
#
headers = event.get('headers',None)
request_context = event.get('requestContext',None)
id = request_context.get('identity')
ua_raw = headers.get('User-Agent','')
ua = httpagentparser.detect(ua_raw)
# if the cookie already exists, then don't generate a new cookie / uuid
cookie = headers.get('Cookie',None)
if cookie == None:
event_id = str(uuid.uuid4())
else:
c = cookies.SimpleCookie()
c.load(cookie)
if 'sid' in c:
event_id = c['sid'].value
else:
event_id = str(uuid.uuid4())
event_wrapper = {
'eventId': event_id, # assign a unique event id to the event or the previous cookie value
'params': event.get('queryStringParameters',''),
'lang': headers.get('Accept-Language',''),
'country': headers.get('CloudFront-Viewer-Country',''),
'referer': headers.get('Referer',''),
'user_agent_raw': ua_raw,
'user_agent': ua,
'x_forward': headers.get('X-Forwarded-For',''),
'req_time_epoch': request_context.get('requestTimeEpoch',''),
'req_time': request_context.get('requestTime',''),
'req_id': request_context.get('requestId',''),
'sourceIP': id.get('sourceIp',''),
'cookie': cookie,
}
print('event_wrapper'+str(event_wrapper))
# do something with the payload, e.g. send data to a message broker
response = drop_message_to_broker(event_wrapper)
# print broker response in CloudWatch for debugging purposes
###print('response: '+str(response))
# finally return the 1x1 gif to the client
return return_pixel_through_gateway(event_id)
def skip_unless_requirements_met(self, test_case):
user_agent_string = self.eval(test_case, 'window.navigator.userAgent')
if user_agent_string[0] == user_agent_string[-1] == '"':
user_agent_string = user_agent_string[1:-1]
agent = httpagentparser.detect(user_agent_string)
if re.match(self.required_name, agent['browser']['name']) is None:
test_case.skipTest('Require browser {}, but have {}.'.format(
self.required_name, agent['browser']['name']))
if self.required_version:
requirement = distutils.versionpredicate.VersionPredicate(
'Browser (%s)' % self.required_version)
skip = not requirement.satisfied_by(
str(agent['browser']['version']))
if skip:
test_case.skipTest('Require {}{}, got {} {}'.format(
self.required_name, self.required_version,
agent['browser']['name'], agent['browser']['version']))
def getAnalyticsData():
global userOS, userBrowser, userIP, userContinent, userCity, userCountry, sessionID
userInfo = httpagentparser.detect(request.headers.get('User-Agent'))
userOS = userInfo['platform']['name']
userBrowser = userInfo['browser']['name']
userIP = "39.52.71.249" if request.remote_addr == '127.0.0.1' else request.remote_addr
api = "https://www.iplocate.io/api/lookup/" + userIP
try:
resp = urllib.request.urlopen(api)
result = resp.read()
result = json.loads(result.decode("utf-8"))
userCountry = result["country"]
userContinent = result["continent"]
userCity = result["city"]
except:
print("Could not find: ", userIP)
getSession()
def getAnalyticsData(): #this function gets visitor's IP address and retreieves data using urlib module
global userOS, userBrowser, userIP, userContinent, userCity, userCountry, sessionID
userInfo = httpagentparser.detect(request.headers.get('User-Agent'))
userOS = userInfo['platform']['name']
userIP = "72.229.28.185" if request.remote_addr == '127.0.0.1' else request.remote_addr
api = "https://www.iplocate.io/api/lookup/" + userIP
try:
resp = urllib.request.urlopen(api)
result = resp.read()
result = json.loads(result.decode("utf-8"))
userCountry = result["country"]
userContinent = result["continent"]
userCity = result["city"]
except:
print("Could not find: ", userIP)
getSession()
def parse(ua: str):
dresult = httpagentparser.detect(ua)
platform = 'unknown'
if 'platform' in dresult and dresult['platform']['name'] != None:
platform = dresult['platform']['name']
elif 'os' in dresult and dresult['os']['name'] != None:
platform = dresult['os']['name']
icon = _PLATFORM_ICON_MAP.get(platform.strip().lower(), 'unknown')
os, browser = httpagentparser.simple_detect(ua)
if (ua.lower().find('amd64') >= 0 or ua.lower().find('x86_64') >= 0
or ua.lower().find('x64') >= 0):
os += ' x64'
return {
'str': ua,
'icon': icon,
'os': os,
'browser': browser,
}
def save_class():
raw_data = request.form
details = httpagentparser.detect(request.headers.get("User-Agent"))
details['operation'] = 'save_class'
details['resolution'] = "%sx%s" % (raw_data.get(
"screen-width", "?"), raw_data.get("screen-height", "?"))
log_event(current_user.kerb, 'submit', details)
data = {col: val.strip() for col, val in raw_data.items()}
try:
class_id = int(data.pop("class_id"))
except Exception as err:
msg = "Error getting class_id: {0}{1!r}".format(
type(err).__name__, err.args)
log_event(current_user.kerb,
'update',
status=-1,
detail={
'data': data,
'msg': msg
})
if debug_mode():
raise
flash_error(msg)
return redirect(url_for("instructor"))
current_user.acknowledge()
try:
flash_notify(current_user.update_class(class_id, data))
except Exception as err:
msg = "Error updating class: {0}{1!r}".format(
type(err).__name__, err.args)
log_event(current_user.kerb,
'update',
status=-1,
detail={
'class_id': class_id,
'data': data,
'msg': msg
})
if debug_mode():
raise
flash_error(msg)
return redirect(url_for("instructor"))
def detect_ua(self):
try:
if self.ua and self.counter == 0:
import httpagentparser
data = httpagentparser.detect(self.ua)
get = lambda b, k: data.get(b, {}).get(k, '')
self.ua_os = get('os', 'name')
self.ua_os_version = get('os', 'version')
self.ua_dist = get('platform', 'name')
self.ua_dist_version = get('platform', 'version')
self.ua_browser = get('browser', 'name')
self.ua_browser_version = get('browser', 'version')
except ImportError:
pass
def send_auditlog_record(line):
global failcount, queuelength
with countlock:
queuelength -= 1
# Invalid json input is not an error we can handle
msg = json.loads(line)
task = msg['event']
user = msg['user']
if task == "User Access":
action = user
else:
action = msg.get('action') or '|'.join(
msg.get(x)
for x in ('study', 'subset1', 'subset2', 'analysis', 'query',
'facetQuery', 'clientId', 'experiment') if msg.get(x))
args = dict(
action=action,
application=msg['program'],
appVersion=msg['programVersion'],
user=user,
task=task,
)
if msg['userAgent']:
args['browser'] = '<unknown browser>'
browser = httpagentparser.detect(msg['userAgent']).get('browser')
if browser:
args['browser'] = browser['name'] + ' ' + browser['version']
else:
args['browser'] = "NA"
fullurl = URL + '?' + urllib.parse.urlencode(args)
#print(fullurl)
try:
#raise Exception('testing')
urllib.request.urlopen(Request(fullurl, method='POST'),
timeout=TIMEOUT).readall()
except Exception as exc:
with countlock:
failcount += 1
log.error("{e}, url: {url}".format(e=' '.join(
str(e) for e in exc.args),
url=fullurl))
def browser_check(self):
""" Will redirect to an error page if an unsupported browser is used. """
browser_name = u''
browser_version = 0
try:
user_agent = httpagentparser.detect(self.request.user_agent)
browser_name = user_agent['browser']['name']
browser_version = Decimal(
user_agent['browser']['version']
[0:user_agent['browser']['version'].find('.')])
except:
pass
#FIXME: maybe this definition should be somewhere else
#FIXME: This will break easilly and should have a try except
if browser_name == u'Microsoft Internet Explorer' and browser_version < Decimal(
8):
url = self.request.resource_url(self.context,
'unsupported_browser')
return HTTPFound(location=url)
def get_ua(self, uas):
'''
generate flat list of UA attributes
:param uas: ua string from client
:return: flat dict of detected ua attributes.
'''
d = httpagentparser.detect(uas)
r = {}
for k, v in d.items():
if isinstance(v, dict):
for k1, v1 in v.items():
if v1:
r[k + '_' + k1] = v1
else:
r[k] = v
if not r:
r['browser_name'] = uas
return r
def wrapper(*args, **kwargs):
g.auth = Auth(PUBLIC, None)
user_agent_str = request.headers.get('user-agent', '')
g.user_agent = httpagentparser.detect(user_agent_str,
fill_none=True)
if validator is not None:
try:
validator.validate(request.get_json(cache=True))
except ValidationError as ex:
raise ApiException(requests.codes.bad_request, ex.message)
auth = request.headers.get(AUTHORIZATION_HEADER)
g.auth_header = auth
if auth is None:
if require_login:
raise ApiException(requests.codes.unauthorized,
"Not logged in")
else:
headers = {AUTHORIZATION_HEADER: auth}
try:
resp = requests.get(OAUTH_USER_API, headers=headers)
resp.raise_for_status()
data = resp.json()
# TODO(dima): Generalize this.
user = data.get('current_user', data.get('login'))
assert user
email = data['email']
g.auth = Auth(user, email)
except requests.HTTPError as ex:
if resp.status_code == requests.codes.unauthorized:
raise ApiException(requests.codes.unauthorized,
"Invalid credentials")
else:
raise ApiException(requests.codes.server_error,
"Server error")
except (ConnectionError, requests.RequestException) as ex:
raise ApiException(requests.codes.server_error,
"Server error")
return f(*args, **kwargs)
def parse(ua):
agent_summary = {}
parsed = httpagentparser.detect(ua)
for attr in ("browser", "os", "platform"):
d = parsed.get(attr)
if d:
for subattr in ("name", "version"):
if subattr in d:
key = "%s_%s" % (attr, subattr)
agent_summary[key] = d[subattr]
agent_summary["bot"] = parsed.get("bot")
dist = parsed.get("dist")
if dist:
agent_summary["sub-platform"] = dist.get("name")
return agent_summary
def parse_useragent(records, searcher):
for record in records:
dua = detect(record.get("http_user_agent", None))
record['platform_version'] = dua.get('platform', {}).get('version', None)
record['platform_name'] = dua.get('platform', {}).get('name', None)
record['os_version'] = dua.get('os', {}).get('version', None)
record['os_name'] = dua.get('os', {}).get('name', None)
record['browser_version'] = dua.get('browser', {}).get('version', None)
record['browser_name'] = dua.get('browser', {}).get('name', None)
record['robot'] = dua.get('bot', False)
value = record.get("remote_addr", None)
remoteip = value if value else record.get("http_x_forwarded_for", None)
if not searcher.isip(remoteip):
logging.error("Invalid ip address", remoteip)
data = {}
else:
data = searcher.btreeSearch(remoteip)
record['region'] = data.get("region", None).decode('utf-8')
yield record
def chat(ws):
print ws
agent = request.environ.get('HTTP_USER_AGENT')
browser = httpagentparser.detect(agent)
print browser
client = MongoClient()
db = client.test
users.add(ws)
cur = db.socket_count.find_one()
data = json.loads(dumps(cur))
count = int(data['count'])
cur = db.socket_count.update({'soc': 'true'},
{'$set': {
'count': count + 1
}})
print 'Clients online :', count + 1
while True:
msg = ws.receive()
if msg is not None:
for u in users:
u.send(msg)
else:
break
cur = db.socket_count.find_one()
data = json.loads(dumps(cur))
count = int(data['count'])
cur = db.socket_count.update({'soc': 'true'},
{'$set': {
'count': count - 1
}})
print 'Clients online :', count - 1
users.remove(ws)
def run(self):
# Return All the users in the User table
self.log = Logger('DashboardSessionGetHandlerThread')
TAG = 'run'
date_handler = lambda obj: obj.isoformat() if isinstance(
obj,
datetime.datetime) else None
offset = self.request.get_argument('offset', None)
count = self.request.get_argument('count', None)
session = SessionDBHelper()
session_list = session.get_sessions_with_page(self.company_id,
offset, count)
if session_list is None or len(session_list) == 0:
self.log.i(TAG, 'No Session in Session table')
session_list = []
for each_session in session_list:
temp_user_agent = httpagentparser.detect(each_session.get(
'user_agent'))
if 'browser' in temp_user_agent:
temp_browser = temp_user_agent.get('browser').get('name')
else:
temp_browser = None
if 'os' in temp_user_agent:
temp_os = temp_user_agent.get('os').get('name')
else:
temp_os = None
each_session[
'user_agent'] = '{0}/{1}'.format(temp_os, temp_browser)
return_dict = {}
return_dict['count'] = session.get_sessions_count(self.company_id)
return_dict['data'] = session_list
return_dict['message'] = "Seems like things are working ..."
return_dict['pass'] = True
opJson = json.dumps(return_dict, default=date_handler)
#self.request.add_header('Access-Control-Allow-Origin', '*')
self.request.set_header('Content-Type', 'application/json')
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
