def post(self, request, *args, **kwargs):
machine = shortcuts.get_object_or_404(self.model, pk=self.kwargs.get('pk'))
force = request.GET.get('force')
form = self.__get_form(machine, request.POST)
if force:
form.force = True
if form.is_valid():
if not form.has_changed():
form.reset_errors()
api.info(request, _(u'Nenhuma alteração efetuada'))
return shortcuts.render(request, self.template_name, {'form': form,
'object': machine})
machine = form.save()
api.success(request, _(u'Máquina alterada com sucesso'))
if form.dynamic_pool_full:
api.warning(request, _(u'O pool associado a máquina tem mais máquinas do que IPs disponíveis.'))
models.Log(user=request.user, msg=_(u"Máquina '%s' alterada" % machine.mac)).save()
return shortcuts.redirect(urlresolvers.reverse('webradius:mac_detail', args=(machine.id,)))
if form.dynamic_ip_in_use:
return shortcuts.render(request, self.template_force_name, {'form': form,
'object': machine})
else:
return shortcuts.render(request, self.template_name, {'form': form,
'object': machine})
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):
machine = shortcuts.get_object_or_404(self.model, pk=self.kwargs.get('pk'))
machine.delete()
api.success(self.request, _(u"Máquina removida com sucesso"))
models.Log(user=self.request.user, msg=_(u"Máquina '%s' removida" % machine.mac)).save()
return shortcuts.redirect(urlresolvers.reverse('webradius:mac_list'))
def get(self, request, *args, **kwargs):
nas = shortcuts.get_object_or_404(self.model, pk=self.kwargs.get('pk'))
name = nas.nasname
nas.delete()
api.success(self.request, _(u"NAS '%s' removido com sucesso" % name))
models.Log(user=self.request.user, msg=_(u"NAS '%s' removido" % name)).save()
return shortcuts.redirect(urlresolvers.reverse('webradius:nas_list'))
def post(self, request, *args, **kwargs):
form = poolinfo.PoolAddForm(request.POST)
if form.is_valid():
pool = form.save()
models.Log(user=request.user, msg=_(u"Pool '%s' cadastrado" % pool.pool_name)).save()
api.success(request, _(u'Pool cadastrado com sucesso'))
return shortcuts.redirect(urlresolvers.reverse('webradius:pool_detail', args=(pool.id,)))
return shortcuts.render(request, self.template_name, {'form': form})
def post(self, request, *args, **kwargs):
form = nas.NASAddForm(request.POST)
if form.is_valid():
if not form._errors:
form.save()
models.Log(user=request.user, msg=_(u"NAS '%s' cadastrado" % form.cleaned_data['nasname'])).save()
api.success(request, _(u'NAS cadastrado com sucesso'))
return shortcuts.redirect(urlresolvers.reverse('webradius:nas_list'))
return shortcuts.render(request, self.template_name, {'form': form})
def create_team(request):
if request.method == 'POST':
form1 = CreateTeamForm(request.POST)
if form1.is_valid():
new_team = form1.save()
messages.success(request, 'The Team was created , Thanks.')
return redirect('home')
else:
form1 = CreateTeamForm()
form1.initial = {'leader': request.user}
return render(request, 'users/user_create_team.html', {'form1': form1})
def delete_many(self, object_list):
qs = self.model._default_manager.filter(pk__in=object_list)
count = qs.count()
for item in qs:
item.delete()
msg = __('%(count)s %(name)s item was deleted.',
'%(count)s %(name)s items were deleted.',
count) % {'count': count,
'name': self.model._meta.verbose_name}
success(self.request, msg)
def form_valid(self, form):
if not self.contest.is_printing_available:
raise PermissionDenied
print_request = PrintRequest(
source=form.cleaned_data['source'],
language=form.cleaned_data['language'],
contest=self.contest,
author=self.request.user)
print_request.save()
success(self.request, _("Print request added to print queue."))
return super(SubmissionPrintCreateView, self).form_valid(form)
def delete_messages(message_ids, request=None):
"""
Takes a list of message ids, deletes them all.
Sends the user a success message if it works.
"""
Message.objects.filter(id__in=message_ids).delete()
if request:
if len(message_ids) > 1:
msg = "As mensagens foram apagadas."
else:
msg = "A mensagem foi apagada."
success(request, msg, User.objects.get(pk=-1))
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 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 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 post(self, request, *args, **kwargs):
nas_edit = shortcuts.get_object_or_404(self.model, pk=self.kwargs.get('pk'))
form = nas.NASEditForm(request.POST, instance=nas_edit)
if form.is_valid():
if not form.has_changed():
api.info(request, _(u'Nenhuma alteração efetuada'))
return shortcuts.render(request, self.template_name, {'form': form,
'object': nas_edit})
if not form._errors:
form.save()
api.success(request, _(u'NAS alterado com sucesso'))
models.Log(user=request.user, msg=_(u"NAS '%s' alterado" % nas_edit.nasname)).save()
return shortcuts.redirect(urlresolvers.reverse('webradius:nas_list'))
return shortcuts.render(request, self.template_name, {'form': form,
'object': nas_edit})
def post(self, request, *args, **kwargs):
pool_edit = shortcuts.get_object_or_404(self.model, pk=self.kwargs.get('pk'))
if pool_edit.pool_name.startswith(models.Poolinfo.get_static_prefix()):
return shortcuts.redirect(urlresolvers.reverse('handler403'))
form = poolinfo.PoolEditForm(request.POST, instance=pool_edit)
if form.is_valid():
if not form.has_changed():
api.info(request, _(u'Nenhuma alteração efetuada'))
form.reset_errors()
return shortcuts.render(request, self.template_name, {'form': form,
'object': pool_edit})
pool = form.save()
api.success(request, _(u'Pool alterado com sucesso'))
models.Log(user=request.user, msg=_(u"Pool '%s' alterado" % pool_edit.pool_name)).save()
return shortcuts.redirect(urlresolvers.reverse('webradius:pool_detail', args=(pool.id,)))
return shortcuts.render(request, self.template_name, {'form': form,
'object': pool_edit})
def post(self, request, *args, **kwargs):
force = request.GET.get('force')
form = macinfo.MacAddForm(request.POST)
if force:
form.force = True
if form.is_valid():
machine = form.save()
models.Log(user=request.user, msg=_(u"Máquina '%s' cadastrado" % machine.mac)).save()
api.success(request, _(u'Máquina cadastrada com sucesso'))
if form.dynamic_pool_full:
api.warning(request, _(u'O pool associado a máquina tem mais máquinas do que IPs disponíveis.'))
return shortcuts.redirect(urlresolvers.reverse('webradius:mac_detail', args=(machine.id,)))
if form.dynamic_ip_in_use:
return shortcuts.render(request, self.template_force_name, {'form': form})
else:
return shortcuts.render(request, self.template_name, {'form': form})
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 form_valid(self, form):
frm = form.save(commit=False)
profile = UserProfile.objects.get(pk=frm.cleaned_data['username'])
user = profile.user
message = render_to_string('userprofile/activation_email.html',
dict(user=user, profile=profile))
success(self.request, _('Registration successfully requested.'))
for admin in User.objects.filter(is_staff=True):
try:
from_user = User.objects.get(pk=-1)
except ObjectDoesNotExist:
from_user = None
mail(self.request, message,
user=admin,
subject=_(u"New account: ") + "%s (%s) " % (profile.name, profile.pk),
from_user=from_user,
)
return super(UserProfileRegister, self).form_valid(form)
def __generate_leases_file(self, request, out_file):
count = 0
for ippool in self.all_radippool:
machine = self.machines.filter(mac=ippool.pool_key)
if len(machine) == 0:
continue
else:
machine = machine[0]
pool = machine.pool
ddns = self.all_ddns.filter(mac=machine.mac)
if len(ddns) == 0:
ddns = None
else:
ddns = ddns[0]
count = count + 1
self.__write_to_file(out_file, ippool, machine, pool, ddns)
api.success(request, _(u"Sucesso ao gerar leases: %s" % (count)))
def register(request):
form = RegisterForm(request.POST or None)
if request.method == 'POST' and form.is_valid():
user = form.save()
if user:
login(request, user)
messages, success(request, 'Usuario Creado Exitosamente')
return redirect('index')
return render(request, 'users/register.html', {
'form': form
})
def register(request):
form = CreateUserForm()
if request.method == 'POST':
form = CreateUserForm(request.POST)
if form.is_valid():
user = form.save()
username = form.cleaned_data.get('username')
messages = success(request,
'user created successfully ' + username)
return redirect('login')
else:
print(form.is_valid)
context = {
'form': form,
}
return render(request, 'cms/register.html', context)
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 __migrate_leases(self, request, out_file, parser, leases):
count = 0
for lease in leases:
# Se for o id do servidor pula e escreve no arquivo de saida
if lease[0] == "server-duid":
self.__write_server_duid(out_file, lease[1])
continue
attr = lease.attr
ip = lease.ipaddress
uid = attr.uid
next_binding = attr.get(parser.next_binding_str)
hostname = attr.get(parser.hostname_str)
fqdn = attr.get(parser.fqdn_str)
txt = attr.get(parser.txt_str)
fwd_name = attr.get(parser.fwd_name_str)
rev_name = attr.get(parser.rev_name_str)
# Sem MAC só escreve no arquivo de saida
if attr.get(parser.hdw_str) is None:
self.__write_to_file(
out_file, parser, attr, lease.ipaddress, next_binding, hostname, fqdn, txt, fwd_name, rev_name
)
continue
mac = attr.hardware.mac
hwtype = attr.hardware.type
end_date = attr.ends.utcdate
end_time = attr.ends.utctime
binding_state = attr.binding[1]
in_pool, pool = self.__is_in_pools(ip)
# Se esse ip não estiver em nenhum pool apenas escreve ele no arquivo de saida
if not in_pool:
self.__write_to_file(
out_file, parser, attr, lease.ipaddress, next_binding, hostname, fqdn, txt, fwd_name, rev_name
)
continue
# Tendo fwd_name eu insiro uma entrada na tabela DDNS
if fwd_name:
name = None
# Se o hostname for nulo usa o fqdn
if hostname is None:
# Se o fqdn for nulo também tenta extrair do fwd_name o hostname
if fqdn is None:
name = self.__extract_hostname(fwd_name, pool.domain_name)
else:
name = fqdn
else:
name = hostname
# Se apesar de tudo name for nulo ou tiver um ponto no name não inclui
if name is not None and name.find(".") == -1:
# Procura uma entrada para esse IP, se não tiver cria
ddns = models.Ddns.objects.filter(fwd_name=fwd_name)
if len(ddns) < 1:
ddns = models.Ddns()
else:
ddns = ddns[0]
# Não pode faltar o cadastro de domínio e domínio reverso
if pool.domain_name is None or pool.rev_domain_name is None:
raise Exception("Pool de destino não tem dominio e dominio reverso: %s" % (pool.pool_name))
dt = datetime.datetime.strptime(end_date + " " + end_time, "%Y/%m/%d %H:%M:%S")
ddns.expiry = dt
ddns.mac = mac
ddns.ip = ip
ddns.hostname = name
ddns.fwd_name = fwd_name
ddns.txt = txt
ddns.rev_name = rev_name
if pool.rev_domain_name != "vazio":
ddns.rev_domain = pool.rev_domain_name
ddns.hw_type = self.__hw_type_to_int(hwtype)
# Insere ou faz update no banco
ddns.save()
# Tem reverso mas não tem fwd_name
# Não vou fazer nada a princípio, o tempo irá resolver
# if rev_name and not fwd_name:
# continue
macinfo = models.Macinfo.objects.filter(mac=mac)
if len(macinfo) >= 1:
macinfo = macinfo[0]
# Se já existe uma máquina com IP estático com esse MAC não altera ela
if macinfo.static:
continue
# Se ja venceu essa concessao prevalece o que ja esta cadastrado
if datetime.datetime.now() > attr.ends.localdatetime:
continue
else:
macinfo = models.Macinfo()
macinfo.mac = mac
macinfo.description = "Máquina migrada."
macinfo.pool = pool
macinfo.static = False
macinfo.static_ip = ""
macinfo.save()
ippool = models.Radippool.objects.filter(framedipaddress=ip)
# Senão achar é algum IP que saiu do range na migração, então não migra o lease do IP
if len(ippool) >= 1:
ippool = ippool[0]
# Se o lease que achou não está vencido eu não mecho nele
if ippool.expiry_time >= datetime.datetime.now():
continue
unset_expiry = "1969-12-31 21:00:00"
str_expiry = "%s" % (ippool.expiry_time)
# Só define o lease se este IP não tinha um lease já definido
if str_expiry == unset_expiry:
ippool.pool_key = mac
ippool.calledstationid = "Freeradius-DHCP"
ippool.callingstationid = mac
dt = datetime.datetime.strptime(end_date + " " + end_time, "%Y/%m/%d %H:%M:%S")
ippool.expiry_time = dt
ippool.username = "******" + mac
ippool.save()
# Contador
count += 1
api.success(request, _(u"Sucesso ao importar Leases: %s" % (count)))
def view_feedback_pending(request, year):
nomcom = get_nomcom_by_year(year)
extra_ids = None
message = None
for message in get_messages(request):
message = ('success', message.message)
FeedbackFormSet = modelformset_factory(Feedback,
form=PendingFeedbackForm,
extra=0)
feedbacks = Feedback.objects.filter(type__isnull=True, nomcom=nomcom)
try:
default_type = FeedbackType.objects.get(slug=settings.DEFAULT_FEEDBACK_TYPE)
except FeedbackType.DoesNotExist:
default_type = None
extra_step = False
if request.method == 'POST' and request.POST.get('move_to_default'):
formset = FeedbackFormSet(request.POST)
if formset.is_valid():
for form in formset.forms:
form.set_nomcom(nomcom, request.user)
form.move_to_default()
formset = FeedbackFormSet(queryset=feedbacks)
for form in formset.forms:
form.set_nomcom(nomcom, request.user)
success(request, 'Feedback saved')
return HttpResponseRedirect(reverse('nomcom_view_feedback_pending', None, args=(year, )))
elif request.method == 'POST' and request.POST.get('end'):
extra_ids = request.POST.get('extra_ids', None)
extra_step = True
formset = FullFeedbackFormSet(request.POST)
for form in formset.forms:
form.set_nomcom(nomcom, request.user)
if formset.is_valid():
formset.save()
if extra_ids:
extra = []
for key in extra_ids.split(','):
id, pk_type = key.split(':')
feedback = Feedback.objects.get(id=id)
feedback.type_id = pk_type
extra.append(feedback)
formset = FullFeedbackFormSet(queryset=Feedback.objects.filter(id__in=[i.id for i in extra]))
for form in formset.forms:
form.set_nomcom(nomcom, request.user, extra)
extra_ids = None
else:
success(request, 'Feedback saved')
return HttpResponseRedirect(reverse('nomcom_view_feedback_pending', None, args=(year, )))
elif request.method == 'POST':
formset = FeedbackFormSet(request.POST)
for form in formset.forms:
form.set_nomcom(nomcom, request.user)
if formset.is_valid():
extra = []
nominations = []
moved = 0
for form in formset.forms:
if form.instance.type and form.instance.type.slug in settings.NOMINEE_FEEDBACK_TYPES:
if form.instance.type.slug == 'nomina':
nominations.append(form.instance)
else:
extra.append(form.instance)
else:
if form.instance.type:
moved += 1
form.save()
if extra or nominations:
extra_step = True
if nominations:
formset = FullFeedbackFormSet(queryset=Feedback.objects.filter(id__in=[i.id for i in nominations]))
for form in formset.forms:
form.set_nomcom(nomcom, request.user, nominations)
extra_ids = ','.join(['%s:%s' % (i.id, i.type.pk) for i in extra])
else:
formset = FullFeedbackFormSet(queryset=Feedback.objects.filter(id__in=[i.id for i in extra]))
for form in formset.forms:
form.set_nomcom(nomcom, request.user, extra)
if moved:
message = ('success', '%s messages classified. You must enter more information for the following feedback.' % moved)
else:
success(request, 'Feedback saved')
return HttpResponseRedirect(reverse('nomcom_view_feedback_pending', None, args=(year, )))
else:
formset = FeedbackFormSet(queryset=feedbacks)
for form in formset.forms:
form.set_nomcom(nomcom, request.user)
type_dict = SortedDict({})
for t in FeedbackType.objects.all().order_by('pk'):
rest = t.name
slug = rest[0]
rest = rest[1:]
while slug in type_dict and rest:
slug = rest[0]
rest = rest[1]
type_dict[slug] = t
return render_to_response('nomcom/view_feedback_pending.html',
{'year': year,
'selected': 'feedback_pending',
'formset': formset,
'message': message,
'extra_step': extra_step,
'default_type': default_type,
'type_dict': type_dict,
'extra_ids': extra_ids,
'types': FeedbackType.objects.all().order_by('pk'),
'nomcom': nomcom}, RequestContext(request))
def get_success_url(self, *args, **kwargs):
success(self.request, u"Senha alterada com sucesso.")
return HttpResponseRedirect(reverse('profiles-userprofile-detail',
kwargs={'username':self.user}))
def get_success_url(self, *args, **kwargs):
success(self.request, _(u'User was modified successfully.'))
return self.object.get_absolute_url()
