def process_request(self, request):
is_mobile = False
if "HTTP_USER_AGENT" in request.META:
user_agent = request.META["HTTP_USER_AGENT"]
# Test common mobile values.
if self.user_agents_test_search_regex.search(
user_agent
) and not self.user_agents_exception_search_regex.search(user_agent):
is_mobile = True
# Test for Amazon CloudFront mobile viewer
elif "HTTP_CLOUDFRONT_IS_MOBILE_VIEWER" in request.META:
if request.META["HTTP_CLOUDFRONT_IS_MOBILE_VIEWER"] == "true":
is_mobile = True
else:
# Nokia like test for WAP browsers.
# http://www.developershome.com/wap/xhtmlmp/xhtml_mp_tutorial.asp?page=mimeTypesFileExtension
if "HTTP_ACCEPT" in request.META:
http_accept = request.META["HTTP_ACCEPT"]
if self.http_accept_regex.search(http_accept):
is_mobile = True
if not is_mobile:
# Now we test the user_agent from a big list.
if self.user_agents_test_match_regex.match(user_agent):
is_mobile = True
if is_mobile:
set_flavour(settings.DEFAULT_MOBILE_FLAVOUR, request)
else:
set_flavour(settings.FLAVOURS[0], request)
def process_request(self, request):
is_mobile = False
if 'HTTP_USER_AGENT' in request.META:
user_agent = request.META['HTTP_USER_AGENT']
uc_header_key = [
k for k in request.META.keys() if 'ucbrowser' in k.lower()]
if uc_header_key and\
'android' in request.META[uc_header_key[0]].lower():
is_mobile = True
# Test common mobile values.
if self.user_agents_test_search_regex.search(user_agent) and not\
self.user_agents_exception_search_regex.search(user_agent):
is_mobile = True
else:
# Nokia like test for WAP browsers.
# http://www.developershome.com/wap/xhtmlmp/xhtml_mp_tutorial.asp?page=mimeTypesFileExtension
if 'HTTP_ACCEPT' in request.META:
http_accept = request.META['HTTP_ACCEPT']
if self.http_accept_regex.search(http_accept):
is_mobile = True
if not is_mobile:
# Now we test the user_agent from a big list.
if self.user_agents_test_match_regex.match(user_agent):
is_mobile = True
if is_mobile:
set_flavour(settings.DEFAULT_MOBILE_FLAVOUR, request)
else:
set_flavour(settings.FLAVOURS[0], request)
def process_request(self, request):
is_mobile = False
if request.META.has_key('HTTP_USER_AGENT'):
user_agent = request.META['HTTP_USER_AGENT']
# Test common mobile values.
if self.user_agents_test_search_regex.search(user_agent):
is_mobile = True
else:
# Nokia like test for WAP browsers.
# http://www.developershome.com/wap/xhtmlmp/xhtml_mp_tutorial.asp?page=mimeTypesFileExtension
if request.META.has_key('HTTP_ACCEPT'):
http_accept = request.META['HTTP_ACCEPT']
if self.http_accept_regex.search(http_accept):
is_mobile = True
if not is_mobile:
# Now we test the user_agent from a big list.
if self.user_agents_test_match_regex.match(user_agent):
is_mobile = True
if is_mobile:
set_flavour(settings.DEFAULT_MOBILE_FLAVOUR, request)
def test_set_flavour_with_session_backend(self):
original_FLAVOURS_STORAGE_BACKEND = settings.FLAVOURS_STORAGE_BACKEND
try:
settings.FLAVOURS_STORAGE_BACKEND = 'session'
request = Mock()
request.session = {}
set_flavour('mobile', request=request)
self.assertEqual(request.session, {})
set_flavour('mobile', request=request, permanent=True)
self.assertEqual(request.session, {
settings.FLAVOURS_SESSION_KEY: u'mobile'
})
self.assertEqual(get_flavour(request), 'mobile')
response = self.client.get('/')
self.assertFalse('sessionid' in response.cookies)
response = self.client.get('/', {
settings.FLAVOURS_GET_PARAMETER: 'mobile',
})
self.assertTrue('sessionid' in response.cookies)
sessionid = response.cookies['sessionid'].value
session = Session.objects.get(session_key=sessionid)
session_data = session.get_decoded()
self.assertTrue(settings.FLAVOURS_SESSION_KEY in session_data)
self.assertEqual(session_data[settings.FLAVOURS_SESSION_KEY], 'mobile')
finally:
settings.FLAVOURS_STORAGE_BACKEND = original_FLAVOURS_STORAGE_BACKEND
def process_request(self, request):
is_mobile = False
if 'HTTP_USER_AGENT' in request.META:
user_agent = request.META['HTTP_USER_AGENT']
# Test common mobile values.
if self.user_agents_test_search_regex.search(user_agent):
is_mobile = True
compile_str = [
r.lower() for r in
self.user_agents_exception_search_regex.findall(user_agent)
]
# in wechat == ['pad', 'micromessenger'] in app == ['pad', 'dkhs'] in brower == ['pad']
if compile_str == ['pad']:
is_mobile = False
else:
# Nokia like test for WAP browsers.
# http://www.developershome.com/wap/xhtmlmp/xhtml_mp_tutorial.asp?page=mimeTypesFileExtension
if 'HTTP_ACCEPT' in request.META:
http_accept = request.META['HTTP_ACCEPT']
if self.http_accept_regex.search(http_accept):
is_mobile = True
if not is_mobile:
# Now we test the user_agent from a big list.
if self.user_agents_test_match_regex.match(user_agent):
is_mobile = True
if is_mobile:
set_flavour(settings.DEFAULT_MOBILE_FLAVOUR, request)
else:
set_flavour(settings.FLAVOURS[0], request)
def process_request(self, request):
_init_flavour(request)
if settings.FLAVOURS_GET_PARAMETER in request.GET:
flavour = request.GET[settings.FLAVOURS_GET_PARAMETER]
if flavour in settings.FLAVOURS:
set_flavour(flavour, request, permanent=True)
def process_request(self, request):
"""
Check if the flavour has been overridden by ?flavour
We don't need this check if it has
"""
if flavour_storage.get(request) == None:
is_mobile = False
if request.META.has_key('HTTP_USER_AGENT'):
user_agent = request.META['HTTP_USER_AGENT']
# Test common mobile values.
if self.user_agents_test_search_regex.search(user_agent) and \
not self.user_agents_exception_search_regex.search(user_agent):
is_mobile = True
else:
# Nokia like test for WAP browsers.
# http://www.developershome.com/wap/xhtmlmp/xhtml_mp_tutorial.asp?page=mimeTypesFileExtension
if request.META.has_key('HTTP_ACCEPT'):
http_accept = request.META['HTTP_ACCEPT']
if self.http_accept_regex.search(http_accept):
is_mobile = True
if not is_mobile:
# Now we test the user_agent from a big list.
if self.user_agents_test_match_regex.match(user_agent):
is_mobile = True
if is_mobile:
set_flavour(settings.DEFAULT_MOBILE_FLAVOUR, request, permanent=True)
else:
set_flavour(settings.FLAVOURS[0], request, permanent=True)
def process_request(self, request):
is_mobile = False
if request.META.has_key('HTTP_USER_AGENT'):
user_agent = request.META['HTTP_USER_AGENT']
# Test common mobile values.
if self.user_agents_test_search_regex.search(user_agent):
is_mobile = True
else:
# Nokia like test for WAP browsers.
# http://www.developershome.com/wap/xhtmlmp/xhtml_mp_tutorial.asp?page=mimeTypesFileExtension
if request.META.has_key('HTTP_ACCEPT'):
http_accept = request.META['HTTP_ACCEPT']
if self.http_accept_regex.search(http_accept):
is_mobile = True
if not is_mobile:
# Now we test the user_agent from a big list.
if self.user_agents_test_match_regex.match(user_agent):
is_mobile = True
if is_mobile:
set_flavour(settings.DEFAULT_MOBILE_FLAVOUR, request)
else:
set_flavour(settings.FLAVOURS[0], request)
def process_request(self, request):
is_mobile = False
# logger.debug('this request META:%s'%request.META)
if 'HTTP_USER_AGENT' in request.META :
user_agent = request.META['HTTP_USER_AGENT']
# Test common mobile values.
if self.user_agents_test_search_regex.search(user_agent) and \
not self.user_agents_exception_search_regex.search(user_agent):
is_mobile = True
else:
# Nokia like test for WAP browsers.
# http://www.developershome.com/wap/xhtmlmp/xhtml_mp_tutorial.asp?page=mimeTypesFileExtension
if 'HTTP_ACCEPT' in request.META :
http_accept = request.META['HTTP_ACCEPT']
if self.http_accept_regex.search(http_accept):
is_mobile = True
if not is_mobile:
# Now we test the user_agent from a big list.
if self.user_agents_test_match_regex.match(user_agent):
is_mobile = True
logger.debug("check is_mobile:%s"%is_mobile)
request.is_mobile = is_mobile
if is_mobile:
set_flavour(settings.DEFAULT_MOBILE_FLAVOUR, request)
else:
set_flavour(settings.FLAVOURS[0], request)
def test_set_flavour_with_session_backend(self):
original_FLAVOURS_STORAGE_BACKEND = settings.FLAVOURS_STORAGE_BACKEND
try:
settings.FLAVOURS_STORAGE_BACKEND = "session"
request = Mock()
request.session = {}
set_flavour("mobile", request=request)
self.assertEqual(request.session, {})
set_flavour("mobile", request=request, permanent=True)
self.assertEqual(
request.session, {settings.FLAVOURS_SESSION_KEY: "mobile"}
)
self.assertEqual(get_flavour(request), "mobile")
response = self.client.get("/")
self.assertFalse("sessionid" in response.cookies)
response = self.client.get(
"/", {settings.FLAVOURS_GET_PARAMETER: "mobile",}
)
self.assertTrue("sessionid" in response.cookies)
sessionid = response.cookies["sessionid"].value
session = Session.objects.get(session_key=sessionid)
session_data = session.get_decoded()
self.assertTrue(settings.FLAVOURS_SESSION_KEY in session_data)
self.assertEqual(session_data[settings.FLAVOURS_SESSION_KEY], "mobile")
finally:
settings.FLAVOURS_STORAGE_BACKEND = original_FLAVOURS_STORAGE_BACKEND
def process_request(self, request):
_init_flavour(request)
if settings.FLAVOURS_GET_PARAMETER in request.GET:
flavour = request.GET[settings.FLAVOURS_GET_PARAMETER]
if flavour in settings.FLAVOURS:
set_flavour(flavour, request, permanent=True)
def testing(filesystem_loader, app_directories_loader):
filesystem_loader.return_value = []
app_directories_loader.return_value = []
from django_mobile.loader import Loader
loader = Loader(get_engine())
set_flavour('mobile')
try:
loader.get_template('base.html')
except TemplateDoesNotExist:
pass
self.assertEqual(filesystem_loader.call_args[0][0],
'mobile/base.html')
self.assertEqual(app_directories_loader.call_args[0][0],
'mobile/base.html')
set_flavour('full')
try:
loader.get_template('base.html')
except TemplateDoesNotExist:
pass
self.assertEqual(filesystem_loader.call_args[0][0],
'full/base.html')
self.assertEqual(app_directories_loader.call_args[0][0],
'full/base.html')
def test_load_template_on_filesystem(self, filesystem_loader,
app_directories_loader):
filesystem_loader.side_effect = TemplateDoesNotExist()
app_directories_loader.side_effect = TemplateDoesNotExist()
from django_mobile.loader import Loader
loader = Loader()
set_flavour('mobile')
try:
loader.load_template('base.html', template_dirs=None)
except TemplateDoesNotExist:
pass
self.assertEqual(filesystem_loader.call_args[0][0], 'mobile/base.html')
self.assertEqual(app_directories_loader.call_args[0][0],
'mobile/base.html')
set_flavour('full')
try:
loader.load_template('base.html', template_dirs=None)
except TemplateDoesNotExist:
pass
self.assertEqual(filesystem_loader.call_args[0][0], 'full/base.html')
self.assertEqual(app_directories_loader.call_args[0][0],
'full/base.html')
def test_set_flavour_with_session_backend(self):
original_FLAVOURS_STORAGE_BACKEND = settings.FLAVOURS_STORAGE_BACKEND
try:
settings.FLAVOURS_STORAGE_BACKEND = 'session'
request = Mock()
request.session = {}
set_flavour('mobile', request=request)
self.assertEqual(request.session, {})
set_flavour('mobile', request=request, permanent=True)
self.assertEqual(request.session, {
settings.FLAVOURS_SESSION_KEY: u'mobile'
})
self.assertEqual(get_flavour(request), 'mobile')
response = self.client.get('/')
self.assertFalse('sessionid' in response.cookies)
response = self.client.get('/', {
settings.FLAVOURS_GET_PARAMETER: 'mobile',
})
self.assertTrue('sessionid' in response.cookies)
sessionid = response.cookies['sessionid'].value
session = Session.objects.get(session_key=sessionid)
session_data = session.get_decoded()
self.assertTrue(settings.FLAVOURS_SESSION_KEY in session_data)
self.assertEqual(session_data[settings.FLAVOURS_SESSION_KEY], 'mobile')
finally:
settings.FLAVOURS_STORAGE_BACKEND = original_FLAVOURS_STORAGE_BACKEND
def test_set_flavour_permanent(self):
request = Mock()
request.session = MagicMock()
set_flavour("mobile", request=request)
self.assertEqual(request.session.__setitem__.call_args, None)
set_flavour("mobile", request=request, permanent=True)
self.assertEqual(request.session.__setitem__.call_args, ((settings.FLAVOURS_SESSION_KEY, "mobile"), {}))
def process_request(self, request):
if request.META.has_key('HTTP_X_PLATTFORM'):
if request.META['HTTP_X_PLATTFORM'] == "mobile":
set_flavour(settings.DEFAULT_MOBILE_FLAVOUR, request, permanent=False)
else:
#set default flavour if none is given in header to avoid old flavours from session
set_flavour(settings.FLAVOURS[0], request, permanent=False)
def dispatch(self, request, *args, **kwargs):
if self.request.GET.get('preview') and self.request.GET.get(
'preview') in settings.FLAVOURS:
set_flavour(self.request.GET.get('preview'), permanent=False)
if self.request.flavour != settings.DEFAULT_MOBILE_FLAVOUR:
return redirect('home')
return super(RedirectNonSP, self).dispatch(request, *args, **kwargs)
def process_request(self, request):
_init_flavour(request)
if settings.FLAVOURS_GET_PARAMETER in request.GET:
flavour = request.GET[settings.FLAVOURS_GET_PARAMETER]
if flavour in settings.FLAVOURS:
set_flavour(flavour, request, permanent=True)
elif flavour_storage.get(request) != None:
#if it's been set, we need it in the request now,
#not after the view has been processed
set_flavour(flavour_storage.get(request), request)
def test_set_flavour_permanent(self):
request = Mock()
request.session = MagicMock()
set_flavour('mobile', request=request)
self.assertEqual(request.session.__setitem__.call_args, None)
set_flavour('mobile', request=request, permanent=True)
self.assertEqual(
request.session.__setitem__.call_args,
((settings.FLAVOURS_SESSION_KEY, 'mobile',), {}))
def __call__(self, request):
_init_flavour(request)
if settings.FLAVOURS_GET_PARAMETER in request.GET:
flavour = request.GET[settings.FLAVOURS_GET_PARAMETER]
if flavour in settings.FLAVOURS:
set_flavour(flavour, request, permanent=True)
response = self.get_response(request)
flavour_storage.save(request, response)
return response
def test_set_flavour_with_session_backend(self):
original_FLAVOURS_STORAGE_BACKEND = settings.FLAVOURS_STORAGE_BACKEND
try:
settings.FLAVOURS_STORAGE_BACKEND = 'session'
request = Mock()
request.session = {}
set_flavour('mobile', request=request)
self.assertEqual(request.session, {})
set_flavour('mobile', request=request, permanent=True)
self.assertEqual(request.session, {settings.FLAVOURS_SESSION_KEY: 'mobile'})
self.assertEqual(get_flavour(request), 'mobile')
finally:
settings.FLAVOURS_STORAGE_BACKEND = original_FLAVOURS_STORAGE_BACKEND
def test_set_flavour_with_cookie_backend(self):
original_FLAVOURS_STORAGE_BACKEND = settings.FLAVOURS_STORAGE_BACKEND
try:
settings.FLAVOURS_STORAGE_BACKEND = 'cookie'
request = Mock()
request.COOKIES = {}
set_flavour('mobile', request=request)
self.assertEqual(request.COOKIES, {})
set_flavour('mobile', request=request, permanent=True)
self.assertEqual(request.COOKIES, {settings.FLAVOURS_COOKIE_KEY: 'mobile'})
self.assertEqual(get_flavour(request), 'mobile')
finally:
settings.FLAVOURS_STORAGE_BACKEND = original_FLAVOURS_STORAGE_BACKEND
def test_functional(self):
from django.template.loader import render_to_string
result = render_to_string('index.html')
result = result.strip()
self.assertEqual(result, 'Hello .')
set_flavour('full')
result = render_to_string('index.html')
result = result.strip()
self.assertEqual(result, 'Hello full.')
set_flavour('mobile')
result = render_to_string('index.html')
result = result.strip()
self.assertEqual(result, 'Mobile!')
def test_functional(self):
from django.template.loader import render_to_string
set_flavour('full')
result = render_to_string('index.html')
result = result.strip()
self.assertEqual(result, 'Hello .')
# simulate RequestContext
result = render_to_string('index.html', context_instance=RequestContext(Mock()))
result = result.strip()
self.assertEqual(result, 'Hello full.')
set_flavour('mobile')
result = render_to_string('index.html')
result = result.strip()
self.assertEqual(result, 'Mobile!')
def test_functional(self):
from django.template.loader import render_to_string
set_flavour('full')
result = render_to_string('index.html')
result = result.strip()
self.assertEqual(result, 'Hello .')
# simulate RequestContext
result = render_to_string('index.html', context_instance=RequestContext(Mock()))
result = result.strip()
self.assertEqual(result, 'Hello full.')
set_flavour('mobile')
result = render_to_string('index.html')
result = result.strip()
self.assertEqual(result, 'Mobile!')
def mobile_switcher(request):
if 'django_mobile' in INSTALLED_APPS:
from django_mobile import set_flavour
from django_mobile import get_flavour
try:
if get_flavour() == 'mobile':
set_flavour('full', request=request, permanent=True)
else:
set_flavour('mobile', request=request, permanent=True)
return HttpResponseRedirect(reverse('site-index'))
except ValueError:
return render(request, '404.html', {
'alert': '"%s" is not a valid display option for this site.' % flavor
})
def test_functional(self):
from django.template.loader import render_to_string
set_flavour("full")
result = render_to_string("index.html")
result = result.strip()
self.assertEqual(result, "Hello .")
# simulate RequestContext
result = render_to_string("index.html", request=RequestContext(Mock()))
result = result.strip()
self.assertEqual(result, "Hello full.")
set_flavour("mobile")
result = render_to_string("index.html")
result = result.strip()
self.assertEqual(result, "Mobile!")
def test_functional(self):
from django.template.loader import render_to_string
set_flavour("full")
result = render_to_string("index.html")
result = result.strip()
self.assertEqual(result, "Hello .")
# simulate RequestContext
result = render_to_string("index.html", context_instance=RequestContext(Mock()))
result = result.strip()
self.assertEqual(result, "Hello full.")
set_flavour("mobile")
result = render_to_string("index.html")
result = result.strip()
self.assertEqual(result, "Mobile!")
def test_functional(self):
from django.template.loader import render_to_string
set_flavour('full')
result = render_to_string('index.html')
result = result.strip()
self.assertEqual(result, 'Hello .')
# simulate RequestContext
response = self.client.get('/')
result = response.content
if six.PY3:
result = result.decode('utf-8')
result = result.strip()
self.assertEqual(result, 'Hello full.')
set_flavour('mobile')
result = render_to_string('index.html')
result = result.strip()
self.assertEqual(result, 'Mobile!')
def index(request):
if mobile==True:
set_flavour("mobile",permanent=True)
redirectUrl = "findSignals/"
if request.flavour == "mobile":
redirectUrl = "mobileViewSignalsNear/"
if request.user.is_authenticated():
# Do something for authenticated users.
try:
extra = UserExtra.objects.get(user=request.user)
except:
extra = None
return redirect(redirectUrl)
def process_request(self, request):
is_tablet = False
user_agent = request.META.get('HTTP_USER_AGENT')
if user_agent:
# Ipad or Blackberry
if self.user_agents_tablets_search_regex.search(user_agent):
is_tablet = True
# Android-device. If User-Agent doesn't contain Mobile, then it's a tablet
elif (self.user_agents_android_search_regex.search(user_agent) and
not self.user_agents_mobile_search_regex.search(user_agent)):
is_tablet = True
else:
# otherwise, let the superclass make decision
super(MobileTabletDetectionMiddleware, self).process_request(request)
# set tablet flavour. It can be `mobile`, `tablet` or anything you want
if is_tablet:
set_flavour(settings.FLAVOURS[2], request)
def process_request(self, request):
user_agent = request.META.get('HTTP_USER_AGENT')
is_tablet = False
if user_agent:
is_ipad = self.user_agents_tablets_search_regex.search(user_agent)
is_android = self.user_agents_android_search_regex.search(
user_agent)
is_not_mobile = not self.user_agents_mobile_search_regex.search(
user_agent)
is_android_tablet = is_android and is_not_mobile
is_tablet = is_ipad or is_android_tablet
if is_tablet:
set_flavour(settings.FLAVOURS[2], request)
else:
super(MobileTabletDetectionMiddleware,
self).process_request(request)
def process_request(self, request):
is_tablet = False
user_agent = request.META.get('HTTP_USER_AGENT')
if user_agent:
# Ipad or Blackberry
if self.user_agents_tablets_search_regex.search(user_agent):
is_tablet = True
# Android-device. If User-Agent doesn't contain Mobile, then it's a tablet
elif (self.user_agents_android_search_regex.search(user_agent) and
not self.user_agents_mobile_search_regex.search(user_agent)):
is_tablet = True
else:
# otherwise, let the superclass make decision
super(MobileTabletDetectionMiddleware,
self).process_request(request)
# set tablet flavour. It can be `mobile`, `tablet` or anything you want
if is_tablet:
set_flavour(settings.FLAVOURS[2], request)
def process_request(self, request):
is_mobile = False;
is_tablet = False;
is_phone = False;
user_agent = request.META.get("HTTP_USER_AGENT")
http_accept = request.META.get("HTTP_ACCEPT")
if user_agent and http_accept:
agent = mdetect.UAgentInfo(userAgent=user_agent, httpAccept=http_accept)
is_tablet = agent.detectTierTablet()
is_phone = agent.detectTierIphone()
is_mobile = is_tablet or is_phone or agent.detectMobileQuick()
request.is_mobile = is_mobile
request.is_tablet = is_tablet
request.is_phone = is_phone
if is_phone:
request.flavour = 'mobile'
set_flavour('mobile')
elif is_tablet:
set_flavour('tablet')
request.flavour = 'tablet'
else:
set_flavour('full')
request.flavour = 'full'
def testing(filesystem_loader, app_directories_loader):
filesystem_loader.side_effect = TemplateDoesNotExist('error')
app_directories_loader.side_effect = TemplateDoesNotExist('error')
from django_mobile.loader import Loader
loader = Loader(get_engine())
set_flavour('mobile')
try:
loader.load_template_source('base.html')
except TemplateDoesNotExist:
pass
self.assertEqual(filesystem_loader.call_args, 'mobile/base.html')
self.assertEqual(app_directories_loader.call_args, 'mobile/base.html')
set_flavour('full')
try:
loader.load_template_source('base.html')
except TemplateDoesNotExist:
pass
self.assertEqual(filesystem_loader.call_args, 'full/base.html')
self.assertEqual(app_directories_loader.call_args, 'full/base.html')
def test_load_template_source_on_filesystem(self, filesystem_loader, app_directories_loader):
filesystem_loader.side_effect = TemplateDoesNotExist()
app_directories_loader.side_effect = TemplateDoesNotExist()
from django_mobile.loader import Loader
loader = Loader()
set_flavour('mobile')
try:
loader.load_template_source('base.html', template_dirs=None)
except TemplateDoesNotExist:
pass
self.assertEqual(filesystem_loader.call_args[0][0], 'mobile/base.html')
self.assertEqual(app_directories_loader.call_args[0][0], 'mobile/base.html')
set_flavour('full')
try:
loader.load_template_source('base.html', template_dirs=None)
except TemplateDoesNotExist:
pass
self.assertEqual(filesystem_loader.call_args[0][0], 'full/base.html')
self.assertEqual(app_directories_loader.call_args[0][0], 'full/base.html')
def testing(filesystem_loader, app_directories_loader):
filesystem_loader.side_effect = TemplateDoesNotExist("error")
app_directories_loader.side_effect = TemplateDoesNotExist("error")
from django_mobile.loader import Loader
loader = Loader(get_engine())
set_flavour("mobile")
try:
loader.get_template("base.html")
except TemplateDoesNotExist:
pass
self.assertEqual(filesystem_loader.call_args[0][0], "mobile/base.html")
self.assertEqual(app_directories_loader.call_args[0][0], "mobile/base.html")
set_flavour("full")
try:
loader.get_template("base.html")
except TemplateDoesNotExist:
pass
self.assertEqual(filesystem_loader.call_args[0][0], "full/base.html")
self.assertEqual(app_directories_loader.call_args[0][0], "full/base.html")
def process_request(self, request):
saved_flavour = flavour_storage.get(request)
if saved_flavour is None:
if UADetector(request).is_user_agent_mobile():
set_flavour(settings.DEFAULT_MOBILE_FLAVOUR, request)
else:
set_flavour(settings.FLAVOURS[0], request)
else:
set_flavour(saved_flavour, request)
def process_request(self, request):
user_agent = request.META.get("HTTP_USER_AGENT")
http_accept = request.META.get("HTTP_ACCEPT")
if user_agent:
esp = UAgentInfo(userAgent=user_agent, httpAccept=http_accept)
if esp.detectTierTablet():
set_flavour(settings.FLAVOURS[1], request)
else:
if esp.detectMobileQuick():
set_flavour(settings.FLAVOURS[2], request)
else:
if esp.detectAndroidPhone():
set_flavour(settings.FLAVOURS[2], request)
else:
#logger.debug('full')
set_flavour(settings.FLAVOURS[0], request)
from django.core.mail import send_mail
from django.template.loader import render_to_string
from django_mobile import set_flavour
from django.contrib.sessions.models import Session
from django.utils import timezone
from django.db.models import Q
from django.template import RequestContext
import json
User = get_user_model()
###########################################################
#Authentication#
set_flavour('mobile')
render_to_string('mobile.html')
def register(request, register_form=UserRegistrationForm):
if request.flavour == 'mobile':
return render(request, 'mobile.html')
if request.user.is_authenticated():
return redirect(profile)
if request.method == 'POST':
def test_set_flavour(self):
set_flavour("full")
self.assertEqual(get_flavour(), "full")
set_flavour("mobile")
self.assertEqual(get_flavour(), "mobile")
self.assertRaises(ValueError, set_flavour, "spam")
def process_request(self, request):
if get_flavour(request) == 'amp':
from django.core.urlresolvers import resolve
current_url = resolve(request.path_info).url_name
if current_url != 'article_detail':
set_flavour('mobile', request, permanent=True)
def test_set_flavour(self):
set_flavour("full")
self.assertEqual(get_flavour(), "full")
set_flavour("mobile")
self.assertEqual(get_flavour(), "mobile")
self.assertRaises(ValueError, set_flavour, "spam")
def test_set_flavour(self):
set_flavour('full')
self.assertEqual(get_flavour(), 'full')
set_flavour('mobile')
self.assertEqual(get_flavour(), 'mobile')
self.assertRaises(ValueError, set_flavour, 'spam')
def test_set_flavour(self):
set_flavour('full')
self.assertEqual(get_flavour(), 'full')
set_flavour('mobile')
self.assertEqual(get_flavour(), 'mobile')
self.assertRaises(ValueError, set_flavour, 'spam')
