Esempio n. 1
0
    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
Esempio n. 2
0
 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
Esempio n. 3
0
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)
Esempio n. 4
0
    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})
Esempio n. 5
0
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)
Esempio n. 6
0
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})
Esempio n. 7
0
 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}
Esempio n. 9
0
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)
Esempio n. 10
0
 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
Esempio n. 11
0
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)
Esempio n. 12
0
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)
Esempio n. 13
0
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"))
Esempio n. 14
0
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')
Esempio n. 15
0
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))
Esempio n. 16
0
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()
Esempio n. 17
0
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))
Esempio n. 18
0
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)