def comentar_perfil(request, username):
"""
guarda un comentario en el grupo, redirige al main del grupo
"""
if request.method == "POST":
comentario = bleach.clean(request.POST.get("comentario", ""))
if comentario:
perfil_muro = Perfil.objects.get(usuario__username=username)
perfil_comenta = obtener_perfil(request.user)
# Crear comment
CommentPerfil.objects.create(muro=perfil_muro, perfil=perfil_comenta, texto=comentario)
if perfil_muro == perfil_comenta:
# Esta comentando en su propio muro, redirigir allá
return redirect('perfiles:perfil_propio')
else:
return redirect('perfiles:perfil_usuario', username=username)
else:
return HttpResponse(status=400)
else:
return HttpResponse(status=400)
def editar_perfil(request):
"""
Procesa el view y el form para que el usuario edite su perfil
"""
template = "perfiles/editar_perfil.html"
perfil = obtener_perfil(request.user)
avatar = obtener_avatar_large(perfil)
if request.method == "POST":
form = FormEditarPerfil(request.POST, instance=perfil)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('perfiles:perfil_propio'))
else:
if perfil.ciudad:
ciudad_default = perfil.ciudad
else:
ciudad_default = obtenerquito()
form = FormEditarPerfil(
initial={
'descripcion': perfil.descripcion,
'ciudad': ciudad_default,
'numero_telefono_contacto': perfil.numero_telefono_contacto
})
context = {'form': form, 'avatar': avatar}
return render(request, template, context)
def comment_notificacion_ajax(request):
if request.is_ajax():
if request.method == "POST":
id_notificacion = int(request.POST.get("id_notificacion", ""))
texto_comment = bleach.clean(request.POST.get("texto_comment", ""))
notificacion = Notificacion.objects.get(id=id_notificacion)
if texto_comment:
perfil = obtener_perfil(request.user)
# Crear objeto CommentNotificacion
r = CommentNotificacion.objects.create(perfil=perfil, notificacion=notificacion, texto=texto_comment)
respuesta = json.dumps([r.id, r.texto, r.perfil.usuario.username, r.perfil.imagen_perfil])
return HttpResponse(respuesta, status=201)
else:
return HttpResponse(status=400)
else:
return HttpResponse(status=400)
else:
return HttpResponse(status=400)
def termino_leer_ajax(request):
if request.is_ajax():
libro_leido_id = request.POST.get('libro_leido_id', '')
if not libro_leido_id:
return HttpResponse("No recibio libro id", status=400)
libro_leyendo = UsuarioLeyendo.objects.get(id=libro_leido_id)
if libro_leyendo.termino is None:
libro_leyendo.termino = datetime.today()
libro_leyendo.save()
perfil = obtener_perfil(request.user)
# notificacion termino leer libro
Notificacion.objects.termino_leer(perfil, libro_leyendo.libro)
# notificaciones para cada grupo
notif_grupos_termino_leer(perfil, libro_leyendo.libro)
return HttpResponse(status=201)
else:
return HttpResponse("Ya había terminado ese libro", status=200)
else:
return HttpResponse(status=400)
def crear_grupo(request):
template = "grupos/crear_grupo.html"
if request.method == "POST":
form = FormCrearGrupo(request.POST)
if form.is_valid():
# Sumar un tipo al grupo (Abierto, Cerrado, Todos puede añadir, Admins pueden añadir)
tipo_grupo = form.obtener_tipo()
nuevo_grupo = form.save(commit=False)
nuevo_grupo.tipo = tipo_grupo
# Situar el grupo en una ciudad si es necesario
situar_ciudad = form.cleaned_data['situar_ciudad']
perfil_admin = obtener_perfil(request.user)
if situar_ciudad:
nuevo_grupo.ciudad = perfil_admin.ciudad
nuevo_grupo.save()
# Crear usuario administrador
usuario_admin = UsuariosGrupo(perfil=perfil_admin, grupo=nuevo_grupo, es_admin=True)
usuario_admin.save()
return redirect('grupos:main_grupo', id_grupo=nuevo_grupo.id)
else:
form = FormCrearGrupo()
context = {'form': form}
return render(request, template, context)
def responder_comment_bcompartida_ajax(request):
"""
Guarda un objeto RespuestaCommentBCompartida con FK al comment_perfil respondido
"""
if request.is_ajax():
if request.method == "POST":
comentario_id = int(request.POST.get("comment_id", ""))
texto_respuesta_base = request.POST.get("texto_respuesta", "")
if texto_respuesta_base:
comment_obj = CommentBCompartida.objects.get(id=comentario_id)
perfil_usuario = obtener_perfil(request.user)
texto_respuesta = bleach.clean(texto_respuesta_base)
# Crear objeto respuesta
r = RespuestaCommentBCompartida.objects.create(comment_bcompartida=comment_obj, perfil=perfil_usuario, texto=texto_respuesta)
respuesta = json.dumps([r.id, r.texto, r.perfil.usuario.username, r.perfil.imagen_perfil])
return HttpResponse(respuesta, status=201)
else:
return HttpResponse(status=400)
else:
return HttpResponse(status=400)
else:
return HttpResponse(status=400)
def redirigir_login(request):
perfil = obtener_perfil(request.user)
if AdminsBibliotecaCompartida.objects.filter(perfil=perfil).exists():
admin_bcompartida_obj = AdminsBibliotecaCompartida.objects.filter(
perfil=perfil).select_related('biblioteca_compartida').first()
bcompartida = admin_bcompartida_obj.biblioteca_compartida
return redirect('libros:biblioteca_compartida', slug_biblioteca_compartida=bcompartida.slug)
else:
return redirect('libros:libros_ciudad', slug_ciudad=perfil.ciudad.slug, id_ciudad=perfil.ciudad.id)
def libros_usuario_ajax(request):
"""
Crea un UsuarioLeyendo object y señala la fecha actual como inicio
"""
if request.is_ajax():
perfil = obtener_perfil(request.user)
titulos_autocomplete, autores_autocomplete = obtener_libros_perfil(perfil)
context = {'titulos_autocomplete': json.dumps(titulos_autocomplete),
'autores_autocomplete': json.dumps(autores_autocomplete)}
return HttpResponse(context, status=200)
else:
return HttpResponse(status=400)
def login_admin_bcompartida(request):
template = "perfiles/login_admin_bcompartida.html"
if request.method == "POST":
form = LoginAdminBcompartida(request.POST)
# Bibliotecas compartidas obtenidas de Quito
bibliotecas_compartidas = BibliotecaCompartida.objects.filter(ciudad__id=18)
form.fields["biblioteca_compartida"].queryset = bibliotecas_compartidas
if form.is_valid():
bcompartida = form.cleaned_data['biblioteca_compartida']
password = form.cleaned_data['password']
n_usuario = form.cleaned_data['nombre_usuario']
if User.objects.filter(username=n_usuario).exists():
usuario = User.objects.get(username=n_usuario)
perfil_admin = obtener_perfil(usuario)
if AdminsBibliotecaCompartida.objects.filter(biblioteca_compartida=bcompartida,
perfil=perfil_admin).exists():
usuario_auth = authenticate(username=perfil_admin.usuario.username, password=password)
if usuario_auth is not None:
if usuario.is_active:
login(request, usuario_auth)
# Redirige al admin logeado a la pagina de su biblioteca compartida
return redirect('libros:biblioteca_compartida',
slug_biblioteca_compartida=bcompartida.slug)
else:
form.add_error(None, "Usuario inactivo")
else:
form.add_error(None, "Nombre de usuario o contraseña incorrecta")
else:
form.add_error(None, "No existe un administrador de esa biblioteca compartida con ese nombre")
else:
form.add_error("nombre_usuario", "Nombre de usuario incorrecto")
else:
form = LoginAdminBcompartida()
# Bibliotecas compartidas obtenidas de Quito
bibliotecas_compartidas = BibliotecaCompartida.objects.filter(ciudad__id=18)
form.fields["biblioteca_compartida"].queryset = bibliotecas_compartidas
context = {'form': form}
return render(request, template, context)
def invitar_ajax(request):
if request.is_ajax():
grupo_id = request.POST.get("grupo_id", "")
invitaciones = json.loads(request.POST.get("invitaciones", ""))
if grupo_id and invitaciones:
grupo = Grupo.objects.get(id=grupo_id)
invitado_por = obtener_perfil(request.user)
for invitacion in invitaciones:
usuario_invitado = Perfil.objects.get(usuario__username=invitacion['nombre_usuario'])
# Si el usuario ya es miembro del grupo
if UsuariosGrupo.objects.filter(perfil=usuario_invitado, grupo=grupo).exists():
pass
# Si cualquier persona puede sumar miembros al grupo
elif grupo.tipo == 1 or grupo.tipo == 3:
RequestInvitacion.objects.create(grupo=grupo, usuario_invitado=usuario_invitado,
invitado_por=invitado_por,
aceptado_por=invitado_por,
aceptado=True) # crea un objecto de RequestInvitacion con aceptado True
UsuariosGrupo.objects.create(perfil=usuario_invitado, grupo=grupo) # Crea un UsuariosGrupo object
# Si el usuario que invita es admin del grupo
elif UsuariosGrupo.objects.filter(perfil=invitado_por, grupo=grupo, es_admin=True,
activo=True).exists():
RequestInvitacion.objects.create(grupo=grupo, usuario_invitado=usuario_invitado,
invitado_por=invitado_por,
aceptado_por=invitado_por,
aceptado=True) # crea un objecto de RequestInvitacion con aceptado True
UsuariosGrupo.objects.create(perfil=usuario_invitado, grupo=grupo) # Crea un UsuariosGrupo object
else:
# No es abierto ni es admin, crear RequestInvitacion sin aceptado=True
RequestInvitacion.objects.create(grupo=grupo, usuario_invitado=usuario_invitado,
invitado_por=invitado_por)
return HttpResponse("Invitaciones Creadas", status=201)
else:
return HttpResponse("No encontro los args", status=400)
else:
return HttpResponse("No Ajax", status=403)
def perfil_propio(request):
"""
Muestra el perfil del usuario que está hecho login enfocado en la actividad
"""
template = "perfiles/perfil_propio.html"
perfil = obtener_perfil(request.user)
avatar = obtener_avatar_large(perfil)
# Grupos Perfil
grupos = None
if UsuariosGrupo.objects.filter(perfil=perfil, activo=True).exists():
usuarios_grupo_obj = UsuariosGrupo.objects.filter(perfil=perfil, activo=True).select_related('grupo')
grupos = [ug.grupo for ug in usuarios_grupo_obj]
# Usuario Leyendo
actualmente_leyendo, libros_leidos_usuario = obtener_usuario_leyendo(perfil)
libros_disponibles = LibrosDisponibles.objects.filter(perfil=perfil).select_related('libro')
# autocomplete Usuario Leyendo
titulos_autocomplete = {}
autores_autocomplete = {}
for l in libros_disponibles:
titulos_autocomplete[l.libro.titulo] = (l.libro.id, l.libro.autor)
# Muro, comentarios y actividades
actividad = []
actividad_0 = obtener_muro_perfil(perfil)
for act in actividad_0:
if act.__class__.__name__ == "CommentPerfil":
actividad.append((act, "comment"))
else:
actividad.append((act, "notificacion"))
for l in libros_disponibles:
autores_autocomplete[l.libro.autor] = l.libro.id
# Si es admin de una biblioteca, poner link a la biblioteca
bibliotecas_compartidas = None
context = {'avatar': avatar, 'grupos': grupos, 'actualmente_leyendo': actualmente_leyendo,
'libros_leidos_usuario': libros_leidos_usuario, 'titulos_autocomplete': json.dumps(titulos_autocomplete),
'autores_autocomplete': json.dumps(autores_autocomplete), 'actividad': actividad,
'bibliotecas_compartidas': bibliotecas_compartidas}
return render(request, template, context)
def editar_info_personal(request):
"""
Permite editar info que esta en User object, incluido cambiar clave
"""
template = "perfiles/editar_info_personal.html"
usuario_editar = request.user
print "metodo actual: %s" % request.method
if request.method == "POST":
form = FormEditarInfoPersonal(usuario_editar, request.POST)
if form.is_valid():
form.save() # Cambia la contraseña
email = form.cleaned_data['email']
usuario_editar.email = email
usuario_editar.save()
print request.user
# render html con mensaje temporal
perfil = obtener_perfil(usuario_editar)
admin_bcompartida = AdminsBibliotecaCompartida.objects.filter(perfil=perfil, activo=True).select_related(
'biblioteca_compartida').first()
razon_mensaje = 'cambio_contrasena'
template = "perfiles/mensaje_temporal.html"
url_redirigir = reverse('libros:biblioteca_compartida',
kwargs={'slug_biblioteca_compartida': admin_bcompartida.biblioteca_compartida.slug})
context = {'razon_mensaje': razon_mensaje, 'admin_bcompartida': admin_bcompartida,
'url_redirigir': url_redirigir}
return render(request, template, context)
else:
form = FormEditarInfoPersonal(usuario_editar, initial={'email': usuario_editar.email})
context = {'form': form}
return render(request, template, context)
def comentar_bcompartida(request, slug_biblioteca_compartida):
"""
guarda un comentario en el grupo, redirige al main del grupo
"""
if request.method == "POST":
comentario = bleach.clean(request.POST.get("comentario", ""))
if comentario:
bcompartida = BibliotecaCompartida.objects.get(slug=slug_biblioteca_compartida)
perfil_usuario = obtener_perfil(request.user)
# Crear comment
CommentBCompartida.objects.create(bcompartida=bcompartida, perfil=perfil_usuario, texto=comentario)
return redirect('libros:biblioteca_compartida', slug_biblioteca_compartida=bcompartida.slug)
else:
return HttpResponse(status=400)
def comentar_grupo(request, id_grupo):
"""
guarda un comentario en el grupo, redirige al main del grupo
"""
if request.method == "POST":
comentario = bleach.clean(request.POST.get("comentario", ""))
if comentario:
grupo = Grupo.objects.get(id=id_grupo)
perfil_usuario = obtener_perfil(request.user)
# Crear comment
CommentGrupo.objects.create(grupo=grupo, perfil=perfil_usuario, texto=comentario)
return redirect('grupos:main_grupo_actividad', id_grupo=grupo.id)
else:
return HttpResponse(status=400)
def editar_grupo(request, id_grupo):
template = "grupos/editar_grupo.html"
grupo = get_object_or_404(Grupo, id=id_grupo)
if request.method == "POST":
form = FormCrearGrupo(request.POST, instance=grupo)
if form.is_valid():
# Sumar un tipo al grupo (Abierto, Cerrado, Todos puede añadir, Admins pueden añadir)
tipo_grupo = form.obtener_tipo()
grupo_editado = form.save(commit=False)
grupo_editado.tipo = tipo_grupo
# Situar el grupo en una ciudad si es necesario
situar_ciudad = form.cleaned_data['situar_ciudad']
perfil_admin = obtener_perfil(request.user)
if situar_ciudad:
grupo_editado.ciudad = perfil_admin.ciudad
# Guardar cambios
grupo_editado.save()
return redirect('grupos:main_grupo', id_grupo=grupo.id)
else:
if grupo.ciudad is not None:
form_situar_ciudad = True
form = FormCrearGrupo(initial={
'nombre': grupo.nombre,
'descripcion': grupo.descripcion,
'imagen': grupo.imagen,
'tipo_apertura': grupo.obtener_tipo_apertura(),
'tipo_invitaciones': grupo.obtener_tipo_invitaciones(),
'situar_ciudad': form_situar_ciudad
})
context = {'form': form, 'grupo': grupo}
return render(request, template, context)
def main_grupo_actividad(request, id_grupo):
template = "grupos/main_grupo.html"
perfil_usuario = None
if request.user.is_authenticated():
perfil_usuario = obtener_perfil(request.user)
grupo = Grupo.objects.get(id=id_grupo)
usuario_es_miembro = False
if request.user.is_authenticated():
usuario_es_miembro = UsuariosGrupo.objects.filter(perfil=perfil_usuario, grupo=grupo).exists()
usuarios_grupo_obj = UsuariosGrupo.objects.filter(grupo=grupo, activo=True).select_related('perfil')
miembros = [u_grupo for u_grupo in usuarios_grupo_obj]
# Invitar a un usuario al grupo
usuario_es_admin = False
request_invitacion_enviada = False
if request.user.is_authenticated():
if usuario_es_miembro:
# Si el usuario es miembro, revisar si es admin
if UsuariosGrupo.objects.filter(perfil=perfil_usuario, grupo=grupo, es_admin=True):
usuario_es_admin = True
else:
# Si el usuario no es miembro, revisar si ya envió solicitud
if RequestInvitacion.objects.filter(grupo=grupo, usuario_invitado=perfil_usuario, aceptado=False,
eliminado=False).exists():
request_invitacion_enviada = True
# Requests pendientes de aceptacion al grupo
requests_entrar_grupo = None
if usuario_es_miembro:
if grupo.tipo in [2, 4]:
# Si solo los admins pueden aceptar !!!
# Si el usuario es admin, mostrar los requests.
if usuario_es_admin:
requests_entrar_grupo = RequestInvitacion.objects.filter(grupo=grupo, aceptado=False, eliminado=False)
else:
requests_entrar_grupo = RequestInvitacion.objects.filter(grupo=grupo, aceptado=False, eliminado=False)
comentarios = CommentGrupo.objects.filter(grupo=grupo, eliminado=False).annotate(num_respuestas=Count("respuestas"))
notificaciones = Notificacion.objects.filter(grupo=grupo).annotate(num_respuestas=Count("respuestas"))
actividad_0 = list(chain(comentarios, notificaciones))
actividad_0.sort(key=lambda x: x.fecha) # Ordena comentarios y notificaciones alternados por fecha.
actividad_0.reverse() # Ordena desde el más reciente.
actividad = []
for act in actividad_0:
if act.__class__.__name__ == "CommentGrupo":
actividad.append((act, "comment"))
else:
actividad.append((act, "notificacion"))
actualmente_leyendo, libros_leidos_usuario = obtener_usuario_leyendo(perfil_usuario)
context = {'grupo': grupo, 'miembros': miembros, 'requests_entrar_grupo': requests_entrar_grupo,
'usuario_es_admin': usuario_es_admin,
'usuario_es_miembro': usuario_es_miembro, 'request_invitacion_enviada': request_invitacion_enviada,
'actividad': actividad,
'actualmente_leyendo': actualmente_leyendo
}
return render(request, template, context)
def compartir_libro_grupo(request, id_grupo):
# No usa un Django form. Utiliza client side validation y en el server utiliza bleach
template = "grupos/compartir_con_grupo.html"
grupo = Grupo.objects.get(id=id_grupo)
perfil_obj = obtener_perfil(request.user)
if request.method == "POST":
tipo = request.POST.get("tipo_libro", "")
if tipo == "existente":
# el form envia el id de un libro disponible existente
id_libro_disp = request.POST.get("libro_disp_id", "")
if LibrosDisponibles.objects.filter(id=int(id_libro_disp)).exists():
libro_disponible = LibrosDisponibles.objects.get(id=int(id_libro_disp))
else:
# !! Llamar a una función que cree un nuevo libro como si fuera c_nuevo
return HttpResponse(staus=400)
# revisa si existe un LibroDisponibleGrupo object con ese libro disponible y el grupo
if LibroDisponibleGrupo.objects.filter(grupo=grupo, libro_disponible=libro_disponible).exists():
libro_disponible_grupo_obj = LibroDisponibleGrupo.objects.get(grupo=grupo,
libro_disponible=libro_disponible)
if not libro_disponible_grupo_obj.activo:
libro_disponible_grupo_obj.activo = True
libro_disponible_grupo_obj.save()
# Crear notificacion libro compartido con grupo !! usar nueva funcion
Notificacion.objects.compartio_libro_grupo(perfil_obj, libro_disponible.libro, grupo)
return redirect('grupos:main_grupo_libros', id_grupo=grupo.id, queryset="titulo")
else:
return redirect('grupos:main_grupo_libros', id_grupo=grupo.id, queryset="titulo")
else:
LibroDisponibleGrupo.objects.create(grupo=grupo, libro_disponible=libro_disponible)
# Crear notificacion libro compartido con grupo !! usar nueva funcion
Notificacion.objects.compartio_libro_grupo(perfil_obj, libro_disponible.libro, grupo)
return redirect('grupos:main_grupo_libros', id_grupo=grupo.id, queryset="titulo")
elif tipo == "nuevo":
# el form envia el titulo y el autor para crear un nuevo libro
titulo = bleach.clean(request.POST.get("titulo", ""))
autor = bleach.clean(request.POST.get("autor", ""))
descripcion = bleach.clean(request.POST.get("descripcion", ""))
if titulo and autor:
# crea un nuevo libro
nuevo_libro = Libro.objects.create(titulo=titulo, autor=autor, descripcion=descripcion)
# crea un Libro Disponible object
libro_disponible_obj = LibrosDisponibles.objects.create(libro=nuevo_libro, perfil=perfil_obj,
abierto_comunidad=False,
ciudad=perfil_obj.ciudad)
# crea un LibroDisponibleGrupo object
LibroDisponibleGrupo.objects.create(libro_disponible=libro_disponible_obj, grupo=grupo)
# crear notificacion libro compartido con grupo
Notificacion.objects.compartio_libro_grupo(perfil_obj, libro_disponible_obj.libro, grupo)
return redirect('grupos:main_grupo_libros', id_grupo=grupo.id, queryset="titulo")
else:
return HttpResponse("Falta titulo o autor", status=400)
else:
return HttpResponse("Formulario mal llenado", status=400)
return HttpResponse("prueba form")
else:
titulos_autocomplete, autores_autocomplete = obtener_libros_perfil(perfil_obj)
context = {'grupo': grupo, 'titulos_autocomplete': json.dumps(titulos_autocomplete),
'autores_autocomplete': json.dumps(autores_autocomplete)}
return render(request, template, context)
def leyendo_libro_ajax(request):
"""
Recibe un libro id o un titulo y un autor. En el primer caso, crea un objeto UsuarioLeyendo, en el segundo,
crea un objeto Libro y luego un objeto UsuarioLeyendo
"""
if request.is_ajax():
libro_id = request.POST.get("libro_id", "")
titulo = request.POST.get("titulo", "")
autor = request.POST.get("autor", "")
perfil = obtener_perfil(request.user)
if not libro_id and (not titulo or not autor):
# Si envio valores vacíos
return HttpResponse(status=400)
if libro_id:
# Significa que el libro está en su biblioteca
libro = Libro.objects.get(id=int(libro_id))
# Revisar si el último UsuarioLeyendo object no es el mismo que declaro estar leyendo, para evitar repeticiones
ultimo_libro = UsuarioLeyendo.objects.filter(perfil=perfil).latest('inicio')
if ultimo_libro.libro.titulo == titulo:
return HttpResponse("es el mismo libro que ya está leyendo", status=400)
# Revisar si no borro el nombre y puso otro que no está en su biblioteca (nuevo)
# El autocomplete pudiera haber llenado el id del hidden input y luego se pudo haber quedado así,
# a pesar de que el usuario borro el nombre del autocomplete e insertó otro título.
if libro.titulo == titulo and libro.autor == autor:
UsuarioLeyendo.objects.create(perfil=perfil, libro=libro)
else:
if not titulo or not autor:
# Si envio valores vacíos
return HttpResponse(status=400)
# crear nuevo libro
libro = Libro.objects.create(titulo=titulo, autor=autor)
# crear objeto UsuarioLeyendo
UsuarioLeyendo.objects.create(libro=libro, perfil=perfil)
# crear notificaciones para cada grupo
Notificacion.objects.comenzo_leer(perfil, libro)
notif_grupos_comenzo_leer(perfil, libro)
else:
# Significa que el libro no está en su biblioteca
# Revisar si el último UsuarioLeyendo object no es el mismo que declaro estar leyendo, para evitar repeticiones
ultimo_libro = UsuarioLeyendo.objects.filter(perfil=perfil).latest('inicio')
if ultimo_libro.libro.titulo == titulo:
return HttpResponse("es el mismo libro que ya está leyendo", status=400)
# Revisar si no existe ya un libro con ese titulo, para evitar repeticiones
if Libro.objects.filter(titulo=titulo, autor=autor).exists():
# Puede darse errores en que get returns more than 1 object. asi que mejor usar last()
libro = Libro.objects.filter(titulo=titulo, autor=autor).last()
else:
# crear nuevo libro
libro = Libro.objects.create(titulo=titulo, autor=autor)
# crear objeto LibroDisponible, suma libro a su biblioteca, solo si no existe ya en la biblioteca
if not LibrosDisponibles.objects.filter(libro=libro, perfil=perfil).exists():
LibrosDisponibles.objects.create(libro=libro, perfil=perfil, disponible=False, ciudad=perfil.ciudad)
# crear objeto UsuarioLeyendo
UsuarioLeyendo.objects.create(libro=libro, perfil=perfil)
# crear notificaciones para cada grupo
Notificacion.objects.comenzo_leer(perfil, libro)
notif_grupos_comenzo_leer(perfil, libro)
return HttpResponse(status=200)
else:
return HttpResponse(status=400)
def main_grupo_libros(request, id_grupo, queryset):
template = "grupos/main_grupo.html"
grupo = Grupo.objects.get(id=id_grupo)
perfil_usuario = None
if request.user.is_authenticated():
perfil_usuario = obtener_perfil(request.user)
usuario_es_miembro = False
if request.user.is_authenticated():
usuario_es_miembro = UsuariosGrupo.objects.filter(perfil=perfil_usuario, grupo=grupo).exists()
usuarios_grupo_obj = UsuariosGrupo.objects.filter(grupo=grupo, activo=True).select_related('perfil')
miembros = [usuario_grupo_obj for usuario_grupo_obj in usuarios_grupo_obj]
# Invitar a un usuario al grupo
usuario_es_admin = False
request_invitacion_enviada = False
if request.user.is_authenticated():
if usuario_es_miembro:
# Si el usuario es miembro, revisar si es admin
if UsuariosGrupo.objects.filter(perfil=perfil_usuario, grupo=grupo, es_admin=True).exists():
usuario_es_admin = True
else:
# Si el usuario no es miembro, revisar si ya envió solicitud
if RequestInvitacion.objects.filter(grupo=grupo, usuario_invitado=perfil_usuario, aceptado=False,
eliminado=False).exists():
request_invitacion_enviada = True
# Requests pendientes de aceptacion al grupo
requests_entrar_grupo = None
if usuario_es_miembro:
if grupo.tipo in [2, 4]:
# Si solo los admins pueden aceptar !!!
# Si el usuario es admin, mostrar los requests.
if usuario_es_admin:
requests_entrar_grupo = RequestInvitacion.objects.filter(grupo=grupo, aceptado=False, eliminado=False)
else:
requests_entrar_grupo = RequestInvitacion.objects.filter(grupo=grupo, aceptado=False, eliminado=False)
# Libros disponibles en el Grupo
if queryset == "autor":
libros_disponibles = LibroDisponibleGrupo.objects.filter(grupo=grupo,
activo=True).select_related(
"libro_disponible").order_by("libro_disponible__libro__autor")
else:
libros_disponibles = LibroDisponibleGrupo.objects.filter(grupo=grupo, activo=True).select_related(
"libro_disponible")
actualmente_leyendo, libros_leidos_usuario = obtener_usuario_leyendo(perfil_usuario)
libros_disponibles = [ldg.libro_disponible for ldg in libros_disponibles]
context = {'grupo': grupo, 'miembros': miembros, 'requests_entrar_grupo': requests_entrar_grupo,
'usuario_es_admin': usuario_es_admin,
'usuario_es_miembro': usuario_es_miembro, 'request_invitacion_enviada': request_invitacion_enviada,
'libros_disponibles': libros_disponibles,
'filtro': 'libros', 'ordenar_por': queryset, 'actualmente_leyendo': actualmente_leyendo
}
return render(request, template, context)
def perfil_propio_libros(request):
"""
Muestra el perfil del usuario loggeado. enfocado en los libros y notificaciones
"""
template = "perfiles/perfil_propio_libros.html"
perfil = obtener_perfil(request.user)
avatar = obtener_avatar_large(perfil)
# Libros Perfil
libros_perfil = {
'tiene_requests_pendientes': False,
'tiene_libros_prestados': False,
'tiene_libros_pedidos': False,
'tiene_libros_pedidos_bcompartida': False
}
libros_requests = libros_prestados = libros_prestados_bcompartida = libros_pedidos = libros_pedidos_bcompartida = []
if LibrosRequest.objects.filter(perfil_envio=perfil, aceptado=False, eliminado=False).exists():
libros_perfil['tiene_libros_pedidos'] = True
libros_pedidos = LibrosRequest.objects.filter(perfil_envio=perfil, aceptado=False, eliminado=False)
if LibrosRequestBibliotecaCompartida.objects.filter(perfil_envio=perfil, retirado=False, eliminado=False).exists():
libros_perfil['tiene_libros_pedidos_bcompartida'] = True
libros_pedidos_bcompartida = LibrosRequestBibliotecaCompartida.objects.filter(perfil_envio=perfil,
retirado=False,
eliminado=False).select_related(
"libro_disponible")
if LibrosRequest.objects.filter(perfil_recepcion=perfil, aceptado=False, eliminado=False).exists():
libros_perfil['tiene_requests_pendientes'] = True
libros_requests = LibrosRequest.objects.filter(perfil_recepcion=perfil, aceptado=False, eliminado=False)
if LibrosPrestados.objects.filter(perfil_receptor=perfil, fecha_devolucion=None).exists():
libros_perfil['tiene_libros_prestados'] = True
libros_prestados = LibrosPrestados.objects.filter(perfil_receptor=perfil, fecha_devolucion=None)
if LibrosPrestadosBibliotecaCompartida.objects.filter(perfil_prestamo=perfil, fecha_devolucion=None).exists():
libros_perfil['tiene_libros_prestados'] = True
libros_prestados_bcompartida = LibrosPrestadosBibliotecaCompartida.objects.filter(perfil_prestamo=perfil,
fecha_devolucion=None)
# Grupos Perfil
grupos = None
if UsuariosGrupo.objects.filter(perfil=perfil, activo=True).exists():
usuarios_grupo_obj = UsuariosGrupo.objects.filter(perfil=perfil, activo=True).select_related('grupo')
grupos = [ug.grupo for ug in usuarios_grupo_obj]
# Usuario Leyendo
actualmente_leyendo, libros_leidos_usuario = obtener_usuario_leyendo(perfil)
libros_disponibles = LibrosDisponibles.objects.filter(perfil=perfil).select_related('libro')
# autocomplete Usuario Leyendo
titulos_autocomplete = {}
autores_autocomplete = {}
for l in libros_disponibles:
titulos_autocomplete[l.libro.titulo] = (l.libro.id, l.libro.autor)
for l in libros_disponibles:
autores_autocomplete[l.libro.autor] = l.libro.id
# Request de entrar a grupos a los que el usuario es admin
requests_entrar_grupo = None
if UsuariosGrupo.objects.filter(perfil=perfil, es_admin=True).exists():
usuarios_grupo_obj = UsuariosGrupo.objects.filter(perfil=perfil, es_admin=True).select_related('grupo')
grupos = [x.grupo for x in usuarios_grupo_obj]
requests_entrar_grupo = RequestInvitacion.objects.filter(aceptado=False, grupo__in=grupos)
# Si es admin de una biblioteca, poner link a la biblioteca
bibliotecas_compartidas = None
context = {'libros_perfil': libros_perfil, 'libros_requests': libros_requests, 'libros_prestados': libros_prestados,
'libros_pedidos': libros_pedidos, 'libros_prestados_bcompartida': libros_prestados_bcompartida,
'libros_pedidos_bcompartida': libros_pedidos_bcompartida, 'libros_disponibles': libros_disponibles,
'avatar': avatar, 'grupos': grupos, 'actualmente_leyendo': actualmente_leyendo,
'libros_leidos_usuario': libros_leidos_usuario, 'requests_entrar_grupo': requests_entrar_grupo,
'titulos_autocomplete': json.dumps(titulos_autocomplete),
'autores_autocomplete': json.dumps(autores_autocomplete),
'bibliotecas_compartidas': bibliotecas_compartidas}
return render(request, template, context)
