def create(self, validated_data):
"""Create and return a new user."""
username = validated_data['usuario']
contenido = validated_data['contenido']
print(username)
print(contenido)
print(validated_data)
try:
usuario = Usuario.objects.get(username=username)
except Usuario.DoesNotExist:
usuario = Usuario(username=username,
nombre='Jonh Doe',
correo='*****@*****.**')
usuario.save()
tweet = Tweet(
usuario=usuario,
contenido=contenido,
)
tweet.fecha = datetime.now()
tweet.save()
#numero_cuenta = datetime.now().strftime('%Y%m%d%H%M%S')
#cuenta.numero = numero_cuenta + str(cuenta.id)
#cuenta.save()
return tweet
def process_request(self, request):
if 'uid' in request.session:
request.user = Usuario.objects.get(id=request.session['uid'])
request.user.anonimo = False
request.user.is_authenticated = lambda: True
request.user.esta_autenticado = lambda: True
usuario = Usuario(id=0, nombre_usuario="anonimo")
usuario.save = lambda: None
usuario.is_authenticated = lambda: False
usuario.esta_autenticado = lambda: False
usuario.anonimo = True
request.user = usuario
def inserir():
usuario = {
"nome": request.form['usuario'],
"senha": request.form['senha']
}
try:
u = Usuario(**usuario)
u.save()
return jsonify(msg = True)
except peewee.OperationalError:
return jsonify(msg = False)
def post(self, request):
form = RegistrarForm(request.POST)
if form.is_valid():
formulario = form.data
usuario_dado = User.objects.create_user(formulario['email_user'],
formulario['email_user'],
formulario['senha_user'])
usuario_final = Usuario(nome=formulario['nome_user'],
nick=formulario['nick_user'],
usuario=usuario_dado)
usuario_final.save()
return redirect('login')
return render(request, self.template_name, {'form': form})
def logar():
usuario = request.form['usuario']
senha = request.form['senha']
qtd = Usuario.select().where((Usuario.nome == usuario) & (Usuario.senha == senha)).count()
if qtd > 0:
return jsonify(logado = True)
else:
return jsonify(logado = False)
def cadastro_validar(request):
if request.method == 'POST':
form = cadastroForm(request.POST)
if form.is_valid():
usuario = Usuario(
username=form.data['login'],
email=form.data['email'],
is_active=False
)
usuario.set_password(form.data['senha'])
usuario.save()
if send_mail('Campo assunto Aqui', 'Valide o seu email: http://unifran-78230.sae1.nitrousbox.com/token/'+str(usuario.pk), '*****@*****.**',
[usuario.email], fail_silently=True):
# Se der erro ele avisa aqui.
# Retornar tela de sucesso! Vc Consegue fazer e tb arrumar esses codigos?
return render(request,'cadastro.html',{'form':form})
return render(request,'index.html',{'form':form})
def new_message(self, tweet):
print "Nuevo Tweet! [%s]: %s" % (tweet['id'], tweet['text'])
if tweet.get('recipient_screen_name') == 'alertas123' or tweet.get('in_reply_to_screen_name') == 'alertas123':
if Usuario.twitter_id_str_validado(get_id_str_sender(tweet)):
print "Procesando mensaje!"
procesar_mensaje(tweet)
else:
print "Mensaje de Usuario No VALIDADO!"
else:
print "Mensaje de control: %s" % tweet
def inserta_usuarios():
"""
:return:
"""
l_ok = []
l_nok = []
for t in l_usuarios:
try:
usu = Usuario(username=t[0].strip(), password=t[1], es_admin=True)
usu.save()
l_ok.append((
usu.username,
usu.id,
))
except Exception as e:
l_nok.append((
t,
e,
))
return {'l_nok': l_nok, 'l_ok': l_ok}
def cadastrar_comentario(request):
if request.is_ajax():
usuario_id = request.GET.get('usuario', '')
post_id = request.GET.get('post', '')
text = request.GET.get('text', '')
usuario = Usuario(pk=usuario_id)
post = Post(pk=post_id)
comentario = Comentario(post=post, usuario=usuario, descricao=text)
comentario.save()
comentarios = Comentario.objects.filter(post=post)
context = {
'post': post,
'comentarios': comentarios,
}
html = render_to_string('forum/coments.html', context=context)
return HttpResponse(html)
def save(self):
usuario = Usuario(email=self.validated_data['email'],
username=self.validated_data['username'],
tipo=self.validated_data['tipo'])
password = self.validated_data['password']
password2 = self.validated_data['password2']
if password != password2:
raise serializers.ValidationError(
{'password': '******'})
usuario.set_password(password)
usuario.save()
return usuario
def buscar_alojamientos_por_habitacion(request):
# Por defecto se mostrarán todos los Alojamientos por Habitación que cumplan con las condiciones de indexado
# Estas condiciones son:
# 1 - Que el usuario propietario esté activo y validado como proveedor
# 2 - Que el servicio esté activo y tenga al menos una habitación registrada y esta tenga fotos
# Debe comprobarse si hay criterios de búsqueda almacenadas en la session para inicializar el Formulario y realizar la primera búsqueda
if 'criterio_alojamientos_por_habitacion' in request.session:
lugar = request.session['criterio_alojamientos_por_habitacion'][
'lugar']
fecha_desde = request.session['criterio_alojamientos_por_habitacion'][
'fecha_desde']
fecha_hasta = request.session['criterio_alojamientos_por_habitacion'][
'fecha_hasta']
huespedes = request.session['criterio_alojamientos_por_habitacion'][
'huespedes']
else:
lugar, fecha_desde, fecha_hasta, huespedes = None, None, None, None
busqueda = {
'lugar': lugar,
'fecha_entrada': fecha_desde,
'fecha_salida': fecha_hasta,
}
# Si se pasan algunos valores iniciales de búsqueda debe inicializarse el formulario con estos valores y realizar una primera búsqueda
if fecha_desde or fecha_hasta or huespedes:
fechas_huespedes = [fecha_desde, fecha_hasta, int(huespedes)]
else:
fechas_huespedes = None
alojamientos = Alojamiento.objects.detalles_alojamientos(
# Se definen los criterios de filtrado para los Alojamientos que deseamos listar
usuarios=Usuario.get_proveedores_validados(),
activos=True,
con_habitaciones=True,
por_modalidad=True,
por_habitacion=True,
lugar=lugar,
fechas_huespedes=fechas_huespedes)
# Se obtiene la lista de todas las habitaciones registradas para los Alojamientos anteriormente definidos
habitaciones = Habitacion.get_habitaciones_alojamientos(alojamientos)
# Se obtienen los Alojamientos agrupados por Evaluación
alojamientos_agrupados_evaluacion = Alojamiento.get_agrupados_evaluacion(
alojamientos)
# Se obtienen los Alojamientos agrupados por Características
alojamientos_agrupados_caracteristicas = Alojamiento.get_agrupados_caracteristicas(
alojamientos)
if request.method == 'POST':
# Si se realiza un POST es porque se están pasando los criterios de búsqueda desde esta misma vitsa, así que debemos eliminar
# los criterios que estaban almacenados en la session para que no interfieran con los actuales criterios de búsqueda
if 'criterio_alojamientos_por_habitacion' in request.session:
del request.session['criterio_alojamientos_por_habitacion']
form = Buscar_Alojamientos_Por_Habitacion(request.POST)
if form.is_valid():
# Se aplican los filtros del Formulario
alojamientos = Alojamiento.objects.detalles_alojamientos(
activos=True,
con_habitaciones=True,
por_modalidad=True,
por_habitacion=True,
lugar=form.cleaned_data['lugar'],
fechas_huespedes=[
form.cleaned_data['fecha_entrada'],
form.cleaned_data['fecha_salida'],
int(form.cleaned_data['huespedes'])
],
ordered=form.cleaned_data['ordenar_por'],
rango_precio=form.cleaned_data['rango_precio'],
rating_1_estrella=form.cleaned_data['rating_1_estrella'],
rating_2_estrellas=form.cleaned_data['rating_2_estrellas'],
rating_3_estrellas=form.cleaned_data['rating_3_estrellas'],
rating_4_estrellas=form.cleaned_data['rating_4_estrellas'],
rating_5_estrellas=form.cleaned_data['rating_5_estrellas'],
acceso_discapacitados=form.
cleaned_data['acceso_discapacitados'],
desayuno_cena=form.cleaned_data['desayuno_cena'],
internet=form.cleaned_data['internet'],
parqueo=form.cleaned_data['parqueo'],
patio_terraza_balcon=form.cleaned_data['patio_terraza_balcon'],
permitido_fumar=form.cleaned_data['permitido_fumar'],
permitido_mascotas=form.cleaned_data['permitido_mascotas'],
permitido_ninnos=form.cleaned_data['permitido_ninnos'],
piscina=form.cleaned_data['piscina'],
transporte_aeropuerto=form.
cleaned_data['transporte_aeropuerto'],
apartamento=form.cleaned_data['apartamento'],
casa=form.cleaned_data['casa'],
mansion=form.cleaned_data['mansion'],
aire_acondicionado=form.cleaned_data['aire_acondicionado'],
agua_caliente=form.cleaned_data['agua_caliente'],
nevera_bar=form.cleaned_data['nevera_bar'],
balcon=form.cleaned_data['balcon'],
caja_fuerte=form.cleaned_data['caja_fuerte'],
tv=form.cleaned_data['tv'],
estereo=form.cleaned_data['estereo'],
ventanas=form.cleaned_data['ventanas'],
banno_independiente=form.cleaned_data['banno_independiente'],
)
context = {
'form':
form,
'alojamientos':
alojamientos,
'habitaciones':
habitaciones,
'alojamientos_5_estrellas':
alojamientos_agrupados_evaluacion['5_estrellas'],
'alojamientos_4_estrellas':
alojamientos_agrupados_evaluacion['4_estrellas'],
'alojamientos_3_estrellas':
alojamientos_agrupados_evaluacion['3_estrellas'],
'alojamientos_2_estrellas':
alojamientos_agrupados_evaluacion['2_estrellas'],
'alojamientos_1_estrellas':
alojamientos_agrupados_evaluacion['1_estrellas'],
'acceso_discapacitados':
alojamientos_agrupados_caracteristicas[
'acceso_discapacitados'],
'desayuno_cena':
alojamientos_agrupados_caracteristicas['desayuno_cena'],
'internet':
alojamientos_agrupados_caracteristicas['internet'],
'parqueo':
alojamientos_agrupados_caracteristicas['parqueo'],
'patio_terraza_balcon':
alojamientos_agrupados_caracteristicas['patio_terraza_balcon'],
'permitido_fumar':
alojamientos_agrupados_caracteristicas['permitido_fumar'],
'permitido_mascotas':
alojamientos_agrupados_caracteristicas['permitido_mascotas'],
'permitido_ninnos':
alojamientos_agrupados_caracteristicas['permitido_ninnos'],
'piscina':
alojamientos_agrupados_caracteristicas['piscina'],
'transporte_aeropuerto':
alojamientos_agrupados_caracteristicas[
'transporte_aeropuerto'],
'apartamento':
alojamientos_agrupados_caracteristicas['apartamento'],
'casa':
alojamientos_agrupados_caracteristicas['casa'],
'mansion':
alojamientos_agrupados_caracteristicas['mansion'],
'aire_acondicionado':
alojamientos_agrupados_caracteristicas['aire_acondicionado'],
'agua_caliente':
alojamientos_agrupados_caracteristicas['agua_caliente'],
'nevera_bar':
alojamientos_agrupados_caracteristicas['nevera_bar'],
'balcon':
alojamientos_agrupados_caracteristicas['balcon'],
'caja_fuerte':
alojamientos_agrupados_caracteristicas['caja_fuerte'],
'tv':
alojamientos_agrupados_caracteristicas['tv'],
'estereo':
alojamientos_agrupados_caracteristicas['estereo'],
'ventanas':
alojamientos_agrupados_caracteristicas['ventanas'],
'banno_independiente':
alojamientos_agrupados_caracteristicas['banno_independiente'],
}
else:
print('El formulario es inválido')
context = {
'form': form,
'message': 'Hay errores en el Formulario',
'class_alert': 'alert alert-danger',
'alojamientos': None,
'habitaciones': None,
'alojamientos_5_estrellas': [],
'alojamientos_4_estrellas': [],
'alojamientos_3_estrellas': [],
'alojamientos_2_estrellas': [],
'alojamientos_1_estrellas': [],
'acceso_discapacitados': [],
'desayuno_cena': [],
'internet': [],
'parqueo': [],
'patio_terraza_balcon': [],
'permitido_fumar': [],
'permitido_mascotas': [],
'permitido_ninnos': [],
'piscina': [],
'transporte_aeropuerto': [],
'apartamento': [],
'casa': [],
'mansion': [],
'aire_acondicionado': [],
'agua_caliente': [],
'nevera_bar': [],
'balcon': [],
'caja_fuerte': [],
'tv': [],
'estereo': [],
'ventanas': [],
'banno_independiente': [],
}
else:
context = {
'form':
Buscar_Alojamientos_Por_Habitacion(busqueda),
'alojamientos':
alojamientos,
'habitaciones':
habitaciones,
'alojamientos_5_estrellas':
alojamientos_agrupados_evaluacion['5_estrellas'],
'alojamientos_4_estrellas':
alojamientos_agrupados_evaluacion['4_estrellas'],
'alojamientos_3_estrellas':
alojamientos_agrupados_evaluacion['3_estrellas'],
'alojamientos_2_estrellas':
alojamientos_agrupados_evaluacion['2_estrellas'],
'alojamientos_1_estrellas':
alojamientos_agrupados_evaluacion['1_estrellas'],
'acceso_discapacitados':
alojamientos_agrupados_caracteristicas['acceso_discapacitados'],
'desayuno_cena':
alojamientos_agrupados_caracteristicas['desayuno_cena'],
'internet':
alojamientos_agrupados_caracteristicas['internet'],
'parqueo':
alojamientos_agrupados_caracteristicas['parqueo'],
'patio_terraza_balcon':
alojamientos_agrupados_caracteristicas['patio_terraza_balcon'],
'permitido_fumar':
alojamientos_agrupados_caracteristicas['permitido_fumar'],
'permitido_mascotas':
alojamientos_agrupados_caracteristicas['permitido_mascotas'],
'permitido_ninnos':
alojamientos_agrupados_caracteristicas['permitido_ninnos'],
'piscina':
alojamientos_agrupados_caracteristicas['piscina'],
'transporte_aeropuerto':
alojamientos_agrupados_caracteristicas['transporte_aeropuerto'],
'apartamento':
alojamientos_agrupados_caracteristicas['apartamento'],
'casa':
alojamientos_agrupados_caracteristicas['casa'],
'mansion':
alojamientos_agrupados_caracteristicas['mansion'],
'aire_acondicionado':
alojamientos_agrupados_caracteristicas['aire_acondicionado'],
'agua_caliente':
alojamientos_agrupados_caracteristicas['agua_caliente'],
'nevera_bar':
alojamientos_agrupados_caracteristicas['nevera_bar'],
'balcon':
alojamientos_agrupados_caracteristicas['balcon'],
'caja_fuerte':
alojamientos_agrupados_caracteristicas['caja_fuerte'],
'tv':
alojamientos_agrupados_caracteristicas['tv'],
'estereo':
alojamientos_agrupados_caracteristicas['estereo'],
'ventanas':
alojamientos_agrupados_caracteristicas['ventanas'],
'banno_independiente':
alojamientos_agrupados_caracteristicas['banno_independiente'],
}
context.update(custom_context(request))
return render(request, 'website/buscar_alojamientos_por_habitacion.html',
context)
def index(request):
if request.method == 'POST':
if 'flight' in request.POST:
pass
# Esta variante estáprogramada en la vista "website/search" a donde se llega con la información del formulario a través del "action" del mismo
elif 'habitaciones' in request.POST:
destino = request.POST['destino_habitacion']
lugar = None
if 'Destino' in destino:
lugar = destino.split(' (Destino)')[0]
elif 'Provincia' in destino:
lugar = destino.split(' (Provincia)')[0]
elif 'Municipio' in destino:
lugar = destino.split(' (Municipio)')[0]
else:
print('Escenario no previsto hasta ahora')
# Ahora obtengo las fechas del Formulario y la cantidad de huéspedes
fecha_desde = request.POST['start']
fecha_hasta = request.POST['end']
huespedes = request.POST['huespedes']
# Se almacenan los criterios de búsqueda en la session para recuperarlos luego desde la otra vista
request.session['criterio_alojamientos_por_habitacion'] = {
'lugar': lugar,
'fecha_desde': fecha_desde,
'fecha_hasta': fecha_hasta,
'huespedes': huespedes,
}
# En este punto tengo el lugar en el que deben estar los Alojamientos que muestre al Usuario, las fechas y la cantidad de huéspedes
return redirect('website:buscar_alojamientos_por_habitacion')
elif 'alojamientos' in request.POST:
destino = request.POST['destino_alojamiento']
lugar = None
if 'Destino' in destino:
lugar = destino.split(' (Destino)')[0]
elif 'Provincia' in destino:
lugar = destino.split(' (Provincia)')[0]
elif 'Municipio' in destino:
lugar = destino.split(' (Municipio)')[0]
else:
print('Escenario no previsto hasta ahora')
# Ahora obtengo las fechas del Formulario y la cantidad de huéspedes
fecha_desde = request.POST['start']
fecha_hasta = request.POST['end']
huespedes = request.POST['huespedes']
# Se almacenan los criterios de búsqueda en la session para recuperarlos luego desde la otra vista
request.session['criterio_alojamientos_completos'] = {
'lugar': lugar,
'fecha_desde': fecha_desde,
'fecha_hasta': fecha_hasta,
'huespedes': huespedes,
}
# En este punto tengo el lugar en el que deben estar los Alojamientos que muestre al Usuario, las fechas y la cantidad de huéspedes
return redirect('website:buscar_alojamientos_completos')
else:
return redirect('website:index')
else:
# Se definen las listas vacías para almacenar los elementos que serán mostrados en el index
alojamientos_por_habitacion = []
alojamientos_completos = []
# Servicios destacados
alojamientos_destacados = []
# Se definen los Alojamientos que pueden ser mostrados
alojamientos = Alojamiento.objects.detalles_alojamientos(
# Se definen los criterios de filtrado para los Alojamientos que deseamos listar
usuarios=Usuario.get_proveedores_validados(
), # Solo Alojamientos de usuarios activos y verificados como proveedores
activos=True, # Solo Alojamientos asociados a Servicios Activos
)[:
12] # Solo se muestra una cantidad limitada de Alojamientos establecida en la Configuración
# Se agrupan los Alojamientos según su tipo de alquiler
for alojamiento in alojamientos:
if alojamiento.por_habitacion:
if alojamiento.cantidad_habitaciones > 0 and alojamiento.fotos:
alojamientos_por_habitacion.append(alojamiento)
elif alojamiento.fotos:
alojamientos_completos.append(alojamiento)
# Destacados
if alojamiento.servicio.destacado:
alojamientos_destacados.append(alojamiento)
# De momento se selecciona un Alojamiento destacado al azar
if alojamientos_destacados:
alojamiento_destacado = alojamientos_destacados[random.randint(
0,
len(alojamientos_destacados) - 1)]
else:
alojamiento_destacado = None
# Se hace un bucle luego de la consulta para realizar una sola consulta a la BD
# En este punto tenemos listas con los tipos de elementos que deben ser mostrados en el index
# Se pasa el listado de Aeropuertos de Cuba, para el selector del buscador de Inicio
aeropuertos_cuba = Aeropuerto.objects.filter(
cuba=True).order_by('codigo_iata')
context = {
'alojamientos_por_habitacion': alojamientos_por_habitacion,
'alojamientos_completos': alojamientos_completos,
'alojamiento_destacado':
alojamiento_destacado, # Si hay más de uno, varía cuál se muestra entre una vista y otra
'aeropuertos_cuba': aeropuertos_cuba,
'GMaps_APIKey': GMaps_APIKey,
}
context.update(custom_context(request))
return render(request, 'website/index.html', context)
def crear_usuario(request):
#PERMISOS
if request.user.groups.filter(name__in=['Mantenedor']).exists():
return HttpResponseRedirect(reverse("home"))
elif request.user.groups.filter(name__in=['Profesional']).exists():
return HttpResponseRedirect(reverse("home"))
elif request.user.groups.filter(name__in=['Asistente Social']).exists():
return HttpResponseRedirect(reverse("home"))
elif request.user.groups.filter(name__in=['Administrativo']).exists():
return HttpResponseRedirect(reverse("home"))
else:
template = "crear_usuario.html"
if request.method == 'GET':
areas = Area.objects.all()
especialidades = Especialidad.objects.all()
return render(request, template, {
"areas": areas,
"especialidades": especialidades
})
if request.method == 'POST':
try:
nombre = request.POST.get('inputNombre').upper()
apellido_paterno = request.POST.get(
'inputApellidoPaterno').upper()
apellido_materno = request.POST.get(
'inputApellidoMaterno').upper()
txt_rut = request.POST.get('inputRut')
rut = txt_rut.replace(".", "")
tipoUsuario = request.POST.get('inputTipoUsuario')
correo = request.POST.get('inputCorreo')
especialidadesElegidas = request.POST.getlist(
'inputEspecialidad')
apellidos = apellido_paterno.upper(
) + " " + apellido_materno.upper()
#print (especialidadesElegidas)
usuarioExiste = Usuario.objects.filter(rut=rut)
if not usuarioExiste:
usuario = Usuario()
usuario.nombre = nombre.upper()
usuario.apellidos = apellidos
usuario.rut = rut
if tipoUsuario == "1":
usuario.profesional = True
elif tipoUsuario == "2":
usuario.administrativo = True
elif tipoUsuario == "3":
usuario.mantenedor = True
elif tipoUsuario == "4":
usuario.asistente_social = True
elif tipoUsuario == "5":
usuario.coordinador = True
usuario.user = crear_user(nombre, apellidos, correo,
tipoUsuario, rut)
usuario.save()
if especialidadesElegidas:
for e in especialidadesElegidas:
obj = UsuarioEspecialidad()
especialidad = Especialidad.objects.get(id=e)
obj.especialidad = especialidad
obj.usuario = usuario
obj.save()
messages.success(request, '¡Usuario agregado con éxito!')
id = usuario.id
del usuario
return HttpResponseRedirect(
reverse("usuarios:verUsuario", args=[id]))
else:
usuario = usuarioExiste[0]
usuario.user = crear_user(nombre, apellidos, correo,
tipoUsuario, rut)
messages.error(request, '¡Este usuario ya existe!')
return HttpResponseRedirect(
reverse("usuarios:crear_usuario"))
except Exception as e:
messages.error(request,
"No fue posible crear usuario. " + repr(e))
return HttpResponseRedirect(reverse("usuarios:crear_usuario"))
def transaccion_exitosa(request):
# En esta vista recibimos la información del pago para proceder según corresponda.
# Obtenemos el paymentID del diccionario GET del objeto request, para si está la información correcta, ejecutar el pago
if 'paymentId' in request.GET and 'PayerID' in request.GET:
paymentId = request.GET.get('paymentId')
PayerID = request.GET.get('PayerID')
# Se ejecuta el pago, pero antes verificamos que el mismo esté reflejado correctamente en nuestra BD
# Lo anterior nos asegura que disponemos de la información necesaria del producto que se ha comprado
if Pago.objects.filter(paypal_payment_id=paymentId):
# Relacionamos el pago de Paypal que nos llega con el pago que debemos tener pendiente registrado en nuestra BD
pago = Pago.objects.get(paypal_payment_id=paymentId)
# Ahora se ejecuta el pago, para que se haga efectiva la transferencia del dinero
executed_payment = pago.ejecutar_pago(PayerID)
if executed_payment:
# Luego que se ha ejecutado el pago, se debe actuar de una forma u otra en función de si el usuario que ha pagado
# se encuentra logeado en el sistema o es un usuario anónimo
# 1 - Escenario en que el usuario está logeado (autenticado) en el sistema
# 1.1 - Se redirecciona a la vista de reserva confirmada sin mayores acciones
payer = executed_payment['payer']
if request.user.is_authenticated:
# Se comprueba si hay que completar algún dato del Usuario que no esté en el perfil y que se pueda tomar de Paypal
usuario = Usuario.objects.get(user=request.user)
usuario.completar_datos_from_Paypal(payer=payer)
reservas = [pago.reserva]
# 2 - El usuario que ha pagado es un usuario anónimo
else:
reservas = []
# Para la creación (o selección) del usuario que ha pagado, hacemos uso del diccionario "payer" que devuelve Paypal
# Creamos el nuevo usuario o seleccionamos el que corresponda con la dirección de email aportada en el pago
n_usuario = Usuario.nuevo_usuario_tras_pago_paypal(
payer=payer)
# Al tener ya un objeto Usuario, debemos pasar a BD todas las Reservas que hay en la session
for reserva_dict in request.session['en_el_carro']:
reservas.append(
Reserva.crear_reserva_from_session(
usuario=n_usuario,
reserva_dict=reserva_dict,
))
# Debemos pasar también a BD los registros de Favoritos
if 'favoritos' in request.session:
for favorito in request.session['favoritos']:
Favorito.nuevo_favorito(
servicio=Servicio.objects.get(
id=int(favorito)),
usuario=n_usuario,
)
# Al terminar de procesar todas las reservas y Favoritos, se vacían dichos diccionarios de request.session
if 'en_el_carro' in request.session:
del request.session['en_el_carro']
request.session['en_el_carro'] = []
if 'favoritos' in request.session:
del request.session['favoritos']
request.session['favoritos'] = []
# Se realiza el login del usuario
login(request, n_usuario.user)
# -- Independientemente del caso de autenticación, hechos todos los pasos anteriores, se prosigue con lo siguiente:
# Se genera un pdf con la información de la reserva y se envía por mail al cliente
# TODO: Sustituir por celery
for reserva in reservas:
Email.enviar_correo_reserva_alojamiento(
host=request.get_host(), reserva_id=reserva.id)
# Se genera un pdf con la información de la reserva y se envía por mail al proveedor
# TODO: sustituir por celery
Email.enviar_correo_reserva_alojamiento_proveedor(
host=request.get_host(), reserva_id=reserva.id)
# Realizados todos los cambios, se redirige a la vista de reserva confirmada
return redirect('pagos:reserva_confirmada', pago_id=pago.id)
else:
return redirect('pagos:transaccion_error')
else:
return redirect('pagos:transaccion_error')
else:
return redirect('pagos:transaccion_error')
def registro_votante(request):
mensaje = ""
llamarMensaje = ""
#Verificación para crear un solo votante
if request.method == 'POST' and "btncreate" in request.POST:
form = FormularioRegistroVotante(request.POST)
form2 = FormularioCargar()
#Si el formulario es valido y tiene datos
if form.is_valid():
#Capture el codigo del votante
cedula_votante = form.cleaned_data["cedula_usuario"]
## Verificando si el usuario existe o no existe
try:
usuario = Usuario.objects.get(cedula_usuario=cedula_votante)
except Usuario.DoesNotExist:
usuario = Usuario()
codigo = form.cleaned_data["codigo_estudiante"]
try:
#Consultando el votante en la base de datos.
votante = Votante.objects.get(codigo=codigo)
#Si el votante no existe, lo crea
except Votante.DoesNotExist:
# Creando el usuario votante
votante = Votante()
createuservotante(usuario, votante, form)
# Borrando los datos del formulario y enviando el mensaje de sactisfacion
#form = FormularioRegistroVotante()
mensaje = "El votante se guardo correctamente, la contraseña se envío al correo " + usuario.email
llamarMensaje = "exito_usuario"
else:
# Si el votante esta en la BD y no esta activo
if not votante.is_active:
createuservotante(usuario, votante, form)
mensaje = "El votante se guardo correctamente, la contraseña se envío al correo " + usuario.email
llamarMensaje = "exito_usuario"
# Si el votante ya existe en la BD y esta activo
else:
mensaje = "El votante con código " + str(votante.codigo)+ " ya esta registrado en el sistema"
llamarMensaje = "fracaso_usuario"
request.session['llamarMensaje'] = llamarMensaje
request.session['mensaje'] = mensaje
return redirect("listar_votantes")
#si no es valido el formulario crear
else:
form = FormularioRegistroVotante()
data = {
'form': form,
'form2':form2,
}
return render(request, 'registro_votante.html', data)
#Verificación para cargar usuarios votantes
elif request.method == 'POST' and "btnload" in request.POST:
form = FormularioRegistroVotante()
form2 = FormularioCargar(request.POST, request.FILES)
crearVotante = False
#Si el formulario es valido y tiene datos
if form2.is_valid():
csvf = StringIO(request.FILES['file'].read().decode())
reader = csv.reader(csvf, delimiter=',')
line=0
useredit =0;
usercreate=0;
userexist=0;
for row in reader:
if (line > 0):
#Consultando el votante en la base de datos.
try:
usuario = Usuario.objects.get(cedula_usuario=row[0])
except Usuario.DoesNotExist:
usuario = Usuario()
usuario.cedula_usuario = row[0]
usuario.first_name = row[1]
usuario.last_name = row[2]
usuario.email = row[3]
usuario.username = row[0]
usuario.is_active = True
#generando el password aleatorio.
password = User.objects.make_random_password()
usuario.set_password(password)
votante = Votante()
votante.usuario = usuario
votante.codigo = row[4]
crearVotante = True
try:
plan = Corporacion.objects.get(id_corporation=row[5], sede__codigo=row[6] )
votante.plan = plan
except Corporacion.DoesNotExist:
mensaje = "ERROR el plan " + str(row[5]) + "No está creado en el sistema, debe de crearlo para continuar.... Votantes creados "+ str(usercreate)
llamarMensaje = "fracaso_usuario"
return render_to_response('registro_votante.html', {'mensaje': mensaje, 'form': form , 'form2':form2, 'llamarMensaje': llamarMensaje}, context_instance=RequestContext(request))
# Enviando contraseña al correo electronico registrado.
mensaje = "Señor(a) ", usuario.first_name , "\nSu usuario de acceso es: ", usuario.cedula_usuario , "\n Contraseña: ", usuario.password
#send_mail('Envío de contraseña de acceso a SIVORE', mensaje, '*****@*****.**', [usuario.email], fail_silently=False)
usercreate +=1
#Usuario ya existe pero esta desactivo
else:
if not usuario.is_active:
usuario.is_active = True
votante = Votante.objects.get(usuario__cedula_usuario=usuario.cedula_usuario)
votante.is_active = True
try:
votante.save()
except Exception as e:
print("No se pudo guardadr " + e)
useredit +=1
else:
userexist +=1
#Crea el usuario en la BD s i hay excepcion
try:
usuario.save()
except Exception as e:
print(e)
#Crea el votante en la BD si hay excepcion
if crearVotante:
try:
votante.save()
crearVotante = False
except Exception as e:
print(e)
#Removiendo los permisos
for permission in usuario.user_permissions.all():
usuario.user_permissions.remove(permission)
# Poniendo el permiso de votante
usuario.user_permissions.add(Permission.objects.get(codename='Votante'))
else:
line += 1
mensaje = "Se crearon exitosamente " + str(usercreate) + " y se activaron " + str(useredit) + " votantes en el sistema."
if userexist != 0:
mensaje = mensaje + ", además estaba activos " + str(userexist) + " votantes."
llamarMensaje = "exito_usuario"
request.session['llamarMensaje'] = llamarMensaje
request.session['mensaje'] = mensaje
return redirect("listar_votantes")
#Ninguno de los dos formularios crear ni cargar Method GET
else:
form = FormularioRegistroVotante()
form2 = FormularioCargar()
return render_to_response('registro_votante.html',{'mensaje': mensaje, 'form': form, 'form2':form2, 'llamarMensaje': llamarMensaje}, context_instance=RequestContext(request))
def init_usuarios():
linkage = Usuario(username='******',
email='*****@*****.**',
birth_date=date.today(),
is_staff=True,
is_superuser=True)
linkage.set_password('linkage123')
linkage.save()
josemhenao = Usuario(username='******',
email='*****@*****.**',
birth_date=date.today(),
is_staff=True,
is_superuser=True)
josemhenao.set_password('josemhenao123')
josemhenao.save()
mfhenao88 = Usuario(username='******',
email='*****@*****.**',
birth_date=date.today())
mfhenao88.set_password('mfhenao88123')
mfhenao88.save()
juanjosegdoj = Usuario(username='******',
email='*****@*****.**',
birth_date=date.today())
juanjosegdoj.set_password('juanjosegdoj123')
juanjosegdoj.save()
marthacardonae = Usuario(username='******',
email='*****@*****.**',
birth_date=date.today())
marthacardonae.set_password('marthacardonae123')
marthacardonae.save()
usuario1 = Usuario(username='******',
email='*****@*****.**',
birth_date=date.today())
usuario1.set_password('usuario1123')
usuario1.save()
usuario2 = Usuario(username='******',
email='*****@*****.**',
birth_date=date.today())
usuario2.set_password('usuario2123')
usuario2.save()
usuario3 = Usuario(username='******',
email='*****@*****.**',
birth_date=date.today())
usuario3.set_password('usuario3123')
usuario3.save()
usuario4 = Usuario(username='******',
email='*****@*****.**',
birth_date=date.today())
usuario4.set_password('usuario4123')
usuario4.save()
usuario5 = Usuario(username='******',
email='*****@*****.**',
birth_date=date.today())
usuario5.set_password('usuario5123')
usuario5.save()
usuario6 = Usuario(username='******',
email='*****@*****.**',
birth_date=date.today())
usuario6.set_password('usuario6123')
usuario6.save()
def registro_usuario(request):
mensaje = ""
llamarMensaje = ""
#Verificación para crear un solo usuario
if request.method == 'POST' and "btncreate" in request.POST:
form = FormularioRegistroUsuario(request.POST)
form2 = FormularioCargar()
#Si el formulario es valido y tiene datos
if form.is_valid():
#Capture la cedula del usuario
cedula_usuario = form.cleaned_data["cedula_usuario"]
try:
#Consultando el usuario en la base de datos.
usuario = Usuario.objects.get(cedula_usuario=cedula_usuario)
#Si el usuario no existe, lo crea
except Usuario.DoesNotExist:
# Creando el usuario
usuario = Usuario()
createuser(usuario, form)
# Borrando los datos del formulario y enviando el mensaje de sactisfacion
form = FormularioRegistroUsuario()
mensaje = "El usuario se guardo correctamente, la contraseña se envío al correo " + usuario.email
llamarMensaje = "exito_usuario"
else:
# Si el usuario esta en la BD y no esta activo
if not usuario.is_active:
createuser(usuario, form)
mensaje = "El usuario se guardo correctamente, la contraseña se envío al correo " + usuario.email
llamarMensaje = "exito_usuario"
# Si el usuario ya existe en la BD y esta activo
else:
mensaje = "El usuario " + str(cedula_usuario) + " ya esta registrado"
llamarMensaje = "fracaso_usuario"
request.session['llamarMensaje'] = llamarMensaje
request.session['mensaje'] = mensaje
return redirect("listar_usuario")
#si no es valido el formulario crear
else:
form = FormularioRegistroUsuario()
data = {
'form': form,
'form2':form2,
}
return render(request, 'registro_usuario.html', data)
#Verificación para cargar usuarios votantes
elif request.method == 'POST' and "btnload" in request.POST:
form = FormularioRegistroUsuario()
form2 = FormularioCargar(request.POST, request.FILES)
crearVotante = False
#Si el formulario es valido y tiene datos
if form2.is_valid():
csvf = StringIO(request.FILES['file'].read().decode())
reader = csv.reader(csvf, delimiter=',')
line=0
useredit =0;
usercreate=0;
userexist=0;
for row in reader:
if (line > 0):
#Consultando el usuario en la base de datos.
try:
usuario = Usuario.objects.get(cedula_usuario=row[0])
except Usuario.DoesNotExist:
usuario = Usuario()
usuario.cedula_usuario = row[0]
usuario.first_name = row[1]
usuario.last_name = row[2]
usuario.email = row[3]
usuario.username = row[0]
usuario.is_active = True
#generando el password aleatorio.
password = User.objects.make_random_password()
usuario.set_password(password)
votante = Votante()
votante.usuario = usuario
votante.codigo = row[4]
crearVotante = True
try:
plan = Corporacion.objects.get(id_corporation=row[5])
votante.plan = plan
except Corporacion.DoesNotExist:
mensaje = "ERROR el plan " + str(row[5]) + "No está creado en el sistema, debe de crearlo para continuar.... Votantes creados "+ str(usercreate)
llamarMensaje = "fracaso_usuario"
return render_to_response('registro_usuario.html', {'mensaje': mensaje, 'form': form , 'form2':form2, 'llamarMensaje': llamarMensaje}, context_instance=RequestContext(request))
# Enviando contraseña al correo electronico registrado.
mensaje = "Señor(a) ", usuario.first_name , "\nSu usuario de acceso es: ", usuario.cedula_usuario , "\n Contraseña: ", usuario.password
#send_mail('Envío de contraseña de acceso a SIVORE', mensaje, '*****@*****.**', [usuario.email], fail_silently=False)
usercreate +=1
#Usuario ya existe pero esta desactivo
else:
if not usuario.is_active:
usuario.is_active = True
useredit +=1
else:
userexist +=1
#Crea el usuario en la BD s i hay excepcion
try:
usuario.save()
except Exception as e:
print(e)
#Crea el votante en la BD si hay excepcion
if crearVotante:
try:
votante.save()
crearVotante = False
except Exception as e:
print(e)
#Removiendo los permisos
for permission in usuario.user_permissions.all():
usuario.user_permissions.remove(permission)
# Poniendo el permiso de votante
usuario.user_permissions.add(Permission.objects.get(codename='Votante'))
else:
line += 1
mensaje = "Se crearon exitosamente " + str(usercreate) + " y se activaron " + str(useredit) + " votantes en el sistemas"
if userexist != 0:
mensaje = mensaje + ", además estaba activos " + str(userexist) + " usuarios"
llamarMensaje = "exito_usuario"
request.session['llamarMensaje'] = llamarMensaje
request.session['mensaje'] = mensaje
return redirect("listar_usuario")
#Ninguno de los dos formularios crear ni cargar Method GET
else:
form = FormularioRegistroUsuario()
form2 = FormularioCargar()
return render_to_response('registro_usuario.html',{'mensaje': mensaje, 'form': form, 'form2':form2, 'llamarMensaje': llamarMensaje}, context_instance=RequestContext(request))
def login_view(request):
# Se obtiene el template
template = loginTemplate
# Si request es GET
if request.method == "GET":
# Funcion para crear contexto a login
context = crearContextParaLoginView()
# Se envia respuesta
return render(request, template, context)
# Si respuesta es POST
else:
# Si se quiere loguear
if "login_button" in request.POST:
# Se obtiene formulario de login
formulario = LoginOwner(request.POST)
# Si formulario es valido
if formulario.is_valid():
# Se limpia la data
formulario = formulario.cleaned_data
# funcion para autenticar a usuario
user = authenticate(username = formulario["email"], password = formulario["password"])
#Si es correcto el login
if user is not None:
if user.is_active:
login(request,user)
# Se agrega mensaje de exito de logout
messages.add_message(request, messages.SUCCESS, mLoginExitoso)
# Redirigir hacia pagina dada en aprametro next de url
urlParaRedirigir = obtenerUrlParaRedirigir(request)
return redirect(urlParaRedirigir)
else:
# Se agrega mensaje de error en login
messages.add_message(request, messages.WARNING, mErrorIntenteNuevamente)
print 'usuario no registrado'
# Funcion para crear contexto a login
context = crearContextParaLoginView()
# Se crea respuesta
return render(request, template, context)
# Si es que no es valido
else:
# Se agrega mensaje de error en login
messages.add_message(request, messages.WARNING, mErrorIntenteNuevamente)
print 'Ocurrio un error'
# Funcion para crear contexto a login
context = crearContextParaLoginView()
# Se crea respuesta
return render(request, template, context)
# Si usuario se quiere registrar
elif "register_button" in request.POST:
# Se obtiene formulario de login
formulario = RegistrarOwner(request.POST, request.FILES)
# Si formulario es valido
if formulario.is_valid():
# Se limpia la data
formulario = formulario.cleaned_data
# Se toma el email
email = formulario["email"]
# Se toma el password
password = formulario["password"]
# Se chequea si existe el usuario
auth_user = User.objects.filter(username__exact = email)
# Si usuario ya esta registrado
if auth_user:
# Se agrega mensaje de error que email ya esta registrado
messages.add_message(request, messages.WARNING, mErrorUsuarioYaEstaRegistrado)
# Se envia respuesta
return redirect(request.META.get('HTTP_REFERER'))
# Si usuario no esta registrado
else:
# Se crea usuario de modelo de usuario de django
auth_user = User.objects.create_user(username = email, password = password)
# Se almacena en DB
auth_user.save()
# Se crea Usuario
owner = Usuario(user = auth_user, nombre = formulario["nombre"], email = email, numeroContacto = formulario["numeroContacto"], password = password, foto = formulario["foto"], fechaCreacion = timezone.now(), ciudad = formulario["ciudad"])
# Se almacena en DB
owner.save()
# funcion para autenticar a usuario
user = authenticate(username = email, password = password)
#Si es correcto el login
if user is not None:
if user.is_active:
# Se agrega mensaje de exito de registro
messages.add_message(request, messages.SUCCESS, mRegistroExitoso)
print 'Registro exitoso'
# Se loguea
login(request,user)
# Redirigir hacia pagina dada en aprametro next de url
urlParaRedirigir = obtenerUrlParaRedirigir(request)
# Se retorna respuesta
return redirect(urlParaRedirigir)
else:
# Se agrega mensaje de exito de registro
messages.add_message(request, messages.SUCCESS, mRegistroExitoso)
print 'Se ha registrado un usuario'
# Funcion para crear contexto a login
context = crearContextParaLoginView()
# Se crea respuesta
return render(request, template, context)
# Si es que no es valido
else:
# Se agrega mensaje de error en login
messages.add_message(request, messages.WARNING, mErrorIntenteNuevamente)
print 'Ocurrio un error'
# Funcion para crear contexto a login
context = crearContextParaLoginView()
# Se crea respuesta
return render(request, template, context)