def balance_anio(request):
accion = request.GET.get('action', 'Ver')
fecha_inicio = request.GET.get('anio', None)
if not fecha_inicio:
fecha_inicio = datetime.date.today().replace(day=1, month=1)
else:
fecha_inicio = get_year(fecha_inicio)
fecha_fin = (fecha_inicio + relativedelta(years=1, days=-1))
query = """
select to_char(fecha, 'MM/YYYY') fecha, sum(monto) monto, tipo_transaccion from (
select fecha, monto, tipo_transaccion from tienda_operacioncaja
UNION
select fecha, monto_total, 'SALIDA' as tipo_transaccion from tienda_compracabecera
UNION
select fecha, monto_total, 'ENTRADA' as tipo_transaccion
from tienda_ventacabecera where estado = 'A' and tipo_pago = 'Contado'
UNION
select r.fecha, r.monto, 'ENTRADA' as tipo_transaccion from tienda_ventacabecera t
join tienda_recibo r on t.id = r.venta_id where t.estado in ('A', 'P') and t.tipo_pago = 'Crédito'
) e
where e.fecha BETWEEN %(fecha_inicio)s AND %(fecha_fin)s
GROUP BY to_char(fecha, 'MM/YYYY'), tipo_transaccion
ORDER BY fecha DESC
"""
cursor = connection.cursor()
cursor.execute(query, { 'fecha_inicio': fecha_inicio, 'fecha_fin': fecha_fin })
resultados = dictfetch(cursor, 100, 0)
if accion == 'Excel':
return export_balance(resultados, fecha_inicio, nombre=fecha_inicio.year)
ingreso = sum(map(lambda x:x["monto"] , filter(lambda x: x["tipo_transaccion"] == 'ENTRADA', resultados)))
egreso = sum(map(lambda x:x["monto"] , filter(lambda x: x["tipo_transaccion"] == 'SALIDA', resultados)))
ganancia = ingreso - egreso
datequery = """
select to_char(dd::date, 'MM/YYYY') as date from generate_series
(%(fecha_inicio)s
, %(fecha_fin)s
, '1 month'::interval) dd
"""
cursor.execute(datequery, {'fecha_inicio': fecha_inicio, 'fecha_fin': fecha_fin})
dates = dictfetch(cursor, 100, 0)
context = { 'anio': '{0}'.format(fecha_inicio.year),
'resultados': resultados, 'dates': dates, 'ingreso': ingreso, 'egreso': egreso, 'ganancia': ganancia }
return render(request, "balance_anio.html", context)
def do(self):
# print('corrio job')
query = '''SELECT EXTRACT(DAY FROM i.fecha_inicio) as dia_vence , g.costo ,i.id
FROM escuela_inscripcion i JOIN escuela_grupo g on g.id = i.grupo_id
LEFT JOIN escuela_cuenta c ON i.id = c.inscripcion_id and c.vencimiento > now()
WHERE c.id is null and i.fecha_fin is NULL
;
'''
cursor = connection.cursor()
cursor.execute(query, {})
ret = dictfetch(cursor, 100, 0)
print(ret)
for fila in ret:
print(fila)
cuenta = Cuenta()
cuenta.inscripcion_id = fila['id']
cuenta.monto = fila['costo']
cuenta.vencimiento = calcular_fecha(int(fila['dia_vence']))
print(cuenta.vencimiento)
cuenta.save()
def asistencia(request):
grupo_id = request.GET.get('grupo', None)
action = request.GET.get('action', 'Ver')
resultados = []
dates = []
alumnos = []
try:
grupo = Grupo.objects.get(id=int(grupo_id))
except:
grupo = None
fecha_inicio = request.GET.get('mes', None)
if not fecha_inicio:
fecha_inicio = datetime.date.today().replace(day=1)
else:
fecha_inicio = get_month(fecha_inicio)
fecha_fin = (fecha_inicio + relativedelta(months=1, days=-1))
if grupo:
query = """
SELECT a.fecha, al.cedula, al.apellido || ', ' || al.nombre as nombre,
case when a.presente then 'Presente' else 'Ausente' end as asistencia,
a.comentario from escuela_asistencia a
JOIN main_persona al on a.id_alumno_id = al.id
WHERE grupo_id = %(grupo_id)s
AND a.fecha BETWEEN %(fecha_inicio)s AND %(fecha_fin)s
ORDER BY a.fecha DESC, al.apellido
"""
cursor = connection.cursor()
cursor.execute(query, {'fecha_inicio': fecha_inicio, 'fecha_fin': fecha_fin, 'grupo_id': grupo.id})
resultados = dictfetch(cursor, 1000, 0)
if action == 'Excel':
return export_asistencia(resultados, fecha_inicio, grupo)
alumnos = {}
for resultado in resultados:
if not resultado['nombre'] in alumnos:
alumnos[resultado['nombre']] = {
"Ausente": 0,
"Presente": 0,
"Nombre": resultado['nombre']
}
alumnos[resultado['nombre']][resultado['asistencia']] += 1
alumnos = [alumnos[alumno] for alumno in alumnos]
context = {'mes': '{0:02}/{1}'.format(fecha_inicio.month, fecha_inicio.year),
'grupo': grupo, 'resultados': resultados, 'alumnos': alumnos}
return render(request, "asistencia.html", context)
def alumnos_por_grupo(request):
accion = request.GET.get('action', None)
fecha = datetime.date.today()
query = """
select
g.cupo_maximo,
g.hora_fin,
g.hora_inicio,
g.lunes,
g.martes,
g.miercoles,
g.jueves,
g.viernes,
g.sabado,
g.domingo,
prof.nombre as nombre,
prof.apellido as apellido,
c.nombre as nombre_curso,
count.cantidad
from (
select
grupo_id,
count(*) as cantidad
from escuela_inscripcion
where estado = 'A'
group by grupo_id
) count
join escuela_grupo g on count.grupo_id = g.id
join escuela_clase c on g.id_clase_id = c.id
join main_persona prof on prof.id = g.id_profesor_id
order by c.nombre, g.hora_inicio;
"""
cursor = connection.cursor()
cursor.execute(query, {})
resultados = dictfetch(cursor, 1000, 0)
if accion == 'Excel':
return export_alumnos_por_grupo(map(to_grupo_map, resultados), fecha)
context = { "resultados": map(to_grupo_map, resultados), 'fecha': fecha }
return render(request, "alumnos_por_grupo.html", context)
def lista_asistencia(request):
def alumno_json(alumno):
grupo = Grupo(lunes=alumno['lunes'], martes=alumno['martes'], miercoles=alumno['miercoles'],
jueves=alumno['jueves'], viernes=alumno['viernes'], sabado=alumno['sabado'],
domingo=alumno['domingo'])
nombre_grupo = "{0} ({1}) Dias: ({2}) - Horario: ({3} - {4})".format(alumno["clase_nombre"],
alumno["profesor_nombre"],
grupo.get_dias(),
format(alumno['hora_inicio'], '%H:%M'),
format(alumno['hora_fin'], '%H:%M'))
return {
"id": alumno["alumno_id"],
"nombre": alumno["alumno_nombre"],
"grupo": {
"id": alumno["id"], # es id de grupo
"nombre": nombre_grupo
},
"asistencia_presente": alumno["asistencia_presente"],
"asistencia_id": alumno["asistencia_id"],
"asistencia_comentario": alumno["asistencia_comentario"],
"inscripcion_vencida": alumno["inscripcion_vencida"]
}
ret = {}
if request.method == 'GET':
fecha = request.GET.get('fecha')
fecha = datetime.strptime(fecha, settings.DATE_INPUT_FORMATS[0]).date()
# .strftime(settings.DATE_INPUT_FORMATS[0])
grupo = request.GET.get('grupo')
# Obtener alumnos
query = '''
SELECT distinct
p.id as alumno_id,
p.nombre::text || ' ' || p.apellido::text || ' (' || p.cedula::text || ')' as alumno_nombre,
g.*,
prof.nombre::text || ' ' || prof.apellido::text as profesor_nombre,
c.nombre as clase_nombre,
asis.id as asistencia_id,
asis.presente as asistencia_presente,
COALESCE(asis.comentario, '') as asistencia_comentario,
COALESCE(i.fecha_fin <= %(fecha)s, FALSE) as inscripcion_vencida
FROM main_alumno a
JOIN main_persona p ON a.persona_ptr_id = p.id
JOIN escuela_inscripcion i ON a.persona_ptr_id = i.alumno_id AND
i.fecha_inicio <= %(fecha)s AND i.estado = 'A'
-- AND (i.fecha_fin >= %(fecha)s OR i.fecha_fin IS NULL)
JOIN escuela_grupo g ON i.grupo_id = g.id
JOIN escuela_clase c ON c.id = g.id_clase_id
JOIN main_persona prof ON g.id_profesor_id = prof.id
LEFT JOIN escuela_asistencia asis
ON g.id = asis.grupo_id AND asis.fecha = %(fecha)s AND asis.id_alumno_id = a.persona_ptr_id
'''
dia = fecha.weekday()
dias = ['lunes', 'martes', 'miercoles', 'jueves', 'viernes', 'sabado', 'domingo']
query += " WHERE g.{0} = true ".format(dias[dia])
if grupo and grupo != '-1':
grupo = int(grupo)
query += " AND g.id = %(grupo)s"
cursor = connection.cursor()
cursor.execute(query, {"fecha": fecha, "grupo": grupo})
ret = dictfetch(cursor, 100, 0)
ret = {
"dia": fecha,
"grupo": grupo,
"alumnos": list(map(alumno_json, ret))
}
return JsonResponse(ret, safe=False)