def comprar_y_vender(request):
g_e = request.session['gauser_extra']
if request.method == 'POST':
if request.POST['action'] == 'introduce_articulo':
codigo = pass_generator(size=35)
articulo = Articulo(vendedor=g_e.gauser, entidad=g_e.ronda.entidad, estado='DISPONIBLE',
codigo=codigo)
elif request.POST['action'] == 'modifica_articulo':
articulo = Articulo.objects.get(id=request.POST['id_articulo'])
form = Articulo_Form(request.POST, instance=articulo)
if form.is_valid():
articulo = form.save()
articulo.categorias.clear()
if request.POST['categorias']:
id_categorias = list(filter(None, request.POST['categorias'].split(',')))
categorias = Categoria_objeto.objects.filter(id__in=id_categorias)
articulo.categorias.add(*categorias)
articulo.fotos.clear()
if request.POST['fotos_existentes']:
id_fotos = list(filter(None, request.POST['fotos_existentes'].split(',')))
fotos_existentes = Foto_objeto.objects.filter(id__in=id_fotos)
articulo.fotos.add(*fotos_existentes)
for input_file, object_file in request.FILES.items():
for fichero in request.FILES.getlist(input_file):
if fichero.content_type in ['image/png', 'image/gif', 'image/jpeg']:
foto = Foto_objeto.objects.create(entidad=g_e.ronda.entidad, fichero=fichero,
content_type=fichero.content_type)
articulo.fotos.add(foto)
foto_url = RUTA_BASE + foto.fichero.url
os.system('convert %s -resize 400x %s' % (foto_url, foto_url))
else:
crear_aviso(request, False,
u'Tipo de imagen: %s, no permitido (sólo jpeg, png y gif)' % (
fichero.content_type))
else:
crear_aviso(request, False, form.errors)
articulos = Articulo.objects.filter(~Q(estado='VENDIDO'), Q(entidad=g_e.ronda.entidad))
respuesta = {
'iconos':
({'tipo': 'button', 'nombre': 'check', 'texto': 'Aceptar', 'title': 'Aceptar los cambios realizados',
'permiso': 'libre'},
{'tipo': 'button', 'nombre': 'plus', 'texto': 'Añadir', 'title': 'Añadir un nuevo artículo o servicio',
'permiso': 'libre'},
{'tipo': 'button', 'nombre': 'list-alt', 'texto': 'Artículos', 'title': 'Mostrar la lista de artículos',
'permiso': 'libre'},
),
'formname': 'compraventa',
'articulos': articulos,
'avisos': Aviso.objects.filter(usuario=request.session["gauser_extra"], aceptado=False),
}
return render(request, "compra_y_venta.html", respuesta)
def documento_seguridad(request):
g_e = request.session["gauser_extra"]
doc_seguridad = render_to_string('doc_seguridad_general.html', {},
request=request)
try:
estructura_lopd = Estructura_lopd.objects.get(
entidad=g_e.ronda.entidad)
estructura_lopd.doc_seguridad = doc_seguridad
estructura_lopd.save()
except:
estructura_lopd = Estructura_lopd.objects.create(
entidad=g_e.ronda.entidad,
doc_seguridad=doc_seguridad,
encargado_tratamiento=
"Sistemas de Gestión Aumentada (NIF: 18034131S)")
if request.method == 'POST':
if request.POST['action'] == 'genera_pdf':
crear_aviso(
request, True, request.META['PATH_INFO'] +
' POST genera PDF del documento de seguridad')
fichero = 'Documento_Seguridad_%s' % (g_e.ronda.entidad.id)
fich = html_to_pdf(request,
doc_seguridad,
fichero=fichero,
media=MEDIA_LOPD,
title=u'Doc_Seguridad',
tipo='doc')
response = HttpResponse(fich, content_type='application/pdf')
response[
'Content-Disposition'] = 'attachment; filename=' + fichero + '.pdf'
return response
return render(
request, "documento_seguridad.html", {
'formname':
'documento_seguridad',
'iconos': ({
'nombre': 'file-pdf-o',
'texto': 'PDF',
'title': 'Generar PDF del documento',
'permiso': 'm70'
}, ),
'estructura_lopd':
estructura_lopd,
'avisos':
Aviso.objects.filter(usuario=request.session["gauser_extra"],
aceptado=False),
})
def responsables_lopd(request):
g_e = request.session["gauser_extra"]
try:
estructura_lopd = Estructura_lopd.objects.get(
entidad=g_e.ronda.entidad)
except:
doc_seguridad = render_to_string('doc_seguridad_general.html', {},
request=request)
estructura_lopd = Estructura_lopd.objects.create(
entidad=g_e.ronda.entidad,
doc_seguridad=doc_seguridad,
encargado_tratamiento=
"Sistemas de Gestión Aumentada (NIF: 18034131S)")
if request.method == 'POST':
crear_aviso(request, True, request.META['PATH_INFO'] + ' POST')
form = Estructura_lopdForm(request.POST)
if form.is_valid():
form = Estructura_lopdForm(request.POST, instance=estructura_lopd)
form.save()
crear_aviso(
request, False,
u'<p>Estructura de LOPD modificada/guardada correctamente.</p>'
)
else:
crear_aviso(request, False, form.errors)
form = Estructura_lopdForm(request.POST)
else:
crear_aviso(request, True, request.META['PATH_INFO'])
form = Estructura_lopdForm(instance=estructura_lopd)
# cargos_entidad = Cargo.objects.filter(entidad=g_e.ronda.entidad)
# cargos = Gauser_extra.objects.filter(cargos__in = cargos_entidad)
hoy = datetime.date.today()
fecha_minima = datetime.datetime(hoy.year, hoy.month, hoy.day)
cargos = Gauser_extra.objects.filter(ronda=g_e.ronda,
gauser__nacimiento__lte=fecha_minima)
return render(
request, "responsables_lopd.html", {
'formname':
'estructura_lopd',
'iconos': ({
'nombre': 'check',
'texto': 'Aceptar',
'title': 'Aceptar los cambios realizados',
'permiso': 'modifica_responsables_fichero'
}, ),
'form':
form,
'estructura_lopd':
estructura_lopd,
'cargos':
cargos,
'avisos':
Aviso.objects.filter(usuario=request.session["gauser_extra"],
aceptado=False),
})
def firmar_orden_adeudo(request, id_oa):
g_e = request.session['gauser_extra']
if request.method == 'POST' and request.is_ajax():
if request.POST['action'] == 'guarda_firma':
try:
orden_adeudo = OrdenAdeudo.objects.get(id=request.POST['orden_adeudo'], gauser=g_e.gauser)
firma_data = request.POST['firma']
format, imgstr = firma_data.split(';base64,')
ext = format.split('/')[-1]
orden_adeudo.firma = ContentFile(base64.b64decode(imgstr), name='temp.' + ext)
orden_adeudo.fecha_firma = date.today()
orden_adeudo.save()
orden_adeudo.texto_firmado = render_to_string('orden_adeudo2pdf.html', {'orden': orden_adeudo,
'firma_data': firma_data})
orden_adeudo.save()
crear_aviso(request, False, 'Orden de adeudo firmada correctamente.')
return JsonResponse({'ok': True})
except:
crear_aviso(request, False, 'Se ha producido un error en tu solicitud.')
return JsonResponse({'ok': False})
try:
orden_firma = OrdenAdeudo.objects.get(gauser=g_e.gauser, politica__entidad=g_e.ronda.entidad,
fecha_firma__isnull=True, id=id_oa)
except:
crear_aviso(request, False, 'Se ha producido un error en tu solicitud.')
return redirect('/mis_ordenes_adeudo/')
return render(request, "firmar_orden_adeudo.html",
{
'formname': 'firmar_orden_adeudo',
'orden_firma': orden_firma
})
def confidencialidad(request):
g_e = request.session["gauser_extra"]
doc_seguridad = render_to_string('doc_seguridad_general.html', {},
request=request)
try:
estructura_lopd = Estructura_lopd.objects.get(
entidad=g_e.ronda.entidad)
estructura_lopd.doc_seguridad = doc_seguridad
estructura_lopd.save()
except:
estructura_lopd = Estructura_lopd.objects.create(
entidad=g_e.ronda.entidad,
doc_seguridad=doc_seguridad,
encargado_tratamiento=
"Sistemas de Gestión Aumentada (NIF: 18034131S)")
if request.method == 'POST':
if request.POST['action'] == 'aceptar':
tipo = request.POST['contrato']
texto_html = {
'CONF':
render_to_string('confidencialidad_personal.html', {
'estructura_lopd': estructura_lopd,
},
request=request)
}
crear_aviso(
request, True, request.META['PATH_INFO'] +
' Firma contrato de confidencialidad')
fichero = 'Contrato_%s_%s' % (tipo, g_e.gauser.username)
fich = html_to_pdf(request,
texto_html[tipo],
fichero=fichero,
media=MEDIA_LOPD + str(g_e.ronda.entidad.code) +
'/',
title=u'Firma de confidencialidad de %s' %
(g_e.gauser.get_full_name()))
doc = Ges_documental.objects.create(
propietario=g_e,
nombre='Contrato de confidencialidad de %s' %
(g_e.gauser.get_full_name()),
texto=texto_html[tipo],
fichero=File(fich),
content_type='application/pdf')
cargos = Cargo.objects.filter(entidad=g_e.ronda.entidad,
nivel__in=[1, 2])
doc.cargos.add(*cargos)
fich.close()
return render(
request, "contratos_confidencialidad.html", {
'formname':
'confidencialidad',
'iconos': ({
'nombre': 'check',
'texto': 'Aceptar',
'title': 'Enviar la solicitud a los interesados',
'permiso': 'm70i20'
}, ),
'estructura_lopd':
estructura_lopd,
'avisos':
Aviso.objects.filter(usuario=request.session["gauser_extra"],
aceptado=False),
})
def inventario_soportes(request):
g_e = request.session['gauser_extra']
form = Soporte_lopdForm()
if request.method == 'POST':
if request.POST['action'] == 'guardar_soporte':
soporte = Soporte_lopd(entidad=g_e.ronda.entidad)
form = Soporte_lopdForm(request.POST, instance=soporte)
if form.is_valid():
soporte = form.save()
crear_aviso(request, True,
u'Soporte guardado: %s' % (soporte.nombre))
else:
crear_aviso(request, False, form.errors)
if request.POST['action'] == 'borrar_soporte':
soportes_id = request.POST['id_soporte'].split(',')
soportes = Soporte_lopd.objects.filter(id__in=soportes_id)
for soporte in soportes:
if g_e.has_cargos([1, 2]):
soporte.delete()
crear_aviso(request, True,
u'Se borra soporte: %s' % (soporte.nombre))
else:
crear_aviso(
request, False,
u'No tienes permisos para borrar el soporte: %s.' %
(soporte.nombre))
soportes = Soporte_lopd.objects.filter(
entidad=g_e.ronda.entidad).order_by('-creado')
return render(
request, "soportes_lopd.html", {
'iconos': (
{
'tipo': 'button',
'nombre': 'check',
'texto': 'Aceptar',
'permiso': 'modifica_inventario_soportes',
'title': 'Grabar el soporte introducido'
},
{
'tipo': 'button',
'nombre': 'plus',
'texto': 'Anadir',
'permiso': 'modifica_inventario_soportes',
'title': 'Anadir un nuevo soporte'
},
{
'tipo': 'button',
'nombre': 'trash-o',
'texto': 'Borrar',
'permiso': 'modifica_inventario_soportes',
'title': 'Eliminar el soporte seleccionado'
},
{
'tipo': 'button',
'nombre': 'list-alt',
'texto': 'Lista',
'permiso': 'modifica_inventario_soportes',
'title': 'Volver a mostrar la lista de soportes'
},
),
'form':
form,
'formname':
'soportes',
'soportes':
soportes,
'avisos':
Aviso.objects.filter(usuario=g_e, aceptado=False),
})
def incidencias_lopd(request):
g_e = request.session["gauser_extra"]
incidencias = Incidencia_lopd.objects.filter(
emisor_incidencia__ronda=g_e.ronda,
resuelta=False).order_by('-fecha_emite')
incidencias_solved = Incidencia_lopd.objects.filter(
emisor_incidencia__ronda=g_e.ronda,
resuelta=True).order_by('-fecha_emite')
estructura_lopd = Estructura_lopd.objects.filter(entidad=g_e.ronda.entidad)
form_emitir = Incidencia_lopdForm()
form_resolver = ResuelveIncidencia_lopdForm()
if request.method == 'POST':
if request.POST['action'] == 'graba_incidencia':
incidencia = Incidencia_lopd(emisor_incidencia=g_e)
form = Incidencia_lopdForm(request.POST, instance=incidencia)
if form.is_valid():
form.save()
crear_aviso(
request, True, request.META['PATH_INFO'] +
' Se graba una nueva incidencia LOPD')
else:
crear_aviso(request, False, form.errors)
if request.POST['action'] == 'resuelve_incidencia':
incidencia = Incidencia_lopd.objects.get(
id=request.POST['id_incidencia'])
form = ResuelveIncidencia_lopdForm(request.POST,
instance=incidencia)
if form.is_valid():
form.save()
incidencia.resuelta = True
incidencia.resolvedor = g_e
incidencia.fecha_resuelve = datetime.date.today()
incidencia.save()
crear_aviso(
request, True, request.META['PATH_INFO'] +
' Se graba una nueva incidencia LOPD')
else:
crear_aviso(request, False, form.errors)
if request.POST['action'] == 'mostrar_incidencia':
if request.is_ajax():
incidencia = Incidencia_lopd.objects.get(
id=request.POST['id_incidencia'])
return HttpResponse(incidencia.incidencia)
return render(
request, "incidencias_lopd.html", {
'formname':
'documento_seguridad',
'iconos': (
{
'tipo': 'button',
'nombre': 'check',
'texto': 'Aceptar',
'permiso': 'm70',
'title': 'Guardar los cambios realizados'
},
{
'tipo': 'button',
'nombre': 'plus',
'texto': 'Anadir',
'permiso': 'm70',
'title': 'Añadir una nueva incidencia LOPD'
},
{
'tipo': 'button',
'nombre': 'trash-o',
'texto': 'Borrar',
'permiso': 'resuelve_incidencias_lopd',
'title': 'Eliminar la incidencia seleccionada'
},
{
'tipo': 'button',
'nombre': 'list-alt',
'texto': 'Lista',
'permiso': 'm70',
'title': 'Volver a mostrar la lista de incidencias'
},
),
'form_emitir':
form_emitir,
'estructura_lopd':
estructura_lopd,
'form_resolver':
form_resolver,
'incidencias':
incidencias,
'incidencias_solved':
incidencias_solved,
'avisos':
Aviso.objects.filter(usuario=request.session["gauser_extra"],
aceptado=False),
})
def derechos_arco(request):
g_e = request.session["gauser_extra"]
doc_seguridad = render_to_string('doc_seguridad_general.html', {},
request=request)
try:
estructura_lopd = Estructura_lopd.objects.get(
entidad=g_e.ronda.entidad)
estructura_lopd.doc_seguridad = doc_seguridad
estructura_lopd.save()
except:
estructura_lopd = Estructura_lopd.objects.create(
entidad=g_e.ronda.entidad,
doc_seguridad=doc_seguridad,
encargado_tratamiento=
"Sistemas de Gestión Aumentada (NIF: 18034131S)")
if request.method == 'POST':
if request.POST['action'] == 'aceptar':
tipo = request.POST['derecho']
tipos_incidencia = dict(TIPOS_INCIDENCIA)
texto_html = {
'DEAC':
render_to_string('derecho_acceso.html', {
'estructura_lopd': estructura_lopd,
},
request=request),
'DERE':
render_to_string(
'derecho_rectificacion.html', {
'estructura_lopd': estructura_lopd,
'datos_rectificar': request.POST['datos_rectificar']
},
request=request),
'DECA':
render_to_string('derecho_cancelacion.html', {
'estructura_lopd': estructura_lopd,
},
request=request),
'DEOP':
render_to_string('derecho_oposicion.html', {
'estructura_lopd': estructura_lopd,
},
request=request)
}
crear_aviso(
request, True,
request.META['PATH_INFO'] + ' Ejerce derecho de ' + tipo)
incidencia = Incidencia_lopd.objects.create(
emisor_incidencia=g_e, tipo=tipo, incidencia=texto_html[tipo])
for input_file, object_file in request.FILES.items():
for fichero in request.FILES.getlist(input_file):
archivo = Fichero_incidencia.objects.create(
propietario=g_e, fichero=fichero)
incidencia.ficheros.add(archivo)
fichero = 'Incidencia_%s' % (incidencia.id)
attach = ''
for archivo in incidencia.ficheros.all():
attach += MEDIA_INCIDENCIAS_LOPD + str(
g_e.ronda.entidad.code) + '/' + archivo.filename() + ' '
fich = html_to_pdf(request,
texto_html[tipo],
fichero=fichero,
media=MEDIA_INCIDENCIAS_LOPD +
str(g_e.ronda.entidad.code) + '/',
title=u'Incidencia LOPD generada por %s' %
(g_e.gauser.get_full_name()),
attach=attach)
doc = Ges_documental.objects.create(propietario=g_e,
nombre='Incidencia: %s' %
(tipos_incidencia[tipo]),
texto=texto_html[tipo],
fichero=File(fich),
content_type='application/pdf')
cargos = Cargo.objects.filter(entidad=g_e.ronda.entidad,
nivel__in=[1, 2])
doc.cargos.add(*cargos)
fich.close()
return render(
request, "derechos_arco.html", {
'formname':
'derechos_arco',
'iconos': ({
'nombre': 'check',
'texto': 'Aceptar',
'title': 'Enviar la solicitud a los interesados',
'permiso': 'm70i20'
}, ),
'estructura_lopd':
estructura_lopd,
'avisos':
Aviso.objects.filter(usuario=request.session["gauser_extra"],
aceptado=False),
})
def sancionar_conductas(request):
g_e = request.session['gauser_extra']
inf_actual = None
if request.method == 'POST' and not request.is_ajax():
if request.POST['action'] == 'genera_pdf':
doc_ie = 'Configuración de informes sancionadores de alumnos'
dce = get_dce(entidad=g_e.ronda.entidad, nombre=doc_ie)
informe = Informe_sancionador.objects.get(
sancionado__ronda=g_e.ronda, id=request.POST['inf_actual'])
coherente, mensaje = informe.is_coherente
if coherente:
if informe.fichero:
os.remove(informe.fichero.path)
listar_conductas, informes, expulsiones = False, None, None
if 'listar_conductas' in request.POST:
listar_conductas = True
informes = Informe_sancionador.objects.filter(
sancionado=informe.sancionado)
sanciones_expulsion = Sancion.objects.filter(
entidad=g_e.ronda.entidad, expulsion=True)
expulsiones = informes.filter(
sanciones__in=sanciones_expulsion)
# Código para enviar correo
asunto = render_to_string(
'informe_sancionador_mail_asunto.html',
{'informe': informe})
texto = render_to_string('informe_sancionador_mail.html',
{'informe': informe})
permisos = ['recibe_mensajes_aviso_informes_sancionadores']
cargos = Cargo.objects.filter(
permisos__code_nombre__in=permisos,
entidad=g_e.ronda.entidad).distinct()
try:
tutor = informe.sancionado.gauser_extra_estudios.tutor.id
q = Q(permisos__code_nombre__in=permisos) | Q(
cargos__in=cargos) | Q(id=tutor)
except:
q = Q(permisos__code_nombre__in=permisos) | Q(
cargos__in=cargos)
receptores = Gauser_extra.objects.filter(
Q(activo=True), Q(ronda=g_e.ronda),
q).values_list('gauser__id', flat=True).distinct()
try:
# Comprobamos si un mensaje igual se ha mandado ya
Mensaje.objects.get(emisor=g_e,
asunto=asunto,
mensaje=texto)
except:
mc = Mensaje_cola.objects.filter(mensaje__emisor=g_e,
mensaje__asunto=asunto,
enviado=False)
if mc.count() > 0:
mc[0].mensaje.delete()
mc.delete()
encolar_mensaje(emisor=g_e,
receptores=receptores,
asunto=asunto,
html=texto,
etiqueta='is%s' % informe.id)
# Fin de código para enviar correo
texto_html = render_to_string(
'is2pdf.html', {
'informe': informe,
'MEDIA_ANAGRAMAS': MEDIA_ANAGRAMAS,
'listar_conductas': listar_conductas,
'expulsiones': expulsiones,
'informes': informes
})
nombre = '%s_%s.pdf' % (
slugify(informe.sancionado.gauser.get_full_name()),
timezone.localtime(
informe.created).strftime('%d-%m-%Y_%H%M'))
url_pdf = MEDIA_CONVIVENCIA + '%s/%s' % (
g_e.ronda.entidad.code, nombre)
pdfkit.from_string(texto_html, url_pdf, dce.get_opciones)
fich = open(url_pdf, 'rb')
informe.texto_html = texto_html
nombre_fichero = 'convivencia/%s/%s' % (g_e.ronda.entidad.code,
nombre)
informe.fichero.save(nombre_fichero, File(fich))
fich.close()
informe.save()
response = HttpResponse(informe.fichero,
content_type='application/pdf')
response[
'Content-Disposition'] = 'attachment; filename=%s' % nombre
return response
else:
inf_actual = informe
crear_aviso(request, False, '<ul>%s</ul>' % mensaje)
if request.POST['action'] == 'descargar_informe':
informe = Informe_sancionador.objects.get(
sancionado__ronda=g_e.ronda, id=request.POST['inf_descargar'])
filename = informe.fichero.name.split('/')[-1]
response = HttpResponse(informe.fichero,
content_type='application/pdf')
response[
'Content-Disposition'] = 'attachment; filename=%s' % filename
return response
informes = Informe_sancionador.objects.filter(Q(sancionador=g_e),
~Q(fichero=''))
informes_como_tutor = Informe_sancionador.objects.filter(
Q(sancionado__gauser_extra_estudios__tutor=g_e),
~Q(fichero='')).exclude(id__in=informes)
respuesta = {
'iconos': ({
'tipo': 'button',
'nombre': 'file-pdf-o',
'texto': 'Generar',
'title': 'Generar informe sancionador',
'permiso': 'genera_informe_sancionador'
}, ),
'formname':
'gestionar_conductas',
'conductas':
Conducta.objects.filter(entidad=g_e.ronda.entidad),
'sanciones':
Sancion.objects.filter(entidad=g_e.ronda.entidad),
'informes':
informes,
'informes_como_tutor':
informes_como_tutor,
'inf_actual':
inf_actual,
'avisos':
Aviso.objects.filter(usuario=g_e, aceptado=False),
}
return render(request, "sancionar_conductas.html", respuesta)
def uniformes(request):
g_e = request.session['gauser_extra']
hijos = Gauser_extra.objects.filter(Q(ronda=g_e.ronda),
Q(tutor1=g_e) | Q(tutor2=g_e))
uniformes = Uniforme.objects.filter(
Q(solicitante__entidad=g_e.ronda.entidad),
Q(entregado=False) | Q(pagado=False)).order_by('tipo')
uniformes_solicitados = Uniforme.objects.filter(
Q(solicitante=g_e) | Q(gauser_extra__in=hijos)).distinct()
if request.method == 'POST':
if request.POST['action'] == 'aceptar':
uniforme = Uniforme(solicitante=g_e, pagado=False, entregado=False)
form = UniformeForm(request.POST, instance=uniforme)
if form.is_valid():
form.save()
crear_aviso(
request, False,
'Tu solicitud de uniforme ha sido guardada correctamente')
else:
crear_aviso(request, False, form.errors)
if request.POST['action'] == 'mod_pedidos':
pagados_id = request.POST.getlist('pagados')
ids = map(int, filter(None, pagados_id))
for uniforme in uniformes.filter(id__in=ids):
uniforme.pagado = True
uniforme.save()
entregados_id = request.POST.getlist('entregados')
ids = map(int, filter(None, entregados_id))
for uniforme in uniformes.filter(id__in=ids):
uniforme.entregado = True
uniforme.save()
if request.POST['action'] == 'genera_pdf':
fichero = 'Uniformidad_%s_%s' % (g_e.ronda.entidad.id,
g_e.ronda.id)
c = render_to_string('uniformes2pdf.html',
{'uniformes': uniformes},
request=request)
fich = html_to_pdf(request,
c,
fichero=fichero,
media=MEDIA_VESTUARIOS,
title=u'Solicitudes de uniformes')
response = HttpResponse(fich, content_type='application/pdf')
response[
'Content-Disposition'] = 'attachment; filename=' + fichero + '.pdf'
return response
if request.POST['action'] == 'borrar_uniforme':
uniformes_id = request.POST.getlist('uniforme_id')
ids = map(int, filter(None, uniformes_id))
Uniforme.objects.filter(id__in=ids).delete()
form = UniformeForm()
respuesta = {
'iconos': (
{
'tipo': 'button',
'nombre': 'check',
'texto': 'Aceptar',
'title': 'Aceptar los cambios realizados',
'permiso': 'libre'
},
{
'tipo': 'button',
'nombre': 'list-alt',
'texto': 'Solicitudes',
'title': 'Ver la lista de pedidos',
'permiso': 've_lista_uniformes'
},
{
'tipo': 'button',
'nombre': 'file-pdf-o',
'texto': 'PDF',
'title': 'Genera pdf con la lista de pedidos',
'permiso': 've_lista_uniformes'
},
{
'tipo': 'button',
'nombre': 'shopping-cart',
'texto': 'Pedido',
'title': 'Mostrar el formulario para realizar pedido',
'permiso': 've_lista_uniformes'
},
{
'tipo': 'button',
'nombre': 'trash-o',
'texto': 'Borrar',
'title': 'Eliminar el pedido de uniforme indicado',
'permiso': 'libre'
},
),
'formname':
'uniformes',
'form':
form,
'hijos':
hijos,
'uniformes':
uniformes,
'uniformes_solicitados':
uniformes_solicitados,
'avisos':
Aviso.objects.filter(usuario=request.session["gauser_extra"],
aceptado=False),
}
return render(request, "uniformes.html", respuesta)
def contrato_gauss(request):
g_e = request.session['gauser_extra']
try:
contrato = Contrato_gauss.objects.get(entidad=g_e.ronda.entidad)
except:
Gn = g_e.ronda.entidad.get__general_name__display()
La_entidad = 'La %s' % (
Gn) if g_e.ronda.entidad.general_name < 100 else 'El %s' % (Gn)
la_entidad = 'la %s' % (
Gn) if g_e.ronda.entidad.general_name < 100 else 'el %s' % (Gn)
a_la_entidad = 'a la %s' % (
Gn) if g_e.ronda.entidad.general_name < 100 else 'al %s' % (Gn)
de_la_entidad = 'de la %s' % (
Gn) if g_e.ronda.entidad.general_name < 100 else 'del %s' % (Gn)
texto = render_to_string(
"texto_contrato_gauss.html", {
'Gn': Gn,
'La_entidad': La_entidad,
'la_entidad': la_entidad,
'de_la_entidad': de_la_entidad,
'a_la_entidad': a_la_entidad
})
contrato = Contrato_gauss.objects.create(entidad=g_e.ronda.entidad,
firma_entidad=g_e,
texto=texto)
if request.method == 'POST':
if request.POST[
'action'] == 'guardar_modificaciones' and g_e.has_permiso(
'guarda_modificaciones_contrato'):
form = Contrato_gaussForm(request.POST, instance=contrato)
if form.is_valid():
contrato = form.save()
crear_aviso(
request, True,
u'Modificación del contrato de la entidad %s guardada.' %
(g_e.ronda.entidad.name))
else:
crear_aviso(request, False, form.errors)
if request.POST['action'] == 'subir_contrato' and g_e.has_permiso(
'puede_subir_contrato'):
contrato.content_type = request.FILES['fichero'].content_type
# contrato.save()
# a = request.FILES['fichero'].content_type
form = Contrato_gaussForm(request.POST,
request.FILES,
instance=contrato)
if form.is_valid():
contrato = form.save()
crear_aviso(
request, True,
u'Se ha subido el contrato escaneado de la entidad %s.' %
(g_e.ronda.entidad.name))
else:
crear_aviso(request, False, form.errors)
if request.POST['action'] == 'bajar_contrato':
contrato = Contrato_gauss.objects.get(entidad=g_e.ronda.entidad)
try:
fichero = contrato.fichero.read()
response = HttpResponse(fichero,
content_type=contrato.content_type)
response['Content-Disposition'] = 'attachment; filename=Contrato_gauss.' + \
contrato.fichero.url.split('.')[-1]
return response
except:
crear_aviso(
request, False,
u'Todavía no se ha subido un archivo con el contrato escaneado.'
)
if request.POST['action'] == 'obtener_pdf':
dce = DocConfEntidad.objects.get(entidad=g_e.ronda.entidad,
predeterminado=True)
contrato = Contrato_gauss.objects.get(entidad=g_e.ronda.entidad)
fichero = 'Contrato_GAUSS_sin_firmar'
c = render_to_string('contrato_gauss2pdf.html', {
'contrato': contrato,
'MA': MEDIA_ANAGRAMAS
},
request=request)
fich = pdfkit.from_string(c, False, dce.get_opciones)
response = HttpResponse(fich, content_type='application/pdf')
response[
'Content-Disposition'] = 'attachment; filename=' + fichero + '.pdf'
return response
form = Contrato_gaussForm(instance=contrato)
return render(
request, "contrato_gauss.html", {
'iconos': (
{
'tipo': 'button',
'nombre': 'file-pdf-o',
'texto': 'PDF',
'permiso': 'descarga_contrato_pdf',
'title': 'Obtener PDF del contrato'
},
{
'tipo': 'button',
'nombre': 'upload',
'texto': 'Subir',
'permiso': 'puede_subir_contrato',
'title': 'Subir el contrato escaneado con firmas'
},
{
'tipo': 'button',
'nombre': 'download',
'texto': 'Descargar',
'permiso': 'puede_descargar_contrato',
'title': 'Descargar el contrato escaneado con firmas'
},
{
'tipo': 'button',
'nombre': 'check',
'texto': 'Guardar',
'permiso': 'guarda_modificaciones_contrato',
'title': 'Guardar modificaciones del contrato'
},
),
'form':
form,
'formname':
'contrato_gauss',
'avisos':
Aviso.objects.filter(usuario=g_e, aceptado=False),
})
def documentos(request):
for d in Ges_documental.objects.all():
try:
d.etiquetas.add(d.etiqueta)
except:
pass
try:
d.entidad = d.propietario.ronda.entidad
d.save()
except:
pass
g_e = request.session['gauser_extra']
if request.method == 'POST':
if request.POST['action'] == 'ver_formulario_subir' and g_e.has_permiso(
'sube_archivos'):
try:
etiquetas = Etiqueta_documental.objects.filter(
entidad=g_e.ronda.entidad)
html = render_to_string("documentos_fieldset_subir.html",
{'etiquetas': etiquetas})
return JsonResponse({'ok': True, 'html': html})
except:
return JsonResponse({'ok': False})
elif request.POST['action'] == 'sube_archivo':
n_files = int(request.POST['n_files'])
if g_e.has_permiso('sube_archivos'):
try:
docs = []
for i in range(n_files):
fichero = request.FILES['fichero_xhr' + str(i)]
doc = Ges_documental.objects.create(
propietario=g_e,
content_type=fichero.content_type,
nombre=fichero.name,
fichero=fichero)
# etiquetas = Etiqueta_documental.objects.filter(id__in=request.POST['etiquetas'].split(','),
# entidad=g_e.ronda.entidad)
# doc.etiquetas.add(*etiquetas)
Compartir_Ges_documental.objects.create(
gauser=g_e.gauser, documento=doc, permiso='rwx')
docs.append(doc)
html = render_to_string('documentos_table_tr.html', {
'docs': docs,
'g_e': g_e
})
return JsonResponse({
'ok': True,
'html': html,
'mensaje': False
})
except:
return JsonResponse({
'ok': False,
'mensaje': 'Se ha producido un error.'
})
else:
mensaje = 'No tienes permiso para subir archivos.'
return JsonResponse({'ok': False, 'mensaje': mensaje})
elif request.POST['action'] == 'borrar_documento':
try:
doc = Ges_documental.objects.get(id=request.POST['doc'],
borrado=False)
if 'x' in doc.permisos(g_e):
try:
doc.compartir_ges_documental_set.filter(
gauser=g_e.gauser).delete()
if Compartir_Ges_documental.objects.filter(
documento=doc).count() == 0:
doc.borrado = True
doc.save()
m = 'Se ha borrado tu acceso personal al archivo.<br>Si todavía lo vieras es porque está compartido con un cargo que tienes asignado o una sección a la que perteneces.'
return JsonResponse({'ok': True, 'mensaje': m})
except:
m = 'Archivo no borrado. <br>Lo sigues viendo porque está compartido con un cargo que tienes asignado o una sección a la que perteneces.'
return JsonResponse({'ok': True, 'mensaje': m})
else:
return JsonResponse({
'ok':
False,
'mensaje':
'No tienes permisos para borrar el documento.'
})
except:
return JsonResponse({'ok': False})
elif request.POST['action'] == 'borrar_doc_completamente':
try:
doc = Ges_documental.objects.get(id=request.POST['doc'],
borrado=False)
if doc.propietario.ronda.entidad == g_e.ronda.entidad:
if g_e.has_permiso('borra_cualquier_archivo'):
doc.borrado = True
doc.save()
cgds = doc.compartir_ges_documental_set.all()
ss = Subentidad.objects.filter(id__in=set(
cgds.values_list('subentidad__id', flat=True)))
cs = Cargo.objects.filter(id__in=set(
cgds.values_list('cargo__id', flat=True)))
interesados = usuarios_ronda(g_e.ronda,
subentidades=ss,
cargos=cs)
q1 = Q(id__in=interesados.values_list('gauser__id',
flat=True))
q2 = Q(id__in=set(
cgds.values_list('gauser__id', flat=True)))
receptores = Gauser.objects.filter(q1, q2)
asunto = 'Se ha eliminado el archivo %s' % (doc.nombre)
texto = render_to_string(
'documentos_correo_archivo_borrado.html', {
'doc': doc,
'emisor': g_e
})
ok, m = enviar_correo(asunto=asunto,
texto_html=texto,
emisor=g_e,
receptores=receptores)
if not ok:
aviso = '<br>Sin embargo, no se ha podido informar a los afectados.<br>(<i>%s</i>)' % m
crear_aviso(request, True, aviso)
else:
aviso = ''
mensaje = 'Durante los próximos 30 días puede ser recuperado por el administrador del sistema.'
return JsonResponse({
'ok': True,
'mensaje': mensaje + aviso
})
else:
return JsonResponse({
'ok':
False,
'mensaje':
'No tienes permisos para borrar el documento.'
})
else:
return JsonResponse({
'ok':
False,
'mensaje':
'No borrado. El archivo no pertenece a esta entidad.'
})
except:
return JsonResponse({'ok': False})
elif request.POST['action'] == 'descargar_doc':
try:
docs = documentos_ge(request)
d = docs.get(id=request.POST['documento'])
nombre, dot, ext = d.fich_name.rpartition(
'.') # slugify(d.fich_name.rpartition('.')[0])
response = HttpResponse(d.fichero, content_type=d.content_type)
response[
'Content-Disposition'] = 'attachment; filename=%s.%s' % (
slugify(d.nombre), ext)
return response
except:
crear_aviso(request, False,
'Error. No se ha podido descargar el archivo.')
elif request.POST[
'action'] == 'ver_formulario_crear_etiqueta' and g_e.has_permiso(
'crea_carpetas'):
try:
etiquetas = Etiqueta_documental.objects.filter(
entidad=g_e.ronda.entidad)
html = render_to_string("documentos_fieldset_etiqueta.html",
{'etiquetas': etiquetas})
return JsonResponse({'ok': True, 'html': html})
except:
return JsonResponse({'ok': False})
elif request.POST[
'action'] == 'ver_formulario_editar_carpeta' and g_e.has_permiso(
'edita_carpetas'):
try:
etiquetas = Etiqueta_documental.objects.filter(
entidad=g_e.ronda.entidad)
e = Etiqueta_documental.objects.get(
id=request.POST['etiqueta'])
html = render_to_string(
"documentos_fieldset_etiqueta_editar.html", {
'etiquetas': etiquetas,
'etiqueta': e
})
return JsonResponse({'ok': True, 'html': html})
except:
return JsonResponse({'ok': False})
elif request.POST['action'] == 'modifica_etiqueta' and g_e.has_permiso(
'edita_carpetas'):
try:
nombre = request.POST['nombre']
try:
Etiqueta_documental.objects.get(entidad=g_e.ronda.entidad,
nombre__iexact=nombre)
return JsonResponse({
'ok':
False,
'mensaje':
'Ya existe una etiqueta/carpeta con ese nombre.'
})
except:
e = Etiqueta_documental.objects.get(
id=request.POST['etiqueta'])
e.nombre = nombre
try:
e.padre = Etiqueta_documental.objects.get(
id=request.POST['padre'])
except:
e.padre = None
e.save()
docs = documentos_ge(request)
html = render_to_string('documentos_table_tr.html', {
'docs': docs,
'g_e': g_e
})
return JsonResponse({'ok': True, 'html': html})
except:
return JsonResponse({'ok': False})
elif request.POST['action'] == 'ver_formulario_buscar':
try:
etiquetas = Etiqueta_documental.objects.filter(
entidad=g_e.ronda.entidad)
html = render_to_string("documentos_fieldset_buscar.html", {
'etiquetas': etiquetas,
'g_e': g_e
})
return JsonResponse({'ok': True, 'html': html})
except:
return JsonResponse({'ok': False})
elif request.POST['action'] == 'crea_etiqueta' and g_e.has_permiso(
'crea_carpetas'):
try:
nombre = request.POST['nombre']
try:
e = Etiqueta_documental.objects.get(
entidad=g_e.ronda.entidad, nombre__iexact=nombre)
return JsonResponse({
'ok': False,
'mensaje':
'Ya existe una etiqueta/carpeta con ese nombre.',
'id_etiqueta': e.id,
'texto_etiqueta': e.etiquetas_text
})
except:
if request.POST['padre']:
padre = Etiqueta_documental.objects.get(
entidad=g_e.ronda.entidad,
id=request.POST['padre'])
e = Etiqueta_documental.objects.create(
entidad=g_e.ronda.entidad,
padre=padre,
nombre=nombre)
else:
e = Etiqueta_documental.objects.create(
entidad=g_e.ronda.entidad, nombre=nombre)
return JsonResponse({
'ok': True,
'id_etiqueta': e.id,
'texto_etiqueta': e.etiquetas_text
})
except:
return JsonResponse({'ok': False})
elif request.POST['action'] == 'borra_etiqueta' and g_e.has_permiso(
'borra_cualquier_carpeta'):
try:
Etiqueta_documental.objects.get(
entidad=g_e.ronda.entidad,
id=request.POST['etiqueta']).delete()
docs = documentos_ge(request)
html = render_to_string('documentos_table_tr.html', {
'docs': docs,
'g_e': g_e
})
return JsonResponse({'ok': True, 'html': html})
except:
return JsonResponse({'ok': False})
elif request.POST['action'] == 'update_page':
try:
docs = documentos_ge(request)
paginator = Paginator(docs, 15)
buscar = {'0': False, '1': True}[request.POST['buscar']]
docs_paginados = paginator.page(int(request.POST['page']))
html = render_to_string('documentos_table.html', {
'docs': docs_paginados,
'g_e': g_e,
'buscar': buscar
})
return JsonResponse({'ok': True, 'html': html})
except:
return JsonResponse({'ok': False})
# elif request.POST['action'] == 'busca_docs_manual':
# try:
# buscar
# docs_search = documentos_ge(request)
# html = render_to_string('documentos_table_tr.html', {'docs': docs_search, 'g_e': g_e, 'buscar': True})
# return JsonResponse({'ok': True, 'html': html})
# except:
# return JsonResponse({'ok': False})
elif request.POST['action'] == 'ver_formulario_editar':
try:
doc = Ges_documental.objects.get(id=request.POST['doc'],
borrado=False)
if g_e.has_permiso(
'edita_todos_archivos') or 'w' in doc.permisos(g_e):
etiquetas = Etiqueta_documental.objects.filter(
entidad=g_e.ronda.entidad)
payload = {'g_e': g_e, 'etiquetas': etiquetas, 'd': doc}
# html = render_to_string("documentos_table_tr_archivo_edit.html", payload)
html = render_to_string("documentos_fieldset_edit.html",
payload)
return JsonResponse({'ok': True, 'html': html})
else:
return JsonResponse({
'ok':
False,
'mensaje':
'No tienes los permisos necesarios.'
})
except:
return JsonResponse({'ok': False})
elif request.POST['action'] == 'update_nombre_archivo':
try:
doc = Ges_documental.objects.get(entidad=g_e.ronda.entidad,
id=request.POST['id'],
borrado=False)
permisos_ge = doc.permisos(g_e)
if 'w' in permisos_ge or 'x' in permisos_ge or g_e.has_permiso(
'edita_todos_archivos'):
doc.nombre = request.POST['nombre']
doc.save()
return JsonResponse({'ok': True})
else:
return JsonResponse({
'ok':
False,
'mensaje':
'No tienes los permisos necesarios'
})
except:
return JsonResponse({
'ok': False,
'mensaje': 'Se ha producido un error'
})
elif request.POST['action'] == 'update_etiquetas_archivo':
# doc = Ges_documental.objects.get(entidad=g_e.ronda.entidad, id=request.POST['doc'], borrado=False)
# permisos_ge = doc.permisos(g_e)
# if 'w' in permisos_ge or 'x' in permisos_ge or g_e.has_permiso('edita_carpetas'):
# etiqueta = Etiqueta_documental.objects.get(id=request.POST['etiqueta'], entidad=g_e.ronda.entidad)
# doc.etiquetas.add(etiqueta)
# html = render_to_string('documentos_list_etiquetas.html',
# {'etiquetas': doc.etiquetas.all(), 'd': doc, 'g_e': g_e})
# return JsonResponse({'ok': True, 'html': html})
try:
doc = Ges_documental.objects.get(entidad=g_e.ronda.entidad,
id=request.POST['id'],
borrado=False)
permisos_ge = doc.permisos(g_e)
if 'w' in permisos_ge or 'x' in permisos_ge or g_e.has_permiso(
'edita_carpetas'):
etiqueta = Etiqueta_documental.objects.get(
id=request.POST['etiqueta'], entidad=g_e.ronda.entidad)
doc.etiquetas.add(etiqueta)
html = render_to_string('documentos_list_etiquetas.html', {
'etiquetas': doc.etiquetas.all(),
'd': doc,
'g_e': g_e
})
return JsonResponse({'ok': True, 'html': html})
else:
return JsonResponse({
'ok':
False,
'mensaje':
'No tienes los permisos necesarios.'
})
except:
return JsonResponse({'ok': False})
elif request.POST['action'] == 'update_permiso_archivo':
try:
cgd = Compartir_Ges_documental.objects.get(
documento__entidad=g_e.ronda.entidad,
id=request.POST['id'],
documento__borrado=False)
permisos_ge = cgd.documento.permisos(g_e)
if 'w' in permisos_ge or 'x' in permisos_ge or g_e.has_permiso(
'edita_todos_archivos'):
cgd.permiso = request.POST['permiso']
cgd.save()
html_tr = render_to_string(
"documentos_table_tr_archivo_compartidocon.html",
{'d': cgd.documento})
return JsonResponse({
'ok': True,
'html_tr': html_tr,
'doc': cgd.documento.id
})
else:
return JsonResponse({
'ok':
False,
'mensaje':
'No tienes los permisos necesarios.'
})
except:
return JsonResponse({'ok': False})
elif request.POST['action'] == 'desasigna_etiquetas_archivo':
try:
doc = Ges_documental.objects.get(entidad=g_e.ronda.entidad,
id=request.POST['doc'],
borrado=False)
permisos_ge = doc.permisos(g_e)
if 'w' in permisos_ge or 'x' in permisos_ge or g_e.has_permiso(
'edita_todos_archivos'):
etiqueta = Etiqueta_documental.objects.get(
id=request.POST['etiqueta'], entidad=g_e.ronda.entidad)
doc.etiquetas.remove(etiqueta)
html = render_to_string('documentos_list_etiquetas.html', {
'etiquetas': doc.etiquetas.all(),
'd': doc,
'g_e': g_e
})
return JsonResponse({'ok': True, 'html': html})
else:
return JsonResponse({
'ok':
False,
'mensaje':
'No tienes los permisos necesarios.'
})
except:
return JsonResponse({'ok': False})
# elif request.POST['action'] == 'update_archivo':
# html = ''
# try:
# valor = request.POST['valor']
# campo = request.POST['campo']
# if request.POST['modelo'] == 'Ges_documental':
# doc = Ges_documental.objects.get(entidad=g_e.ronda.entidad, id=request.POST['id'], borrado=False)
# permisos_ge = doc.permisos(g_e)
# if 'w' in permisos_ge or 'x' in permisos_ge:
# if campo == 'etiquetas':
# etiqueta = Etiqueta_documental.objects.get(id=valor, entidad=g_e.ronda.entidad)
# doc.etiquetas.add(etiqueta)
# html = render_to_string('documentos_list_etiquetas.html',
# {'etiquetas': doc.etiquetas.all()})
# else:
# setattr(doc, campo, valor)
# doc.save()
# return JsonResponse({'ok': True, 'html': html, 'campo': campo})
# else:
# return JsonResponse({'ok': False, 'mensaje': 'No tienes los permisos necesarios.'})
# else:
# cgd = Compartir_Ges_documental.objects.get(id=request.POST['id'])
# doc = cgd.documento
# if valor in doc.permisos(g_e):
# cgd.permiso = valor
# cgd.save()
# return JsonResponse({'ok': True, 'campo': campo})
# else:
# return JsonResponse({'ok': False, 'mensaje': 'No tienes los permisos necesarios.'})
# except:
# return JsonResponse({'ok': False})
elif request.POST['action'] == 'update_new_permiso':
try:
doc = Ges_documental.objects.get(id=request.POST['doc'],
borrado=False)
if 'w' in doc.permisos(g_e) or g_e.has_permiso(
'edita_todos_archivos'):
ges, cs, ss = decode_selectgcs(
[request.POST['seleccionados']], g_e.ronda)
for ge in ges:
Compartir_Ges_documental.objects.get_or_create(
documento=doc, gauser=ge.gauser)
for c in cs:
Compartir_Ges_documental.objects.get_or_create(
documento=doc, cargo=c)
for s in ss:
Compartir_Ges_documental.objects.get_or_create(
documento=doc, subentidad=s)
html = render_to_string(
"documentos_fieldset_edit_permisos.html", {
'd': doc,
'g_e': g_e
})
html_tr = render_to_string(
"documentos_table_tr_archivo_compartidocon.html",
{'d': doc})
return JsonResponse({
'ok': True,
'html': html,
'doc': doc.id,
'html_tr': html_tr
})
else:
return JsonResponse({
'ok':
False,
'mensaje':
'No tienes permisos para compartir el archivo.'
})
except:
return JsonResponse({
'ok':
False,
'mensaje':
'No existe el archivo solicitado.'
})
elif request.POST['action'] == 'borrar_permiso_archivo':
try:
cgd = Compartir_Ges_documental.objects.get(
id=request.POST['cgd'])
doc = cgd.documento
if 'w' in doc.permisos(g_e) or g_e.has_permiso(
'edita_todos_archivos'):
cgd.delete()
return JsonResponse({
'ok': True,
'cgd': request.POST['cgd']
})
else:
return JsonResponse({
'ok':
False,
'mensaje':
'No tienes permisos para borrar compartido.'
})
except:
return JsonResponse({'ok': False})
elif request.POST['action'] == 'fieldset_archivo_editar_close':
try:
doc = Ges_documental.objects.get(id=request.POST['doc'],
borrado=False)
if 'w' in doc.permisos(g_e) or g_e.has_permiso(
'edita_todos_archivos'):
html = render_to_string('documentos_table_tr_archivo.html',
{
'd': doc,
'g_e': g_e
})
return JsonResponse({
'ok': True,
'html': html,
'doc': doc.id
})
else:
return JsonResponse({
'ok':
False,
'mensaje':
'No tienes permisos para editar el archivo.'
})
except:
return JsonResponse({'ok': False})
elif request.POST['action'] == 'get_etiquetas':
try:
etiquetas = Etiqueta_documental.objects.filter(
entidad=g_e.ronda.entidad)
html = render_to_string(
"documentos_fieldset_subir_select_etiquetas.html",
{'etiquetas': etiquetas})
return JsonResponse({'ok': True, 'html': html})
except:
return JsonResponse({'ok': False})
else:
return JsonResponse({
'ok': False,
'mensaje': 'Solicitud incorrecta.'
})
# -----------
# for d in Ges_documental.objects.all():
# for sub in d.acceden.all():
# Compartir_Ges_documental.objects.get_or_create(subentidad=sub, documento=d)
# for car in d.cargos.all():
# Compartir_Ges_documental.objects.get_or_create(cargo=car, documento=d)
# for p in d.permiso_ges_documental_set.all():
# c, v = Compartir_Ges_documental.objects.get_or_create(gauser=p.gauser, documento=d)
# if 'x' in p.permiso:
# c.permiso = 'rwx'
# elif 'w' in p.permiso:
# c.permiso = 'rw'
# else:
# c.permiso = 'r'
# c.save()
# -----------
Etiqueta_documental.objects.get_or_create(entidad=g_e.ronda.entidad,
nombre='General')
paginator = Paginator(documentos_ge(request), 15)
return render(
request, "documentos.html", {
'iconos': (
{
'tipo': 'button',
'nombre': 'plus',
'texto': 'Añadir',
'permiso': 'sube_archivos',
'title': 'Anadir un nuevo documento'
},
{
'tipo': 'button',
'nombre': 'folder',
'texto': 'Nueva',
'permiso': 'crea_carpetas',
'title': 'Crear una nueva carpeta/etiqueta'
},
{
'tipo':
'button',
'nombre':
'search',
'texto':
'Buscar/Filtrar',
'permiso':
'libre',
'title':
'Busca/Filtra resultados entre los diferentes archivos'
},
),
'g_e':
g_e,
'docs':
paginator.page(1),
'formname':
'documentos',
'avisos':
Aviso.objects.filter(usuario=g_e, aceptado=False),
})
def crea_evento(request):
g_e = request.session["gauser_extra"]
vista_actual = request.GET['v']
if request.method == 'POST':
form = VeventForm(request.POST)
if form.is_valid():
vevent = form.save()
dtstart = datetime.strptime(request.POST['dtstart'], "%d/%m/%Y %H:%M")
vevent.entidad = g_e.ronda.entidad
if 'festivo' in request.POST:
if request.POST['festivo'] == '0':
vevent.festivo = False
elif request.POST['festivo'] == '1':
vevent.festivo = True
if not vevent.dtend:
vevent.dtend = datetime.combine(dtstart, datetime.max.time())
else:
vevent.dtend = datetime.strptime(request.POST['dtend'], "%d/%m/%Y %H:%M")
vevent.dtstart = dtstart
vevent.save()
crear_aviso(request, True, "Se graba un nuevo evento con id %s" % (vevent.id))
if request.POST['send_telegram'] == 'true':
# Preparamos instrucciones para mandar un correo a los usuarios afectados
try:
etiqueta = Etiqueta.objects.get(nombre='vevent' + str(vevent.id))
except:
etiqueta = Etiqueta.objects.create(nombre='vevent' + str(vevent.id), propietario=g_e)
asunto = u'Nuevo evento: ' + vevent.summary
texto_html = render_to_string('evento_informar_mail.html',
{'vevent': vevent, 'actualizador': g_e, 'tipo': 'Nuevo'})
mensaje = Mensaje.objects.create(emisor=g_e, fecha=datetime.now(), asunto=asunto, mensaje=texto_html)
mensaje.etiquetas.add(etiqueta)
for g in vevent.invitados.all():
mensaje.receptores.add(g)
for g in vevent.propietarios.all():
mensaje.receptores.add(g)
for ge in Gauser_extra.objects.filter(ronda=g_e.ronda, subentidades__in=vevent.subentidades.all()):
mensaje.receptores.add(ge.gauser)
crea_mensaje_cola(mensaje)
if request.POST['send_correo'] == 'true':
texto_telegram = render_to_string('evento_informar_telegram.html',
{'vevent': vevent, 'actualizador': g_e, 'tipo': 'Nuevo'})
envia_telegram(g_e, texto_telegram, gausers=vevent.invitados.all(),
subentidades=vevent.subentidades.all())
# En este punto se han encolado los correos electrónicos y telegrams. Se enviarán según kronos
return redirect('/calendario/?fecha=%s&v=%s' % (vevent.dtstart.strftime('%d%m%Y'), vista_actual))
else:
errores = form.errors
data = errores
if 'summary' in errores:
data += '<b>Nombre del evento</b> es un campo obligatorio.<br>'
if 'dtstart' in errores:
data += '<b>Inicio</b> es un campo obligatorio con la forma: dd/mm/yyyy hh:mm<br>'
data += '<i>Por ejemplo, un evento que comience el 3 de mayo de 2018 a las 9:35, debería '
data += 'escribirse:<br></i> 03/05/2018 09:35<br>'
crear_aviso(request, False, data)
return render(request, "crea_evento.html",
{
'iconos':
({'tipo': 'button', 'nombre': 'check', 'texto': 'Aceptar', 'permiso': 'crea_eventos',
'title': 'Grabar el nuevo evento/acontecimiento'},
{'tipo': 'button', 'nombre': 'arrow-left', 'texto': 'Cancelar',
'title': 'Cancelar y volver a ver el calendario', 'permiso': 'crea_eventos'},
{'tipo': 'button', 'nombre': 'file-pdf-o', 'texto': 'PDF', 'permiso': 'crea_eventos',
'title': 'Genera documento PDF con tus eventos marcados en el calendario'},
),
'formname': 'Crea_evento',
'avisos': Aviso.objects.filter(usuario=g_e, aceptado=False),
'form': VeventForm(),
'vista_actual': vista_actual,
'subentidades': Subentidad.objects.filter(entidad=g_e.ronda.entidad,
fecha_expira__gt=datetime.today()),
'cargos': Cargo.objects.filter(entidad=g_e.ronda.entidad),
'fecha': datetime.strptime(request.GET['f'], '%d%m%Y')
})
def presupuestos(request):
g_e = request.session["gauser_extra"]
if request.method == 'POST':
if request.POST['action'] == 'pdf_presupuesto':
dce = get_dce(g_e.ronda.entidad, 'Configuración de informes de contabilidad')
presupuesto = Presupuesto.objects.get(id=request.POST['id_presupuesto'], entidad=g_e.ronda.entidad)
partidas = Partida.objects.filter(presupuesto=presupuesto)
gastos = partidas.filter(tipo='GASTO').aggregate(gasto_total=Sum('cantidad'))
ingresos = partidas.filter(tipo='INGRE').aggregate(ingreso_total=Sum('cantidad'))
fichero = 'presupuesto_%s_%s' % (g_e.ronda.entidad.id, presupuesto.id)
c = render_to_string('presupuesto2pdf.html',
{'presupuesto': presupuesto, 'partidas': partidas, 'gastos': gastos,
'ingresos': ingresos})
fich = pdfkit.from_string(c, False, dce.get_opciones)
logger.info('%s, pdf_presupuesto' % g_e)
response = HttpResponse(fich, content_type='application/pdf')
response['Content-Disposition'] = 'attachment; filename=' + fichero + '.pdf'
return response
elif request.POST['action'] == 'add_presupuesto':
describir = request.POST['describir']
describir = 'No hay descripción para este presupesto.' if len(describir) < 5 else describir
Presupuesto.objects.create(nombre=request.POST['nombre'], describir=describir, entidad=g_e.ronda.entidad)
elif request.POST['action'] == 'mod_presupuesto':
presupuesto = Presupuesto.objects.get(id=request.POST['id_presupuesto'], entidad=g_e.ronda.entidad)
presupuesto.nombre = request.POST['nombre']
presupuesto.describir = request.POST['describir']
presupuesto.save()
elif request.POST['action'] == 'borrar_presupuesto':
presupuesto = Presupuesto.objects.get(id=request.POST['id_presupuesto'], entidad=g_e.ronda.entidad)
if Partida.objects.filter(presupuesto=presupuesto).count() == 0:
presupuesto.delete()
else:
crear_aviso(request, False, 'El presupuesto no se puede borrar porque contiene partidas')
elif request.POST['action'] == 'copiar_presupuesto':
presupuesto = Presupuesto.objects.get(id=request.POST['id_presupuesto'], entidad=g_e.ronda.entidad)
p = Presupuesto.objects.create(entidad=g_e.ronda.entidad, nombre=presupuesto.nombre + ' (copia)',
describir=presupuesto.describir)
partidas = Partida.objects.filter(presupuesto=presupuesto)
for partida in partidas:
Partida.objects.create(presupuesto=p, tipo=partida.tipo, nombre=partida.nombre,
cantidad=partida.cantidad)
elif request.POST['action'] == 'archivar_presupuesto':
presupuesto = Presupuesto.objects.get(id=request.POST['id_presupuesto'], entidad=g_e.ronda.entidad)
presupuesto.archivado = True
presupuesto.save()
elif request.POST['action'] == 'abrir_presupuesto':
presupuesto = Presupuesto.objects.get(id=request.POST['id_presupuesto'], entidad=g_e.ronda.entidad)
presupuesto.archivado = False
presupuesto.save()
presupuestos = Presupuesto.objects.filter(entidad=g_e.ronda.entidad)
return render(request, "presupuestos_list.html",
{
'formname': 'Presupuestos',
'iconos':
({'tipo': 'button', 'nombre': 'check', 'texto': 'Aceptar',
'title': 'Aceptar los cambios realizados', 'permiso': 'edita_presupuestos'},
{'tipo': 'button', 'nombre': 'plus', 'texto': 'Presupuesto',
'title': 'Crear un nuevo presupuesto',
'permiso': 'crea_presupuestos'},
{'tipo': 'button', 'nombre': 'list-alt', 'texto': 'Presupuestos',
'title': 'Mostrar la lista de presupuestos',
'permiso': 'edita_presupuestos'},),
'presupuestos': presupuestos,
'avisos': Aviso.objects.filter(usuario=request.session["gauser_extra"],
aceptado=False),
})