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)