def verificar_movil(request, usuario_id):
usuario = Usuario.objects.detalles_usuario(usuario=Usuario.objects.get(
id=usuario_id))
# Lo primero es validar que el usuario pueda continuar haciendo solicitudes de verificación de móvil
n_solicitud_verificacion = Solicitud_Verificacion.nueva_solicitud_verificacion(
usuario=usuario,
movil=usuario.movil,
)
if isinstance(n_solicitud_verificacion, dict):
message = n_solicitud_verificacion['message']
class_alert = 'alert alert-danger'
context = {
'usuario': usuario,
'message': message,
'class_alert': class_alert,
}
context.update(custom_context(request))
return render(request, 'usuarios/centro_verificacion_datos.html',
context)
# Llegados a este punto, se genera un nuevo Código de verificación para el usuario
codigo_verificacion = Codigo_Verificacion.generar_codigo_verificacion_twilio(
)
usefull = False
n_codigo_verificacion = None
while not usefull:
n_codigo_verificacion = Codigo_Verificacion.nuevo_codigo_verificacion(
usuario=usuario,
codigo=codigo_verificacion,
)
if not isinstance(n_codigo_verificacion, dict):
usefull = True
# Una vez obtenido el código de verificación y relacionado con el usuario, se envía el SMS
twilio_client = Twilio_Client.objects.get(en_uso=True)
twilio_client.send_sms(
to=usuario.complete_movil,
message='El código para verificar tu móvil en Ontraveline es: %s' %
(n_codigo_verificacion.codigo))
context = {
'usuario':
usuario,
'message':
'Hemos enviado un SMS con código de confirmación al %s, por favor, introdúzcalo a continuación para que podamos verificar su móvil'
% (usuario.complete_movil),
'class_alert':
'alert alert-success',
}
context.update(custom_context(request))
return redirect('usuarios:centro_verificacion_datos')
def forgot_password(request):
if request.method == 'POST':
form = Forgot_Password_Form(request.POST)
if form.is_valid():
email = form.cleaned_data['email']
recovery_password = Usuario.recovery_password(
email, host=request.get_host())
if isinstance(recovery_password, dict):
message = recovery_password['message']
class_alert = 'alert alert-danger'
else:
form = Forgot_Password_Form()
message = 'Hemos enviado un E-Mail a la dirección indicada con las instrucciones que debes seguir para recuperar tu contraseña'
class_alert = 'alert alert-info'
else:
message = 'Hay errores en el Formulario'
class_alert = 'alert alert-danger'
else:
form = Forgot_Password_Form()
message = None
class_alert = None
context = {
'form': form,
'message': message,
'class_alert': class_alert,
}
context.update(custom_context(request))
return render(request, 'usuarios/forgot_password.html', context)
def galeria_blog(request):
galeria = Galeria_Blog.objects.get(en_uso = True)
context = {
'galeria': galeria,
}
context.update(custom_context(request))
return render(request, 'blog/galeria.html', context)
def ofreces_servicios(request):
testimonios = Testimonio.objects.filter(mostrar=True,
usuario__proveedor=True)[:3]
context = {
'testimonios': testimonios,
}
context.update(custom_context(request))
return render(request, 'website/ofreces_servicios.html', context)
def documentos_verificacion_actividad(request, usuario_id):
usuario = Usuario.objects.get(id=usuario_id)
documentos_actividad = usuario.foto_licencia_actividad_set.all()
context = {
'usuario': usuario,
'documentos_actividad': documentos_actividad,
}
context.update(custom_context(request))
return render(request, 'usuarios/documentos_verificacion_actividad.html',
context)
def como_funciona(request):
testimonios = Testimonio.objects.filter(mostrar=True,
usuario__proveedor=False)[:3]
# alojamientos_populares = Alojamiento.objects.detalles_alojamientos()[:4]
context = {
'testimonios': testimonios,
# 'alojamientos_populares': alojamientos_populares,
}
context.update(custom_context(request))
return render(request, 'website/como_funciona.html', context)
def pdf_reserva_alojamiento_completo(request, reserva_id):
reserva = Reserva.objects.detalles_reserva(id=reserva_id)
alojamiento = Alojamiento.objects.detalles_alojamiento(
id_alojamiento=reserva.servicio.alojamiento.id)
context = {
'alojamiento': alojamiento,
'reserva': reserva,
}
context.update(custom_context(request))
return render(request,
'emails/plantillas/reserva_alojamiento_completo.html',
context)
def pdf_reserva_alojamiento_por_habitacion(request, reserva_id):
reserva = Reserva.objects.detalles_reserva(id=reserva_id)
alojamiento = Alojamiento.objects.detalles_alojamiento(
id_alojamiento=reserva.servicio.alojamiento.id)
context = {
'alojamiento': alojamiento,
'reserva': reserva,
'reservas_habitaciones': reserva.reserva_habitacion_set.all(),
}
context.update(custom_context(request))
return render(request,
'emails/plantillas/reserva_alojamiento_por_habitacion.html',
context)
def datos_prueba(request):
# Todos los usuarios registrados en el sistema (Se obtiene más información con el Object Manager)
usuarios = Usuario.objects.detalles_usuarios()
# Objeto Usuario del Administrador que está accediendo a la vista. Se utilizará para comparar con los demás usuarios en el template
# y así poder diferenciar algunos comportamientos y opciones disponibles
myself = Usuario.objects.get(user__id=request.user.id)
context = {
'usuarios': usuarios,
'myself': myself,
}
context.update(custom_context(request))
return render(request, 'administracion/datos_prueba.html', context)
def destino(request, destino_id):
# Se identifica el destino que se ha seleccionado por el usuario
destino = Destino.objects.get(id=destino_id)
# Se obtiene un alista de Destinos Populares
destinos_populares = Destino.get_destinos_populares()[:4]
# Se obtiene una lista de alojamientos cerca del destino
alojamientos_cercanos = destino.get_alojamientos_cercanos()[:4]
context = {
'destino': destino,
'destinos_populares': destinos_populares,
'alojamientos_cercanos': alojamientos_cercanos,
}
context.update(custom_context(request))
return render(request, 'website/destino.html', context)
def search(request, elemento):
if request.method == 'POST':
if 'flight' in request.POST:
aeropuerto_salida = request.POST['aeropuerto_salida'].split(' ')[0]
aeropuerto_cuba = Aeropuerto.objects.get(
id=request.POST['aeropuerto_cuba']).codigo_iata
fecha_ida = request.POST['start'].split('-')
fecha_ida = '%s/%s/%s' % (fecha_ida[2], fecha_ida[1], fecha_ida[0])
fecha_regreso = request.POST['end'].split('-')
fecha_regreso = '%s/%s/%s' % (fecha_regreso[2], fecha_regreso[1],
fecha_regreso[0])
adultos = request.POST['adultos']
ninnos = request.POST['ninnos']
bebes = request.POST['bebes']
onlinetravel_url = 'http://booking.ontraveline.com/air/index.php?goal=direct_search&action=listAvailableAirports&search=true' \
'&airsearchhtmlformview_incluir_vuelos=true&airsearchhtmlformview_lowcost=true' \
'&airsearchhtmlformview_vuelos_regulares=true&language_code=es&airsearchhtmlformview_flight_type=roundtrip' \
'&s_0_airsearchhtmlformview_airsearchflighthtmlformview_from=%s' \
'&s_0_airsearchhtmlformview_airsearchflighthtmlformview_to=%s' \
'&s_0_airsearchhtmlformview_airsearchflighthtmlformview_depart_date=%s' \
'&s_1_airsearchhtmlformview_airsearchflighthtmlformview_depart_date=%s' \
'&airsearchhtmlformview_adults=%s' \
'&airsearchhtmlformview_children=%s' \
'&airsearchhtmlformview_babies=%s' \
'&airsearchhtmlformview_residente=false' %(aeropuerto_salida, aeropuerto_cuba, fecha_ida, fecha_regreso, adultos, ninnos, bebes)
request.session['onlinetravel_url'] = onlinetravel_url
# return redirect('website:search', 'flights')
else:
return redirect('website:index')
else:
return redirect('website:index')
if elemento == 'flights':
context = {'elemento': 'vuelos'}
context.update(custom_context(request))
return render(request, 'website/loading.html', context)
def contacto(request):
if request.method == 'POST':
form = Contacto_Form(request.POST)
if form.is_valid():
nombre = form.cleaned_data['nombre']
email = form.cleaned_data['email']
message = form.cleaned_data['message']
n_mensaje = Mensaje_Contacto.nuevo_mensaje_contacto(
nombre=nombre,
email=email,
message=message,
)
if n_mensaje:
context = {
'form': Contacto_Form(),
'message':
'Gracias por ponerse en contacto con nosotros. En breve le responderemos a la dirección de correo que nos ha indicado',
'class_alert': 'alert alert-success',
}
else:
context = {
'form': Contacto_Form(request.POST),
'message':
'No ha sido posible procesar su solicitud en este momento, inténtelo más tarde por favor.',
'class_alert': 'alert alert-danger',
}
else:
context = {
'form': Contacto_Form(request.POST),
'message':
'Hay errores en el formulario, por favor revise los datos introducidos',
'class_alert': 'alert alert-danger',
}
else:
context = {
'form': Contacto_Form(),
}
context['GMaps_APIKey'] = GMaps_APIKey
context.update(custom_context(request))
return render(request, 'website/contacto.html', context)
def reserva_confirmada(request, pago_id):
# Esta vista procesa la información del pago recibido de Paypal y la muestra en el template
pago = Pago.objects.get(id=pago_id)
reserva = Reserva.objects.detalles_reserva(id=pago.reserva.id)
servicio = reserva.servicio
if servicio.alojamiento:
# Se trata de un Alojamiento
alojamiento = Alojamiento.objects.detalles_alojamiento(
id_alojamiento=servicio.alojamiento.id)
context = {
'pago': pago,
'reserva': reserva,
'alojamiento': alojamiento,
}
context.update(custom_context(request))
# Lo próximo es ver si el Alojamiento se alquila completo o por habitaciones
if servicio.alojamiento.por_habitacion:
# Si el Alojamiento se alquila por habitaciones, añadimos la información de las reservas de habitaciones
context[
'reservas_habitaciones'] = reserva.reserva_habitacion_set.all(
),
# Se llama a una vista preparada para mostrar la confirmación del pago para reservas de Alojamientos por habitación
return render(
request,
'pagos/pago_exitoso_reserva_alojamiento_por_habitacion.html',
context)
else:
# Se llama a una vista preparada para mostrar la confirmación del pago para reservas de Alojamientos completos
return render(
request,
'pagos/pago_exitoso_reserva_alojamiento_completo.html',
context)
else:
# todo: Escenario de reservas de otros servicios que no sean alojamientos
pass
def buscar_destinos(request):
context = {}
context.update(custom_context(request))
return render(request, 'website/buscar_destinos.html', context)
def buscar_excursiones(request):
context = {}
context.update(custom_context(request))
return render(request, 'website/buscar_excursiones.html', context)
def buscar_alojamientos_completos(request):
# Por defecto se mostrarán todos los Alojamientos Completos que cumplan con las condiciones de indexado
# Estas condiciones son: que el servicio se encuentre activo
# 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_completos' in request.session:
lugar = request.session['criterio_alojamientos_completos']['lugar']
fecha_desde = request.session['criterio_alojamientos_completos'][
'fecha_desde']
fecha_hasta = request.session['criterio_alojamientos_completos'][
'fecha_hasta']
huespedes = request.session['criterio_alojamientos_completos'][
'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(
activos=True,
por_modalidad=True,
con_habitaciones=True,
por_habitacion=False,
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_completos' in request.session:
del request.session['criterio_alojamientos_completos']
form = Buscar_Alojamientos_Completos(request.POST)
if form.is_valid():
# Se aplican los filtros del Formulario
alojamientos = Alojamiento.objects.detalles_alojamientos(
activos=True,
por_modalidad=True,
con_habitaciones=True,
por_habitacion=False,
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'],
cantidad_habitaciones=form.
cleaned_data['cantidad_habitaciones'],
cocina=form.cleaned_data['cocina'],
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'],
lavadora=form.cleaned_data['lavadora'],
)
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'],
'lavadora':
alojamientos_agrupados_caracteristicas['lavadora'],
'cocina':
alojamientos_agrupados_caracteristicas['cocina'],
'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'],
}
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': [],
}
else:
context = {
'form':
Buscar_Alojamientos_Completos(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'],
'lavadora':
alojamientos_agrupados_caracteristicas['lavadora'],
'cocina':
alojamientos_agrupados_caracteristicas['cocina'],
'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'],
}
context.update(custom_context(request))
return render(request, 'website/buscar_alojamientos_completos.html',
context)
def politica_de_privacidad_de_datos(request):
context = {}
context.update(custom_context(request))
return render(request, 'website/politica_de_privacidad_de_datos.html',
context)
def perfil_usuario(request):
# Se determina el usuario para poder obtener sus servicios asociados
cstm_context = custom_context(request)
usuario = cstm_context['usuario']
fixed_message = None
message = None
fixed_class_alert = None
class_alert = None
allow_resend_verification_mail = False
# Si el usuario no ha verificado su email, debe mostrarse de manera permanente un aviso en su perfil
if not usuario.verificado_email:
fixed_message = 'Hemos enviado un email de confirmación a la cuenta que nos ha facilitado cuando se registró. Por favor siga las instrucciones en el mismo para verificar su email'
fixed_class_alert = 'alert alert-info'
allow_resend_verification_mail = True
if request.method == 'POST':
# Variante si se trata del formulario de los datos personales del usuario
if 'datos_personales' in request.POST:
datos_usuario_form = Datos_Usuario_Form(request.POST,
request.FILES)
if datos_usuario_form.is_valid():
# Definiendo si el usuario ha subido una foto en el formulario
if request.FILES:
foto = request.FILES['foto']
else:
foto = None
m_usuario = usuario.modificar_usuario(
nombre=datos_usuario_form.cleaned_data['nombre'],
apellidos=datos_usuario_form.cleaned_data['apellidos'],
email=datos_usuario_form.cleaned_data['email'],
movil=datos_usuario_form.cleaned_data['movil'],
pais=datos_usuario_form.cleaned_data['pais'],
direccion=datos_usuario_form.cleaned_data['direccion'],
provincia=datos_usuario_form.cleaned_data['provincia'],
ciudad=datos_usuario_form.cleaned_data['ciudad'],
codigo_postal=datos_usuario_form.
cleaned_data['codigo_postal'],
proveedor=datos_usuario_form.cleaned_data['proveedor'],
foto=foto,
)
context = {
'datos_usuario_form':
Datos_Usuario_Form(request.POST, request.FILES),
'password_form':
Cambiar_Password_Form(),
'message':
'Se han modificado correctamente sus datos del perfil',
'class_alert':
'alert alert-success',
'usuario':
usuario,
'fixed_message':
fixed_message,
'fixed_class_alert':
fixed_class_alert,
'allow_resend_verification_mail':
allow_resend_verification_mail,
}
else:
context = {
'datos_usuario_form':
Datos_Usuario_Form(request.POST, request.FILES),
'password_form':
Cambiar_Password_Form(),
'message':
'Hay errores en el Formulario',
'class_alert':
'alert alert-danger',
'usuario':
usuario,
'fixed_message':
fixed_message,
'fixed_class_alert':
fixed_class_alert,
'allow_resend_verification_mail':
allow_resend_verification_mail,
}
# Variante si se trata del formulari para cambiar la contraseña del usuario
elif 'contraseña' in request.POST:
# Se definen los datos que se mostrarán siempre en el formulario superior
datos_usuario = usuario.get_datos()
password_form = Cambiar_Password_Form(request.POST)
if password_form.is_valid():
# Se extraen los datos introducidos por el usuario
new_password = password_form.cleaned_data['new_password']
new_password_2 = password_form.cleaned_data['new_password_2']
old_password = password_form.cleaned_data['old_password']
# La primera comprobación es que el password actual introducido sea el correcto
if usuario.user.check_password(old_password):
# Si se supera esta prueba lo próximo es comprobar que los dos passwords nuevos coincidan
if new_password == new_password_2:
# Si son iguales entonces se procede a realizar el cambio de contraseña
usuario.user.set_password(new_password)
usuario.user.save()
# Autenticando al usuario de nuevo tras el cambio de password, para que no tenga que volver a iniciar su sesion
user = authenticate(username=datos_usuario['usuario'],
password=new_password)
login(request, user)
context = {
'datos_usuario_form':
Datos_Usuario_Form(datos_usuario),
'password_form':
Cambiar_Password_Form(),
'message':
'Se ha cambiado correctamente su contraseña',
'class_alert':
'alert alert-success',
'usuario':
usuario,
'fixed_message':
fixed_message,
'fixed_class_alert':
fixed_class_alert,
'allow_resend_verification_mail':
allow_resend_verification_mail,
}
else:
context = {
'datos_usuario_form':
Datos_Usuario_Form(datos_usuario),
'password_form':
Cambiar_Password_Form(),
'message':
'Las dos nuevas contraseñas introducidas no coinciden',
'class_alert':
'alert alert-danger',
'usuario':
usuario,
'fixed_message':
fixed_message,
'fixed_class_alert':
fixed_class_alert,
'allow_resend_verification_mail':
allow_resend_verification_mail,
}
else:
context = {
'datos_usuario_form':
Datos_Usuario_Form(datos_usuario),
'password_form':
Cambiar_Password_Form(),
'message':
'Su contraseña Actual y la introducida no coinciden',
'class_alert':
'alert alert-danger',
'usuario':
usuario,
'fixed_message':
fixed_message,
'fixed_class_alert':
fixed_class_alert,
'allow_resend_verification_mail':
allow_resend_verification_mail,
}
else:
context = {
'datos_usuario_form':
Datos_Usuario_Form(datos_usuario),
'password_form':
Cambiar_Password_Form(),
'message':
'Hay valores incorrectos en el formulario',
'class_alert':
'alert alert-danger',
'usuario':
usuario,
'fixed_message':
fixed_message,
'fixed_class_alert':
fixed_class_alert,
'allow_resend_verification_mail':
allow_resend_verification_mail,
}
else:
context = {
'datos_usuario_form': Datos_Usuario_Form(usuario.get_datos()),
'password_form': Cambiar_Password_Form(),
'message':
'Ha habido un error al leer el origen de la petición POST por generada',
'class_alert': 'alert alert-danger',
'usuario': usuario,
'fixed_message': fixed_message,
'fixed_class_alert': fixed_class_alert,
'allow_resend_verification_mail':
allow_resend_verification_mail,
}
else:
# Se obtiene un diccionario con los datos del usuario para rellenar el Formulario
datos_usuario_form = Datos_Usuario_Form(usuario.get_datos())
context = {
'datos_usuario_form': datos_usuario_form,
'password_form': Cambiar_Password_Form(),
'message': message,
'class_alert': class_alert,
'usuario': usuario,
'fixed_message': fixed_message,
'fixed_class_alert': fixed_class_alert,
'allow_resend_verification_mail': allow_resend_verification_mail,
}
context.update(custom_context(request))
return render(request, 'usuarios/perfil_usuario.html', context)
def transaccion_error(request):
context = {}
context.update(custom_context(request))
return render(request, 'pagos/pago_erroneo.html', context)
def login_view(request):
if request.user.is_authenticated():
return redirect('website:index')
if request.method == 'POST':
# Caso en que el POST venga del formulario de Login de usuario
if 'login' in request.POST: # Esto debe aparecer en el name del submit
login_form = Login_Form(request.POST)
register_form = Registro_Usuario()
if login_form.is_valid():
username = login_form.cleaned_data['username']
password = login_form.cleaned_data['password']
# Comprueba que existe un usuario con ese username o con ese email
if User.objects.filter(username=username):
user = authenticate(username=username, password=password)
elif User.objects.filter(email=username):
usuario = User.objects.get(email=username)
user = authenticate(username=usuario.username,
password=password)
else:
# Si no existe ningún usuario registrado con un username o un email igual al valor pasado por el usuario, user = None
user = None
# Realiza las acciones correspondientes si se ha encontrado un usuario con las credenciales adquiridas
if user:
# Comprueba que el usuario no está desactivado
if user.is_active:
# Realiza el login del usuario
login(request, user)
# Redirecciona a la página que se desee
return redirect('/index/')
else:
class_alert = 'alert alert-danger'
message = 'Este usuario se encuentra inactivo'
login_form = Login_Form(request.POST)
else:
class_alert = 'alert alert-danger'
message = 'El usuario o password introducido es incorrecto'
login_form = Login_Form(request.POST)
else:
class_alert = 'alert alert-danger'
message = 'Hay errores en el formulario'
login_form = Login_Form(request.POST)
# Caso en que el POST venga del formulario de Registro de nuevo usuario
elif 'register' in request.POST: # Esto debe aparecer en el name del submit
register_form = Registro_Usuario(request.POST)
login_form = Login_Form()
if register_form.is_valid():
username = register_form.cleaned_data['username']
email = register_form.cleaned_data['email']
password = register_form.cleaned_data['password']
password2 = register_form.cleaned_data['password2']
# Comprueba que el username no exista en la BD
if register_form.check_username(username):
# Comprueba que el email no exista en la BD
if register_form.check_email(email):
# Comprueba que los dos passwords introducidos coinciden
if register_form.check_password(password, password2):
# Crea el nuevo usuario
user_model = User.objects.create(
username=username,
email=email,
)
# Se le asigna el password
user_model.set_password(password)
user_model.save()
# Intentamos determinar el País a partir de la IP para añadir el dato en la creación del Usuario
pais, provincia = None, None
if 'user_data' in request.session:
user_data = request.session['user_data']
if 'country_code' in user_data:
country_code = user_data['country_code']
if Pais.objects.filter(
codigo_iso_alfa2__exact=country_code
):
pais = Pais.objects.get(
codigo_iso_alfa2=country_code)
else:
pais = None
if 'region_name' in user_data:
provincia_name = user_data['region_name']
provincia = Provincia.get_provincia_from_name(
provincia_name)
# Crea el objeto Usuario asociado al Usuario creado.
n_usuario = Usuario.nuevo_usuario(
user=user_model,
raw_password=password,
pais=pais,
provincia=provincia,
)
# Se envía el email con el link de Activación del Usuario
# 1 - Se crea el Email de Registro de Usuario
Email.enviar_correo_registro_usuario(
n_usuario, request.get_host())
# Se define el mensaje a mostrar en la página
# TODO: Definir mensaje a mostrar en el Index que indique al usuario que se ha creado la cuenta y que se ha enviado un mail para su validación
# Realiza el login del usuario
# login(request, user_model)
# Se definen los parámetros a pasar en el template
context = {
'login_form': Login_Form(),
'register_form': Registro_Usuario(),
}
# Se añade el mensaje de acción exitosa
context['class_alert'] = 'alert alert-success'
context[
'message'] = 'Hemos enviado un email con un enlcace de confirmación a la dirección que nos ha indicado. Por favor, siga las instrucciones para poder validar su cuenta'
# Se renderiza el template con la información correspondiente
context.update(custom_context(request))
return render(request, 'usuarios/login.html',
context)
else:
class_alert = 'alert alert-danger'
message = 'Las contraseñas no coinciden'
register_form = Registro_Usuario(request.POST)
else:
class_alert = 'alert alert-danger'
message = 'Ya existe un usuario registrado con este E-Mail'
register_form = Registro_Usuario(request.POST)
else:
class_alert = 'alert alert-danger'
message = 'Ya existe un usuario registrado con este username(%s)' % (
username)
register_form = Registro_Usuario(request.POST)
else:
class_alert = 'alert alert-danger'
message = 'El formulario de registro contiene errores'
register_form = Registro_Usuario(request.POST)
else:
print(
'Se ha recibido un POST que no viene ni de Login ni de Registro'
)
class_alert = None
message = None
login_form = Login_Form()
register_form = Registro_Usuario()
else:
class_alert = None
message = None
login_form = Login_Form()
register_form = Registro_Usuario()
# Se definen los parámetros a pasar en el template
context = {
'login_form': login_form,
'register_form': register_form,
}
# Se añade un mensaje si es necesario
if class_alert and message:
context['class_alert'] = class_alert
context['message'] = message
# Se renderiza el template con la información correspondiente
context.update(custom_context(request))
return render(request, 'usuarios/login.html', context)
def sobre_nosotros(request):
context = {}
context.update(custom_context(request))
return render(request, 'website/sobre_nosotros.html', context)
def servicios(request):
context = {}
context.update(custom_context(request))
return render(request, 'website/servicios.html', context)
def blog(request, categoria_id = None, post_id = None):
posts = Post.objects.order_by('fecha_post')
post, categoria = None, None
# Validamos el escenario de búsqueda a través del buscador del blog
if request.method == 'POST':
form = Blog_Form(request.POST)
if form.is_valid():
# Obtenemos el criterio de búsqueda del usuario
buscar = form.cleaned_data['search']
# Obtenemos una de los Posts que responden al criterio de búsqueda
posts = Post.objects.filter(titulo__contains = buscar)
else:
form = Blog_Form()
if post_id:
posts = posts.filter(id = post_id)
post = posts[0]
if categoria_id:
categoria = Categoria.objects.get(id = categoria_id)
p = []
for i in posts:
if categoria in i.categorias.all():
p.append(i)
posts = p
# Categorías
categorias = Categoria.objects.order_by('nombre')
# Posts populares
posts_populares = Post.get_posts_populares(cantidad = 4)
# Últimos comentarios
ultimos_comentarios = Comentario_Post.get_ultimos_comentarios(cantidad = 4)
# Meses para otras publicaciones
today = datetime.date.today()
month = today.month
year = today.year
fechas_otras_publicaciones = []
for i in range(10):
if month > 1:
month -= 1
else:
year -= 1
month = 12
if Post.get_posts_mes(year, month):
fechas_otras_publicaciones.append([year, month])
# Galería del Blog
if Galeria_Blog.objects.filter(en_uso = True):
galeria_blog = Galeria_Blog.objects.get(en_uso = True)
else:
galeria_blog = []
context = {
'posts': posts,
'categorias': categorias,
'posts_populares': posts_populares,
'ultimos_comentarios': ultimos_comentarios,
'fechas_otras_publicaciones': fechas_otras_publicaciones,
'galeria_blog': galeria_blog,
'post_': post,
'categoria_': categoria,
'form': form,
}
context.update(custom_context(request))
return render(request, 'blog/index.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 recovery_password(request, code):
codigo_recovery_password = Codigo_Recovery_Password.objects.filter(
codigo=code)
if codigo_recovery_password:
codigo_recovery_password = Codigo_Recovery_Password.objects.get(
codigo=code)
if request.method == 'POST':
form = Recovery_Password_Form(request.POST)
if form.is_valid():
new_password = form.cleaned_data['new_password']
new_password_2 = form.cleaned_data['new_password_2']
if new_password == new_password_2:
# Si las dos contraseñas indicadas por el usuario coinciden se realiza el cambio de contraseña
codigo_recovery_password.usuario.change_password(
new_password)
# Se actualiza el Código para que no pueda volver a ser reutilizado
codigo_recovery_password.valido = False
codigo_recovery_password.save()
message = 'Se ha modificado correctamente su Contraseña'
class_alert = 'alert alert-success'
form = Recovery_Password_Form()
else:
message = 'Las contraseñas deben coincidir. Por favor inténtelo de nuevo'
class_alert = 'alert alert-danger'
form = Recovery_Password_Form()
else:
message = 'Hay errores en el formulario'
class_alert = 'alert alert-danger'
form = Recovery_Password_Form(request.POST)
context = {
'form': form,
'message': message,
'class_alert': class_alert,
}
else:
form = Recovery_Password_Form()
context = {
'form': form,
'message': None,
'class_alert': None,
}
context.update(custom_context(request))
return render(request, 'usuarios/recovery_password.html', context)
else:
message = 'Ups! parece que el link que has seguido ya no es válido. Por favor, vuelve a solicitar un enlace para recuperar tu contraseña en la página de Ingreso'
context = {
'message': message,
'class_alert': 'alert alert-danger',
}
context.update(custom_context(request))
return render(request, 'usuarios/error_recovery_password.html',
context)
def blog(request):
context = {}
context.update(custom_context(request))
return render(request, 'website/blog.html', context)
def pruebas_html(request):
context = {}
context.update(custom_context(request))
return render(request, 'website/pruebas_html.html', context)
def terminos_de_uso(request):
context = {}
context.update(custom_context(request))
return render(request, 'website/terminos_de_uso.html', context)
def condiciones_legales(request):
context = {}
context.update(custom_context(request))
return render(request, 'website/condiciones_legales.html', context)
def centro_verificacion_datos(request):
# Definición del usuario y de los formularios para los posibles escenarios de Validación previstos
usuario = Usuario.objects.detalles_usuario(usuario=Usuario.objects.get(
user=request.user))
form_movil = Verificar_Movil()
form_identidad = Verificar_Identidad()
form_actividad = Verificar_Actividad()
# Conectores a redes sociales
twitter_conector = usuario.get_conector_twitter()
if request.method == 'POST':
# Escenario de Verificación del número móvil del usuario
if 'verificar_movil' in request.POST:
form_movil = Verificar_Movil(request.POST)
if form_movil.is_valid():
codigo_verificacion = form_movil.cleaned_data[
'codigo_verificacion']
if Codigo_Verificacion.validate_codigo_usuario(
codigo_verificacion, usuario):
usuario.verificar_movil()
message = 'Se ha verificado correctamente el móvil %s %s' % (
usuario.pais.prefijo_movil, usuario.movil)
class_alert = 'alert alert-success'
else:
message = 'El código es incorrecto, vuelve a intentarlo nuevamente'
class_alert = 'alert alert-danger'
else:
message = 'Hay errores en el formulario'
class_alert = 'alert alert-danger'
# Escenario de Verificación de Documentos de Permiso de Actividad del Proveedor
elif 'verificar_actividad' in request.POST:
form_actividad = Verificar_Actividad(request.POST)
if form_actividad.is_valid():
# Definiendo si el usuario ha subido una foto en el formulario
if request.FILES:
foto = request.FILES['foto']
n_foto_licencia_actividad = Foto_Licencia_Actividad.nueva_foto_licencia_actividad(
foto=foto,
usuario=usuario,
)
message = 'Se ha enviado correctamente el documento para su revisión. Por favor, deje pasar hasta 48 horas para su validación'
class_alert = 'alert alert-success'
else:
message = 'Debe seleccionar un Documento primero para poder enviarlo'
class_alert = 'alert alert-danger'
else:
message = 'Hay errores en el Formulario'
class_alert = 'alert alert-danger'
else:
message = None
class_alert = None
else:
message = None
class_alert = None
context = {
'usuario': usuario,
'form_movil': form_movil,
'form_identidad': form_identidad,
'form_actividad': form_actividad,
'message': message,
'class_alert': class_alert,
'confirmaciones_agotadas': usuario.
confirmaciones_agotadas, # Determina si el usuario puede seguir solicitando confirmar su móvil
}
context.update(custom_context(request))
return render(request, 'usuarios/centro_verificacion_datos.html', context)
