def get(self, request, *args, **kwargs):
messages.info(request, 'Welcome to the Legend of..')
messages.success(request, 'AWESOME')
messages.debug(request, 'debugging')
messages.warning(request, 'Take care..')
messages.error(request, 'This will change your life!')
return super(TestView, self).get(request, *args, **kwargs)
def list(request):
success, code, msg = test_connection()
if not success:
messages.error(
request,
_("Unable to connect (HTTP %(code)s) to API at <code>%(url)s</code>%(msg)s")
% {
"url": settings.CARDSHOP_API_URL,
"code": code,
"msg": " -- " + msg if msg else "",
},
)
return redirect("admin")
items = OrdersQuerySet("/orders/")
page = request.GET.get("page")
paginator = Paginator(items, 10)
orders_page = paginator.get_page(page)
context = {
"orders_page": orders_page,
"orders": orders_page.object_list,
}
if success:
messages.set_level(request, messages.DEBUG)
messages.debug(
request,
_("Connected to Scheduler API at <code>%(url)s</code>")
% {"url": settings.CARDSHOP_API_URL},
)
return render(request, "all_orders.html", context)
def detail(request, order_id):
success, code, msg = test_connection()
if not success:
messages.error(
request,
_("Unable to connect (HTTP %(code)s) to API at <code>%(url)s</code>%(msg)s")
% {
"url": settings.CARDSHOP_API_URL,
"code": code,
"msg": " -- " + msg if msg else "",
},
)
return redirect("admin")
retrieved, order = get_order(order_id)
context = {"orderdata": OrderData(order)}
if success:
messages.set_level(request, messages.DEBUG)
messages.debug(
request,
_("Connected to Scheduler API at <code>%(url)s</code>")
% {"url": settings.CARDSHOP_API_URL},
)
return render(request, "all_orders-detail.html", context)
def dashboard(request):
messages.error(request, 'Test error message!')
messages.info(request, 'Test info message!')
messages.warning(request, 'Test warning message!')
messages.success(request, 'Test success message!')
messages.debug(request, 'Test debug message!')
return render(request, 'account/dashboard.html', {'section': 'dashboard'})
def list(request):
success, code, msg = test_connection()
if not success:
messages.error(
request,
"Unable to connect (HTTP {code}) to API at <code>{url}</code>{msg}"
.format(
url=settings.CARDSHOP_API_URL,
code=code,
msg=" -- " + msg if msg else "",
),
)
return redirect("admin")
items = OrdersQuerySet("/orders/")
page = request.GET.get("page")
paginator = Paginator(items, 10)
orders_page = paginator.get_page(page)
context = {
"orders_page": orders_page,
"orders": orders_page.object_list,
}
if success:
messages.set_level(request, messages.DEBUG)
messages.debug(
request,
"Connected to Scheduler API at <code>{url}</code>".format(
url=settings.CARDSHOP_API_URL),
)
return render(request, "all_orders.html", context)
def index(request):
# 筛选并保留比messages.WARNING级别高的消息提示
# set_level必须在添加信息提示之前使用，否则无法筛选
# messages.set_level(request, messages.WARNING)
# 消息添加方法一
messages.debug(request, 'debug类型')
messages.info(request, 'info类型', 'MyInfo')
messages.success(request, 'success类型')
messages.warning(request, 'warning类型')
messages.error(request, 'error类型')
# 消息添加方法二
messages.add_message(request, messages.INFO, 'info类型2')
# 自定义消息类型
# request代表参数request
# 66代表参数level
# 自定义类型代表参数message
# MyDefine代表参数extra_tags
messages.add_message(request, 66, '自定义类型', 'MyDefine')
# 获取所以消息提示的最低级别
current_level = messages.get_level(request)
print(current_level)
# 获取当前用户的消息提示对象
mg = messages.get_messages(request)
print(mg)
return render(request, 'index.html', locals(), RequestContext(request))
def get_filters(self, request, filter_language=True):
"""
Construct queryset filter kwargs, to limit the queryset for the current user
"""
filters = {"entry__sites__id__exact": settings.SITE_ID}
if filter_language:
# Filter by language
preferences = get_preferences()
language_filter = preferences["language_filter"]
if DEBUG_LANG_FILTER:
messages.debug(request,
"language filter: %s" % language_filter)
if language_filter == BlogPrefForm.CURRENT_LANGUAGE:
# Display only blog entries in current language (select on the page)
filters["language"] = request.PYLUCID.current_language
elif language_filter == BlogPrefForm.PREFERED_LANGUAGES:
# Filter by client prefered languages (set in browser and send by HTTP_ACCEPT_LANGUAGE header)
filters["language__in"] = request.PYLUCID.languages
if not request.user.has_perm(
"blog.change_blogentry") or not request.user.has_perm(
"blog.change_blogentrycontent"):
filters["entry__is_public"] = True
filters["is_public"] = True
if DEBUG_LANG_FILTER:
messages.debug(request, "queryset filter: %s" % repr(filters))
return filters
def debug(self, message, extra_tags='alert-warning'):
"""
Add a debug message in request
:param message: content of message
:param extra_tags: tags of message
"""
messages.debug(self.request, mark_safe(message), extra_tags=extra_tags)
def index(request):
messages.debug(request, '%s SQL statements were executed.' % 100)
messages.info(request, 'Three credits remain in your account.')
messages.success(request, 'Profile details updated.')
messages.warning(request, 'Your account expires in three days.')
messages.error(request, 'Document deleted.')
return render_to_response("demo/index.html",context_instance=RequestContext(request))
def test_debug(self):
messages.debug(self.user, "Hello")
# 0 messages because by default django.contrib.messages ignore DEBUG
# messages (this can be changed using set_level)
response = self.client.get('/')
msgs = list(response.context['messages'])
self.assertEqual(0, len((msgs)))
def post(self, request, *args, **kwargs):
form = self.form_class(request.POST or None)
post = Post.objects.get(pk=kwargs['pk'])
comments = Comment.objects.filter(post=post.id)
if form.is_valid():
fields = {}
for key, value in form.cleaned_data.items():
fields[key]=value
fields['creator']=request.user
fields['post_id']=kwargs['pk']
fields['pub_date']=timezone.now()
comment = Comment(**fields)
try:
comment.save()
except IntegrityError as e:
messages.error(request, "Something went wrong while saving")
messages.debug(request, f'{e.__cause__}')
else:
messages.success(request, "Your comment have been saved!")
else:
messages.error(request, "Something went wrong, your comment wasn't created!")
return render(request, self.template_name, {'post':post, 'comments':comments, 'form':form})
def detail(request, order_id):
success, code, msg = test_connection()
if not success:
messages.error(
request,
"Unable to connect (HTTP {code}) to API at <code>{url}</code>{msg}"
.format(
url=settings.CARDSHOP_API_URL,
code=code,
msg=" -- " + msg if msg else "",
),
)
return redirect("admin")
retrieved, order = get_order(order_id)
context = {"orderdata": OrderData(order)}
if success:
messages.set_level(request, messages.DEBUG)
messages.debug(
request,
"Connected to Scheduler API at <code>{url}</code>".format(
url=settings.CARDSHOP_API_URL),
)
return render(request, "all_orders-detail.html", context)
def dashboard(request):
success, code, msg = test_connection()
if not success:
messages.error(
request,
_("Unable to connect (HTTP %(code)s) to API at <code>%(url)s</code>%(msg)s")
% {
"url": settings.CARDSHOP_API_URL,
"code": code,
"msg": " -- " + msg if msg else "",
},
)
return redirect("admin")
context = {
"channels": as_items_or_none(*get_channels_list()) or None,
"warehouses": as_items_or_none(*get_warehouses_list()) or None,
"users": as_items_or_none(*get_users_list()) or None,
"workers": as_items_or_none(*get_workers_list()) or None,
"images": as_items_or_none(*get_autoimages_list()) or None,
"api_url": settings.CARDSHOP_API_URL_EXTERNAL,
}
forms_map = {
"channel_form": ChannelForm,
"user_form": UserForm,
"warehouse_form": WarehouseForm,
"image_form": ImageForm,
}
for key, value in forms_map.items():
context[key] = value(prefix=key, client=request.user.profile)
if request.method == "POST" and request.POST.get("form") in forms_map.keys():
# which form is being saved?
form_key = request.POST.get("form")
context[form_key] = forms_map.get(form_key)(
request.POST, prefix=form_key, client=request.user.profile
)
if context[form_key].is_valid():
try:
res = context[form_key].save()
except Exception as exp:
logger.error(exp)
messages.error(request, _("Error while saving… %(err)s") % {"err": exp})
else:
messages.success(request, context[form_key].success_message(res))
return redirect("scheduler")
if success:
messages.set_level(request, messages.DEBUG)
messages.debug(
request,
_("Connected to Scheduler API at <code>%(url)s</code>")
% {"url": settings.CARDSHOP_API_URL},
)
return render(request, "scheduler.html", context)
def get_filters(self, request, filter_language=True):
"""
Construct queryset filter kwargs, to limit the queryset for the current user
"""
filters = {"entry__sites__id__exact": settings.SITE_ID}
if filter_language:
# Filter by language
preferences = get_preferences()
language_filter = preferences["language_filter"]
if DEBUG_LANG_FILTER:
messages.debug(request, "language filter: %s" % language_filter)
if language_filter == BlogPrefForm.CURRENT_LANGUAGE:
# Display only blog entries in current language (select on the page)
filters["language"] = request.PYLUCID.current_language
elif language_filter == BlogPrefForm.PREFERED_LANGUAGES:
# Filter by client prefered languages (set in browser and send by HTTP_ACCEPT_LANGUAGE header)
filters["language__in"] = request.PYLUCID.languages
if not request.user.has_perm("blog.change_blogentry") or not request.user.has_perm("blog.change_blogentrycontent"):
filters["entry__is_public"] = True
filters["is_public"] = True
if DEBUG_LANG_FILTER:
messages.debug(request, "queryset filter: %s" % repr(filters))
return filters
def _update08plugins(request, language):
site = Site.objects.get_current()
title = "Update PyLucid v0.8 plugin data"
out = SimpleStringIO()
method_kwargs = {
"out": out,
"language": language,
}
filename = settings.PYLUCID.UPDATE08_PLUGIN_FILENAME
view_name = settings.PYLUCID.UPDATE08_PLUGIN_VIEWNAME
for plugin_name, plugin_instance in PYLUCID_PLUGINS.iteritems():
try:
plugin_instance.call_plugin_view(request, filename, view_name,
method_kwargs)
except Exception, err:
if str(err).endswith("No module named %s" % filename):
# Plugin has no update API
continue
if settings.DEBUG:
raise
messages.error(request, "failed updating %s." % plugin_name)
messages.debug(request,
mark_safe("<pre>%s</pre>" % traceback.format_exc()))
else:
out.write(" --- %s END ---" % plugin_name)
def messages_test(request):
messages.debug(request, "This is a debug message.")
messages.info(request, "This is an info message.")
messages.success(request, "This is a success message.")
messages.warning(request, "This is a warning message.")
messages.error(request, "This is an error message.")
return direct_to_template(request, "base.html", {})
def list(request):
success, code, msg = test_connection()
if not success:
messages.error(
request,
"Unable to connect (HTTP {code}) to API at <code>{url}</code>{msg}"
.format(
url=settings.CARDSHOP_API_URL,
code=code,
msg=" -- " + msg if msg else "",
),
)
return redirect("admin")
orders = sorted(
[OrderData(order) for order in as_items_or_none(*get_orders_list())],
key=lambda item: item["statuses"][0]["on"],
reverse=True,
)
context = {"orders": orders or None}
if success:
messages.set_level(request, messages.DEBUG)
messages.debug(
request,
"Connected to Scheduler API at <code>{url}</code>".format(
url=settings.CARDSHOP_API_URL),
)
return render(request, "all_orders.html", context)
def plugin_permalink(request, absolute_url):
"""
Append a additional url part to the normal page permalink.
e.g.: Deeplink to a blog entry detail view
"""
current_url = request.PYLUCID.pagemeta.get_absolute_url()
pagemeta = request.PYLUCID.pagemeta
page_permalink = pagemeta.get_permalink()
if not absolute_url.startswith(current_url):
# Should normally never happen...
if DEBUG or settings.DEBUG or request.user.is_staff:
messages.error(request,
"entry url %r doesn't start with current url %r!" % (absolute_url, current_url)
)
return absolute_url # fallback
additional_url = absolute_url[len(current_url):]
permalink = posixpath.join(page_permalink, additional_url)
if DEBUG:
messages.debug(request, "absolute_url: %r" % absolute_url)
messages.debug(request, "current_url: %r" % current_url)
messages.debug(request, "page_permalink: %r" % page_permalink)
messages.debug(request, "additional_url: %r" % additional_url)
messages.debug(request, "new permalink: %r" % permalink)
return permalink
def _ip_limit_reached(request, poll):
"""
Return True if IP limit reached for this poll.
"""
if poll.limit_ip == 0:
# No limit set
return False
# Check if IP Address has too many votes
ip = request.META['REMOTE_ADDR']
try:
queryset = IPVotes.objects.only("count").get(poll=poll, ip=ip)
except IPVotes.DoesNotExist:
return False
else:
count = queryset.count
if count >= poll.limit_ip:
if settings.DEBUG:
messages.debug(
request, "We get %i votes from %s and only %i are allowed" %
(count, ip, poll.limit_ip))
return True
else:
return False
def flash_message(param_request,param_message,param_message_type="INFO"):
if param_message_type==MESSAGE_TYPE_INFO:
messages.info(
param_request,
param_message
)
elif param_message_type==MESSAGE_TYPE_WARNING:
messages.warning(
param_request,
param_message
)
elif param_message_type==MESSAGE_TYPE_ERROR:
messages.error(
param_request,
param_message
)
elif param_message_type==MESSAGE_TYPE_SUCCESS:
messages.success(
param_request,
param_message
)
elif param_message_type==MESSAGE_TYPE_DEBUG:
messages.debug(
param_request,
param_message
)
else:
messages.info(
param_request,
param_message
)
def export_movimientos_pdf(request):
template = loader.get_template('movimientos.html')
#template = Template("My name is {{ my_name }}.")
movimientos = IngresoEgreso.objects.all().order_by('-fecha').values_list('num_documento','rut_asociado', 'item', 'subitem', 'tipo_mov', 'monto', 'rut_aprob_id', 'est_aprob')
#print(saldos)
context = {
'movimientos':movimientos,
}
html = template.render(context)
for mov in movimientos:
messages.debug(request,mov)
# messages.debug(request,mov.num_documento)
# if mov.est_aprob is None:
# mov.est_aprob = False
for mov in movimientos:
html2 = "<tr><td align='center'>"+ str(mov[0])+" </td><td align='center'>"+mov[1]+"</td><td align='center'>"+mov[2]+"</td><td align='center'>"+mov[3]+"</td><td align='center'>"+str(mov[4])+"</td><td align='center'>"+str(mov[5])+"</td><td align='center'>"+str(mov[6])+"</td><td align='center'>"+str(mov[7])+"</td></tr>"
html2 = html2+"</tbody></table>"
html = html + html2
file = open('movimientos.pdf', "w+b")
pisaStatus = pisa.CreatePDF(html.encode('utf-8'), dest=file,
encoding='utf-8')
file.seek(0)
pdf = file.read()
file.close()
return HttpResponse(pdf, 'application/pdf')
def test_debug(self):
messages.debug(self.user, "Hello")
# 0 messages because by default django.contrib.messages ignore DEBUG
# messages (this can be changed using set_level)
response = self.client.get('/')
msgs = list(response.context['messages'])
self.assertEqual(0, len((msgs)))
def dashboard(request):
if not request.user.is_authenticated:
messages.error(request, 'Login required')
messages.debug(request, "You can't use dashboard if not logged in!")
return redirect('login')
else:
# The signal that alerts on social user creation by allauth module doesn't work, so -->
# -- > this condiftion checks if user is new or 10 secs have passed since he used the social register
if SocialAccount.objects.filter(
user=request.user,
date_joined__gte=datetime.datetime.now() -
datetime.timedelta(seconds=5 * 2)).exists():
request.session['new_socialuser'] = True
return redirect('profile/username/' + str(request.user.id))
user_liked_programs = Program_User.objects.order_by(
'-program__list_date').filter(user=request.user.id,
is_liked=True,
program__is_published=True)
paginator = Paginator(user_liked_programs, 6)
page = request.GET.get('page')
user_liked_programs_paginated = paginator.get_page(page)
context = {'programs': user_liked_programs_paginated}
return render(request, 'accounts/dashboard.html', context)
def new_question(request, quiz_id):
if not request.method == "POST":
messages.debug(request, "Question creation is only allowed via POST.")
return reload(request)
form = NewQuestionForm(request.POST, request.FILES)
if not form.is_valid():
messages.error(
request, "The submitted form is incorrect: {}".format(form.errors))
return reload(request)
associated_quiz = Quiz.objects.get(id=quiz_id)
if request.user != associated_quiz.created_by:
messages.error(request, "You can only edit your own quizzes!")
return reload(request)
if not associated_quiz:
messages.error(request, "No associated quiz found.")
return reload(request)
TextualQuestion.objects.create(
description=form.cleaned_data["description"],
solution=form.cleaned_data["solution"],
quiz=associated_quiz,
description_image=form.cleaned_data["description_image"],
solution_image=form.cleaned_data["solution_image"])
messages.success(request, "A new textual question was added!")
Interaction.objects.create(interaction_type="New question added")
return edit_quiz(request, quiz_id)
def set_msg(request, name, msg, audit=False):
"""
Método interno, que asigna el mensaje en la variable messages de django
y, deacuerdo al tipo de mensaje recibido en name, guarda en
logger.info() #por ejemplo.
Level Constant Value
DEBUG 10
INFO 20
SUCCESS 25
WARNING 30
ERROR 40
messages.debug(request, '%s SQL statements were executed.' % count) # no imprime
messages.info(request, 'Three credits remain in your account.')
messages.success(request, 'Profile details updated.')
messages.warning(request, 'Your account expires in three days.')
messages.error(request, 'Document deleted.')
"""
messagesToCall = getattr(messages, "info")
messagesToCall(request, (u''
u'<div class="alert alert-block alert-%s"><button type="button" class="close" data-dismiss="alert">×</button>%s</div>'
u'' % (name, force_text(msg)))
)
# m = __import__ ('logger')
if audit:
methodToCall = getattr(logger, name) # logger.debug donde name=debug p.e.
methodToCall(("[%s][%s][%s] %s ") % (request.get_full_path(), request.user, request.META['REMOTE_ADDR'], removetags(msg, 'b'))) # logger.debug(msg) #(str(u'%s'%msg)).encode('utf-8')
def search(request):
if not request.method == "POST":
messages.debug(request, "Search is only allowed via POST.")
return reload(request)
form = SearchForm(request.POST)
if not form.is_valid():
return reload(request)
query = form.cleaned_data["search"]
if not query:
return index(request)
title_quizzes = Quiz.objects.filter(title__icontains=query)
description_quizzes = Quiz.objects.filter(description__icontains=query)
quizzes = set((title_quizzes | description_quizzes).distinct())
hashtags = HashTag.objects.filter(title__icontains=query)
for hashtag in hashtags:
quizzes.update(hashtag.quiz_set)
title_compilations = Compilation.objects.filter(title__icontains=query)
description_compilations = Compilation.objects.filter(
description__icontains=query)
compilations = set(title_compilations | description_compilations)
Interaction.objects.create(interaction_type="Questionnaire searched")
return TemplateResponse(
request, "index.html", {
"quizzes": quizzes,
"compilations": compilations,
"search": form.cleaned_data["search"],
})
def get(self, request, *args, **kwargs):
messages.info(request, 'Welcome to the Legend of..')
messages.success(request, 'AWESOME')
messages.debug(request, 'debugging')
messages.warning(request, 'Take care..')
messages.error(request, 'This will change your life!')
return super(TestView, self).get(request, *args, **kwargs)
def process(request, methods=['POST']):
context = {}
try:
request.session['counter'] += 1
except Exception as e:
request.session['counter'] = 1
try:
yourName = request.POST['yourName']
dojoLocation = request.POST['dojoLocation']
favLanguage = request.POST['favLanguage']
comment = request.POST['comment']
except Exception as e:
messages.append("Exception thrown:", str(e))
return redirect('/')
if len(yourName) == 0:
messages.debug(request, 'Your Name can not be blank.')
if len(dojoLocation) == 0:
messages.debug(request, 'Dojo Location can not be blank.')
if len(favLanguage) == 0:
messages.debug(request, 'Fav Language can not be blank.')
if len(comment) == 0:
messages.debug(request, 'Comment can not be blank.')
if len(comment) > 640:
messages.debug(request,
'Comment can not be more thanb 640 characters.')
request.session['yourName'] = yourName
request.session['dojoLocation'] = dojoLocation
request.session['favLanguage'] = favLanguage
request.session['comment'] = comment
return redirect('/results')
def index(request):
count = request.session.get("index_page_count", 0) + 1
request.session["index_page_count"] = count
post_list = Post.objects.all()
# post_list = Post.timeline(request.user)
# messages.error(request, '기본으로 뜹니다요.')
messages.debug(request, "debug도 뜹니다요.")
lorempixel_categories = (
"abstract",
"animals",
"business",
"cats",
"city",
"food",
"night",
"life",
"fashion",
"people",
"nature",
"sports",
"technics",
"transport",
)
return render(
request,
"blog/index.html",
{"count": count, "post_list": post_list, "lorempixel_categories": lorempixel_categories},
)
def getCompanyDetail(company_id):
detail = {}
try:
cursor = connection.cursor()
cursor.execute("SELECT * FROM Company WHERE company_id = '{}';".format(company_id))
data = cursor.fetchone()
cursor.close()
except Exception as e:
data = []
print e
messages.debug(request,"Error in database fetch" + str(e))
messages.error(request,"An error occured please try later")
print data
if data:
detail['company_id'] = data[0]
detail['company_name'] = data[1]
detail['email'] = data[2]
detail['ppt_date'] = data[3]
detail['interview_date'] = data[5]
detail['package_take_home'] = data[6]
detail['package_ctc'] = data[7]
detail['jd'] = data[8]
return detail
def plugin_permalink(request, absolute_url):
"""
Append a additional url part to the normal page permalink.
e.g.: Deeplink to a blog entry detail view
"""
current_url = request.PYLUCID.pagemeta.get_absolute_url()
pagemeta = request.PYLUCID.pagemeta
page_permalink = pagemeta.get_permalink()
if not absolute_url.startswith(current_url):
# Should normally never happen...
if DEBUG or settings.DEBUG or request.user.is_staff:
messages.error(
request, "entry url %r doesn't start with current url %r!" %
(absolute_url, current_url))
return absolute_url # fallback
additional_url = absolute_url[len(current_url):]
permalink = posixpath.join(page_permalink, additional_url)
if DEBUG:
messages.debug(request, "absolute_url: %r" % absolute_url)
messages.debug(request, "current_url: %r" % current_url)
messages.debug(request, "page_permalink: %r" % page_permalink)
messages.debug(request, "additional_url: %r" % additional_url)
messages.debug(request, "new permalink: %r" % permalink)
return permalink
def _update08plugins(request, language):
site = Site.objects.get_current()
title = "Update PyLucid v0.8 plugin data"
out = SimpleStringIO()
method_kwargs = {
"out": out,
"language": language,
}
filename = settings.PYLUCID.UPDATE08_PLUGIN_FILENAME
view_name = settings.PYLUCID.UPDATE08_PLUGIN_VIEWNAME
for plugin_name, plugin_instance in PYLUCID_PLUGINS.iteritems():
try:
plugin_instance.call_plugin_view(request, filename, view_name,
method_kwargs)
except Exception, err:
if str(err).endswith("No module named %s" % filename):
# Plugin has no update API
continue
if settings.DEBUG:
raise
messages.error(request, "failed updating %s." % plugin_name)
messages.debug(request,
mark_safe("<pre>%s</pre>" % traceback.format_exc()))
else:
out.write(" --- %s END ---" % plugin_name)
def new_account(request):
hostlist = set()
for account in MysqlAccounts.objects.all():
hostlist.add(account.host)
if request.method == 'POST':
if not request.form['name'] or not request.form['password'] or not request.form['host'] or not request.form[ 'priv'] \
or not request.form['remoteHost'] or not request.form['database'] or not request.form['tableName']:
messages.error(request, 'Please enter all the fields')
else:
dec_passwd = MyCrypto(key).encrypt(request.form['password'])
messages.debug(request, "encrypt passwd was %s" % dec_passwd)
account = MysqlAccounts(name=request.form['name'], password=dec_passwd,
host=request.form['host'], priv=request.form['priv'],
remoteHost=request.form['remoteHost'],
database=request.form['database'], tableName=request.form['tableName'])
if add_account(account):
account.save()
messages.success(request, 'Record was successfully added')
return redirect('http://bigdata-app.whaley.cn/show_all')
# return redirect(url_for('show_all'))
else:
messages.error(request, 'cmd run Faild.PLS check it')
# return render(request, 'my_account/new_account.html', context={'Hostlist': hostlist})
return render_to_response('my_account/new_account.html', {'Hostlist': hostlist}, context_instance=RequestContext(request))
def flash_alert(request, type, text):
'''
(obj,str,str)->void
Creates a bootstrap flash message alert for parameters
'''
if (type == "debug"):
messages.debug(request, text, extra_tags='alert alert-primary')
elif (type == "info"):
messages.info(request, text, extra_tags='alert alert-info')
elif (type == "success"):
messages.success(request, text, extra_tags='alert alert-success')
elif (type == "warning"):
messages.warning(request, text, extra_tags='alert alert-warning')
elif (type == "error"):
messages.error(request, text, extra_tags='alert alert-danger')
return
else:
return
################################################################################
################################################################################
# Hidden
################################################################################
def all_events(request):
EventsFormSet = modelformset_factory(Event,
fields=('name', 'event_date'),
extra=0)
qry = Event.events.all().order_by('event_date')
pg = Paginator(qry, 4)
page = request.GET.get('page')
try:
event_records = pg.page(page)
except PageNotAnInteger:
event_records = pg.page(1)
except EmptyPage:
event_records = pg.page(pg.num_pages)
if request.method == 'POST':
formset = EventsFormSet(request.POST)
if formset.is_valid():
formset.save()
return_url = '/allevents/'
if 'page' in request.GET:
return_url += '?page=' + request.GET['page']
return HttpResponseRedirect(return_url)
else:
page_qry = qry.filter(id__in=[event.id for event in event_records])
formset = EventsFormSet(queryset=page_qry)
context = {'event_records': event_records, 'formset': formset}
messages.debug(request, qry)
return render(request, 'events/all_events.html', context)
def get(self, request, *args, **kwargs):
messages.debug(request, 'Debug message.')
messages.info(request, 'Info message.')
messages.success(request, 'Success message.')
messages.warning(request, 'Warning message.')
messages.error(request, 'Error message.')
return super().get(request, *args, **kwargs)
def send_messages(request):
messages.debug(request, 'debug:hello world!')
messages.info(request, 'info:hello world!')
messages.success(request, 'success:hello world!')
messages.warning(request, 'warning:hello world!')
messages.error(request, 'error:hello world!')
return render(request, 'polls/show_messages.html')
pass
def get_queryset(self):
place = get_object_or_404(Space, url=self.kwargs['space_name'])
if settings.DEBUG:
messages.set_level(self.request, messages.DEBUG)
messages.debug(self.request, "Succesful query.")
return Post.objects.all().filter(space=place).order_by('-pub_date')
def index(request):
form = ContactForm
# reqs = Req.objects.filter(active=True).order_by('-pub_date')[:15]
# platforms = Platform.objects.all()
messages.debug(request, 'Test')
return render(request, 'cts_app/index.html',
{''' 'platforms': platforms, 'reqs': reqs,''' 'nbar': 'home'})
def __call__(self, request):
messages.debug(request, 'A debug message.')
messages.info(request, 'An info message.')
messages.success(request, 'A success message.')
messages.warning(request, 'A warning message.')
messages.error(request, 'An error message.')
return self.get_response(request)
def _send_verify_email(request, preferences, db_entry, rnd_hash, new_entry):
""" Send a verify email """
location = reverse("KursAnmeldung-verify_email", kwargs={"hash": rnd_hash})
verify_link = request.build_absolute_uri(location)
# FIXME: convert to users local time.
now = datetime.datetime.utcnow()
email_context = {"verify_link": verify_link, "db_entry": db_entry, "now": now}
# Render the internal page
emailtext = render_to_string("kurs_anmeldung/verify_mailtext.txt", email_context)
# Get the preferences from the database:
raw_notify_list = preferences["notify"]
notify_list = raw_notify_list.splitlines()
notify_list = [i.strip() for i in notify_list if i]
email_kwargs = {
"from_email": preferences["from_email"],
"subject": preferences["email_subject"],
"body": emailtext,
"to": [db_entry.email],
"bcc": notify_list,
}
if settings.KURS_ANMELDUNG.MAIL_DEBUG == True or settings.RUN_WITH_DEV_SERVER:
msg = u"MAIL_DEBUG is on: No Email was sended!"
messages.debug(request, msg)
db_entry.log(request, msg)
db_entry.mail_sended = False
messages.debug(request, "django.core.mail.EmailMessage kwargs:")
messages.debug(request, repr(email_kwargs))
messages.debug(request, "debug mail text:")
messages.debug(request, mark_safe("<pre>%s</pre>" % emailtext))
return
# We can't use django.core.mail.send_mail, because all members
# of the recipient list will see the others in the 'To' field.
# But we would like to notify the admins via 'Bcc' field.
# connection = SMTPConnection(fail_silently=False)
email = EmailMessage(**email_kwargs)
try:
sended = email.send(fail_silently=False)
except Exception, err:
msg = "Error sending mail: %s" % err
LogEntry.objects.log_action(app_label="kurs_anmeldung", action="error", message=msg)
db_entry.log(request, msg)
db_entry.mail_sended = False
if settings.DEBUG or request.user.is_staff:
db_entry.save()
raise
def messages_example(request):
messages.set_level(request, messages.DEBUG)
messages.debug(request, 'This is a debug message')
messages.info(request, 'This is an informational message. It also happens to be a decently long one just to see how everything looks when it has to wrap to multiple lines')
messages.success(request, '<strong>Great success!</strong> Whatever you did seems to have worked out!')
messages.warning(request, 'Better watch out! This is a warning.')
messages.error(request, 'Bad bad bad! Something really awful happened!')
messages.add_message(request, 8000, 'Custom message level')
pass
def content_ratings_edit(request, addon_id, addon):
if settings.DEBUG:
messages.debug(request, "DEBUG mode on; you may use IARC id 0 with any code")
initial = {}
data = request.POST if request.method == "POST" else None
if waffle.switch_is_active("iarc-upgrade-v2"):
form_class = IARCV2ExistingCertificateForm
else:
try:
app_info = addon.iarc_info
initial["submission_id"] = app_info.submission_id
initial["security_code"] = app_info.security_code
except IARCInfo.DoesNotExist:
pass
form_class = IARCGetAppInfoForm
form = form_class(data=data, initial=initial, app=addon)
if request.method == "POST" and form.is_valid():
try:
form.save()
return redirect(addon.get_dev_url("ratings"))
except django_forms.ValidationError:
pass # Fall through to show the form error.
# Save some information for _ratings_success_msg.
if "ratings_edit" not in request.session:
request.session["ratings_edit"] = {}
last_rated = addon.last_rated_time()
request.session["ratings_edit"][str(addon.id)] = {
"app_status": addon.status,
"rating_modified": last_rated.isoformat() if last_rated else None,
}
request.session.modified = True
ctx = {
"addon": addon,
"app_name": get_iarc_app_title(addon),
"form": form,
"company": addon.latest_version.developer_name,
"now": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
}
if waffle.switch_is_active("iarc-upgrade-v2"):
try:
iarc_request = addon.iarc_request
outdated = datetime.now() - iarc_request.created > timedelta(hours=1)
if outdated:
# IARC request outdated. Re-create.
iarc_request.delete()
iarc_request = IARCRequest.objects.create(app=addon, uuid=uuid.uuid4())
except IARCRequest.DoesNotExist:
# No IARC request exists. Create.
iarc_request = IARCRequest.objects.create(app=addon, uuid=uuid.uuid4())
ctx["iarc_request_id"] = unicode(uuid.UUID(iarc_request.uuid))
return render(request, "developers/apps/ratings/ratings_edit.html", ctx)
def test(request):
messages.set_level(request, messages.DEBUG)
messages.debug(request, 'This is a debug alert')
messages.info(request, 'This is an info alert')
messages.success(request, 'This is a success alert')
messages.warning(request, 'This is a warning alert')
messages.error(request, 'This is an error alert')
return render(request, 'alerts/test.html')
def call_searchs(self, search_languages, search_strings, search_results):
""" Call every plugin, witch has the search API. """
filename = settings.PYLUCID.SEARCH_FILENAME
class_name = settings.PYLUCID.SEARCH_CLASSNAME
max_hits = self.preferences["max_hits"]
plugin_count = 0
too_much_hits = 0
use_plugin = 0
for plugin_name, plugin_instance in PYLUCID_PLUGINS.iteritems():
try:
SearchClass = plugin_instance.get_plugin_object(filename, class_name)
# plugin_instance.call_plugin_view(self.request, filename, view_name, method_kwargs)
except plugin_instance.ObjectNotFound:
# Plugin has no search API
continue
except Exception:
if self.request.debug or self.request.user.is_staff:
messages.error(self.request, "Can't collect search results from %s." % plugin_name)
messages.debug(self.request, mark_safe("<pre>%s</pre>" % traceback.format_exc()))
continue
try:
search_instance = SearchClass()
except PluginNotOnSite, err:
# Plugin is not used on this SITE
if self.request.debug or self.request.user.is_staff:
messages.debug(self.request, "Skip %s: %s" % (plugin_name, err))
continue
else:
plugin_count += 1
queryset = search_instance.get_queryset(self.request, search_languages, search_strings)
count = queryset.count()
if self.request.user.is_staff:
messages.info(self.request, "%s hits in %s" % (count, plugin_name))
if count >= max_hits:
too_much_hits += 1
messages.info(self.request, "Skip too many results from %s" % plugin_name)
LogEntry.objects.log_action(
app_label="search", action="too mutch hits",
message="Skip %s hits in %s for %s" % (count, plugin_name, repr(search_strings)),
data={
"search_strings": search_strings,
"hits": count,
}
)
continue
use_plugin += 1
if count > 0:
search_instance.add_search_results(self.request, queryset, search_results)
def content_ratings_edit(request, addon_id, addon):
initial = {}
try:
app_info = addon.iarc_info
initial['submission_id'] = app_info.submission_id
initial['security_code'] = app_info.security_code
except IARCInfo.DoesNotExist:
pass
messages.debug(request,
"DEBUG mode on; you may use IARC id 0 with any code")
form = IARCGetAppInfoForm(data=request.POST or None, initial=initial,
app=addon)
if request.method == 'POST' and form.is_valid():
try:
form.save()
return redirect(addon.get_dev_url('ratings'))
except django_forms.ValidationError:
pass # Fall through to show the form error.
# Save some information for _ratings_success_msg.
if 'ratings_edit' not in request.session:
request.session['ratings_edit'] = {}
last_rated = addon.last_rated_time()
request.session['ratings_edit'][str(addon.id)] = {
'app_status': addon.status,
'rating_modified': last_rated.isoformat() if last_rated else None
}
request.session.modified = True
ctx = {
'addon': addon,
'app_name': get_iarc_app_title(addon),
'form': form,
'company': addon.latest_version.developer_name,
'now': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
}
if waffle.switch_is_active('iarc-upgrade-v2'):
try:
iarc_request = addon.iarc_request
outdated = (datetime.now() - iarc_request.created >
timedelta(hours=1))
if outdated:
# IARC request outdated. Re-create.
iarc_request.delete()
iarc_request = IARCRequest.objects.create(
app=addon, uuid=uuid.uuid4())
except IARCRequest.DoesNotExist:
# No IARC request exists. Create.
iarc_request = IARCRequest.objects.create(
app=addon, uuid=uuid.uuid4())
ctx['iarc_request_id'] = unicode(uuid.UUID(iarc_request.uuid))
return render(request, 'developers/apps/ratings/ratings_edit.html', ctx)
def article_new(request, category_pk):
if request.method == 'POST':
form = ArticleForm(request.POST)
if form.is_valid():
article = form.save(commit=False)
article.category = get_object_or_404(Category, pk=category_pk)
article.save()
messages.debug(request, 'New article posted')
return redirect('magazine.views.article_detail', category_pk, article.pk)
else:
form = ArticleForm()
return render(request, 'magazine/article_form.html', {'form': form, })
def voir_messages(request):
articles = Article.objects.all()
messages.set_level(request, messages.DEBUG) # je suis obligé de le faire sinon je n'ai pas les debug...
messages.add_message(request, messages.INFO, 'Bonjour visiteur !')
messages.debug(request, '%s requêtes SQL ont été exécutées.' % articles)
messages.info(request, 'Rebonjour !')
messages.success(request, 'Votre article a bien été mis à jour.')
messages.warning(request, 'Votre compte expire dans 3 jours.')
messages.error(request, 'Cette image n\'existe plus.')
return render(request, 'blog/messages.html')
def employee_create(request, template_name = 'employee_form.html'):
form = EmployeeForm(request.POST or None)
if form.is_valid():
form.save()
messages.add_message(request,messages.INFO,'employee added successfully')
messages.debug(request,'a debug information')
messages.warning(request,'a note of information')
messages.success(request,'adding successfully')
messages.error(request,'a error message')
return redirect('crud:employee_list')
return render(request,template_name,{'form':form})
def comment_new(request, post_pk):
if request.method == 'POST':
form = CommentForm(request.POST)
if form.is_valid():
comment = form.save(commit=False)
comment.post = get_object_or_404(Post, pk=post_pk)
comment.save()
messages.debug(request, '새로운 댓글 등록 성공')
return redirect('blog.views.postdetail', post_pk)
else:
form = CommentForm()
return render(request, 'blog/commentform.html', {'form':form})
def comment_new(request, post_pk):
if request.method == 'POST':
form = CommentForm(request.POST)
if form.is_valid():
form.save()
messages.debug(request, '새로운 댓글을 등록했습니다.')
return redirect('post_detail', post_pk)
else:
form = CommentForm()
return render(request, 'blog/comment_form.html', {'form':form,
})
def comment_new(request, post_pk):
if request.method == 'POST':
form = CommentForm(request.POST)
if form.is_valid():
comment = form.save(commit=False)
comment.post = Post.objects.get(pk=post_pk)
comment.save()
messages.debug(request, '새로운 댓글을 등록했습니다.') # request를 받으므로 view 내에서만 쓸 수 있음.
return redirect('blog,.post_detail', post_pk)
else:
form = CommentForm()
return render(request, 'blog/comment_form.html', {'form': form,
})
def comment_edit(request, category_pk, article_pk, pk):
comment = get_object_or_404(Comment, pk=pk)
if request.method == 'POST':
form = CommentForm(request.POST, instance=comment)
if form.is_valid():
comment = form.save(commit=False)
comment.artcle = get_object_or_404(Article, pk=article_pk)
comment.save()
messages.debug(request, 'Comment edited')
return redirect('magazine.views.article_detail', category_pk, article_pk)
else:
form = CommentForm(instance=comment)
return render(request, 'magazine/comment_form.html', {'form': form, })
def _error(request, msg, staff_msg):
etype, value, tb = sys.exc_info()
if tb is not None:
# if settings.DEBUG and settings.RUN_WITH_DEV_SERVER:
# raise
if request.user.is_superuser:
# put the full traceback into page_msg, but only for superusers
messages.debug(request, mark_safe("%s:<pre>%s</pre>" % (escape(staff_msg), escape(traceback.format_exc()))))
return
if request.user.is_staff:
messages.error(request, staff_msg)
return "[%s]" % msg
def _is_active(request, preferences):
"""
return True/False for "courses registration is disabled" response
"""
if not preferences["active"]:
messages.debug(request, "Disabled by DBpreferences.")
return False
active_courses = Kurs.objects.all().filter(active=True).count()
if active_courses == 0:
messages.debug(request, "No active courses found.")
return False
return True
def comments_new(request, post_pk):
if request.method == 'POST':
form = CommentForm(request.POST)
if form.is_valid():
comment = form.save(commit= False)
comment.author = request.user
comment.post = get_object_or_404(Post,pk = post_pk)
comment.save()
## 메세지 쓰는법 알아보기
messages.debug(request, '새로운 댓글을 등록했습니다.')
return redirect(comment.post) ## redirect comment.post
else:
form = CommentForm()
return render(request,'blog/comment_form.html',{'form' : form})
def comment_new(request, category_pk, article_pk):
if request.method == 'POST':
form = CommentForm(request.POST)
if form.is_valid():
comment = form.save(commit=False)
comment.article = get_object_or_404(Article, pk=article_pk)
# comment.article.category.pk = category_pk
comment.save()
messages.debug(request, 'New Comment posted')
form.save()
return redirect('magazine.views.article_detail', category_pk, article_pk)
else:
form = CommentForm()
return render(request, 'magazine/comment_form.html', {'form': form, })
def test_view_css(request):
'''
.. py:function:: test_view_css(request)
Returns a test page with a demonstration of corecap styling for various
bootstrap constructs, including django messages.
'''
messages.debug(request, 'This is a debug message.')
messages.info(request, 'This is an info message.')
messages.success(request, 'This is a success message.')
messages.warning(request, 'This is a warning message.')
messages.error(request, 'This is an error message.')
return render(request, 'corecap/test.html')
