def test_pickling(self):
# Create a template response. The context is
# known to be unpicklable (e.g., a function).
response = TemplateResponse(self.factory.get("/"), "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", "_request")
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 index(request):
print " "
print "*******VIEWS INDEX******"
print " "
response = TemplateResponse(request, 'index.html', {} )
response.render()
return response
def test_pickling(self):
# Create a template response. The context is
# known to be unpickleable (e.g., a function).
response = TemplateResponse(self.factory.get('/'),
'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.assertEquals(unpickled_response.content, response.content)
self.assertEquals(unpickled_response['content-type'], response['content-type'])
self.assertEquals(unpickled_response.status_code, response.status_code)
# ...and the unpickled reponse doesn't have the
# template-related attributes, so it can't be re-rendered
self.assertFalse(hasattr(unpickled_response, '_request'))
self.assertFalse(hasattr(unpickled_response, 'template_name'))
self.assertFalse(hasattr(unpickled_response, 'context_data'))
self.assertFalse(hasattr(unpickled_response, '_post_render_callbacks'))
def home(request):
html = "appointment.home"
t = TemplateResponse(request, "base.html", {})
t.template_name = "index.html"
t.render()
# return HttpResponse(html)
return t
def mount_owncloud(request):
# If the request is a http post
if request.method == 'POST' and 'operation' not in request.POST:
form = OwncloudForm(request.POST)
if form.is_valid():
# Mount ownCloud
is_mounted = WebFolder.mount_owncloud(request.user, request.POST["user"], request.POST["password"])
if is_mounted:
message = "Your ownCloud directory was successfully mounted."
t = TemplateResponse(request, 'info.html',
{'message': message})
else:
message = "Mounting your ownCloud directory failed. Please try again!"
t = TemplateResponse(request, 'error.html',
{'message': message})
return HttpResponse(t.render())
else:
# The supplied form contained errors - just print them to the terminal.
print form.errors
else:
# If the request was not a POST, display the form to enter details.
form = OwncloudForm()
t = TemplateResponse(request, 'collection/mount_owncloud.html', {'form': form})
return HttpResponse(t.render())
def html_response(request, response, content):
"""Return a html layout with sort options as the response content."""
template = TemplateResponse(request, "profile_stats.html",
{"stats": content,
"order_by": request.GET.get('profile', None)})
template.render()
return template
def verify_attendances(request):
if 'attendance' in request.POST:
for member in request.POST.getlist('attendance'):
"""attendance = Attendance.objects.get(pk=request.POST.get('attendance'))"""
attendance = Attendance.objects.get(pk=member)
attendance.verified = True
attendance.save()
if 'delete' in request.POST:
for member in request.POST.getlist('delete'):
attendance = Attendance.objects.get(pk=member)
attendance.delete()
order_by = request.GET.get('order_by', 'user')
own_guild = request.user.userprofile.guild
general_guild = Guild.objects.filter(id = general_id)
if own_guild.abbreviation != 'TF':
guild_users = User.objects.filter(userprofile__guild = own_guild)
else:
guild_users = User.objects.filter(userprofile__is_tf = True)
unverified = Attendance.objects.filter(Q(user__in = guild_users)
& (Q(event__guild = own_guild) | Q(event__guild = general_guild))
& Q(verified = False)).order_by(order_by)
verified = Attendance.objects.filter(Q(user__in = guild_users)
& (Q(event__guild = own_guild) | Q(event__guild = general_guild))
& Q(verified = True)).order_by(order_by)
response = TemplateResponse(request, 'admin_attendances.html', {'unverified': unverified, 'verified': verified})
response.render()
return response
def test_pickling(self):
# Create a template response. The context is
# known to be unpicklable (e.g., a function).
response = TemplateResponse(self.factory.get('/'),
'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', '_request', '_current_app')
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 process_response(self, request, response):
if isinstance(response, HttpResponseNotAllowed):
response = TemplateResponse(request=request,
template="method_not_allowed.html",
status=405,
context={})
response.render()
return response
def list_events(request):
"""
Lists all events. Available only for admins.
"""
order_by = request.GET.get('order_by', 'name')
events = Event.objects.all().order_by(order_by)
response = TemplateResponse(request, 'admin_eventlist.html', {'events': events})
response.render()
return response
def render_tariff_plan_template(upc_code):
from django.template.response import TemplateResponse
t_p = request.db_session.query(TariffPlan).\
join(CompanyUpcTariffPlan).\
filter_by(company=request.user.company).\
filter_by(upc=upc_code).first()
html = TemplateResponse(request, 'upc_detailed.html', {'upc': upc_code, 'movie': upc_code.movie, 'tariff_plan': t_p})
html.render()
return html
def IndexView(request):
template_name = 'index.html'
dict = {}
posts = lp_posts.objects.all()
options = lp_options.objects.all()
dict['posts'] = posts
t = TemplateResponse(request, 'index.html', dict)
t.render()
return t
def user_ranking(request):
usersGuild = User.objects.filter(Q(userprofile__guild = request.user.userprofile.guild) & Q(userprofile__role = 'user'))
#usersAll = User.objects.filter(Q(userprofile__role = 'user'))
score_list_guild = get_user_ranking(usersGuild)
score_list_guild = sorted(score_list_guild, key=lambda points: points[3], reverse=True)
#score_list_all = get_user_ranking(usersAll) This shit will likely crash the whole site
#score_list_all = sorted(score_list_all, key=lambda points: points[3], reverse=True)[:20]
response = TemplateResponse(request, 'userrank.html', {'score_list_guild': score_list_guild})
response.render()
return response
def test_render_page(self):
template_string = 'url: {{ get_protected_url(page) }}'
template = engines['wagtail-env'].from_string(template_string)
page = self.make_page(path='foo', live=True)
request = self.request_for_hostname('localhost')
context = page.get_context(request)
response = TemplateResponse(request, template, context)
response.render()
self.assertEqual(response.content, 'url: /foo/')
def user_info(request):
cur_user = request.user
cur_user_profile = UserProfile.objects.get(user_id = cur_user.id)
attendances = Attendance.objects.filter(user = cur_user)
points = sum([x.event.points for x in attendances])
response = TemplateResponse(request, 'user_info.html', {
'profile': cur_user_profile,
'attendances': attendances,
'user_points': points
})
response.render()
return response
def test_template_response(self):
msg = (
"TemplateResponse's template argument cannot be a "
"django.template.Template anymore. It may be a backend-specific "
"template like those created by get_template()."
)
with warnings.catch_warnings(record=True) as warns:
warnings.simplefilter("always")
response = TemplateResponse(HttpRequest(), Template("foo"))
response.render()
self.assertEqual(response.content, b"foo")
self.assertEqual(len(warns), 1)
self.assertEqual(str(warns[0].message), msg)
def list_users(request):
"""
Lists all users. Available only for admins.
"""
order_by = request.GET.get('order_by', 'username')
users = User.objects.all().order_by(order_by)
if check_moderator:
users = User.objects.filter(userprofile__guild = request.user.userprofile.guild).order_by(order_by)
if check_admin:
users = User.objects.all().order_by(order_by)
response = TemplateResponse(request, 'userlist.html', {'users': users})
response.render()
return response
def maillist_maintain_ajax(request, list_id):
data = request.GET
order_column = data.get('order[0][column]', '')
order_dir = data.get('order[0][dir]', '')
search = data.get('search[value]', '')
colums = ['id', 'id', 'address', 'permit', 'update_time']
lists = ExtListMember.objects.filter(list_id=list_id)
lobj = ExtList.objects.get(id=list_id)
if search:
lists = lists.filter(address__icontains=search)
if order_column and int(order_column) < len(colums):
if order_dir == 'desc':
lists = lists.order_by('-%s' % colums[int(order_column)])
else:
lists = lists.order_by('%s' % colums[int(order_column)])
try:
length = int(data.get('length', 1))
except ValueError:
length = 1
try:
start_num = int(data.get('start', '0'))
page = start_num / length + 1
except ValueError:
start_num = 0
page = 1
count = lists.count()
if start_num >= count:
page = 1
paginator = Paginator(lists, length)
try:
lists = paginator.page(page)
except (EmptyPage, InvalidPage):
lists = paginator.page(paginator.num_pages)
rs = {"sEcho": 0, "iTotalRecords": count, "iTotalDisplayRecords": count, "aaData": []}
re_str = '<td.*?>(.*?)</td>'
number = length * (page - 1) + 1
for d in lists.object_list:
t = TemplateResponse(request, 'maillist/maillist_maintain_ajax.html', {'d': d, 'number': number, 'lobj': lobj,})
t.render()
rs["aaData"].append(re.findall(re_str, t.content, re.DOTALL))
number += 1
return HttpResponse(json.dumps(rs), content_type="application/json")
def get_js_hierarchy(request,
who_url,
obj_self,
obj_parent,
level=2,
obj_visited=set(),
show_inactive_user=False):
"""
Recursively go through obj_self...
"""
relationships = [] # used by the Google JavaScript
ldap_objects = []
if level <= 0 or obj_self in obj_visited:
return relationships, ldap_objects
if not show_inactive_user and not obj_self.is_active:
# if flag is to not show inactive and user is not active, skip
return relationships, ldap_objects
ldap_obj_dict = obj_self.__dict__
ldap_obj_dict['username'] = obj_self.username
ldap_obj_dict['photo_url'] = obj_self.photo_url
_template = TemplateResponse(request,
APP_NAME + '/person.html',
{'ldap_obj': ldap_obj_dict,
'who_url': who_url})
_template.render()
relationships.append(({
'v': obj_self.mail,
'f': _template.content
},
obj_parent.mail if obj_parent else '',
obj_self.mail))
ldap_objects.append(obj_self)
obj_visited.add(obj_self)
for report_obj in obj_self.reports:
_relationship, _ldap_objects = get_js_hierarchy(request,
who_url,
report_obj,
obj_self,
level - 1,
obj_visited,
show_inactive_user)
relationships.extend(_relationship)
ldap_objects.extend(_ldap_objects)
return relationships, ldap_objects
def ajax_reviewrule_list(request):
data = request.GET
order_column = data.get('order[0][column]', '')
order_dir = data.get('order[0][dir]', '')
search = data.get('search[value]', '')
colums = ['id', 'id', 'review', 'name', 'workmode', 'cond_logic', 'pre_action', 'target_dept', 'sequence', 'disabled']
lists = ReviewRule.objects.all()
if search:
lists = lists.filter(name__icontains=search)
if order_column and int(order_column) < len(colums):
if order_dir == 'desc':
lists = lists.order_by('-%s' % colums[int(order_column)])
else:
lists = lists.order_by('%s' % colums[int(order_column)])
try:
length = int(data.get('length', 1))
except ValueError:
length = 1
try:
start_num = int(data.get('start', '0'))
page = start_num / length + 1
except ValueError:
start_num = 0
page = 1
count = lists.count()
if start_num >= count:
page = 1
paginator = Paginator(lists, length)
try:
lists = paginator.page(page)
except (EmptyPage, InvalidPage):
lists = paginator.page(paginator.num_pages)
rs = {"sEcho": 0, "iTotalRecords": count, "iTotalDisplayRecords": count, "aaData": []}
re_str = '<td.*?>(.*?)</td>'
number = length * (page-1) + 1
for d in lists.object_list:
t = TemplateResponse(request, 'review/ajax_reviewrule.html', {'d': d, 'number': number})
t.render()
rs["aaData"].append(re.findall(re_str, t.content, re.DOTALL))
number += 1
return HttpResponse(json.dumps(rs), content_type="application/json")
def perfil(request):
profile = Profile.objects.get(user_id=request.user.id)
alertas = AvisoPorEmail.objects.filter(user_alerta=request.user.id)
if request.method == 'POST':
pais = request.POST.get('pais')
email = request.POST.get('email')
telefone = request.POST.get('telefone')
profissao = request.POST.get('profissao')
organizacao = request.POST.get('organizacao')
first_name = request.POST.get('first_name')
last_name = request.POST.get('last_name')
user = request.user
if User.objects.filter(email=email).exists():
messages.error(request, 'E-mail já cadastrado.')
else:
user.email = email
user.first_name = first_name
user.last_name = last_name
profile.telefone = telefone
profile.organizacao = organizacao
profile.pais = pais
user.save()
profile.save()
html = TemplateResponse(request, 'app2/perfil.html', {
'profile': profile,
'alertas': alertas
})
return HttpResponse(html.render())
def submissionIndex(request, rpk):
'''Make a new Submission for Report/Template selected'''
scope = 'submission'
form = SubmissionForm(rpk, request.POST or None, request.FILES or None)
if request.method == 'POST':
if form.is_valid():
cxt = check_quality(request, request.FILES['upload'],
form.cleaned_data['template'])
if cxt:
obj = form.save(commit=False)
obj.report_id = rpk
obj.name = request.FILES['upload'].name
obj.submitted_by = request.user
if cxt['clean'] == 'false':
obj.is_clean = False
obj.upload.delete(save=False)
else:
obj.is_clean = True
request.session['analysis'] = cxt
obj.save()
return redirect('porter:result', rpk=rpk)
else:
messages.error(request, 'Please submit a valid xlsx or csv file')
html = TemplateResponse(request, 'porter/submit.html', {
'form': form,
'scope': scope
})
return HttpResponse(html.render())
def dayofweeklist(request):
try:
logger.info("/todos/dayofweeklist")
c = {}
c.update(csrf(request))
if request.user.is_superuser:
response = TemplateResponse(request,
'todos/admin_dayofweeklist.html', c)
else:
response = TemplateResponse(request, 'todos/dayofweeklist.html', c)
response.render()
return response
except Exception as e:
logger.error(traceback.format_exc())
return ErrClass('UNKNWON_ERROR').response()
def get_ruta(request, video): #ejemplo
global array
ruta, distancia, MA = rutaRecoleccion(array)
mr = []
#Calcula todas las posibles rutas y la que tiene la menor distancia
mejorR, mejorD = mejorRuta(MA)
print(mejorR, mejorD)
error = round(abs(mejorD - distancia) * 100 / mejorD, 1)
for e in MA:
mr.append([round(elem, 1) for elem in e])
distancia = round(distancia, 1)
context = {
'vector': str(array),
'ruta': str(ruta),
'distancia': distancia,
'video': video,
'MatAdy': mr,
'mejorRuta': mejorR,
'mejorDistancia': mejorD,
'error': error
}
html = TemplateResponse(request, 'ruta.html', context)
return HttpResponse(html.render())
def news(request):
try:
if request.POST.get("date_filter"):
date_filter = int(request.POST.get("date_filter"))
else:
date_filter = 10
last_date = timezone.now()-timedelta(days=date_filter)
if request.user.is_anonymous():
news = [n for n in News.objects.order_by("-date")
if (n.collection!=None and n.collection.public_access) # user news (public collection)
and (n.date>=last_date)]
else:
news = [n for n in News.objects.order_by("-date")
if ((n.collection==None and n.group==None) # general news
or (n.collection!=None and n.collection.public_access) # user news (public collection)
or (n.collection!=None and n.collection in request.user.get_all_permissible_collections()) # user news (collection)
or (n.group!=None and n.group in request.user.groups.all())) # user news (group)
and (n.date>=last_date)]
except Collection.DoesNotExist:
raise Http404
t = TemplateResponse(request, 'log/news.html',
{'news': news,
'date_filter': date_filter})
return HttpResponse(t.render())
def resultIndex(request, rpk):
'''Result page showing analysis of data quality'''
scope = 'result'
df_meta, df_report = None, None
if 'analysis' in request.session:
cxt = request.session['analysis']
clean, df_meta, df_report = cxt['clean'], cxt['df_meta'], cxt[
'df_report']
if clean == 'true':
messages.success(
request,
'SUCCESS: Uploaded data passes all quality checks. Thank you!')
elif clean == 'false':
messages.error(
request,
'ERROR: Quality check for submission failed, please correct accordingly and resubmit'
)
del request.session['analysis']
else:
messages.error(request, 'SYSTEM ERROR: No valid submission found')
return redirect('porter:submission', rpk=rpk)
html = TemplateResponse(request, 'porter/result.html', {
'scope': scope,
'df_meta': df_meta,
'df_report': df_report
})
return HttpResponse(html.render())
def job_list(request):
context = {}
context['jobs'] = JobList.objects.all()
print(context)
html = TemplateResponse(request, 'joblist.html', context)
return HttpResponse(html.render())
def products_list(request):
context = {}
context['products'] = Product.objects.all()
html = TemplateResponse(request, 'adding_to_cart.html', context)
return HttpResponse(html.render())
def show(request, slug):
slideshow = get_object_or_404(Slideshow, slug=slug)
options = slideshow.user.profile.options
if options is None:
options = {}
try:
options.update(slideshow.options)
except TypeError:
pass
engine = options.get('engine', 'remark').replace(
'../', '') # TODO get from site wide config
if engine == 'cleaver':
slides, cleaver_options = slideshow.parse_cleaver_slides()
default_cleaver_options = {
'controls': True,
'progress': True,
'encoding': 'utf-8'
}
options = {**default_cleaver_options, **options, **cleaver_options}
if options['author']:
t = TemplateResponse(request, f'{engine}/author.html',
{'author': options['author']})
t.render()
slides.append({
'classes': 'hidden',
'content': t.rendered_content,
})
slideshow.slides = slides
slideshow.options = options
try:
engine_options = options[engine]
except KeyError:
engine_options = {}
return render(request, f'{engine}/show.html', {
'slideshow': slideshow,
'options': json.dumps(engine_options),
})
def check_upc_price_plan(request, upc):
upc_obj = request.db_session.query(UPC).filter_by(upc=upc).first()
if upc_obj.tariff_plan:
return JsonResponse(json_response_content('success', 'Tariff plan is assigned'))
else:
from django.template.response import TemplateResponse
tariff_plans = request.db_session.query(TariffPlan)\
.filter(TariffPlan.company_id == request.user.company_id)\
.all()
response = json_response_content('warning', 'Please assign tariff plan before going on.')
html = TemplateResponse(request, 'modals/add_disk_priceplan_issue.html',
{'upc': upc_obj, 'tariffPlans': tariff_plans})
html.render()
response['data'] = {
'modal_html': html.content
}
return JsonResponse(response)
def noteDetailView(request, pk):
note_obj = Notes.objects.filter(pk=pk).first()
if not note_obj or note_obj.user != request.user:
response = TemplateResponse(request, 'notes/403.html', {})
response.render()
return HttpResponseForbidden(response)
tag_list = concatTags(note_obj)
print(tag_list)
context = {
'note_id': note_obj.id,
'title': note_obj.title,
'last_modified': note_obj.last_modified,
'note_text': note_obj.note_text,
'tags': tag_list
}
return render(request, 'notes/notes_detail.html', context=context)
def preferences(request):
try:
collections = Collection.objects.all()
except Collection.DoesNotExist:
raise Http404
t = TemplateResponse(request, 'authentication/preferences.html',
{'collections': collections})
return HttpResponse(t.render())
def editar_alerta(request, id):
editar = AvisoPorEmail.objects.get(id=id)
alertas = AvisoPorEmail.objects.filter(user_alerta=request.user.id)
igual = False
if request.method == 'POST':
nome = request.POST.get('nome_alerta')
frequencia = request.POST.get('frequencia')
busca_global = request.POST.get('busca_global')
idiomas = request.POST.get('idiomas')
autor = request.POST.get('autor')
titulo_e_resumo = request.POST.get('titulo_e_resumo')
opcao_titulo_resumo = request.POST.get('titulo_resumo')
button_autores = request.POST.get('tipoAutores')
button_titulo_e_resumo = request.POST.get('tipoTituloResumo')
if busca_global or idiomas or autor or titulo_e_resumo:
for alerta in alertas:
if alerta.busca_global == busca_global and alerta.idiomas == idiomas and alerta.titulo_e_resumo == titulo_e_resumo and alerta.autor == autor:
if alerta.opcao_titulo_resumo == opcao_titulo_resumo or (
alerta.opcao_titulo_resumo != opcao_titulo_resumo
and alerta.titulo_e_resumo == ""
and titulo_e_resumo == ""):
if alerta.button_titulo_e_resumo == button_titulo_e_resumo or (
alerta.button_titulo_e_resumo !=
button_titulo_e_resumo
and alerta.titulo_e_resumo == ""
and titulo_e_resumo == ""):
if alerta.button_autores == button_autores or (
alerta.button_autores != button_autores
and alerta.autor == "" and autor == ""):
if alerta.id != editar.id:
igual = True
else:
if nome == alerta.nome and frequencia == alerta.frequencia:
igual = True
if not igual:
editar.nome = nome
editar.frequencia = frequencia
editar.busca_global = busca_global
editar.idiomas = idiomas
editar.autor = autor
editar.titulo_e_resumo = titulo_e_resumo
editar.opcao_titulo_resumo = opcao_titulo_resumo
editar.button_autores = button_autores
editar.button_titulo_e_resumo = button_titulo_e_resumo
editar.save()
return redirect('/cadastro/meus-alertas')
else:
messages.error(
request,
'Esse alerta já foi criado. Verifique seus alertas.')
else:
messages.error(request,
'Alerta vazio. Preencha pelo menos um campo.')
html = TemplateResponse(request, 'app2/meus_alertas.html',
{'alerta': editar})
return HttpResponse(html.render())
def department_member_ajax(request, dpt_id):
data = request.GET
order_column = data.get('order[0][column]', '')
order_dir = data.get('order[0][dir]', '')
search = data.get('search[value]', '')
obj = Department.objects.get(id=dpt_id)
colums = ['id', 'id']
lists = DepartmentMember.objects.filter(dept_id=dpt_id)
if lists.exists() and order_column and int(order_column) < len(colums):
if order_dir == 'desc':
lists = lists.order_by('-%s' % colums[int(order_column)])
else:
lists = lists.order_by('%s' % colums[int(order_column)])
try:
length = int(data.get('length', 1))
except ValueError:
length = 1
try:
start_num = int(data.get('start', '0'))
page = start_num / length + 1
except ValueError:
start_num = 0
page = 1
count = lists.count()
if start_num >= count:
page = 1
paginator = Paginator(lists, length)
try:
lists = paginator.page(page)
except (EmptyPage, InvalidPage):
lists = paginator.page(paginator.num_pages)
rs = {"sEcho": 0, "iTotalRecords": count, "iTotalDisplayRecords": count, "aaData": []}
re_str = '<td.*?>(.*?)</td>'
number = length * (page - 1) + 1
for d in lists.object_list:
mailobj = Mailbox.objects.filter(id=d.mailbox_id).first()
t = TemplateResponse(request, 'dpt/dpt_mem_ajax.html', {'d': d, 'number': number, 'mailobj': mailobj})
t.render()
rs["aaData"].append(re.findall(re_str, t.content, re.DOTALL))
number += 1
return HttpResponse(json.dumps(rs), content_type="application/json")
def index(request):
# news = News.objects.order_by('-pub_date')[:4]
last_session = CourseSession.objects.order_by('-pub_date').last()
video = Video.objects.order_by('-pub_date')[:5]
poster = Poster.objects.order_by('-pub_date')[:4]
event = Course.objects.order_by('-pub_date')[0]
events = Course.objects.order_by('-pub_date')[:4]
t = TemplateResponse(
request, 'home.html', {
'last_session': last_session,
'posters': poster,
'videos': video,
'events': events,
'event': event
})
t.render()
return HttpResponse(t)
def game(request):
gameID = request.GET['gameID']
owned = False
currentuser = request.user
purchased = Purchased.objects.filter(owner__id=currentuser.id)
game = Games.objects.get(id=gameID)
scorelist = []
for entry in purchased:
if game == entry.game:
owned = True
break
pid = "{}:{}".format(currentuser.id, game.id)
checksumstr = "pid={}&sid={}&amount={}&token={}".format(pid, "GameshopAAC", game.price, "c858a84d04755915ded5daba44a3644f")
m = md5(checksumstr.encode("ascii"))
checksum = m.hexdigest()
response = TemplateResponse(request, 'game.html', {'game': game, 'owned': owned, 'checksum':checksum, 'pid':pid})
response.render()
return response
def results_view(request):
query = request.GET.get('q', '')
results = dotgov.search(query)
context = {'q': query, 'results': results}
response = TemplateResponse(request, 'search/results.html', context)
return response.render()
def docs_resources(request):
context = dict()
context['title'] = 'Resources'
context['resources'] = dict(organisation=OrganisationResource.__name__,
organisation_doc=OrganisationResource.__doc__,
activity=ActivityResource.__name__,
activity_doc=ActivityResource.__doc__)
t = TemplateResponse(request, 'documentation/resources.html', context)
return t.render()
def login(request,
template_name='login.html',
redirect_field_name=REDIRECT_FIELD_NAME,
authentication_form=StrictAuthenticationForm,
current_app=None,
extra_context=None):
"""
Displays the login form and handles the login action.
This view is the same as the Django 1.6 login view but uses the
StrictAuthenticationForm
"""
redirect_to = request.POST.get(redirect_field_name,
request.GET.get(redirect_field_name, ''))
if request.method == "POST":
form = authentication_form(request, data=request.POST)
if form.is_valid():
# Ensure the user-originating redirection url is safe.
if not is_safe_url(url=redirect_to, host=request.get_host()):
redirect_to = resolve_url(settings.LOGIN_REDIRECT_URL)
# Okay, security check complete. Log the user in.
auth_login(request, form.get_user())
return HttpResponseRedirect(redirect_to)
else:
form = authentication_form(request)
current_site = get_current_site(request)
context = {
'form': form,
redirect_field_name: redirect_to,
'site': current_site,
'site_name': current_site.name,
}
if extra_context is not None:
context.update(extra_context)
response = TemplateResponse(request, template_name, context)
# current_app=current_app)
response.render()
return response
def ajax_get_mails(request):
data = request.GET
mails = get_all_data(data, user=request.user)
try:
length = int(data.get('length', 1))
except ValueError:
length = 1
try:
page = int(data.get('start', '0')) / length + 1
except ValueError:
page = 1
try:
count = mails.count()
except:
count = len(mails)
paginator = Paginator(mails, length)
try:
mails = paginator.page(page)
except (EmptyPage, InvalidPage):
mails = paginator.page(paginator.num_pages)
rs = {
"sEcho": 0,
"iTotalRecords": count,
"iTotalDisplayRecords": count,
"aaData": []
}
re_str = '<td.*?>(.*?)</td>'
for m in mails.object_list:
t = TemplateResponse(request, 'collect_mail/ajax_get_mails.html', {
'm': m,
'date': m.get_date()
})
t.render()
rs["aaData"].append(re.findall(re_str, t.content, re.DOTALL))
return HttpResponse(json.dumps(rs, ensure_ascii=False),
content_type="application/json")
def page_to_html(page, language=None, encoding='utf-8'):
# generate request
request = CMSRequestFactory().request()
request.current_page = page
# generate request context
context = RequestContext(request)
context['lang'] = language or app_settings.DEFAULT_LANGUAGE
context['current_page'] = page
# generate template response
template_name = get_template_from_request(request, page)
response = TemplateResponse(request, template_name, context)
response.render()
# generate html
html = response.content.decode(encoding)
return html
def render(self, request, templates, context, tz=None, **kwargs):
logger.debug(
"{app}.render: {request.path}".format(
app=self.__class__.__name__, request=request
)
)
context.update({"application": self})
kwargs.setdefault("context", context)
response = TemplateResponse(request, templates, **kwargs)
response.current_app = self.current_app
if tz is not None:
with timezone.override(tz):
response.render()
if not request.user.is_anonymous:
patch_cache_control(response, private=True)
return response
def get_video(request, n): #numero de elementos
global array, real
#Para el video de 3
if n == "3":
array = [[36.498141627543035, 18.134324942062158],
[100.33624093043105, 30.837831651842286],
[119.65437940140836, 15.18749713897705]]
real = [[33, 22.2], [77, 30.5], [94, 16]]
#Para el de 3
elif n == "5":
array = [[29.51785714285714, 19.596770501905876],
[48.30952380952381, 9.848212242126465],
[65.27771335807051, 26.63414075897961],
[87.63265306122445, 13.806815580888228],
[103.59226190476184, 30.837831651842286]]
real = [[31, 21.5], [46, 10.8], [60, 27.8], [83, 16], [99, 32.2]]
elif n == "6":
array = [[5.35066526610644, 16.651682821552411],
[26.588662790697676, 18.999997174298311],
[41.14233193277305, 22.9245239833616],
[63.77083333333323, 24.83783165184227],
[76.67867772108823, 25.928565979003906],
[100.29501488095215, 24.837831651842286]]
real = [[5, 17.8], [26, 20.6], [40.7, 24.8], [60.7, 26.7],
[80.7, 27.3], [100.6, 26.4]]
elif n == "8":
array = [[5.545454545454547, 17.525770836269736],
[20.1375, 18.13432494206214],
[40.07675438596492, 13.499997456868483],
[50.92538759689921, 27.3749942779541],
[73.93311403508767, 21.112672832650208],
[88.74621212121211, 30.153840285081102],
[100.38541666666673, 10.878046919659877],
[112.77559523809535, 19.285710652669273]]
real = [[5, 17.3], [20.7, 21], [40.3, 13.8], [50.7, 27.3], [73, 20.5],
[88, 28], [100.5, 11.5], [112, 25.5]]
#calculo de error
promErrorDist = 0
promErrorAng = 0
for i in range(len(real)):
promErrorAng += round(abs(real[i][0] - array[i][0]) * 100 / real[i][0])
promErrorDist += round(
abs(real[i][1] - array[i][1]) * 100 / real[i][1])
promErrorDist = promErrorDist / (i + 1)
promErrorAng = promErrorAng / (i + 1)
promErrorDist = round(promErrorDist, 2)
promErrorAng = round(promErrorAng, 2)
context = {'n': n, 'ea': promErrorAng, 'ed': promErrorDist}
html = TemplateResponse(request, 'video.html', context)
return HttpResponse(html.render())
def my_shared_folder(request, rel_path=''):
# create ownCloud directory
if "create_owncloud_dir" in request.POST:
WebFolder.create_owncloud_dir(request.user)
# class the files in categories collection, directory or file
dirs = []
files = []
owncloud = None
for item_name in WebFolder.list_dir(request.user, rel_path):
rel_item_path = os.path.join(utils.path.no_slash(rel_path), item_name)
if WebFolder.is_file(request.user, rel_item_path):
file_size = WebFolder.get_file_size(request.user, rel_item_path)
f = WebFolder.get_file(request.user, rel_item_path)
file_revision = f.revision if f else "-"
files.append({"name": item_name,
"size": utils.units.convert_data_size(file_size),
"revision": file_revision,
"part_of_collection": bool(f)})
elif WebFolder.is_dir(request.user, rel_item_path):
collection = WebFolder.get_collection(request.user, rel_item_path)
dir_size = WebFolder.get_dir_size(request.user, rel_item_path)
# ownCloud directory
if utils.path.no_slash(rel_item_path)==OWNCLOUD_DIR_NAME:
owncloud = {"name": item_name,
"size": utils.units.convert_data_size(dir_size),
"is_mounted": WebFolder.is_mounted(request.user)}
# collection
elif collection:
dirs.append({"type": "c",
"id": collection.identifier,
"name": collection.directory.name,
"size": utils.units.convert_data_size(dir_size),
"revision": collection.revision,
"access": request.user.get_permission(collection)})
# standard directory
else:
d = WebFolder.get_dir(request.user, rel_item_path)
dir_revision = d.revision if d else "-"
dirs.append({"type": "d",
"name": item_name,
"size": utils.units.convert_data_size(dir_size),
"revision": dir_revision,
"part_of_collection": bool(d)})
# call html
t = TemplateResponse(request, 'collection/my_shared_folder.html',
{'rel_path': utils.path.both_slash(rel_path),
'rel_parent_path': utils.path.no_slash(os.path.dirname(rel_path)),
'dirs': dirs,
'files': files,
'owncloud': owncloud})
return HttpResponse(t.render())
def docs_resources(request):
context = dict()
context['title'] = 'Resources'
context['resources'] = dict(
organisation = OrganisationResource.__name__,
organisation_doc = OrganisationResource.__doc__,
activity = ActivityResource.__name__,
activity_doc = ActivityResource.__doc__
)
t = TemplateResponse(request, 'documentation/resources.html', context)
return t.render()
def results_view(request):
query = request.GET.get('q', '')
results = dotgov.search(query)
context = {
'q': query,
'results': results
}
response = TemplateResponse(request, 'search/results.html', context)
return response.render()
def ajax_mailLogActiveUserStat(request):
last_time = time.time()
flag, lists, condition, start_num, page, length, showmax = mailLogActiveSearch(
request)
#print "mailLogActiveSearch: ",condition
#last_time = count_time(last_time)
MB = 1024 * 1024.0
count = len(lists)
if showmax > 0 and count > showmax:
count = showmax
if start_num >= count:
page = 1
paginator = Paginator(lists, length)
#print "mailLogActiveSearch Paginator"
#last_time = count_time(last_time)
try:
page_lists = paginator.page(page)
except (EmptyPage, InvalidPage):
page_lists = paginator.page(paginator.num_pages)
rs = {
"sEcho": 0,
"iTotalRecords": count,
"iTotalDisplayRecords": count,
"aaData": []
}
re_str = '<td.*?>(.*?)</td>'
number = length * (page - 1) + 1
for d in page_lists.object_list:
data = mailLogActiveStatSingle(flag, lists, d, condition)
#print "mailLogActiveStatSingle: ",d
#last_time = count_time(last_time)
data["number"] = number
t = TemplateResponse(request, 'maillog/ajax_active_user.html', data)
t.render()
rs["aaData"].append(re.findall(re_str, t.content, re.DOTALL))
number += 1
return HttpResponse(json.dumps(rs), content_type="application/json")
def retrieve_new_collections(request):
post = request.POST
chosen_filters = []
collections = []
retrieve = False
error_msg = ""
# click tab retrieve new collections
if not post:
chosen_filters = [(0, enum.Tag.TITLE, "")]
# add filter
elif "add_filter" in post:
nr_filters = int(post["nr_filters"])
chosen_filters = []
for i in range(nr_filters):
chosen_filters.append((i, post["filter"+str(i)], post["query"+str(i)]))
chosen_filters.append((nr_filters, enum.Tag.TITLE, ""))
# remove filter
elif "remove_filter" in post:
nr = int(post["remove_filter"])
nr_filters = int(post["nr_filters"])
chosen_filters = []
for i in range(nr_filters):
if i < nr:
chosen_filters.append((i, post["filter"+str(i)], post["query"+str(i)]))
elif i > nr:
chosen_filters.append((i-1, post["filter"+str(i)], post["query"+str(i)]))
# retrieve collections
elif "retrieve" in post:
try:
retrieve = True
nr_filters = int(post["nr_filters"])
chosen_filters = []
for i in range(nr_filters):
chosen_filters.append((i, post["filter"+str(i)], post["query"+str(i)]))
collections = Collection.retrieve_collections(request.user, [(k,v) for (_,k,v) in chosen_filters])
except CannotParseStringToDateException as exc:
error_msg = "Incorrect date: " + exc.date
else:
pass
t = TemplateResponse(request, 'collection/retrieve_new_collections.html',
{'filter_choices': [t for t in enum.Tag.CHOICES_B],
'chosen_filters': chosen_filters,
'collections': collections,
'error_msg': error_msg,
'retrieve': retrieve})
return HttpResponse(t.render())
def ajax_get_notices(request):
data = request.GET
notices = get_notices(data, request.user)
try:
length = int(data.get('length', 1))
except ValueError:
length = 1
try:
page = int(data.get('start', '0')) / length + 1
except ValueError:
page = 1
count = len(notices)
paginator = Paginator(notices, length)
try:
notices = paginator.page(page)
except (EmptyPage, InvalidPage):
notices = paginator.page(paginator.num_pages)
rs = {
"sEcho": 0,
"iTotalRecords": count,
"iTotalDisplayRecords": count,
"aaData": []
}
re_str = '<td.*?>(.*?)</td>'
for n in notices.object_list:
t = TemplateResponse(request, 'core/ajax_get_notices.html', {
'n': n,
'type': type
})
t.render()
rs["aaData"].append(re.findall(re_str, t.content, re.DOTALL))
return HttpResponse(json.dumps(rs, ensure_ascii=False),
content_type="application/json")
def test_pickling(self):
# Create a template response. The context is
# known to be unpicklable (e.g., a function).
response = TemplateResponse(
self.factory.get("/"),
"first/test.html",
{
"value": 123,
"fn": datetime.now,
},
)
with 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.headers["content-type"],
response.headers["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",
"_request",
)
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 simple_upload(request):
html = TemplateResponse(request, 'upload_category.html')
if request.method == 'POST':
category_resource = CategoryResource
dataset = Dataset()
new_categories = request.FILES['myfile']
imported_data = dataset.load(new_categories.read())
result = category_resource.import_data(imported_data, dry_run=True)
if not result.has_errors():
category_resource.import_data(imported_data, dry_run=False)
return HttpResponse(html.render())
def ajax_get_maillist_trigger(request):
data = request.GET
list_id = int(data.get('list_id', 0))
task_id = data.get('task_id', None)
cr = connections['mm-pool'].cursor()
tablename = 'ml_subscriber_' + str(request.user.id)
sql = "SELECT COUNT(1) FROM %s WHERE list_id=%d;" % (tablename, list_id)
cr.execute(sql)
data = cr.fetchone()
count = data[0] if data else 0
# 获取 关联的触发器
html = ''
trigger_ids = []
if task_id:
task_obj = SendTask.objects.filter(id=task_id).first()
trigger_ids = task_obj.trigger_set.filter(status='enable').values_list("id", flat=True)
lists = Trigger.getTriggerBylist(request.user.id, list_id, type='open')
if lists:
t = TemplateResponse(request, 'task/trigger.html', {'lists': lists, 'task_id': task_id, 'trigger_ids': trigger_ids,})
t.render()
html = t.content
return HttpResponse(json.dumps({'count': count, 'html': html}), content_type="application/json")
def list_user_events(request):
order_by_events = request.GET.get('order_by_events', 'guild')
user = request.user
if user.profile.is_tf == 1:
tf = 14
else:
tf = 20 # ???
events = Event.objects.filter(Q(guild__id = user.profile.guild_id) | Q(guild__id = general_id) | Q(guild__id = tf)).order_by(order_by_events)
attendances = Attendance.objects.filter(Q(user__id = request.user.pk))
for event in events:
event.times_attended = attendances.filter(event=event.pk).count()
# check if event is attended more than it's allowed amount and disable attending it if so
event.disabled = event.times_attended >= event.repeats
response = TemplateResponse(request,
'eventlist.html',
{
'events': events,
'order_by_events': order_by_events
})
response.render()
return response
def profile(request, username):
if request.user.username == username:
if request.method == "POST":
u_form = UserUpdateForm(request.POST, instance=request.user)
p_form = ProfileUpdateForm(request.POST,
request.FILES,
instance=request.user.profile)
if u_form.is_valid() and p_form.is_valid():
u_form.save()
p_form.save()
messages.success(
request, 'Your profile has successfully been updated.')
return redirect('/profile/{}'.format(request.user.username))
else:
u_form = UserUpdateForm(instance=request.user)
p_form = ProfileUpdateForm(instance=request.user.profile)
context = {'u_form': u_form, 'p_form': p_form, 'title': 'Profile'}
return render(request, 'users/profile.html', context=context)
response = TemplateResponse(request, 'notes/403.html', {})
response.render()
return HttpResponseForbidden(response)
def ajax_get_maillistcount_and_triggers(request):
data = request.GET
list_ids = data.get('list_ids', "0")
task_id = data.get('task_id', None)
lists = MailList.objects.filter(
Q(customer=request.user) | Q(sub_share_maillist__user=request.user)).filter(
id__in=map(int, list_ids.split(","))).values_list("id", "customer_id", "count_real")
count = 0
index = 0
html = ''
user_ids = defaultdict(list)
for list_id, customer_id, count_real in lists:
user_ids[customer_id].append(list_id)
index += 1
count += count_real
# cr = connections['mm-pool'].cursor()
# for customer_id, listids in user_ids.items():
# tablename = 'ml_subscriber_' + str(customer_id)
# sql = "SELECT COUNT(1) FROM {} WHERE list_id IN ({});".format(tablename, ",".join(map(str, listids)))
# cr.execute(sql)
# data = cr.fetchone()
# c = data[0] if data else 0
# MailList
# count += c
# index += 1
if index==1 and user_ids.keys()[0] == request.user.id:
# 获取 关联的触发器
trigger_ids = []
if task_id:
task_obj = SendTask.objects.filter(id=task_id).first()
trigger_ids = task_obj.trigger_set.filter(status='enable').values_list("id", flat=True)
lists = Trigger.getTriggerBylistids(request.user.id, list_ids.split(","), type='open')
if lists:
t = TemplateResponse(request, 'task/trigger.html', {'lists': lists, 'task_id': task_id, 'trigger_ids': trigger_ids,})
t.render()
html = t.content
return HttpResponse(json.dumps({'count': count, 'html': html}), content_type="application/json")
def reportsetIndex(request, pk=None):
'''Reportset organizes both Templates and Reports, under a Group/Account'''
scope = 'reportset'
instance = get_object_or_404(ReportSet, pk=pk) if pk else None
form = ReportSetForm(request.user, request.POST or None, instance=instance)
if form.is_valid():
obj = form.save(commit=False)
if not pk:
obj.create_by = request.user
obj.save()
html = TemplateResponse(request, 'porter/create.html', {
'form': form,
'scope': scope
})
return HttpResponse(html.render())
def submit_login(request):
if request.method == "POST":
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
return redirect('/cadastro/')
else:
messages.error(request,
'Usuário/Senha inválidos. Favor tentar novamente.')
html = TemplateResponse(request, 'app2/login.html')
return HttpResponse(html.render())
def unsupported(request):
if hasattr(settings, "BADBROWSER_SUGGEST"):
suggest = settings.BADBROWSER_SUGGEST
else:
suggest = ("firefox",)
if hasattr(settings, "BADBROWSER_BASE_TEMPLATE"):
base_template = settings.BADBROWSER_BASE_TEMPLATE
else:
base_template = "badbrowser/base.html"
t = TemplateResponse(request, 'badbrowser/unsupported.html', {
"next": request.path,
"suggest": suggest,
"base_template": base_template
})
return t.render()
def manage_my_collections(request):
try:
collections = request.user.subscriptions.all()
except Collection.DoesNotExist:
raise Http404
cols = []
for c in collections:
cols.append({"id": c.identifier,
"name": c.name,
"abstract": c.abstract,
"revision": c.revision,
"access": request.user.get_permission(c)})
t = TemplateResponse(request, 'collection/manage_my_collections.html',
{'collections': cols})
return HttpResponse(t.render())
def public_folder(request, rel_path=''):
# class the files in categories collection, directory or file
dirs = []
files = []
for item_name in PublicFolder.list_dir(rel_path):
rel_item_path = os.path.join(utils.path.no_slash(rel_path), item_name)
if PublicFolder.is_file(rel_item_path):
file_size = PublicFolder.get_file_size(rel_item_path)
f = PublicFolder.get_file(rel_item_path)
file_revision = f.revision if f else "-"
files.append({"name": item_name,
"size": utils.units.convert_data_size(file_size),
"revision": file_revision,
"part_of_collection": bool(f)})
elif PublicFolder.is_dir(rel_item_path):
collection = PublicFolder.get_collection(rel_item_path)
dir_size = PublicFolder.get_dir_size(rel_item_path)
# collection
if collection:
dirs.append({"type": "c",
"id": collection.identifier,
"name": collection.directory.name,
"size": utils.units.convert_data_size(dir_size),
"revision": collection.revision})
# standard directory
else:
d = PublicFolder.get_dir(rel_item_path)
dir_revision = d.revision if d else "-"
dirs.append({"type": "d",
"name": item_name,
"size": utils.units.convert_data_size(dir_size),
"revision": dir_revision,
"part_of_collection": bool(d)})
# call html
t = TemplateResponse(request, 'collection/public_folder.html',
{'rel_path': utils.path.both_slash(rel_path),
'rel_parent_path': utils.path.no_slash(os.path.dirname(rel_path)),
'dirs': dirs,
'files': files})
return HttpResponse(t.render())
