def generar_informe_de_region(numero_de_region, desde, hasta, aplicacion):
trabajo = utils.crear_modelo_trabajo(
"Informe de region {0} completo desde {1} hasta {2}".format(
numero_de_region, desde, hasta))
directorio_temporal = tempfile.mkdtemp()
directorio_del_archivo_zip = tempfile.mkdtemp()
region = models.Region.objects.get(numero=numero_de_region)
cantidad_de_pasos = region.perfiles.count() + 2
trabajo.actualizar_paso(
1, cantidad_de_pasos,
"Solicitando perfiles con acceso a {}".format(aplicacion))
try:
objeto_aplicacion = models.Aplicacion.objects.get(
identificador=aplicacion)
except models.Aplicacion.DoesNotExist:
trabajo.error = "No se encuentra ese tipo de aplicacion: {}.".format(
aplicacion)
trabajo.save()
return
# Genera un archivo pdf por cada perfil.
for (numero, perfil) in enumerate(
region.perfiles.filter(fecha_de_renuncia=None,
aplicaciones=objeto_aplicacion)):
trabajo.actualizar_paso(
1 + numero, cantidad_de_pasos,
u"Obteniendo informe de {0} {1}".format(perfil.apellido,
perfil.nombre))
nombre_del_archivo = u"informe_de_{0}".format(perfil.nombre)
ruta = os.path.join(directorio_temporal,
obtener_nombre_de_archivo_informe(perfil))
crear_informe_en_archivo_pdf(ruta, perfil, desde, hasta, aplicacion)
trabajo.actualizar_paso(cantidad_de_pasos, cantidad_de_pasos,
u"Generando archivo .zip para descargar")
# Genera un archivo .zip con todos los informes
nombre_del_archivo_zip = u'informes_region_{0}'.format(numero_de_region)
ruta_del_archivo_zip = os.path.join(directorio_del_archivo_zip,
nombre_del_archivo_zip)
shutil.make_archive(ruta_del_archivo_zip, 'zip', directorio_temporal)
# Guarda el .zip como un archivo django para preservarlo en el trabajo.
archivo = open(ruta_del_archivo_zip + ".zip")
trabajo.archivo.save(u"informe_de_la_region_{0}.zip".format(region.numero),
django.core.files.base.File(archivo))
archivo.close()
trabajo.resultado = json.dumps({'region': region.numero})
trabajo.save()
# Elimina los directorios temporales (y el .zip temporal)
shutil.rmtree(directorio_temporal)
shutil.rmtree(directorio_del_archivo_zip)
return trabajo
def sumar(a, b):
trabajo = utils.crear_modelo_trabajo("sumar a+b")
for x in range(10):
estado = "trabajando %d/10 ..." % (x)
trabajo.actualizar_paso(x, 10, estado)
time.sleep(0.1)
resultado = a + b
trabajo.resultado = str(resultado)
trabajo.actualizar_paso(10, 10, "finalizado")
trabajo.save()
time.sleep(1)
return resultado
def exportar_talleres(inicio, fin, criterio):
trabajo = utils.crear_modelo_trabajo("Exportación de talleres segun criterio {0} completo desde {1} hasta {2}".format(criterio, inicio, fin))
directorio_temporal = tempfile.mkdtemp()
if criterio:
if criterio == "fechaDeRealizacion":
eventos = models.EventoDeRobotica.objects.filter(fecha__range=(inicio, fin))
else:
eventos = models.EventoDeRobotica.objects.filter(fecha_de_creacion__range=(inicio, fin))
# if region:
# eventos = eventos.filter(escuela__localidad__distrito__region__numero=region)
wb = xlwt.Workbook(encoding='utf-8')
ws = wb.add_sheet('Talleres')
font_style = xlwt.XFStyle()
font_style.font.bold = True
columns = ['Fecha de Creación', 'Fecha', 'Hora Inicio', 'Hora Fin', 'Título', 'Área', 'Curso', 'Sección', 'Cant. de Alumnos', 'Tallerista', 'Escuela', 'CUE', 'Región', 'Distrito', 'Localidad', 'Docente a Cargo', 'Se realizó el taller?', 'Motivo si NO se realizó', 'Acta', 'Estado', 'Observaciones']
col_num = 2 # 0 y 1 son obligatorias
# Escribir los headers
for col_num in range(len(columns)):
ws.write(0, col_num, columns[col_num], font_style)
ws.col(0).width = 512 * 12 # Fecha de Creación
ws.col(1).width = 256 * 12 # Fecha
ws.col(2).width = 256 * 12 # Hora Inicio
ws.col(3).width = 256 * 12 # Hora Fin
ws.col(4).width = 600 * 12 # Titulo
ws.col(5).width = 400 * 12 # Área
ws.col(6).width = 256 * 12 # Curso
ws.col(7).width = 256 * 12 # Sección
ws.col(8).width = 256 * 12 # Cantidad de Alumnos
ws.col(9).width = 600 * 12 # Tallerista
ws.col(10).width = 600 * 12 # Escuela
ws.col(11).width = 256 * 12 # CUE
ws.col(12).width = 200 * 12 # Región
ws.col(13).width = 400 * 12 # Distrito
ws.col(14).width = 400 * 12 # Localidad
ws.col(15).width = 600 * 12 # Docente a Cargo
ws.col(16).width = 600 * 12 # Se pudo realizar el taller?
ws.col(17).width = 600 * 12 # Si no se pudo, motivo.
ws.col(18).width = 256 * 12 # Acta
ws.col(19).width = 300 * 12 # Estado
ws.col(20).width = 600 * 12 # Observaciones
font_style = xlwt.XFStyle()
row_num = 0
total = eventos.count()
trabajo.actualizar_paso(row_num, total, "Comenzando a exportar {} registros".format(total))
for taller in eventos:
if row_num % 400 == 0:
trabajo.actualizar_paso(row_num, total, "Procesando {} de {} registros".format(row_num, total))
fecha_de_creacion = taller.fecha_de_creacion
fecha_de_creacion = fecha_de_creacion.strftime("%d-%m-%Y")
fecha = taller.fecha
fecha = fecha.strftime("%d-%m-%Y")
hora_inicio = taller.inicio
hora_inicio = hora_inicio.strftime("%H:%m")
hora_fin = taller.fin
hora_fin = hora_fin.strftime("%H:%m")
titulo = taller.titulo.nombre
region = taller.escuela.localidad.distrito.region.numero
distrito = taller.escuela.localidad.distrito.nombre
localidad = taller.escuela.localidad.nombre
cue = taller.escuela.cue
escuela = taller.escuela.nombre
tallerista = taller.tallerista.apellido + ", " + taller.tallerista.nombre
area = taller.area_en_que_se_dicta.nombre
curso = taller.curso.nombre
seccion = taller.seccion.nombre
cantidad_de_alumnos = taller.cantidad_de_alumnos
docente_a_cargo = taller.docente_a_cargo
se_dio_el_taller = taller.se_dio_el_taller
motivo = taller.motivo
observaciones = taller.minuta
acta = taller.acta
if acta:
acta = "Con Acta"
else:
acta = "Sin Acta"
cerrar_evento = taller.cerrar_evento
if cerrar_evento == True:
estado = "Cerrado"
else:
estado = "Abierto"
row_num += 1
ws.write(row_num, 0, fecha_de_creacion, font_style)
ws.write(row_num, 1, fecha, font_style)
ws.write(row_num, 2, hora_inicio, font_style)
ws.write(row_num, 3, hora_fin, font_style)
ws.write(row_num, 4, titulo, font_style)
ws.write(row_num, 5, area, font_style)
ws.write(row_num, 6, curso, font_style)
ws.write(row_num, 7, seccion, font_style)
ws.write(row_num, 8, cantidad_de_alumnos, font_style)
ws.write(row_num, 9, tallerista, font_style)
ws.write(row_num, 10, escuela, font_style)
ws.write(row_num, 11, cue, font_style)
ws.write(row_num, 12, region, font_style)
ws.write(row_num, 13, distrito, font_style)
ws.write(row_num, 14, localidad, font_style)
ws.write(row_num, 15, docente_a_cargo, font_style)
ws.write(row_num, 16, se_dio_el_taller, font_style)
ws.write(row_num, 17, motivo, font_style)
ws.write(row_num, 18, acta, font_style)
ws.write(row_num, 19, estado, font_style)
ws.write(row_num, 20, observaciones, font_style)
ruta_para_el_archivo = os.path.join(directorio_temporal, "listado_de_talleres.xls")
wb.save(ruta_para_el_archivo)
archivo = open(ruta_para_el_archivo)
trabajo.archivo.save(u"exportacion_de_talleres_{0}_hasta_{1}_segun_{2}.xls".format(inicio, fin, criterio), django.core.files.base.File(archivo))
archivo.close()
trabajo.resultado = json.dumps({'data': "ok"})
trabajo.save()
shutil.rmtree(directorio_temporal)
trabajo.actualizar_paso(total, total, "Finalizado")
return trabajo
def exportar_paquetes(inicio, fin, estadoPedido):
trabajo = utils.crear_modelo_trabajo(
"Exportación de paquetes de estado {0} completo desde {1} hasta {2}".
format(estadoPedido, inicio, fin))
try:
directorio_temporal = tempfile.mkdtemp()
directorio_del_archivo_zip = tempfile.mkdtemp()
trabajo.actualizar_paso(
1, 3,
'Solicitando paquetes de estado "{0}" desde {1} hasta {2}'.format(
estadoPedido, inicio, fin))
data = models.Paquete.obtener_paquetes_para_exportar(
inicio, fin, estadoPedido)
trabajo.actualizar_paso(
1, 3, "Se van a exportar {0} paquetes".format(len(data['tabla'])))
trabajo.actualizar_paso(
1, 3, "Para solicitar estos paquetes se van a exportar {0} llaves".
format(len(data['llaves'])))
trabajo.actualizar_paso(1, 3,
"Creando estructura para el archivo .zip")
llaves = data['llaves']
data['llaves'] = [str(llave) for llave in data['llaves']]
# copia las llaves al directorio temporal que se comprimirá
for llave in llaves:
trabajo.actualizar_paso(1, 3,
"Copiando llave {0}".format(llave.name))
shutil.copy(llave.path, directorio_temporal)
crear_listado_excel_de_paquetes(data['tabla'], directorio_temporal)
# Genera un archivo .zip del directorio temporal con todas las llaves
nombre_del_archivo_zip = u'exportacion_de_paquetes_desde_{0}_hasta_{1}'.format(
inicio, fin)
ruta_del_archivo_zip = os.path.join(directorio_del_archivo_zip,
nombre_del_archivo_zip)
shutil.make_archive(ruta_del_archivo_zip, 'zip', directorio_temporal)
# Guarda el .zip como un archivo django para preservarlo en el trabajo.
archivo = open(ruta_del_archivo_zip + ".zip")
trabajo.archivo.save(
u"exportacion_de_paquetes_{0}_hasta_{1}".format(inicio, fin),
django.core.files.base.File(archivo))
archivo.close()
trabajo.resultado = json.dumps({'data': data})
trabajo.save()
trabajo.actualizar_paso(2, 3, "Generando archivo comprimido")
# Si se pidió exportar los paquetes Pendientes, y el estado del paquete era Pendiente, cambiarlo por EducAr
# Esto es para evitar que al exportar Todos, se actualicen los paquetes.
# Se guarda la fecha en que se hizo el pedido
if estadoPedido == "Pendiente":
trabajo.actualizar_paso(
2, 3, "Cambiando paquetes desde el estado Pendiente a EducAr")
models.Paquete.marcar_paquetes_pendientes_como_enviados_a_educar(
inicio, fin)
else:
trabajo.actualizar_paso(
2, 3, "No se cambiara el estado de ningun paquete")
trabajo.actualizar_paso(3, 3, "Finalizado")
# Elimina los directorios temporales (y el .zip temporal)
shutil.rmtree(directorio_temporal)
shutil.rmtree(directorio_del_archivo_zip)
except Exception as e:
trabajo.error = str(e)
trabajo.save()
raise Exception(e)
return trabajo
def generar_informe_de_perfil(perfil_id, desde, hasta, aplicacion):
trabajo = utils.crear_modelo_trabajo(
"Informe de perfil {0} desde {1} hasta {2}".format(
perfil_id, desde, hasta))
if None in [perfil_id, desde, hasta, aplicacion]:
trabajo.error = "No han especificado todos los argumentos: perfil_id, desde y hasta."
trabajo.save()
return
try:
objeto_aplicacion = models.Aplicacion.objects.get(
identificador=aplicacion)
except models.Aplicacion.DoesNotExist:
trabajo.error = "No se encuentra ese tipo de aplicacion."
trabajo.save()
return
if not re.match(FORMATO_FECHA, desde) or not re.match(
FORMATO_FECHA, hasta):
trabajo.error = "Las fechas están en formato incorrecto, deben ser YYYY-MM-DD."
trabajo.save()
return
trabajo.actualizar_paso(
1, 4, "Solicitando datos desde {0} hasta {1}".format(desde, hasta))
perfil = models.Perfil.objects.get(id=perfil_id)
if aplicacion == 'suite':
eventos = perfil.obtener_eventos_por_fecha(desde, hasta)
elif aplicacion == 'robotica':
eventos = perfil.obtener_eventos_de_robotica_por_fecha(desde, hasta)
else:
trabajo.error = "No se pueden filtrar los eventos para la aplicacion {}.".format(
aplicacion)
trabajo.save()
return
trabajo.actualizar_paso(1, 4,
"Procesando {0} eventos".format(len(eventos)))
trabajo.actualizar_paso(2, 4, "Generando archivo")
trabajo.resultado = json.dumps({
'perfil_id': perfil_id,
'cantidad_de_eventos': len(eventos)
})
contexto = {
"perfil": perfil,
"eventos": eventos,
"desde": formatear_fecha(desde),
"hasta": formatear_fecha(hasta),
}
if aplicacion == 'suite':
contenido = render_to_pdf("informe.html", contexto)
else:
contenido = render_to_pdf("informe_robotica.html", contexto)
archivo = django.core.files.base.ContentFile(contenido)
trabajo.archivo.save(obtener_nombre_de_archivo_informe(perfil), archivo)
trabajo.actualizar_paso(4, 4, "Finalizando")
trabajo.save()
return trabajo
def distribuir_paquetes(distribucion_de_paquete):
trabajo = utils.crear_modelo_trabajo(
"Distribución de paquetes id={0}".format(distribucion_de_paquete.id))
try:
directorio_temporal = tempfile.mkdtemp()
ruta_del_archivo_de_log = os.path.join(directorio_temporal, "log.txt")
archivo_log = open(ruta_del_archivo_de_log, "wt")
trabajo.actualizar_paso(1, 3, 'Comenzando distribucion de paquetes')
trabajo.actualizar_paso(1, 3,
'Descomprimiendo archivo .zip de educ.ar')
archivo_zip = zipfile.ZipFile(distribucion_de_paquete.archivo.path)
archivo_zip.extractall(directorio_temporal)
archivo_zip.close()
# Aquí se asume que el archivo tiene un directorio dentro, y ahí todos
# los archivos .zip (uno por cada cue) y directorios por cada uno de
# los cue.
archivos = glob.glob(os.path.join(directorio_temporal, "*", "*"))
directorios = [
archivo for archivo in archivos if os.path.isdir(archivo)
]
archivos_de_paquetes = glob.glob(
os.path.join(directorio_temporal, "*", "*", "*"))
paquetes_bin = [
paquete for paquete in archivos_de_paquetes
if paquete.endswith("bin")
]
paquetes_min = [
paquete for paquete in archivos_de_paquetes
if paquete.endswith("min")
]
if len(directorios) > 0:
trabajo.actualizar_paso(2, 3, " ")
trabajo.actualizar_paso(
2, 3, "Buscando solicitudes de {0} paquetes devueltos".format(
len(paquetes_bin)))
trabajo.actualizar_paso(
2, 3, "===================================================")
else:
raise Exception(
"No se buscaran solicitudes porque la devolucion parece vacia."
)
for (indice, ruta) in enumerate(paquetes_bin):
nombre = os.path.basename(ruta)
regex = re.search('tcopp_(.*)_(.*)\.bin', os.path.basename(ruta))
if regex:
(id_hardware, marca_de_arranque_decimal) = regex.groups()
marca_de_arranque_hex = hex(
int(marca_de_arranque_decimal)).split('x')[-1]
mensaje = models.Paquete.cambiar_estado_a_entregado(
id_hardware, marca_de_arranque_hex, ruta)
else:
mensaje = "CUIDADO: ignorando el archivo {0} porque no coincide con el formato de paquete esperado (tcopp_idhardware_ma.bin)"
archivo_log.write("%04d - " % (indice + 1) + mensaje + "\n")
trabajo.actualizar_paso(2, 3, "%04d - " % (indice + 1) + mensaje)
trabajo.actualizar_paso(3, 3, "Finalizado")
archivo_log.close()
archivo = open(ruta_del_archivo_de_log, "rt")
trabajo.archivo.save("resultado.log",
django.core.files.base.File(archivo))
archivo.close()
trabajo.resultado = json.dumps({'ok': True})
trabajo.save()
shutil.rmtree(directorio_temporal)
except Exception as e:
trabajo.error = str(e)
trabajo.save()
raise Exception(e)
return trabajo