def log_exceptions_to_messages(request, backend, err):
"""Log exception messages to messages app if it's installed."""
print err
if 'django.contrib.messages' in setting('INSTALLED_APPS'):
from django.contrib.messages.api import error
name = backend.AUTH_BACKEND.name
error(request, unicode(err), extra_tags='social-auth %s' % name)
def wrapper(request, backend, *args, **kwargs):
if redirect_name:
redirect = reverse(redirect_name, args=(backend,))
else:
redirect = request.path
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError("Incorrect authentication " + "service")
try:
return func(request, backend, *args, **kwargs)
except Exception, e: # some error ocurred
backend_name = backend.AUTH_BACKEND.name
logger.error(unicode(e), exc_info=True, extra=dict(request=request))
# Why!?
msg = str(e)
if "django.contrib.messages" in settings.INSTALLED_APPS:
from django.contrib.messages.api import error
error(request, msg, extra_tags=backend_name)
else:
logger.warn("Messages framework not in place, some " + "errors have not been shown to the user.")
return HttpResponseRedirect(BACKEND_ERROR_REDIRECT)
def wrapper(request, backend, *args, **kwargs):
if redirect_name:
redirect = reverse(redirect_name, args=(backend, ))
else:
redirect = request.path
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError('Incorrect authentication ' + \
'service')
try:
return func(request, backend, *args, **kwargs)
except Exception, e: # some error ocurred
backend_name = backend.AUTH_BACKEND.name
logger.error(unicode(e),
exc_info=True,
extra=dict(request=request))
if 'django.contrib.messages' in settings.INSTALLED_APPS:
from django.contrib.messages.api import error
error(request, unicode(e), extra_tags=backend_name)
else:
logger.warn('Messages framework not in place, some ' +
'errors have not been shown to the user.')
return HttpResponseRedirect(BACKEND_ERROR_REDIRECT)
def get(self, request, *args, **kwargs):
filename = self.kwargs.get("filename")
parser = ParserDHCPDLease("/tmp/", filename)
leases = parser.parse()
if len(leases) == 0:
api.error(request, _(u"Erro ao carregar o arquivo %s" % (filename)))
return shortcuts.redirect(urlresolvers.reverse("webradius:mac_list"))
try:
out_file_name = "/tmp/out_leases"
out_file = open(out_file_name, "w")
except:
api.error(request, _(u"Erro ao abrir o arquivo %s" % (out_file_name)))
return shortcuts.redirect(urlresolvers.reverse("webradius:mac_list"))
try:
self.__migrate_leases(request, out_file, parser, leases)
finally:
out_file.close()
# Da um redirect para o mac_list, vai mostrar as mensagens de erro lá usando a api de mensagens do django
return shortcuts.redirect(urlresolvers.reverse("webradius:mac_list"))
def wrapper(request, backend, *args, **kwargs):
if redirect_name:
redirect = reverse(redirect_name, args=(backend,))
else:
redirect = request.path
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError('Incorrect authentication ' + \
'service')
try:
return func(request, backend, *args, **kwargs)
except Exception, e: # some error ocurred
if setting('DEBUG'):
raise
backend_name = backend.AUTH_BACKEND.name
log('error', unicode(e), exc_info=True,
extra=dict(request=request))
if 'django.contrib.messages' in setting('INSTALLED_APPS'):
from django.contrib.messages.api import error
error(request, unicode(e), extra_tags=backend_name)
else:
log('warn', 'Messages framework not in place, some '+
'errors have not been shown to the user.')
url = setting('SOCIAL_AUTH_BACKEND_ERROR_URL', LOGIN_ERROR_URL)
return HttpResponseRedirect(url)
def wrapper(request, backend, *args, **kwargs):
if redirect_name:
redirect = reverse(redirect_name, args=(backend,))
else:
redirect = request.path
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError('Incorrect authentication ' + \
'service')
try:
return func(request, backend, *args, **kwargs)
except Exception, e: # some error ocurred
backend_name = backend.AUTH_BACKEND.name
msg = str(e)
if 'django.contrib.messages' in settings.INSTALLED_APPS:
from django.contrib.messages.api import error
error(request, msg, extra_tags=backend_name)
else:
if ERROR_KEY: # store error in session
request.session[ERROR_KEY] = msg
if NAME_KEY: # store the backend name for convenience
request.session[NAME_KEY] = backend_name
return HttpResponseRedirect(BACKEND_ERROR_REDIRECT)
def wrapper(request, backend, *args, **kwargs):
if redirect_name:
redirect = reverse(redirect_name, args=(backend,))
else:
redirect = request.path
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError(
"Incorrect authentication " + "service or service API settings not available!"
)
try:
return func(request, backend, *args, **kwargs)
except Exception, e: # some error ocurred
if RAISE_EXCEPTIONS:
raise
backend_name = backend.AUTH_BACKEND.name
log("error", unicode(e), exc_info=True, extra=dict(request=request))
if "django.contrib.messages" in setting("INSTALLED_APPS"):
from django.contrib.messages.api import error
error(request, unicode(e), extra_tags=backend_name)
else:
log("warn", "Messages framework not in place, some " + "errors have not been shown to the user.")
url = backend_setting(backend, "SOCIAL_AUTH_BACKEND_ERROR_URL", LOGIN_ERROR_URL)
return HttpResponseRedirect(url)
def log_errors_and_redirect(self, error_s):
""" Pass errors via django message queue
Args:
error_s: (list) Error list (every object in list is a distinct row)
Returns:
HttpRequestRedirect to the same page
"""
for err in error_s:
error(self.request, err)
return redirect(self.request.META['HTTP_REFERER'])
def get(self, request, *args, **kwargs):
try:
out_file_name = "/tmp/out_leases"
out_file = open(out_file_name, "w")
except:
api.error(request, _(u"Erro ao abrir o arquivo %s" % (out_file_name)))
return shortcuts.redirect(urlresolvers.reverse("webradius:mac_list"))
try:
self.__generate_leases_file(request, out_file)
finally:
out_file.close()
return shortcuts.redirect(urlresolvers.reverse("webradius:mac_list"))
def get(self, request, *args, **kwargs):
filename = self.kwargs.get("filename")
parser = ParserPools("/tmp/", filename)
pools = parser.parse()
if len(pools) == 0:
api.error(request, _(u"Erro ao carregar o arquivo %s" % (filename)))
return shortcuts.redirect(urlresolvers.reverse("webradius:pool_list"))
for pool in pools:
result = models.Poolinfo.objects.filter(pool_name=pool.name)
if len(result) >= 1:
api.error(request, _(u"Um pool com o mesmo nome já está cadastrado: %s" % (pool.name)))
return shortcuts.redirect(urlresolvers.reverse("webradius:pool_list"))
new_pool = Poolinfo()
new_pool.pool_name = pool.name
new_pool.description = pool.desc
new_pool.mask = pool.mask
new_pool.router_address = pool.router
new_pool.domain_name = pool.domain
new_pool.rev_domain_name = pool.rev_domain
new_pool.dns_server = pool.dns
new_pool.dns_server2 = pool.dns2
new_pool.ntp_server = pool.ntp
new_pool.root_path = pool.root_path
new_pool.boot_filename = pool.filename
new_pool.next_server = pool.next_server
new_pool.init_address = pool.start
new_pool.end_address = pool.end
new_pool.netbios_name_server = pool.wins
new_pool.netbios_name_server2 = pool.wins2
new_pool.netbios_node_type = pool.node_type
new_pool.lease_time = 60 * 60 * 24 * 3
result, name = new_pool.validate()
if not result:
api.error(request, _(u"Erro ao validar pool: %s" % (name)))
return shortcuts.redirect(urlresolvers.reverse("webradius:pool_list"))
result, name, pool_collide = new_pool.is_range_avaiable()
if not result:
api.error(
request,
_(u"Erro ao validar pool, IP já usado em outro Pool: %s - %s" % (name, pool_collide.pool_name)),
)
return shortcuts.redirect(urlresolvers.reverse("webradius:pool_list"))
new_pool.save()
api.success(request, _(u"Sucesso ao importar POOLs"))
# Da um redirect para o mac_list, vai mostrar as mensagens de erro lá usando a api de mensagens do django
return shortcuts.redirect(urlresolvers.reverse("webradius:pool_list"))
def get(self, request, *args, **kwargs):
submission = get_object_or_404(Submission, pk=self.kwargs['pk'])
if not submission.contest.is_printing_available or \
submission.author != self.request.user:
error(request, _("Printing not available."))
else:
print_request = PrintRequest(
source=submission.source,
language=submission.language,
contest=submission.contest,
author=submission.author,
problem=submission.problem)
print_request.save()
success(request, _("Print request added to print queue."))
return redirect('submission', int(self.kwargs['pk']))
def get(self, request, *args, **kwargs):
pool = shortcuts.get_object_or_404(self.model, pk=self.kwargs.get('pk'))
if pool.pool_name.startswith(models.Poolinfo.get_static_prefix()):
return shortcuts.redirect(urlresolvers.reverse('handler403'))
if pool.count_machines_on_pool() >= 1:
api.error(self.request, _(u"O Pool %s não pode ser deletado pois ele contem máquinas associadas" % pool.pool_name))
return shortcuts.redirect(urlresolvers.reverse('webradius:pool_detail', args=(pool.id,)))
name = pool.pool_name
pool.delete()
api.success(self.request, _(u"Pool '%s' removido com sucesso" % name))
models.Log(user=self.request.user, msg=_(u"Pool '%s' removido" % pool.pool_name)).save()
return shortcuts.redirect(urlresolvers.reverse('webradius:pool_list'))
def process_exception(self, request, exception):
self.backend = self.get_backend(request, exception)
if self.raise_exception(request, exception):
return
if isinstance(exception, SocialAuthBaseException):
backend_name = get_backend_name(self.backend)
message = self.get_message(request, exception)
url = self.get_redirect_uri(request, exception)
tags = ['social-auth']
if backend_name:
tags.append(backend_name)
try:
error(request, message, extra_tags=' '.join(tags))
except MessageFailure: # messages app is not installed
url += ('?' in url and '&' or '?') + 'message=' + message
if backend_name:
url += '&backend=' + backend_name
return redirect(url)
def process_exception(self, request, exception):
self.backend = self.get_backend(request, exception)
if self.raise_exception(request, exception):
return
if isinstance(exception, SocialAuthBaseException):
backend_name = get_backend_name(self.backend)
message = self.get_message(request, exception)
url = self.get_redirect_uri(request, exception)
tags = ['social-auth']
if backend_name:
tags.append(backend_name)
try:
error(request, message, extra_tags=' '.join(tags))
except MessageFailure: # messages app is not installed
url += ('?' in url and '&' or '?') + 'message=' + message
if backend_name:
url += '&backend=' + backend_name
return redirect(url)
def get(self, request, *args, **kwargs):
filename = self.kwargs.get("filename")
parser = ParserStaticOverlappedIps("/tmp/", filename)
static_macs = parser.parse()
if len(static_macs) == 0:
api.error(request, _(u"Erro ao carregar o arquivo %s" % (filename)))
return shortcuts.redirect(urlresolvers.reverse("webradius:mac_list"))
for smac in static_macs:
result = models.Macinfo.objects.filter(mac=smac.mac)
if len(result) >= 1:
api.error(request, _(u"O seguinte MAC já está cadastrado: %s" % (smac.mac)))
return shortcuts.redirect(urlresolvers.reverse("webradius:mac_list"))
machine = models.Macinfo()
# Checa se o Pool associado a máquina existe
try:
machine.pool = models.Poolinfo.objects.get(pool_name=smac.pool_name)
except:
api.error(request, _(u"O Pool associado a máquina não existe: %s -> %s" % (smac.pool_name, smac.mac)))
return shortcuts.redirect(urlresolvers.reverse("webradius:mac_list"))
if not machine.pool.is_in_range(smac.ip):
api.error(request, _(u"O IP não está contido no Pool: %s -> %s" % (smac.ip, smac.pool_name)))
return shortcuts.redirect(urlresolvers.reverse("webradius:mac_list"))
machine.mac = smac.mac
machine.description = smac.name
machine.static = True
machine.static_standalone = False
machine.static_ip = smac.ip
machine.vland_id = 0
if smac.full_access == "true":
machine.full_access = True
else:
machine.full_access = False
machine.reserve_overlapped_static_ip()
machine.save()
api.success(request, _(u"Sucesso ao importar MACs"))
# Da um redirect para o mac_list, vai mostrar as mensagens de erro lá usando a api de mensagens do django
return shortcuts.redirect(urlresolvers.reverse("webradius:mac_list"))
def wrapper(request, backend, *args, **kwargs):
if redirect_name:
redirect = reverse(redirect_name, args=(backend,))
else:
redirect = request.path
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError('Incorrect authentication ' + \
'service')
try:
return func(request, backend, *args, **kwargs)
except Exception, e: # some error ocurred
backend_name = backend.AUTH_BACKEND.name
logger.error(unicode(e), exc_info=True,
extra=dict(request=request))
# Why!?
msg = str(e)
if 'django.contrib.messages' in settings.INSTALLED_APPS:
from django.contrib.messages.api import error
error(request, msg, extra_tags=backend_name)
else:
logger.warn('Messages framework not in place, some '+
'errors have not been shown to the user.')
# What's the use in this, having not both the messages
# framework and decent logging in place?
# Also: do we really want to share all and any errors back
# to the user, in a security-wise sensitive application?
#
# else:
# if ERROR_KEY: # store error in session
# request.session[ERROR_KEY] = msg
# if NAME_KEY: # store the backend name for convenience
# request.session[NAME_KEY] = backend_name
return HttpResponseRedirect(BACKEND_ERROR_REDIRECT)
def gatekeeper_mark_ok(request, issue_id):
"""Set the reviewed revision on a case to latest.
This will tell us the issue has been reviewed.
:param request: HTTP request.
:param: issue_id: `str` id of the `Issue` to approve
"""
try:
try:
issue = models.Issue.objects.get(id=issue_id)
except models.Issue.DoesNotExist:
raise RuntimeError('Issue does not exist!')
case_id = get_case_id(issue)
form = GatekeeperApprove(case_id, request.POST)
if not form.is_valid():
raise RuntimeError(
'You need to pass a target_branch parameter when approving a review. '
'Please do so and try again.')
target_branch = form.cleaned_data['target_branch']
mark_issue_approved(request, issue, case_id, target_branch)
messages_api.success(
request, 'Revision {issue.latest_reviewed_rev} was sucesssfully approved '
'on issue {issue.id} '
'for Fogbugz case <a href="{settings.FOGBUGZ_URL}default.asp?{case_id}" '
'target="_blank">{case_id}</a>, '
'target branch: {target_branch}.'
.format(issue=issue, settings=settings, case_id=case_id, target_branch=target_branch))
except Exception as exc:
messages_api.error(
request,
unicode(exc))
finally:
return HttpResponseRedirect('/{0}/show'.format(issue_id))
def log_exceptions_to_messages(request, backend, err):
"""Log exception messages to messages app if it's installed."""
if 'django.contrib.messages' in setting('INSTALLED_APPS'):
from django.contrib.messages.api import error
name = backend.AUTH_BACKEND.name
error(request, unicode(err), extra_tags='social-auth %s' % name)
def get(self, request, *args, **kwargs):
filename = self.kwargs.get("filename")
parser = ParserStaticIps("/tmp/", filename)
static_macs = parser.parse()
if len(static_macs) == 0:
api.error(request, _(u"Erro ao carregar o arquivo %s" % (filename)))
return shortcuts.redirect(urlresolvers.reverse("webradius:mac_list"))
for smac in static_macs:
result = models.Macinfo.objects.filter(mac=smac.mac)
if len(result) >= 1:
api.error(request, _(u"O seguinte MAC já está cadastrado: %s" % (smac.mac)))
return shortcuts.redirect(urlresolvers.reverse("webradius:mac_list"))
machine = models.Macinfo()
machine.mac = smac.mac
machine.description = smac.name
machine.static = True
machine.static_standalone = True
machine.static_ip = smac.ip
machine.vland_id = 0
if smac.full_access == "true":
machine.full_access = True
else:
machine.full_access = False
pool = models.Poolinfo.create_static_pool(
smac,
smac.ip,
smac.router,
smac.mask,
smac.dns,
smac.domain,
smac.rev_domain,
None,
None,
None,
None,
None,
1,
)
result, name = pool.validate()
if not result:
api.error(request, _(u"Erro ao validar pool para MAC estático: %s" % (name)))
return shortcuts.redirect(urlresolvers.reverse("webradius:mac_list"))
result, name, pool_collide = pool.is_range_avaiable()
if not result:
api.error(
request,
_(u"Erro ao validar pool, IP já usado em outro Pool: %s - %s" % (name, pool_collide.pool_name)),
)
return shortcuts.redirect(urlresolvers.reverse("webradius:mac_list"))
machine.create_static_pool(
smac.router, smac.mask, smac.dns, smac.domain, smac.rev_domain, None, None, None, None, None, 1
)
machine.save()
api.success(request, _(u"Sucesso ao importar MACs"))
# Da um redirect para o mac_list, vai mostrar as mensagens de erro lá usando a api de mensagens do django
return shortcuts.redirect(urlresolvers.reverse("webradius:mac_list"))
def _fn(req):
if not req.user.is_authenticated:
error(req, 'Для доступа к этой странице необходимо авторизоваться')
return redirect('login')
else:
return func(req)
