def newGeneralGroup(request):
saveViewsLog(request, "apps.groups_app.views_groups.newGeneralGroup")
orgs = None
sel_org = request.GET.get('org')
if request.method == "POST": # selecciona los datos para crear un nuevo grupo
form = newGroupForm(request.POST)
if form.is_valid():
resp = create_group(request, form)
if resp:
saveActionLog(
request.user, 'NEW_GROUP',
"id_group: %s, group_name: %s, admin: %s" %
(resp.pk, resp.name, request.user.username),
request.META['REMOTE_ADDR'])
return HttpResponseRedirect("/groups/" + str(resp.slug) +
"?saved=1")
else:
pass ## No se pudo crear
else:
form = newGroupForm()
orgs = request.user.organizationsuser_user.get_orgs_by_role_code(
"is_admin")
ctx = {
"newGroupForm": form,
"organizations": orgs,
"sel_org": sel_org,
"full_path": request.get_full_path(),
}
return render(request, 'groups/templates/new_group.html', ctx)
def get_user_org_groups(request, slug_org=False):
"""Only org admin can use this function"""
saveViewsLog(request,
"actarium_apps.organizations.views_ajax.getListMembers")
if not request.is_ajax():
raise Http404
if request.method == "GET":
org = request.user.organizationsuser_user.get_org(slug=slug_org)
uname = request.GET.get("uname")
if uname:
_user = User.objects.get_or_none(username=str(uname))
if _user and org.has_user_role(_user,
"is_member") or org.has_user_role(
_user, "is_admin"):
my_group_list = []
for g in org.get_groups():
rel = rel_user_group.objects.get_rel(_user, g)
if rel:
my_group_list.append({
"id": g.id,
"name": g.name,
"url": g.get_absolute_url(),
"image": g.image_path.url_100x100
})
return HttpResponse(json.dumps(my_group_list),
mimetype="application/json")
def showGroupDNISettings(request, slug_group):
'''
Muestra la configuracion de DNI de los integrantes de un grupo
'''
saveViewsLog(request, "apps.groups_app.views.groupDNISettings")
try:
g = Groups.objects.get_group(slug=slug_group)
_user_rel = getRelUserGroup(request.user, g)
members_dni = DNI_permissions.objects.filter(id_group=g)
users_dni = []
for m in members_dni:
users_dni.append(m.id_user)
members = rel_user_group.objects.filter(
id_group=g, is_member=True).exclude(id_user__in=users_dni)
ctx = {
"group": g,
"rel_user": _user_rel,
'members': members,
'members_dni': members_dni,
"breadcrumb": _("Config. DNI")
}
return render_to_response('groups/templates/showGroupDNI.html',
ctx,
context_instance=RequestContext(request))
except groups.DoesNotExist:
return HttpResponseRedirect('/groups/')
def editInfoGroup(request, slug_group):
'''
Muestra la configuracion de un grupo
'''
saveViewsLog(request, "apps.groups_app.views.groupInfoSettings")
g = Groups.objects.get_group(slug=slug_group)
_user_rel = getRelUserGroup(request.user, g)
if _user_rel.is_admin and _user_rel.is_active:
message = False
if request.method == "POST":
form = newGroupForm(request.POST)
if form.is_valid():
g.name = form.cleaned_data['name']
g.description = form.cleaned_data['description']
g.save()
message = "Los datos del grupo han sido actualizados"
else:
message = "Hubo un error en los datos del grupo. Intenta de nuevo."
form = newGroupForm(initial={
"name": g.name,
"description": g.description
})
ctx = {
"group": g,
"rel_user": _user_rel,
"form": form,
"message": message,
"breadcrumb": _(u"Editar información")
}
return render_to_response('groups/templates/editInfoGroup.html',
ctx,
context_instance=RequestContext(request))
else:
return HttpResponseRedirect('/groups/' + str(g.slug))
def newUser(request):
'''crea un nuevo usuario usando un formulario propio'''
saveViewsLog(request, "apps.account.views.newUser")
if not request.user.is_anonymous():
return HttpResponseRedirect(reverse("personal_data"))
if not request.method == "POST":
formulario = RegisterForm()
else:
formulario = RegisterForm(request.POST)
if formulario.is_valid():
email_user = formulario.cleaned_data.get('email')
name_newuser = formulario.cleaned_data.get('username')
new_user = formulario.save()
new_user.is_active = False
new_user.username = new_user.username.replace(" ", "-")
new_user.save()
ak = activation_keys.objects.create_key_to_user(new_user)
data = u"username: {}, email: {}".format(name_newuser, email_user)
saveActionLog(new_user, "SIGN_IN", data,
request.META['REMOTE_ADDR']
) # Guarda datos de usuarios antes de modificarse
if ak:
try:
sendEmailHtml(
1, {
'username': name_newuser,
'activation_key': ak.activation_key
}, [str(email_user)
]) # Envio de correo con clave de activacion
except Exception, e:
print e
return HttpResponseRedirect('/#Error-al-enviar-correo')
return render(request, 'account/registered.html', locals())
def changePassword(request):
'''
Opcion para cambiar password
'''
saveViewsLog(request, "apps.account.views.savePassword")
passUpdate = False
if request.method == "POST":
passUpdate = False
passForm = PasswordChangeForm(data=request.POST, user=request.user)
if passForm.is_valid():
passForm.save()
saveActionLog(request.user, "CHG_PASS", "Password changed",
request.META['REMOTE_ADDR']
) # Guarda datos de usuarios antes de modificarse
passUpdate = True
else:
passForm = PasswordChangeForm(user=request.user)
passUpdate = False
ctx = {
"passForm": passForm,
"dataUpdate": False,
"passwordUpdate": passUpdate,
"error_email": False
}
return render_to_response('account/password.html',
ctx,
context_instance=RequestContext(request))
def help(request):
saveViewsLog(request, "website.views.help")
try:
faqs = faq.objects.filter(is_active=True).order_by("date_added")
except faq.DoesNotExist:
faqs = None
return render(request, 'website/help.html', {"faqs": faqs})
def assignTemplateAjax(request):
saveViewsLog(request, "asettings.views.assignTemplateAjax")
if request.is_ajax():
if request.method == 'GET':
try:
id_template = str(request.GET['id_template'])
id_group = str(request.GET['id_group'])
except:
response = _(u"Problema al intentar recibir los parametros para realizar esta operación")
return HttpResponse(json.dumps(response), mimetype="application/json")
try:
_rel_user_private_templates = rel_user_private_templates.objects.get(id_user=request.user, id_template=templates.objects.get(pk=id_template))
_group = rel_user_group.objects.get(id_user=request.user, id_group=Groups.objects.get(pk=id_group), is_admin=True)
except:
response = _(u"Error: No se ha podido guardar la asignación.")
return HttpResponse(json.dumps(response), mimetype="application/json")
try:
private_templates(id_template=_rel_user_private_templates.id_template, id_group=_group.id_group, id_user=request.user).save()
response = "True"
except:
response = _(u'Error al guardar los datos, probablemente la plantilla que desea asignar ya se encuentra relacionada con el grupo seleccionado, por favor verifica los datos')
return HttpResponse(json.dumps(response), mimetype="application/json")
# print id_template, id_group
else:
response = "No se recibio una peticion get"
else:
response = "No ser recibio una consulta Ajax"
return HttpResponse(json.dumps(response), mimetype="application/json")
def unassignTemplateAjax(request):
saveViewsLog(request, "asettings.views.unassignTemplateAjax")
if request.is_ajax():
if request.method == 'GET':
try:
id_template = str(request.GET['id_template'])
id_group = str(request.GET['id_group'])
except:
response = _(u"Problema con los parametros get")
return HttpResponse(json.dumps(response), mimetype="application/json")
try:
_rel_user_private_templates = rel_user_private_templates.objects.get(id_user=request.user, id_template=templates.objects.get(pk=id_template))
_group = rel_user_group.objects.get(id_user=request.user, id_group=Groups.objects.get(pk=id_group), is_admin=True)
except:
response = _(u"Error: los datos no coinciden con los datos guardados")
return HttpResponse(json.dumps(response), mimetype="application/json")
try:
private_templates.objects.get(id_template=_rel_user_private_templates.id_template, id_group=_group.id_group, id_user=request.user).delete()
response = "True"
except:
response = _(u'La plantilla seleccionada no está asignada al grupo seleccionado')
return HttpResponse(json.dumps(response), mimetype="application/json")
# print id_template, id_group
else:
response = "No se recibio una peticion get"
else:
response = "No ser recibio una consulta Ajax"
return HttpResponse(json.dumps(response), mimetype="application/json")
def personalData(request):
'''
Control para usuarios logueados.
se consultan los datos y se los envia al template para imprimirlos
'''
saveViewsLog(request, "apps.account.views.personalData")
last_data = "last=> username: %s, name: %s, last_name: %s, email %s" % (
request.user.username, request.user.first_name, request.user.last_name,
request.user.email)
if request.method == "POST":
form = UserForm(request.POST, instance=request.user)
if form.is_valid():
_email = form.cleaned_data['email']
try:
_user = User.objects.get(email=_email)
if request.user == _user:
saveActionLog(
request.user, "CHG_USDATA", last_data,
request.META['REMOTE_ADDR']
) # Guarda datos de usuarios antes de modificarse
form.save()
update = True
error_email = None
else:
error_email = True
update = False
except User.DoesNotExist:
saveActionLog(
request.user, "CHG_USDATA", last_data,
request.META['REMOTE_ADDR']
) # Guarda datos de usuarios antes de modificarse
form.save()
update = True
error_email = None
except User.MultipleObjectsReturned:
error_email = True
update = False
except:
print "Error desconocido"
error_email = True
update = False
else:
update = False
error_email = None
else:
form = UserForm(instance=request.user)
update = False
error_email = None
print "update: ", update
ctx = {
"formUser": form,
"dataUpdate": update,
"passwordUpdate": False,
"error_email": error_email
}
return render_to_response('account/personal_data.html',
ctx,
context_instance=RequestContext(request))
def terms(request):
saveViewsLog(request, "website.views.terms")
try:
t = conditions.objects.get(is_active=True)
except conditions.DoesNotExist:
t = None
title = _(u"Términos y condiciones")
ctx = {"title": title, "content": t, "privacy": False, "terms": True}
return render(request, 'website/conditions_privacy.html', ctx)
def privacy_(request):
saveViewsLog(request, "website.views.privacy_")
try:
p = privacy.objects.get(is_active=True)
except privacy.DoesNotExist:
p = None
title = _(u"Políticas de privacidad")
ctx = {"title": title, "content": p, "privacy": True, "terms": False}
return render(request, 'website/conditions_privacy.html', ctx)
def showFeedBack(request):
'''
Visualizacion de comentarios ingresados en Actarium (feedback)
'''
saveViewsLog(request, "website.views.showFeedBack")
if request.user.is_staff:
_feedBack = feedBack.objects.all().order_by("-date_added")
return render_to_response('website/feedback.html', {'feeds': _feedBack}, context_instance=RequestContext(request))
else:
return HttpResponseRedirect("/")
def password_reset_done2(request):
"""
django.contrib.auth.views.password_reset_done - after password reset view
"""
saveViewsLog(request, "apps.account.views.password_reset_done2")
if not request.user.is_authenticated():
return password_reset_done(
request, template_name='account/password_reset_done.html')
else:
return HttpResponseRedirect("/account/")
def read_meetings(request, slug_group, date=None):
from django.utils.timezone import make_aware, get_default_timezone, make_naive
saveViewsLog(request, "apps.groups_app.views.calendar")
# gr = Groups.objects.filter(rel_user_group__id_user=request.user) # grupos
gr = Groups.objects.get(slug=slug_group)
# my_reu = reunions.objects.filter(id_group__in=gr, is_done=False).order_by("-date_convened") # reuniones
# my_reu_day = reunions.objects.filter(id_group__in=gr).order_by("-date_convened") # reuniones para un dia
my_reu = reunions.objects.filter(id_group=gr.id, is_done=False).order_by(
"-date_convened") # reuniones
my_reu_day = reunions.objects.filter(id_group=gr.id).order_by(
"-date_convened") # reuniones para un dia
i = 0
json_array = {}
for reunion in my_reu_day:
td = make_naive(reunion.date_reunion,
get_default_timezone()) - datetime.datetime.now()
if not (td.days >= 0 and td.seconds >= 0 and td.microseconds >= 0):
is_last = 1
else:
is_last = 0
try:
confirm = assistance.objects.get(id_user=request.user,
id_reunion=reunion.pk)
is_confirmed = confirm.is_confirmed
is_saved = 1
except assistance.DoesNotExist:
is_confirmed = False
is_saved = 0
json_array[i] = {
"id_r": str(reunion.id),
# "group":gr,
"group_slug": reunion.id_group.slug,
"group_name": reunion.id_group.name,
"date": humanize.naturaltime(reunion.date_reunion),
"date_normal": date_time_format_form(reunion.date_reunion),
'is_confirmed': str(is_confirmed),
'is_saved': is_saved,
"title": reunion.title,
'is_last': is_last
}
i = i + 1
response = json_array
ctx = {
"reunions_day": my_reu,
"reunions": my_reu,
"my_reu_day_json": json.dumps(response),
# "groups": gr,
"group": gr,
"breadcrumb": _("Mis reuniones"),
"current_date": date,
}
return render_to_response('groups/read_meetings.html',
ctx,
context_instance=RequestContext(request))
def pricing(request):
return HttpResponseRedirect("/")
saveViewsLog(request, "website.views.pricing")
MIN_MONTHLY_PAYMENT = getGlobalVar("MIN_MONTHLY_PAYMENT")
TRIAL_MEMBERS = getGlobalVar("TRIAL_MEMBERS")
TRIAL_MONTH = getGlobalVar("TRIAL_MONTH")
FREE_SERVICE = getGlobalVar("FREE_SERVICE")
services_list = Services.objects.filter(service_category__code="C001", is_active=True).exclude(code=FREE_SERVICE).order_by("-price_per_period")
from actarium_apps.core.models import Packages
queryset_packages = Packages.objects.filter(is_active = True)
return render(request, 'website/pricing.html', locals())
def settingsTemplates(request):
saveViewsLog(request, "asettings.views.settingsTemplates")
_templates = rel_user_private_templates.objects.filter(id_user=request.user)
_groups = rel_user_group.objects.filter(id_user=request.user, is_admin=True)
_private_templates = private_templates.objects.filter(id_user=request.user)
ctx = {
"templates": _templates,
"groups": _groups,
"private_templates_assigned": _private_templates
}
return render_to_response('asettings/settings_templates.html', ctx, context_instance=RequestContext(request))
def activate_account(request, activation_key):
saveViewsLog(request, "apps.account.views.activate_account")
if activate_account_now(request, activation_key):
is_invited = request.GET.get('is_invited')
data = u"username: {}, email: {}".format(request.user.username,
request.user.email)
saveActionLog(request.user, "ACCOUNT_ACTIVATED", data,
request.META['REMOTE_ADDR'])
return render(request, 'account/account_actived.html',
{"invited": is_invited})
else:
return render(request, 'account/invalid_link.html', {})
def log_out(request):
'''
Finaliza una sesion activa
'''
saveViewsLog(request, "apps.account.views.log_out")
try:
_user = request.user
saveActionLog(
_user, "LOG_OUT", "username: %s" % (_user.username),
request.META['REMOTE_ADDR']) # Guarda la accion de cerrar sesion
logout(request)
except Exception, e:
print e
def password_reset_confirm2(request, uidb36, token):
"""
django.contrib.auth.views.password_reset_done - after password reset view
"""
saveViewsLog(request, "apps.account.views.password_reset_confirm2")
if not request.user.is_authenticated():
return password_reset_confirm(
request,
uidb36,
token,
template_name='account/password_reset_confirm.html',
post_reset_redirect='/account/password/done/')
else:
return HttpResponseRedirect("/account/")
def password_reset2(request):
"""django.contrib.auth.views.password_reset view (forgotten password)"""
saveViewsLog(request, "apps.account.views.password_reset2")
if not request.user.is_authenticated():
try:
return password_reset(
request,
template_name='account/password_reset_form.html',
email_template_name='account/password_reset_email.html',
subject_template_name='account/password_reset_subject.txt',
post_reset_redirect='/account/password/reset/done/')
except Exception:
return HttpResponseRedirect("/account/password/reset/done/")
else:
return HttpResponseRedirect("/account/")
def emailAjax(request, slug_group):
saveViewsLog(request, "apps.groups_app.views.emailAjax")
# if request.is_ajax():
_email_admin_type = email_admin_type.objects.get(name='grupo')
from apps.groups_app.views import getGroupBySlug
_group = getGroupBySlug(slug=slug_group)
if request.method == "GET":
try:
id_email_type = str(request.GET['id_email_type'])
input_status = str(request.GET['input_status'])
if input_status == "false":
input_status = False
elif input_status == "true":
input_status = True
try:
_email = email.objects.get(admin_type=_email_admin_type,
email_type=id_email_type)
try:
_email_group_permission = email_group_permissions.objects.get(
id_user=request.user,
id_group=_group,
id_email_type=_email)
_email_group_permission.is_active = input_status
_email_group_permission.save()
message = {"saved": True}
return HttpResponse(json.dumps(message),
mimetype="application/json")
except email_group_permissions.DoesNotExist:
email_group_permissions(id_user=request.user,
id_group=_group,
id_email_type=_email,
is_active=input_status).save()
message = {"saved": True}
return HttpResponse(json.dumps(message),
mimetype="application/json")
except:
message = False
return HttpResponse(message)
except:
message = False
return HttpResponse(message)
except:
message = False
return HttpResponse(message)
else:
message = False
return HttpResponse(message)
def dni(request):
saveViewsLog(request, "apps.account.views.dni")
if request.method == "POST":
formDNI = NewDNI(request.POST)
if formDNI.is_valid():
dni = formDNI.cleaned_data['dni']
dni_type = DNI_type.objects.get(
pk=formDNI.cleaned_data['dni_type'])
try:
_DNI = DNI.objects.get(id_user=request.user)
_DNI.dni_value = dni
_DNI.dni_type = dni_type
except:
_DNI = DNI(dni_value=dni,
dni_type=dni_type,
id_user=request.user)
_DNI.save()
dataSaved = True
else:
dataSaved = False
else:
dataSaved = False
try:
_DNI = DNI.objects.get(id_user=request.user)
formDNI = NewDNI(initial={
"dni": _DNI.dni_value,
"dni_type": _DNI.dni_type.pk
})
except:
formDNI = NewDNI()
_dni_permissions = DNI_permissions.objects.filter(id_user=request.user)
if len(_dni_permissions) > 0:
permissions = True
else:
permissions = False
# print "hay permissions? ", permissions, len(_dni_permissions)
ctx = {
'formDNI': formDNI,
'dataSaved': dataSaved,
'dni_permissions': _dni_permissions,
'permissions': permissions
}
return render_to_response('account/dni.html',
ctx,
context_instance=RequestContext(request))
def log_in(request):
'''
Inicia session de un usuario que usa el formulario propio del sistema.
Retorna y crea una sesion de usuario
'''
saveViewsLog(request, "apps.account.views.log_in")
if not request.user.is_anonymous():
return HttpResponseRedirect('/account')
if request.method == 'POST':
formulario = AuthenticationForm(data=request.POST)
if formulario.is_valid():
return userLogin(request, request.POST.get('username'),
request.POST.get('password'))
else:
next = request.GET.get('next') if 'next' in request.GET else ""
formulario = AuthenticationForm()
return render(request, 'account/login.html', locals())
def sendFeedBack(request):
'''
Formulario para feedback
'''
saveViewsLog(request, "website.views.sendFeedBack")
if request.is_ajax():
if request.method == 'GET':
rate = request.GET['rate']
comment = request.GET['comment']
mail = request.GET['email']
if(validateEmail(mail)):
feed = feedBack(type_feed=rate, email=mail, comment=comment)
feed.save()
response = {"feed_id": feed.id}
# Send Email to staff
_users = User.objects.filter(is_staff=True)
staff_emails = []
for i in _users:
staff_emails.append(i.email)
if rate == '0':
type_feed = _(u'General')
elif rate == '1':
type_feed = _(u'Sugerencia')
elif rate == '2':
type_feed = _(u'Error')
elif rate == '3':
type_feed = _(u'Pregunta')
else:
type_feed = _(u'No definido')
ctx_email = {
'type_feed': type_feed,
'email': mail,
'comment': comment,
}
sendEmailHtml(9, ctx_email, staff_emails)
else:
response = {"error": _(u"Correo invalido")}
return HttpResponse(json.dumps(response), mimetype="application/json")
else:
return HttpResponseRedirect("/")
return True
def setDNIPermissions(request):
"""
Set permissions for DNI
"""
saveViewsLog(request, "apps.groups_app.views.setDNIPermissions")
error = False
saved = False
if request.is_ajax():
if request.method == 'GET':
try:
pk_dni = int(request.GET['pk_dni'])
state = int(request.GET['status'])
_dni_permissions = DNI_permissions.objects.get(pk=pk_dni)
_dni_permissions.state = state
try:
_dni = DNI.objects.get(id_user=_dni_permissions.id_user)
_dni_permissions.save()
# print "pk_dni: ",pk_dni," status: ",state
saved = True
except DNI.DoesNotExist:
error = "Aun no se has guardado un DNI, debes agregar primero tu información del DNI en <a href='/account/dni'>configuración de DNI</a>"
saved = False
except:
error = "Ha ocurrido un error"
saved = False
except DNI_permissions.DoesNotExist:
error = "No hay permisos asignados"
saved = False
except Exception, e:
print e
error = "Por favor recarga la página e intenta de nuevo."
if error:
return HttpResponse(json.dumps({
"error": error,
"saved": False
}),
mimetype="application/json")
response = {"saved": saved, "error": error}
return HttpResponse(json.dumps(response),
mimetype="application/json")
else:
return "Ha ocurrido un error"
def userLogin(request, user_name, password):
'''Autentica a un usuario con los parametros recibidos
actualmente solo se loguea con username, se espera autenticar con mail'''
saveViewsLog(request, "apps.account.views.userLogin")
next = request.GET.get('next') if 'next' in request.GET else None
if not next:
next = request.POST.get('next') if 'next' in request.POST else '/'
user = authenticate(username=user_name, password=password)
if user is not None:
if user.is_active:
login(request, user)
saveActionLog(user, "LOG_IN", "username: %s" % (user_name),
request.META['REMOTE_ADDR']
) # Guarda la accion de inicar sesion
return HttpResponseRedirect(next)
else:
return render_to_response('account/noactivo.html',
context_instance=RequestContext(request))
else:
return HttpResponseRedirect('/account/login?next=' + next)
def showCalendarGroup(request, slug_group):
saveViewsLog(request, "apps.groups_app.views.showCalendarGroup")
g = Groups.objects.get_group(slug=slug_group)
_user = getRelUserGroup(request.user, g)
is_org_admin = g.organization.has_user_role(request.user, "is_admin")
if is_org_admin or _user:
if is_org_admin or _user.is_active:
_reunions = reunions.objects.filter(
id_group=g).order_by("date_reunion")
ctx = {
"group": g,
"rel_user": _user,
"reunions": _reunions,
"breadcrumb": _("Agenda de reuniones")
}
return render_to_response("groups/templates/calendar.html",
ctx,
context_instance=RequestContext(request))
return HttpResponseRedirect('/groups/#you-are-not-active')
return HttpResponseRedirect('/groups/#error-view-group')
def confirm_account(request, activation_key, is_invited=False):
saveViewsLog(request, "apps.account.views.confirm_account")
ak = activationKeyIsValid(activation_key)
if ak:
try:
rels = rel_user_group.objects.filter(id_user=ak.id_user,
is_active=False)
except rel_user_group.DoesNotExist:
return False
except Exception:
return False
update = False
if request.method == "POST":
form = UserForm(request.POST, instance=ak.id_user)
if form.is_valid():
form.save()
update = True
return HttpResponseRedirect("/account/activate/" +
activation_key + "?is_invited=1")
else:
update = False
else:
form = UserForm(
initial={
"username": ak.id_user.username,
"first_name": ak.id_user.first_name,
"last_name": ak.id_user.last_name,
"email": ak.id_user.email
})
ctx = {
"invitations": rels,
"invited": True,
"form": form,
"update": update
}
return render_to_response('account/confirm_account.html',
ctx,
context_instance=RequestContext(request))
else:
return render_to_response('account/invalid_link.html', {},
context_instance=RequestContext(request))
def activate_account_now(request, activation_key):
saveViewsLog(request, "apps.account.views.activate_account_now")
from models import activation_keys
try:
activation_obj = activation_keys.objects.get(
activation_key=activation_key)
if not activation_obj.is_expired:
user = User.objects.get(id=activation_obj.id_user.pk)
user.is_active = True
user.save()
user.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, user)
activation_obj.is_expired = True
activation_obj.save()
return True
else:
return False
except activation_keys.DoesNotExist:
return False
except Exception:
return False
