def queryMyGithub(self):
conn = httplib.HTTPSConnection(host = 'api.github.com')
if self.etag is not None:
if self.lastTimeFetchedGithub is not None and self.myGithubInfo is not None:
delta = datetime.timedelta(minutes = 20)
now = datetime.datetime.now()
if now - self.lastTimeFetchedGithub < delta:
return self.myGithubInfo
conn.request(method = 'GET', url = '/users/lpgray', headers = {'User-Agent' : 'lpgray', 'If-None-Match' : self.etag})
resp = conn.getresponse()
self.etag = resp.getheader('ETag')
if resp.status is 304:
conn.close()
return self.myGithubInfo
else:
self.myGithubInfo = json.loads(resp.read())
conn.close()
return self.myGithubInfo
else:
conn.request(method = 'GET', url = '/users/lpgray', headers = {'User-Agent' : 'lpgray'})
resp = conn.getresponse()
if resp.status is 200:
self.etag = resp.getheader('ETag')
self.myGithubInfo = json.loads(resp.read())
self.lastTimeFetchedGithub = datetime.datetime.now()
conn.close()
return self.myGithubInfo
else:
file = open(settings.PROJECT_PATH + '/github_profile.json')
self.myGithubInfo = json.loads(file.read())
file.close()
conn.close()
return self.myGithubInfo
def render(self, name, value, attrs=None):
output = super(TypeaheadTextInput, self).render(name=name, value=value, attrs=attrs,)
if self.local != "":
self.local = 'local: $.map('+self.local+', function(v) { return { value: v }; }),'
if self.prefetch != "":
self.prefetch = '''prefetch: {url: "'''+self.prefetch+'''",
ttl: '''+str(self.prefetch_ttl*60000)+''',
filter: function(list) {
return $.map(list, function(v) { return { value: v }; });
}
},'''
if self.remote != "":
self.remote = '''remote: {url: "'''+self.remote+'''",
filter: function(list) {
return $.map(list, function(v) { return { value: v }; });
}
}'''
stresponse = SimpleTemplateResponse("django_typeahead_textinput/typeahead-bloodhound-script.html",
{"typeahead_name": "id_"+name,
"typeahead_local": self.local,
"typeahead_prefetch": self.prefetch,
"typeahead_remote": self.remote})
stresponse.render()
output += stresponse.rendered_content
return output
def test_pickling(self):
# Create a template response. The context is
# known to be unpicklable (e.g., a function).
response = SimpleTemplateResponse('first/test.html', {
'value': 123,
'fn': datetime.now,
})
self.assertRaises(ContentNotRenderedError,
pickle.dumps, response)
# But if we render the response, we can pickle it.
response.render()
pickled_response = pickle.dumps(response)
unpickled_response = pickle.loads(pickled_response)
self.assertEqual(unpickled_response.content, response.content)
self.assertEqual(unpickled_response['content-type'], response['content-type'])
self.assertEqual(unpickled_response.status_code, response.status_code)
# ...and the unpickled response doesn't have the
# template-related attributes, so it can't be re-rendered
template_attrs = ('template_name', 'context_data', '_post_render_callbacks')
for attr in template_attrs:
self.assertFalse(hasattr(unpickled_response, attr))
# ...and requesting any of those attributes raises an exception
for attr in template_attrs:
with self.assertRaises(AttributeError):
getattr(unpickled_response, attr)
def saveComment( request ):
email = request.POST['email']
usrname = request.POST['usrname']
content = request.POST['content']
article = Article.objects.get(id = request.POST['aId'])
kwarg = {'user' : util.get_or_create_usr(email, usrname),'content' : content}
desc = request.POST.get('memo', None)
if desc : kwarg['desc'] = desc
rootId = request.POST.get('rootId', None)
if rootId : kwarg['root_komment'] = Comment.objects.get(id = rootId)
kommentId = request.POST.get('cId', None)
if content.strip().count('#-') is 1 and kommentId:
pattern = re.compile('(#-).*(-#\s*)')
content = pattern.sub('', content)
komment = Comment.objects.get(id = kommentId)
kwarg['content'] = content
kwarg['komment'] = komment
else:
kwarg['article'] = article
comment = Comment(**kwarg)
comment.save()
resp = HttpResponseRedirect('/article/feeds?aId='+str(article.id)+'#comment-'+str(comment.id))
## if not request.COOKIES.has_key('email') or not request.COOKIES.has_key('usrname'):
resp.set_cookie('email', value = email, max_age = 31536000, httponly = True)
resp.set_cookie('usrname', value = usrname.encode('utf-8'), max_age = 31536000, httponly = True)
return resp
def test_repickling(self):
response = SimpleTemplateResponse("first/test.html", {"value": 123, "fn": datetime.now})
self.assertRaises(ContentNotRenderedError, pickle.dumps, response)
response.render()
pickled_response = pickle.dumps(response)
unpickled_response = pickle.loads(pickled_response)
pickle.dumps(unpickled_response)
def regenerate_widget():
ads = Advert.objects.filter(sell=True, is_selled=False).order_by("-created")[:5]
current_site = Site.objects.get_current()
response = SimpleTemplateResponse("widget.html", {"ads": ads, "domain": current_site.domain})
response.render()
widget_file = open(os.path.join(settings.STATICFILES_DIRS[0], "widget.html"), "w")
content = response.rendered_content.encode("utf-8")
widget_file.write(content)
widget_file.close()
def process_template_response(self, string_template, user=None):
request = HttpRequest()
request.user = user
context = Context({'request': request})
template = BackendTemplate(Template(string_template).render(context))
response = SimpleTemplateResponse(template, context)
response.content = string_template
mw = ToolbarMiddleware()
return mw.process_response(request, response).render()
class NavBarTemplateTagTestCase(TestCase):
def setUp(self):
create_pages()
def test_navbar_renders(self):
t = Template('{% load pages_tags %}{% navbar %}')
self.response = SimpleTemplateResponse(t)
self.response.render()
self.assertTrue(self.response.is_rendered)
def test_pickling_cookie(self):
response = SimpleTemplateResponse("first/test.html", {"value": 123, "fn": datetime.now})
response.cookies["key"] = "value"
response.render()
pickled_response = pickle.dumps(response, pickle.HIGHEST_PROTOCOL)
unpickled_response = pickle.loads(pickled_response)
self.assertEqual(unpickled_response.cookies["key"].value, "value")
def process_template_response(self, string_template):
settings.TOOLBAR_INSTANT_UPDATE = False
request = HttpRequest()
context = Context({'request': request})
node = Template(string_template).render(context)
template = BackendTemplate(node)
response = SimpleTemplateResponse(template, context)
response.content = node
mw = TextMiddleware()
return mw.process_response(request, response).render()
def process_template_response(self, name, default=''):
settings.TOOLBAR_INSTANT_UPDATE = False
request = HttpRequest()
context = Context({'request': request})
node = Template(
'{%% load text %%}{%% text "%s" "%s" %%}' % (name, default)).render(context)
template = BackendTemplate(node)
response = SimpleTemplateResponse(template, context)
response.content = node
mw = TextMiddleware()
return mw.process_template_response(request, response).render()
def process_response(self, request, response):
if 300 <= int(response.status_code) < 400:
redirect_to = response.get('Location', None)
if redirect_to:
status_line = '%s %s' % (response.status_code, response.reason_phrase)
cookies = response.cookies
context = {'redirect_to': redirect_to, 'status_line': status_line}
# Using SimpleTemplateResponse avoids running global context processors.
response = SimpleTemplateResponse('debug_toolbar/redirect.html', context, using='django')
response.cookies = cookies
response.render()
return response
def test_repickling(self):
response = SimpleTemplateResponse('first/test.html', {
'value': 123,
'fn': datetime.now,
})
self.assertRaises(ContentNotRenderedError,
pickle.dumps, response)
response.render()
pickled_response = pickle.dumps(response)
unpickled_response = pickle.loads(pickled_response)
pickle.dumps(unpickled_response)
def regenerate_widget():
ads = Advert.objects.filter(sell=True, is_selled=False).\
order_by('-created')[:5]
current_site = Site.objects.get_current()
response = SimpleTemplateResponse('widget.html',
{'ads' : ads,
'domain' : current_site.domain})
response.render()
widget_file = open(os.path.join(settings.STATICFILES_DIRS[0],
'widget.html'), 'w')
content = response.rendered_content.encode('utf-8')
widget_file.write(content)
widget_file.close()
def test_pickling_cookie(self):
response = SimpleTemplateResponse('first/test.html', {
'value': 123,
'fn': datetime.now,
})
response.cookies['key'] = 'value'
response.render()
pickled_response = pickle.dumps(response, pickle.HIGHEST_PROTOCOL)
unpickled_response = pickle.loads(pickled_response)
self.assertEqual(unpickled_response.cookies['key'].value, 'value')
def process_response(self, request, response):
if 300 <= int(response.status_code) < 400:
redirect_to = response.get("Location", None)
if redirect_to:
status_line = "%s %s" % (response.status_code, response.reason_phrase)
cookies = response.cookies
context = {"redirect_to": redirect_to, "status_line": status_line}
# Using SimpleTemplateResponse avoids running global context processors.
response = SimpleTemplateResponse(
"debug_toolbar/redirect.html", context
)
response.cookies = cookies
response.render()
return response
class GetPageTemplateTagTestCase(TestCase):
urls = 'ostinato.pages.urls'
def setUp(self):
create_pages()
t = Template('{% load pages_tags %}{% get_page "page-1" as somepage %}{{ somepage }}')
self.response = SimpleTemplateResponse(t)
def test_tag_renders(self):
self.response.render()
self.assertTrue(self.response.is_rendered)
def test_page_in_content(self):
self.response.render()
self.assertIn('Page 1', self.response.content)
def test_post_callbacks(self):
"Rendering a template response triggers the post-render callbacks"
post = []
def post1(obj):
post.append('post1')
def post2(obj):
post.append('post2')
response = SimpleTemplateResponse('first/test.html', {})
response.add_post_render_callback(post1)
response.add_post_render_callback(post2)
# When the content is rendered, all the callbacks are invoked, too.
response.render()
self.assertEqual('First template\n', response.content)
self.assertEqual(post, ['post1','post2'])
class BreadCrumbsTempalteTagTestCase(TestCase):
urls = 'ostinato.pages.urls'
def setUp(self):
create_pages()
t = Template('{% load pages_tags %}{% get_page "page-3" as page %}{% breadcrumbs %}')
self.response = SimpleTemplateResponse(t)
def test_tag_renders(self):
self.response.render()
self.assertTrue(self.response.is_rendered)
def test_breadcrumbs_in_context(self):
self.response.render()
self.assertIn('<a href="/">Page 1</a> >> ', self.response.content)
self.assertIn('<strong>Page 3</strong>', self.response.content)
def test_post_callbacks(self):
"Rendering a template response triggers the post-render callbacks"
post = []
def post1(obj):
post.append("post1")
def post2(obj):
post.append("post2")
response = SimpleTemplateResponse("first/test.html", {})
response.add_post_render_callback(post1)
response.add_post_render_callback(post2)
# When the content is rendered, all the callbacks are invoked, too.
response.render()
self.assertEqual(response.content, b"First template\n")
self.assertEqual(post, ["post1", "post2"])
def test_template_resolving(self):
response = SimpleTemplateResponse('first/test.html')
response.render()
self.assertEqual(response.content, b'First template\n')
templates = ['foo.html', 'second/test.html', 'first/test.html']
response = SimpleTemplateResponse(templates)
response.render()
self.assertEqual(response.content, b'Second template\n')
response = self._response()
response.render()
self.assertEqual(response.content, b'foo')
def test_template_resolving(self):
response = SimpleTemplateResponse("first/test.html")
response.render()
self.assertEqual("First template\n", response.content)
templates = ["foo.html", "second/test.html", "first/test.html"]
response = SimpleTemplateResponse(templates)
response.render()
self.assertEqual("Second template\n", response.content)
response = self._response()
response.render()
self.assertEqual(response.content, "foo")
class NavBarTemplateTagTestCase(TestCase):
urls = 'ostinato.pages.urls'
def setUp(self):
create_pages()
t = Template('{% load pages_tags %}{% navbar %}')
self.response = SimpleTemplateResponse(t)
def test_navbar_renders(self):
self.response.render()
self.assertTrue(self.response.is_rendered)
def test_navbar_content(self):
self.response.render()
self.assertIn('<a href="/">Page 1</a>',
self.response.content)
self.assertIn('<a href="/page-2/">P2</a>',
self.response.content)
def make_result_list(self):
# Get search parameters from the query string.
self.base_queryset = self.queryset()
self.list_queryset = self.get_list_queryset()
self.ordering_field_columns = self.get_ordering_field_columns()
self.paginator = self.get_paginator()
# Get the number of objects, with admin filters applied.
self.result_count = self.paginator.count
# Get the total number of objects, with no admin filters applied.
# Perform a slight optimization: Check to see whether any filters were
# given. If not, use paginator.hits to calculate the number of objects,
# because we've already done paginator.hits and the value is cached.
if not self.list_queryset.query.where:
self.full_result_count = self.result_count
else:
self.full_result_count = self.base_queryset.count()
self.can_show_all = self.result_count <= self.list_max_show_all
self.multi_page = self.result_count > self.list_per_page
# Get the list of objects to display on this page.
if (self.show_all and self.can_show_all) or not self.multi_page:
self.result_list = self.list_queryset._clone()
else:
try:
self.result_list = self.paginator.page(
self.page_num + 1).object_list
except InvalidPage:
if ERROR_FLAG in self.request.GET.keys():
return SimpleTemplateResponse('xadmin/views/invalid_setup.html', {
'title': _('Database error'),
})
return HttpResponseRedirect(self.request.path + '?' + ERROR_FLAG + '=1')
self.has_more = self.result_count > (
self.list_per_page * self.page_num + len(self.result_list))
def test_post_callbacks(self):
"Rendering a template response triggers the post-render callbacks"
post = []
def post1(obj):
post.append("post1")
def post2(obj):
post.append("post2")
response = SimpleTemplateResponse("first/test.html", {})
response.add_post_render_callback(post1)
response.add_post_render_callback(post2)
# When the content is rendered, all the callbacks are invoked, too.
response.render()
self.assertEqual(response.content, b"First template\n")
self.assertEqual(post, ["post1", "post2"])
def listview_sales(request):
result = ""
users = []
for u in User.objects.extra(
select=
{
'campaign_name':
'SELECT name FROM users_usercampaigndata WHERE users_usercampaigndata.user_id = auth_user.id',
'country':
'SELECT country FROM users_usercampaigndata WHERE users_usercampaigndata.user_id = auth_user.id',
'referrer':
'SELECT referrer FROM users_usercampaigndata WHERE users_usercampaigndata.user_id = auth_user.id',
'num_videos':
'SELECT COUNT(*) FROM videos_video JOIN users_team ON (videos_video.team_id = users_team.id) WHERE users_team.owner_id = auth_user.id AND videos_video.archived != True',
'num_videos_published':
'SELECT COUNT(*) FROM videos_video JOIN users_team ON (videos_video.team_id = users_team.id) WHERE users_team.owner_id = auth_user.id AND videos_video.archived != True AND videos_video.published = 1',
}).order_by('-date_joined'):
user = [
"<span>" + helpers.userlink(u) + "</span>",
u.email,
"" + str(u.country if u.country else '') + "",
"" + str(u.campaign_name if u.campaign_name else '') + "",
referral_link(u.referrer),
"<b>" + str(u.num_videos) + "</b> v",
"<b>" + str(u.num_videos_published) + "</b> p",
"<b>" + str(u.date_joined.date()) + "</b>",
]
users.append(user)
result += helpers.table(users)
return SimpleTemplateResponse("insights/base.html", {
"title": "All Users (Sales List)",
"insight_content": result
})
def test_post_callbacks(self):
"Rendering a template response triggers the post-render callbacks"
post = []
def post1(obj):
post.append('post1')
def post2(obj):
post.append('post2')
response = SimpleTemplateResponse('first/test.html', {})
response.add_post_render_callback(post1)
response.add_post_render_callback(post2)
# When the content is rendered, all the callbacks are invoked, too.
response.render()
self.assertEqual(response.content, b'First template\n')
self.assertEqual(post, ['post1', 'post2'])
def add_view(self, request):
""" 添加页面 """
if request.method == 'GET':
form = self.get_model_form_cls()
elif request.method == "POST":
form = self.get_model_form_cls(data=request.POST,
files=request.FILES)
if form.is_valid():
obj = form.save()
popup_id = request.GET.get("_popup")
if popup_id:
context = {
'pk': obj.pk,
'value': str(obj),
'popup_id': popup_id
}
return SimpleTemplateResponse(
'carry/popup_response.html',
{"popup_response_data": json.dumps(context)})
else:
_change_filter = request.GET.get('_change_filter')
if _change_filter:
change_list_url = "{0}?{1}".format(
self.changelist_url(), _change_filter)
else:
change_list_url = self.changelist_url()
return redirect(change_list_url)
else:
raise Exception('当前URL只支持GET/POST方法')
context = {'form': form}
return TemplateResponse(
request, self.add_form_template or [
'carry/%s/%s/add.html' % (self.app_label, self.model_name),
'carry/%s/add.html' % self.app_label, 'carry/add.html'
], context)
def sql_select(request):
"""Returns the output of the SQL SELECT statement"""
form = SQLSelectForm(request.POST or None)
if form.is_valid():
sql = form.cleaned_data['raw_sql']
params = form.cleaned_data['params']
cursor = form.cursor
cursor.execute(sql, params)
headers = [d[0] for d in cursor.description]
result = cursor.fetchall()
cursor.close()
context = {
'result': result,
'sql': form.reformat_sql(),
'duration': form.cleaned_data['duration'],
'headers': headers,
'alias': form.cleaned_data['alias'],
}
# Using SimpleTemplateResponse avoids running global context processors.
return SimpleTemplateResponse('debug_toolbar/panels/sql_select.html',
context,
using='django')
return HttpResponseBadRequest('Form errors')
def test_random_zone_ad_renders(self):
template = Template(
"{% load adzone_tags %}{% random_zone_ad 'sidebar' %}")
response = SimpleTemplateResponse(template)
response.render()
self.assertTrue(response.is_rendered)
def template_source(request):
"""
Return the source of a template, syntax-highlighted by Pygments if
it's available.
"""
template_origin_name = request.GET.get('template_origin', None)
if template_origin_name is None:
return HttpResponseBadRequest('"template_origin" key is required')
try:
template_origin_name = signing.loads(template_origin_name)
except Exception:
return HttpResponseBadRequest('"template_origin" is invalid')
template_name = request.GET.get('template', template_origin_name)
final_loaders = []
loaders = Engine.get_default().template_loaders
for loader in loaders:
if loader is not None:
# When the loader has loaders associated with it,
# append those loaders to the list. This occurs with
# django.template.loaders.cached.Loader
if hasattr(loader, 'loaders'):
final_loaders += loader.loaders
else:
final_loaders.append(loader)
for loader in final_loaders:
if Origin: # django>=1.9
origin = Origin(template_origin_name)
try:
source = loader.get_contents(origin)
break
except TemplateDoesNotExist:
pass
else: # django<1.9
try:
source, _ = loader.load_template_source(template_name)
break
except TemplateDoesNotExist:
pass
else:
source = "Template Does Not Exist: %s" % (template_origin_name, )
try:
from pygments import highlight
from pygments.lexers import HtmlDjangoLexer
from pygments.formatters import HtmlFormatter
source = highlight(source, HtmlDjangoLexer(), HtmlFormatter())
source = mark_safe(source)
source.pygmentized = True
except ImportError:
pass
# Using SimpleTemplateResponse avoids running global context processors.
return SimpleTemplateResponse('debug_toolbar/panels/template_source.html',
{
'source': source,
'template_name': template_name
})
def _response(self, template='foo', *args, **kwargs):
return SimpleTemplateResponse(Template(template), *args, **kwargs)
def setUp(self):
create_pages()
t = Template('{% load pages_tags %}{% get_page "page-1" as somepage %}{{ somepage }}')
self.response = SimpleTemplateResponse(t)
def test_tag_renders(self):
t = Template('{% load pages_tags %}{% get_page slug="page-1" as somepage %}{{ somepage.title }}')
response = SimpleTemplateResponse(t)
response.render()
self.assertTrue(response.is_rendered)
def test_tag_renders(self):
create_pages()
t = Template('{% load pages_tags %}{% get_page slug="page-3" as page %}{% breadcrumbs %}')
response = SimpleTemplateResponse(t)
response.render()
self.assertTrue(response.is_rendered)
def addGallery(request):
if request.method == 'GET':
form = UploadForm()
c = RequestContext({'form': form})
c.update(csrf(request))
return (SimpleTemplateResponse('admin/upload.html', c))
else:
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
# First, copy zipfile to a tmpfile
zipfile = NamedTemporaryFile(delete=False)
zipfile.write(request.FILES['file'].read())
zipfile.close()
# Now we got the Zip, unzip it!!
imagesObj = imagesFromZip(zipfile.name)
imagesList = imagesObj.listImages()
# Is there images in this zip ?
if len(imagesList) > 0:
# regexp for extractiong name ...
nameRe = re.compile('/([^/]+)$')
# Create corresponding gallery
gallery = Gallery()
gallery.title = form.cleaned_data['title']
gallery.desc = form.cleaned_data['desc']
gallery.category = form.cleaned_data['category']
gallery.save() # Must save gallery
# Now, for each images in it, create an image object and bind it to gallery
for imgPath in imagesList:
src = PILImage.open(imgPath)
m = nameRe.search(imgPath)
imgObj = Image()
imgObj.gallery = gallery
# First, put the original sized picture
# use StringIO hack to save image to a string ...
output = StringIO.StringIO()
src.save(output, 'JPEG')
imgObj.original.save(m.groups()[0],
ContentFile(output.getvalue()))
output.close()
# Then, resize it to something like 1600*1200
(orig_w, orig_h) = src.size
orig_s = orig_w * orig_h
new_s = 1024 * 768
ratio = orig_s / new_s
# Resize only if requested size is lower than original
if ratio > 1:
(new_w, new_h) = (orig_w / (sqrt(ratio)),
orig_h / (sqrt(ratio)))
resized = src.resize((int(new_w), int(new_h)))
else: # Else, just keep original one ...
(new_w, new_h) = (orig_w, orig_h)
resized = src
output = StringIO.StringIO()
resized.save(output, 'JPEG')
imgObj.screen.save(m.groups()[0],
ContentFile(output.getvalue()))
output.close()
# Finally, get a thumb of 150px*150px, work on resized picture to be faster
if new_w < new_h:
maxi = new_w
else:
maxi = new_h
thumb = resized.transform((150, 150), PILImage.EXTENT,
(0, 0, maxi, maxi))
output = StringIO.StringIO()
thumb.save(output, 'JPEG')
imgObj.thumb.save(m.groups()[0],
ContentFile(output.getvalue()))
output.close()
imgObj.save()
gallery.save()
return (HttpResponseRedirect(
reverse('gallery.admin.views.editGallery',
kwargs={'id': gallery.pk})))
# Cleanup...
imagesObj.cleanup()
os.rm(zipfile)
else:
c = RequestContext(request, csrf(request))
c['form'] = form
return (SimpleResponseTemplate('admin/upload.html', c))
def test_localisationmiddleware_process_response(self):
import geoip2
class Context(dict):
pass
context = Context()
context['page_obj'] = Context()
context['page_obj'].has_other_pages = lambda: False
response = SimpleTemplateResponse('pagination/pagination.html', context)
localisation_middleware = LocalisationMiddleware()
geoip_dat_file = '{}/geolite2/GeoLite2-Country.mmdb'.format(os.path.dirname(os.path.realpath(__file__)))
self.request = self.factory.get('/media/')
processed_response = localisation_middleware.process_response(self.request, response, geoip_path=geoip_dat_file)
self.assertEqual(processed_response, response)
self.assertEqual(processed_response.status_code, 200)
obj = Country.objects.create(
code='GB',
)
self.request = self.factory.get('/')
localisation_middleware.process_request(self.request)
try:
processed_response = localisation_middleware.process_response(self.request, response, geoip_path=geoip_dat_file)
except geoip2.errors.AddressNotFoundError:
self.request.country = obj
processed_response = localisation_middleware.process_response(self.request, response, geoip_path=geoip_dat_file)
self.assertEqual(processed_response, response)
# Give ourselves a direct IP.
self.request = self.factory.get('/')
self.request.META['REMOTE_ADDR'] = '212.58.246.103'
localisation_middleware.process_request(self.request)
processed_response = localisation_middleware.process_response(self.request, response, geoip_path=geoip_dat_file)
self.assertEqual(processed_response.status_code, 302)
self.assertNotEqual(processed_response, response)
self.assertEqual(self.request.country, obj)
# Give ourselves a proxied IP.
self.request = self.factory.get('/')
self.request.META['HTTP_X_FORWARDED_FOR'] = '212.58.246.103'
localisation_middleware.process_request(self.request)
processed_response = localisation_middleware.process_response(self.request, response, geoip_path=geoip_dat_file)
self.assertEqual(processed_response.status_code, 302)
self.assertNotEqual(processed_response, response)
self.assertEqual(self.request.country, obj)
# Give ourselves a French IP.
self.request = self.factory.get('/')
self.request.META['REMOTE_ADDR'] = '2.15.255.255'
localisation_middleware.process_request(self.request)
processed_response = localisation_middleware.process_response(self.request, response, geoip_path=geoip_dat_file)
self.assertEqual(processed_response.status_code, 200)
self.assertEqual(processed_response, response)
self.assertIsNone(self.request.country)
obj = Country.objects.create(
code='US',
)
self.request = self.factory.get('/')
# Give ourselves a US West IP.
self.request.META['REMOTE_ADDR'] = '52.52.95.213'
localisation_middleware.process_request(self.request)
processed_response = localisation_middleware.process_response(self.request, response, geoip_path=geoip_dat_file)
self.assertEqual(processed_response.status_code, 302)
self.assertNotEqual(processed_response, response)
self.assertEqual(self.request.country, obj)
obj = Country.objects.create(
code='IN',
)
self.request = self.factory.get('/')
# Give ourselves an Indian IP.
self.request.META['REMOTE_ADDR'] = '13.232.220.164'
localisation_middleware.process_request(self.request)
processed_response = localisation_middleware.process_response(self.request, response, geoip_path=geoip_dat_file)
self.assertEqual(processed_response.status_code, 302)
self.assertNotEqual(processed_response, response)
self.assertEqual(self.request.country, obj)
# Give ourselves a Japanese IP
self.request.META['REMOTE_ADDR'] = '52.194.115.181'
localisation_middleware.process_request(self.request)
processed_response = localisation_middleware.process_response(self.request, response, geoip_path=geoip_dat_file)
# Test Indian country code with Japanese IP
self.assertNotEqual(self.request.country, obj)
def response_add(self, request, obj, post_url_continue=None):
"""
Determines the HttpResponse for the add_view stage.
"""
opts = obj._meta
pk_value = obj._get_pk_val()
preserved_filters = self.get_preserved_filters(request)
msg_dict = {
'name': force_text(opts.verbose_name),
'obj': force_text(obj)
}
# Here, we distinguish between different save types by checking for
# the presence of keys in request.POST.
if '_popup' in request.POST:
to_field = request.POST.get('_to_field')
if to_field:
attr = str(to_field)
else:
attr = obj._meta.pk.attname
value = obj.serializable_value(attr)
return SimpleTemplateResponse(
'admin/popup_response.html',
{
'pk_value':
escape(pk_value), # for possible backwards-compatibility
'value': escape(value),
'obj': escapejs(obj)
})
elif "_continue" in request.POST:
# Translators: Translation included with Django
msg = _(
'The %(name)s "%(obj)s" was added successfully. You may edit it again below.'
) % msg_dict
self.message_user(request, msg, messages.SUCCESS)
if post_url_continue is None:
post_url_continue = request.prefix + reverse(
'admin:%s_%s_change' % (opts.app_label, opts.model_name),
args=(quote(pk_value), ),
current_app=self.admin_site.name)
post_url_continue = add_preserved_filters(
{
'preserved_filters': preserved_filters,
'opts': opts
}, post_url_continue)
return HttpResponseRedirect(post_url_continue)
elif "_addanother" in request.POST:
# Translators: Translation included with Django
msg = _(
'The %(name)s "%(obj)s" was added successfully. You may add another %(name)s below.'
) % msg_dict
self.message_user(request, msg, messages.SUCCESS)
redirect_url = request.prefix + request.path
redirect_url = add_preserved_filters(
{
'preserved_filters': preserved_filters,
'opts': opts
}, redirect_url)
return HttpResponseRedirect(redirect_url)
else:
# Translators: Translation included with Django
msg = _(
'The %(name)s "%(obj)s" was added successfully.') % msg_dict
self.message_user(request, msg, messages.SUCCESS)
# Redirect to previous url
return HttpResponseRedirect(
"%s%s" % (request.prefix,
request.session['crumbs'][request.prefix][-2][2]))
def response_change(self, request, obj):
"""
Determines the HttpResponse for the change_view stage.
"""
if '_popup' in request.POST:
to_field = request.POST.get('_to_field')
attr = str(to_field) if to_field else obj._meta.pk.attname
# Retrieve the `object_id` from the resolved pattern arguments.
value = request.resolver_match.args[0]
new_value = obj.serializable_value(attr)
return SimpleTemplateResponse(
'admin/popup_response.html', {
'action': 'change',
'value': escape(value),
'obj': escapejs(obj),
'new_value': escape(new_value),
})
opts = self.model._meta
pk_value = obj._get_pk_val()
preserved_filters = self.get_preserved_filters(request)
msg_dict = {
'name': force_text(opts.verbose_name),
'obj': force_text(obj)
}
if "_continue" in request.POST:
# Translators: Translation included with Django
msg = _(
'The %(name)s "%(obj)s" was changed successfully. You may edit it again below.'
) % msg_dict
self.message_user(request, msg, messages.SUCCESS)
redirect_url = request.prefix + request.path
redirect_url = add_preserved_filters(
{
'preserved_filters': preserved_filters,
'opts': opts
}, redirect_url)
return HttpResponseRedirect(redirect_url)
elif "_saveasnew" in request.POST:
# Translators: Translation included with Django
msg = _(
'The %(name)s "%(obj)s" was added successfully. You may edit it again below.'
) % msg_dict
self.message_user(request, msg, messages.SUCCESS)
redirect_url = request.prefix + reverse(
'admin:%s_%s_change' % (opts.app_label, opts.model_name),
args=(pk_value, ),
current_app=self.admin_site.name)
redirect_url = add_preserved_filters(
{
'preserved_filters': preserved_filters,
'opts': opts
}, redirect_url)
return HttpResponseRedirect(redirect_url)
elif "_addanother" in request.POST:
# Translators: Translation included with Django
msg = _(
'The %(name)s "%(obj)s" was added successfully. You may add another %(name)s below.'
) % msg_dict
self.message_user(request, msg, messages.SUCCESS)
redirect_url = request.prefix + reverse(
'admin:%s_%s_add' % (opts.app_label, opts.model_name),
current_app=self.admin_site.name)
redirect_url = add_preserved_filters(
{
'preserved_filters': preserved_filters,
'opts': opts
}, redirect_url)
return HttpResponseRedirect(redirect_url)
else:
# Translators: Translation included with Django
msg = _(
'The %(name)s "%(obj)s" was changed successfully.') % msg_dict
self.message_user(request, msg, messages.SUCCESS)
# Redirect to previous url
return HttpResponseRedirect(
"%s%s" % (request.prefix,
request.session['crumbs'][request.prefix][-2][2]))
def overview_view(request):
return SimpleTemplateResponse("products/overview.html")
def changelist_view(self, request, extra_context=None):
"""
Overriding the changelist view of ModelAdmin to allow the list view to be displayed
when the user only has view permissions.
In this case, the list view will be displayed without the 'Add' button and without list actions
"""
from django.contrib.admin.views.main import ERROR_FLAG
opts = self.model._meta
app_label = opts.app_label
# Adding check for view permissions
if not self.has_change_permission(
request, None) and not self.has_view_permission(request, None):
raise PermissionDenied
list_display = self.get_list_display(request)
list_display_links = self.get_list_display_links(request, list_display)
list_filter = self.get_list_filter(request)
search_fields = self.get_search_fields(request)
# If use only has view permissions, then don't render actions
# Check actions to see if any are available on this changelist
if self.has_change_permission(request, None):
actions = self.get_actions(request)
if actions:
# Add the action checkboxes if there are any actions available.
list_display = ['action_checkbox'] + list(list_display)
else:
actions = None
ChangeList = self.get_changelist(request)
try:
cl = ChangeList(request, self.model, list_display,
list_display_links, list_filter,
self.date_hierarchy, search_fields,
self.list_select_related, self.list_per_page,
self.list_max_show_all, self.list_editable, self)
except IncorrectLookupParameters:
# Wacky lookup parameters were given, so redirect to the main
# changelist page, without parameters, and pass an 'invalid=1'
# parameter via the query string. If wacky parameters were given
# and the 'invalid=1' parameter was already in the query string,
# something is screwed up with the database, so display an error
# page.
if ERROR_FLAG in request.GET.keys():
return SimpleTemplateResponse('admin/invalid_setup.html', {
'title': _('Database error'),
})
return HttpResponseRedirect(request.path + '?' + ERROR_FLAG + '=1')
# If the request was POSTed, this might be a bulk action or a bulk
# edit. Try to look up an action or confirmation first, but if this
# isn't an action the POST will fall through to the bulk edit check,
# below.
action_failed = False
selected = request.POST.getlist(helpers.ACTION_CHECKBOX_NAME)
# Actions with no confirmation
if (actions and request.method == 'POST' and 'index' in request.POST
and '_save' not in request.POST):
if selected:
response = self.response_action(
request, queryset=cl.get_queryset(request))
if response:
return response
else:
action_failed = True
else:
msg = _("Items must be selected in order to perform "
"actions on them. No items have been changed.")
self.message_user(request, msg, messages.WARNING)
action_failed = True
# Actions with confirmation
if (actions and request.method == 'POST'
and helpers.ACTION_CHECKBOX_NAME in request.POST
and 'index' not in request.POST
and '_save' not in request.POST):
if selected:
response = self.response_action(
request, queryset=cl.get_queryset(request))
if response:
return response
else:
action_failed = True
# If we're allowing changelist editing, we need to construct a formset
# for the changelist given all the fields to be edited. Then we'll
# use the formset to validate/process POSTed data.
formset = cl.formset = None
# Handle POSTed bulk-edit data.
if (request.method == "POST" and cl.list_editable
and '_save' in request.POST and not action_failed):
FormSet = self.get_changelist_formset(request)
formset = cl.formset = FormSet(request.POST,
request.FILES,
queryset=cl.result_list)
if formset.is_valid():
changecount = 0
for form in formset.forms:
if form.has_changed():
obj = self.save_form(request, form, change=True)
self.save_model(request, obj, form, change=True)
self.save_related(request,
form,
formsets=[],
change=True)
change_msg = self.construct_change_message(
request, form, None)
self.log_change(request, obj, change_msg)
changecount += 1
if changecount:
if changecount == 1:
name = force_text(opts.verbose_name)
else:
name = force_text(opts.verbose_name_plural)
msg = ungettext(
"%(count)s %(name)s was changed successfully.",
"%(count)s %(name)s were changed successfully.",
changecount) % {
'count': changecount,
'name': name,
'obj': force_text(obj)
}
self.message_user(request, msg, messages.SUCCESS)
return HttpResponseRedirect(request.get_full_path())
# Handle GET -- construct a formset for display.
elif cl.list_editable:
FormSet = self.get_changelist_formset(request)
formset = cl.formset = FormSet(queryset=cl.result_list)
# Build the list of media to be used by the formset.
if formset:
media = self.media + formset.media
else:
media = self.media
# Build the action form and populate it with available actions.
if actions:
action_form = self.action_form(auto_id=None)
action_form.fields['action'].choices = self.get_action_choices(
request)
else:
action_form = None
selection_note_all = ungettext('%(total_count)s selected',
'All %(total_count)s selected',
cl.result_count)
context = dict(
self.admin_site.each_context(request),
module_name=force_text(opts.verbose_name_plural),
selection_note=_('0 of %(cnt)s selected') %
{'cnt': len(cl.result_list)},
selection_note_all=selection_note_all %
{'total_count': cl.result_count},
title=cl.title,
is_popup=cl.is_popup,
to_field=cl.to_field,
cl=cl,
media=media,
has_add_permission=self.has_add_permission(request),
opts=cl.opts,
action_form=action_form,
actions_on_top=self.actions_on_top,
actions_on_bottom=self.actions_on_bottom,
actions_selection_counter=self.actions_selection_counter,
preserved_filters=self.get_preserved_filters(request),
)
context.update(extra_context or {})
request.current_app = self.admin_site.name
return TemplateResponse(
request, self.change_list_template or [
'admin/%s/%s/change_list.html' % (app_label, opts.model_name),
'admin/%s/change_list.html' % app_label,
'admin/change_list.html'
], context)
def test_random_category_ad_renders(self):
template = Template("{% load adzone_tags %}{% random_category_ad 'sidebar' 'internet-services' %}")
response = SimpleTemplateResponse(template)
response.render()
self.assertTrue(response.is_rendered)
def export(coll, context):
'''
Export des données d'une collection
'''
# Cherchons la configuration pour avoir des valeurs par défaut
config = Config.objects.get(code=CODE_CONFIG_DEFAUT)
periode = range(config.annee_min_publis, config.annee_max_publis + 1)
# Lecture des modèles de graphiques
diag_barres = SimpleTemplateResponse('publis/charts/diagramme_barres.json',
{})
diag_camembert = SimpleTemplateResponse(
'publis/charts/diagramme_camembert.json', {})
# On crée le répertoire pour la collection s'il n'existe pas
coll_dir = os.path.join(settings.EXPORT_DIR, coll.code)
if not os.path.isdir(coll_dir):
os.mkdir(coll_dir)
prefixe_fichier = "graphiques_" + coll.code
# Export des graphiques
diag_barres.context_data["chart_annees"] = list(periode)
diag_barres.context_data[
"chart_donnees"] = Publication.stats_par_annee_type(
coll.code, config.annee_min_publis, config.annee_max_publis)
with open(os.path.join(coll_dir, prefixe_fichier + "_par_annee_type.json"),
mode='w',
encoding="utf-8") as filehandle:
filehandle.write(str(diag_barres.rendered_content))
diag_barres.context_data[
"chart_donnees"] = Publication.stats_par_annee_classement(
coll.code, config.annee_min_publis, config.annee_max_publis)
with open(os.path.join(coll_dir,
prefixe_fichier + "_par_annee_classement.json"),
mode='w',
encoding="utf-8") as filehandle:
filehandle.write(str(diag_barres.rendered_content))
diag_camembert.context_data["chart_annees"] = periode
diag_camembert.context_data[
"chart_donnees"] = Publication.stats_par_classement(
coll.code, config.annee_min_publis, config.annee_max_publis)
with open(os.path.join(coll_dir, prefixe_fichier + "_par_classement.json"),
mode='w',
encoding="utf-8") as filehandle:
filehandle.write(str(diag_camembert.rendered_content))
# Export des publis en Bibtex
prefixe_fichier = "publis_" + coll.code
for classement in ClassementPubli.objects.all():
with open(os.path.join(
coll_dir,
prefixe_fichier + "_{0}.bib".format(classement.code)),
mode='w',
encoding="utf-8") as filehandle:
for publi in Publication.objects.filter(
annee__gte=config.annee_min_publis).filter(
annee__lte=config.annee_max_publis).filter(
classement=classement).filter(collections=coll):
filehandle.writelines([publi.bibtex_hal(), "\n"])
# Pour finir on met tout ça dans un zip et on envoie
contenu_zip = BytesIO()
zf = zipfile.ZipFile(contenu_zip, "w")
for file in os.listdir(coll_dir):
if file.endswith(".json") or file.endswith(".bib") or file.endswith(
".tex"):
zf.write(os.path.join(coll_dir, file), file)
zf.close()
return contenu_zip
def account(request):
return SimpleTemplateResponse(get_template('account.html'))
def _response(self, template='foo', *args, **kwargs):
template = engines['django'].from_string(template)
return SimpleTemplateResponse(template, *args, **kwargs)
def changelist_view(self, request, extra_context=None):
if not self.has_change_permission(request, None):
raise PermissionDenied
if not SEARCH_VAR in request.GET or "action" in request.POST:
# Do the usual song and dance.
return super(MetaShareSearchModelAdmin,
self).changelist_view(request, extra_context)
# Do a search of just this model and populate a Changelist with the
# returned bits.
if not self.model in connections['default'].get_unified_index(
).get_indexed_models():
# Oops. That model isn't being indexed. Return the usual
# behavior instead.
return super(MetaShareSearchModelAdmin,
self).changelist_view(request, extra_context)
# So. Much. Boilerplate.
# Why copy-paste a few lines when you can copy-paste TONS of lines?
list_display = self.get_list_display(request)
list_display_links = self.get_list_display_links(request, list_display)
list_filter = self.get_list_filter(request)
search_fields = self.get_search_fields(request)
ChangeListClass = self.get_changelist(request)
try:
changelist = ChangeListClass(
request, self.model, list_display, list_display_links,
list_filter, self.date_hierarchy, search_fields,
self.list_select_related, self.list_per_page,
self.list_max_show_all, self.list_editable, self)
except IncorrectLookupParameters:
# Wacky lookup parameters were given, so redirect to the main
# changelist page, without parameters, and pass an 'invalid=1'
# parameter via the query string. If wacky parameters were given
# and the 'invalid=1' parameter was already in the query string,
# something is screwed up with the database, so display an error
# page.
if ERROR_FLAG in request.GET.keys():
return SimpleTemplateResponse('admin/invalid_setup.html', {
'title': _('Database error'),
})
return HttpResponseRedirect(request.path + '?' + ERROR_FLAG + '=1')
formset = changelist.formset = None
media = self.media
# Build the action form and populate it with available actions.
# Check actions to see if any are available on this changelist
actions = self.get_actions(request)
if actions:
action_form = self.action_form(auto_id=None)
action_form.fields['action'].choices = self.get_action_choices(
request)
else:
action_form = None
selection_note = ungettext('0 of %(count)d selected',
'of %(count)d selected',
len(changelist.result_list))
selection_note_all = ungettext('%(total_count)s selected',
'All %(total_count)s selected',
changelist.result_count)
context = {
'module_name':
force_unicode(self.model._meta.verbose_name_plural),
'selection_note':
selection_note % {
'count': len(changelist.result_list)
},
'selection_note_all':
selection_note_all % {
'total_count': changelist.result_count
},
'title':
changelist.title,
'is_popup':
changelist.is_popup,
'cl':
changelist,
'media':
media,
'has_add_permission':
self.has_add_permission(request),
'app_label':
self.model._meta.app_label,
'action_form':
action_form,
'actions_on_top':
self.actions_on_top,
'actions_on_bottom':
self.actions_on_bottom,
'actions_selection_counter':
getattr(self, 'actions_selection_counter', 0),
}
context.update(extra_context or {})
context_instance = template.RequestContext(
request, current_app=self.admin_site.name)
return render_to_response(self.change_list_template or [
'admin/%s/%s/change_list.html' %
(self.model._meta.app_label, self.model._meta.object_name.lower()),
'admin/%s/change_list.html' % self.model._meta.app_label,
'admin/change_list.html'
],
context,
context_instance=context_instance)
def test_navbar_renders(self):
t = Template('{% load pages_tags %}{% navbar %}')
self.response = SimpleTemplateResponse(t)
self.response.render()
self.assertTrue(self.response.is_rendered)
def get(request, team_identifier):
context = {}
context.update(csrf(request))
return SimpleTemplateResponse(template='whiteboard_web/new_face_form.html', context=context)
def test_tag_renders(self):
t = Template('{% load pages_tags %}{% get_page template="pages.basicpage" as page_list %}')
response = SimpleTemplateResponse(t)
response.render()
self.assertTrue(response.is_rendered)
def index(request):
return SimpleTemplateResponse(template="index.html")
def test_args(self):
response = SimpleTemplateResponse('', {}, 'application/json', 504)
self.assertEqual(response['content-type'], 'application/json')
self.assertEqual(response.status_code, 504)
def plain_text_vision(request, pk):
vision = Vision.objects.get(pk=pk)
return SimpleTemplateResponse(template="plain_text_vision.txt", context={"vision": vision},
content_type="text/plain")
def setUp(self):
create_pages()
t = Template('{% load pages_tags %}{% get_page "page-3" as page %}{% breadcrumbs %}')
self.response = SimpleTemplateResponse(t)
def _render(self, template_name):
response = SimpleTemplateResponse(
template=template_name,
context=self.get_context_data())
response.render()
return response.content.decode('utf-8')
def response_add(self, request, obj, post_url_continue=None):
opts = obj._meta
pk_value = obj._get_pk_val()
preserved_filters = self.get_preserved_filters(request)
url_args = self.get_base_url_args(request)
if "_saveasnew" in request.POST:
url_args = url_args[:-1]
obj_url = self.reverse_url('change', *url_args + [quote(pk_value)])
if self.has_change_permission(request, obj):
obj_repr = format_html('<a href="{}">{}</a>', urlquote(obj_url),
obj)
else:
obj_repr = force_text(obj)
msg_dict = {
'name': force_text(opts.verbose_name),
'obj': obj_repr,
}
if IS_POPUP_VAR in request.POST:
to_field = request.POST.get(TO_FIELD_VAR)
if to_field:
attr = str(to_field)
else:
attr = obj._meta.pk.attname
value = obj.serializable_value(attr)
popup_response_data = json.dumps({
'value': six.text_type(value),
'obj': six.text_type(obj),
})
return SimpleTemplateResponse(
'admin/popup_response.html', {
'popup_response_data': popup_response_data,
})
elif "_continue" in request.POST or (
"_saveasnew" in request.POST and self.save_as_continue
and self.has_change_permission(request, obj)):
msg = format_html(
_('The {name} "{obj}" was added successfully. You may edit it again below.'
), **msg_dict)
self.message_user(request, msg, messages.SUCCESS)
if post_url_continue is None:
post_url_continue = obj_url
post_url_continue = self.add_preserved_filters(
{
'preserved_filters': preserved_filters,
'opts': opts
}, post_url_continue)
return HttpResponseRedirect(post_url_continue)
elif "_addanother" in request.POST:
msg = format_html(
_('The {name} "{obj}" was added successfully. You may add another {name} below.'
), **msg_dict)
self.message_user(request, msg, messages.SUCCESS)
redirect_url = request.path
redirect_url = self.add_preserved_filters(
{
'preserved_filters': preserved_filters,
'opts': opts
}, redirect_url)
return HttpResponseRedirect(redirect_url)
else:
msg = format_html(_('The {name} "{obj}" was added successfully.'),
**msg_dict)
self.message_user(request, msg, messages.SUCCESS)
return self.response_post_save_add(request, obj)
def inbound_users(request):
rows = []
header = ['ID', 'Email', 'Phone', 'Date Joined',
'Country', 'Referrer', 'Campaign',
'Created', 'Published', 'Plan', 'Pipedrive', 'Retentionmails', 'Pro Demo',
]
days = int(request.GET.get('days', 14))
date = datetime.date.today() - datetime.timedelta(days=days)
#
# Toggle pipedrive export
#
pipedrive_export = int(request.GET.get('pipedrive', -1))
export_user_to_pipedrive(pipedrive_export)
#
# toggle retention
#
change_mail_settings = int(request.GET.get('retention', -1))
change_mail_value = int(request.GET.get('value', -1))
if change_mail_settings > 0:
u = User.objects.get(pk=change_mail_settings)
u.settings.receive_retention_emails = True if change_mail_value else False
u.settings.save()
if len(request.GET):
return redirect(BASE_URL)
# build row from user
for user in User.objects.select_related('sales_info').select_related('settings').select_related('campaign_data').filter(date_joined__gte=date).order_by('-date_joined'):
try:
phone = user.settings.phone_number
except:
phone = ''
# standard data
row = [user.pk, user.username, phone, user.date_joined.date()]
# signup data
try:
row.extend([user.campaign_data.country, referral_link(user.campaign_data.referrer), user.campaign_data.name])
except:
row.extend(['', '', ''])
user_videos = Video.objects.filter(team__owner=user)
row.extend([user_videos.count(), user_videos.filter(published=True).count()] )
try:
row.append(user.subscription.plan)
except:
row.append('-')
# pipedrive info
try:
url = PIPEDRIVE_PERSON_URL + str(user.sales_info.pipedrive_person_id)
row.append('<a target = "_blank" href = "{0}">Linked</a>'.format(url))
except:
url = BASE_URL + '?pipedrive=' + str(user.pk)
row.append('<a href = "{0}">Export</a>'.format(url))
url = BASE_URL + '?retention=' + str(user.pk) +'&value=' + ('0' if user.settings.receive_retention_emails else '1')
title = 'Enabled' if user.settings.receive_retention_emails else 'Disabled'
row.append('<a href = "{0}">{1}</a>'.format(url, title))
row.append('Upgrade (15 days)')
rows.append(row)
return SimpleTemplateResponse("insights/base.html", {
"title": "Inbound Users",
"insight_content": table(rows, header)
})
def view(request):
#
# General Query Building blocks
#
SELECT_PUBLISHED_REVISIONS = "SELECT COUNT(*) FROM videos_video as v JOIN videos_videorevision as vr ON(v.current_revision_id = vr.id) JOIN users_team as t ON (t.id = v.team_id) JOIN auth_user as u ON (u.id = t.owner_id) "
SELECT_PUBLISHED_MARKERS = SELECT_PUBLISHED_REVISIONS + " JOIN videos_marker vm ON (vm.video_revision_id = vr.id)"
SELECT_PUBLISHED_CONTENT_BLOCKS = SELECT_PUBLISHED_MARKERS + " JOIN videos_markercontent vmc ON (vmc.marker_id = vm.id)"
SELECT_VIDEO_SOURCES = SELECT_PUBLISHED_REVISIONS + " JOIN videos_source as s ON (vr.source_id = s.id)"
result = "Staff videos are not included in these statistics. <br />Only published videos are counted."
#
# Overall stats
#
result += helpers.header("Overall Stats (Published)")
num_videos = get_result(SELECT_PUBLISHED_REVISIONS)
num_markers = get_result(SELECT_PUBLISHED_MARKERS)
num_blocks = get_result(SELECT_PUBLISHED_CONTENT_BLOCKS)
table = []
table.append(["Published Videos", num_videos])
table.append(["Published Markers", num_markers])
table.append(["Published Content Blocks", num_blocks])
table.append([""])
table.append(["Markers per publ. Video", num_markers / num_videos])
table.append(["Content Blocks per publ. Video", num_blocks / num_videos])
table.append(["Content Blocks per publ. Marker", num_blocks / num_markers])
result += helpers.table(table, ["Feature", "All", "Upgraded"])
#
# Import Source Stats
#
result += helpers.header("Import Source Stats (Published)")
num_uploaded = get_result(SELECT_VIDEO_SOURCES +
" WHERE s.service like 'videopath'")
num_youtube = get_result(SELECT_VIDEO_SOURCES +
" WHERE s.service like 'youtube'")
num_vimeo = get_result(SELECT_VIDEO_SOURCES +
" WHERE s.service like 'vimeo'")
num_wistia = get_result(SELECT_VIDEO_SOURCES +
" WHERE s.service like 'wistia'")
num_brightcove = get_result(SELECT_VIDEO_SOURCES +
" WHERE s.service like 'brightcove'")
table = [["Import Source", 'Videos']]
table.append(["Uploaded Files", num_uploaded])
table.append(["Youtube Hosting", num_youtube])
table.append(["Vimeo Hosting", num_vimeo])
table.append(["Wistia Hosting", num_wistia])
table.append(["Brightcove Hosting", num_brightcove])
result += helpers.chart(table, 'column')
#
# Video Feature Stats
#
result += helpers.header("Video Feature Stats (Published)")
num_custom_colors = get_result(SELECT_PUBLISHED_REVISIONS +
" WHERE vr.ui_color_1 != '#424242'")
num_continuous_playback = get_result(
SELECT_PUBLISHED_REVISIONS + " WHERE vr.continuous_playback = true")
num_equal_marker_lengths = get_result(
SELECT_PUBLISHED_REVISIONS + "WHERE vr.ui_equal_marker_lengths = true")
num_custom_thumbnail = get_result(SELECT_PUBLISHED_REVISIONS +
" WHERE vr.custom_thumbnail_id != 0")
num_disable_share_buttons = get_result(
SELECT_PUBLISHED_REVISIONS +
" WHERE vr.ui_disable_share_buttons = true")
num_fit_video = get_result(SELECT_PUBLISHED_REVISIONS +
" WHERE vr.ui_fit_video = true")
num_custom_tracking_code = get_result(
SELECT_PUBLISHED_REVISIONS + " WHERE vr.custom_tracking_code != ''")
num_password = get_result(SELECT_PUBLISHED_REVISIONS +
" WHERE vr.password !=''")
# num_iphone_enabled = get_result(SELECT_PUBLISHED_REVISIONS + " WHERE vr.iphone_images > 20")
table = [['Feature', 'Videos']]
table.append(["Custom Colors", num_custom_colors])
table.append(["Custom Thumbnail", num_custom_thumbnail])
table.append(["Disabled Share Buttons", num_disable_share_buttons])
table.append(["Equal Marker Lengths", num_equal_marker_lengths])
table.append(["Fit Video", num_fit_video])
table.append(["Custom Tracking Code", num_custom_tracking_code])
table.append(["Password Protection", num_password])
table.append(["Continuous Playback", num_continuous_playback])
# table.append(["Iphone enabled", num_iphone_enabled])
result += helpers.chart(table, 'column')
#
# Content Block Stats
#
result += helpers.header("Content Block Stats (Published)")
num_text_block = get_result(SELECT_PUBLISHED_CONTENT_BLOCKS +
" WHERE vmc.type = 'text'")
num_image_block = get_result(SELECT_PUBLISHED_CONTENT_BLOCKS +
" WHERE vmc.type = 'image'")
num_social_block = get_result(SELECT_PUBLISHED_CONTENT_BLOCKS +
" WHERE vmc.type = 'social'")
num_media_block = get_result(SELECT_PUBLISHED_CONTENT_BLOCKS +
" WHERE vmc.type = 'media'")
num_website_block = get_result(SELECT_PUBLISHED_CONTENT_BLOCKS +
" WHERE vmc.type = 'website'")
num_maps_block = get_result(SELECT_PUBLISHED_CONTENT_BLOCKS +
" WHERE vmc.type = 'maps'")
num_button_block = get_result(SELECT_PUBLISHED_CONTENT_BLOCKS +
" WHERE vmc.type = 'simple_button'")
table = [["Type", "Amount"]]
table.append(["Text ", num_text_block])
table.append(["Image ", num_image_block])
table.append(["Social ", num_social_block])
table.append(["Media ", num_media_block])
table.append(["Website ", num_website_block])
table.append(["Button ", num_button_block])
table.append(["Maps ", num_maps_block])
result += helpers.chart(table, 'pie')
return SimpleTemplateResponse("insights/base.html", {
"title": "Features",
"insight_content": result
})
def response_change(self, request, obj):
if IS_POPUP_VAR in request.POST:
to_field = request.POST.get(TO_FIELD_VAR)
attr = str(to_field) if to_field else obj._meta.pk.attname
value = request.resolver_match.args[0]
new_value = obj.serializable_value(attr)
popup_response_data = json.dumps({
'action':
'change',
'value':
six.text_type(value),
'obj':
six.text_type(obj),
'new_value':
six.text_type(new_value),
})
return SimpleTemplateResponse(
'admin/popup_response.html', {
'popup_response_data': popup_response_data,
})
opts = self.model._meta
pk_value = obj._get_pk_val()
preserved_filters = self.get_preserved_filters(request)
msg_dict = {
'name': force_text(opts.verbose_name),
'obj': format_html('<a href="{}">{}</a>', urlquote(request.path),
obj),
}
if "_continue" in request.POST:
msg = format_html(
_('The {name} "{obj}" was changed successfully. You may edit it again below.'
), **msg_dict)
self.message_user(request, msg, messages.SUCCESS)
redirect_url = request.path
redirect_url = self.add_preserved_filters(
{
'preserved_filters': preserved_filters,
'opts': opts
}, redirect_url)
return HttpResponseRedirect(redirect_url)
elif "_saveasnew" in request.POST:
msg = format_html(
_('The {name} "{obj}" was added successfully. You may edit it again below.'
), **msg_dict)
self.message_user(request, msg, messages.SUCCESS)
redirect_url = self.reverse_url('change',
*self.get_base_url_args(request))
redirect_url = self.add_preserved_filters(
{
'preserved_filters': preserved_filters,
'opts': opts
}, redirect_url)
return HttpResponseRedirect(redirect_url)
elif "_addanother" in request.POST:
msg = format_html(
_('The {name} "{obj}" was changed successfully. You may add another {name} below.'
), **msg_dict)
self.message_user(request, msg, messages.SUCCESS)
redirect_url = self.reverse_url(
'add',
*self.get_base_url_args(request)[:-1])
redirect_url = self.add_preserved_filters(
{
'preserved_filters': preserved_filters,
'opts': opts
}, redirect_url)
return HttpResponseRedirect(redirect_url)
else:
msg = format_html(
_('The {name} "{obj}" was changed successfully.'), **msg_dict)
self.message_user(request, msg, messages.SUCCESS)
return self.response_post_save_change(request, obj)
def get(self, request):
return SimpleTemplateResponse('MainContent.html')
def handle_index(request):
print request.user
if request.user is None:
return SimpleTemplateResponse("index.html")
else:
return redirect('/navigate/')
