def ogm_bubble_chart_data(municipio=None, year=None, portada=False):
year_list = getYears(Gasto)
if not year:
year = year_list[-1]
# obtiene último periodo del año que se quiere ver
year_data = Anio.objects.get(anio=year)
periodo = year_data.periodo
if periodo == PERIODO_INICIAL:
data_source = 'asignado'
else:
data_source = 'ejecutado'
if municipio:
municipio_row = Municipio.objects.get(slug=municipio)
municipio_id = municipio_row.id
level_0_sql = """select sum(sd.asignado) as asignado,
sum(sd.ejecutado) as ejecutado
from (
select id.asignado, id.ejecutado, id.gasto_id,
id.subsubtipogasto_id, i.municipio_id, i.periodo, i.anio,
ssti.subtipogasto_id, ssti.origen_id
from core_gastodetalle as id
left join core_gasto as i
on id.gasto_id = i.id
left join core_subsubtipogasto as ssti
on id.subsubtipogasto_id=ssti.codigo
where i.anio = %s
and i.periodo = %s
and i.municipio_id = %s
and origen_id is not null) as sd
left join core_origengasto as o
on sd.origen_id=o.id"""
cursor = connection.cursor()
cursor.execute(level_0_sql, [year_data.anio, periodo, municipio_id])
totals = dictfetchall(cursor)
data = {
'label': "Gastos Totales",
'amount': round(xnumber(totals[0][data_source]) / 1000000, 2)
}
child_l1 = []
level_1_sql = """select sum(sd.asignado) as asignado,
sum(sd.ejecutado) as ejecutado, o.nombre, o.id,
o.shortname
from (
select id.asignado, id.ejecutado, id.gasto_id,
id.subsubtipogasto_id, i.municipio_id, i.periodo, i.anio,
ssti.subtipogasto_id, ssti.origen_id
from core_gastodetalle as id
left join core_gasto as i
on id.gasto_id = i.id
left join core_subsubtipogasto as ssti
on id.subsubtipogasto_id=ssti.codigo
where i.anio = %s
and i.periodo = %s
and i.municipio_id = %s
and origen_id is not null) as sd
left join core_origengasto as o
on sd.origen_id=o.id
group by nombre, shortname, id"""
cursor = connection.cursor()
cursor.execute(level_1_sql, [year_data.anio, periodo, municipio_id])
revenuesource_list = dictfetchall(cursor)
for source in revenuesource_list:
if source['shortname'] is not None:
label = source['shortname']
else:
label = source['nombre']
source_data = {
'taxonomy': "expense",
'name': source['id'],
'id': source['id'],
'label': label,
'amount': round(xnumber(source[data_source]) / 1000000, 2)
}
child_l2 = []
level_2_sql = """select sum(sd.asignado) as asignado,
sum(sd.ejecutado) as ejecutado, sd.nombre, sd.codigo,
sd.shortname
from (
select id.asignado, id.ejecutado, id.gasto_id,
id.subsubtipogasto_id, i.municipio_id, i.periodo, i.anio,
ssti.subtipogasto_id as codigo, ssti.origen_id, sti.nombre,
sti.shortname
from core_gastodetalle as id
left join core_gasto as i
on id.gasto_id = i.id
left join core_subsubtipogasto as ssti
on id.subsubtipogasto_id=ssti.codigo
left join (
select stg.nombre, stg.shortname,
stg.codigo
from core_subtipogasto stg) as sti
on sti.codigo= ssti.subtipogasto_id
where i.anio = %s
and i.periodo = %s and i.municipio_id = %s
and ssti.origen_id = '%s') as sd
group by sd.nombre, sd.shortname, sd.codigo"""
cursor = connection.cursor()
cursor.execute(
level_2_sql,
[year_data.anio, periodo, municipio_id, source['id']])
subtype_list = dictfetchall(cursor)
for subtype in subtype_list:
if subtype['shortname'] is not None:
label = subtype['shortname']
else:
label = subtype['nombre']
subtype_data = {
'label': label,
'amount':
round(xnumber(subtype[data_source]) / 1000000, 2)
}
child_l2.append(subtype_data)
source_data['children'] = child_l2
child_l1.append(source_data)
data['children'] = child_l1
else:
level_0_sql = """select sum(sd.asignado) as asignado,
sum(sd.ejecutado) as ejecutado
from (
select id.asignado, id.ejecutado, id.gasto_id,
id.subsubtipogasto_id, i.municipio_id, i.periodo, i.anio,
ssti.subtipogasto_id, ssti.origen_id
from core_gastodetalle as id
left join core_gasto as i
on id.gasto_id = i.id
left join core_subsubtipogasto as ssti
on id.subsubtipogasto_id=ssti.codigo
where i.anio = %s
and i.periodo = %s
and origen_id is not null) as sd
left join core_origengasto as o on sd.origen_id=o.id"""
cursor = connection.cursor()
cursor.execute(level_0_sql, [year_data.anio, periodo])
totals = dictfetchall(cursor)
data = {
'label': "Gastos Totales",
'amount': round(xnumber(totals[0][data_source]) / 1000000, 2)
}
child_l1 = []
level_1_sql = """select sum(sd.asignado) as asignado,
sum(sd.ejecutado) as ejecutado, o.nombre, o.id,
o.shortname
from (
select id.asignado, id.ejecutado, id.gasto_id,
id.subsubtipogasto_id, i.municipio_id, i.periodo, i.anio,
ssti.subtipogasto_id, ssti.origen_id
from core_gastodetalle as id
left join core_gasto as i
on id.gasto_id = i.id
left join core_subsubtipogasto as ssti
on id.subsubtipogasto_id=ssti.codigo
where i.anio = %s and i.periodo = %s
and origen_id is not null) as sd
left join core_origengasto as o
on sd.origen_id=o.id
group by nombre, shortname, id"""
cursor = connection.cursor()
cursor.execute(level_1_sql, [year_data.anio, periodo])
revenuesource_list = dictfetchall(cursor)
for source in revenuesource_list:
child_l3 = []
if source['shortname'] is not None:
label = source['shortname']
else:
label = source['nombre']
source_data = {
'taxonomy': "expense",
'name': source['id'],
'id': source['id'],
'label': label,
'amount': round(xnumber(source[data_source]) / 1000000, 2)
}
child_l2 = []
level_2_sql = """select sum(sd.asignado) as asignado,
sum(sd.ejecutado) as ejecutado, sd.nombre, sd.codigo,
sd.shortname
from (
select id.asignado, id.ejecutado, id.gasto_id,
id.subsubtipogasto_id, i.municipio_id, i.periodo, i.anio,
ssti.subtipogasto_id as codigo, ssti.origen_id, sti.nombre,
sti.shortname
from core_gastodetalle as id
left join core_gasto as i
on id.gasto_id = i.id
left join core_subsubtipogasto as ssti
on id.subsubtipogasto_id::text=ssti.codigo::text
left join (
select stg.nombre, stg.shortname,
stg.codigo
from core_subtipogasto stg) as sti
on sti.codigo= ssti.subtipogasto_id
where i.anio = %s
and i.periodo = %s
and ssti.origen_id = '%s') as sd
group by sd.nombre, sd.shortname, sd.codigo"""
cursor = connection.cursor()
cursor.execute(level_2_sql,
[year_data.anio, periodo, source['id']])
subtype_list = dictfetchall(cursor)
for subtype in subtype_list:
if subtype['shortname'] is not None:
label = subtype['shortname']
else:
label = subtype['nombre']
subtype_data = {
'label': label,
'amount':
round(xnumber(subtype[data_source]) / 1000000, 2)
}
child_l2.append(subtype_data)
source_data['children'] = child_l2
child_l1.append(source_data)
data['children'] = child_l1
return json.dumps(data)
def oim_bubble_chart_data(municipio=None, year=None, portada=False):
year_list = getYears(Ingreso)
if not year:
year = year_list[-1]
year_data = Anio.objects.get(anio=year)
periodo = year_data.periodo
if periodo == PERIODO_INICIAL:
data_source = 'asignado'
else:
data_source = 'ejecutado'
saldo_caja = '39000000'
if municipio:
municipio_row = Municipio.objects.get(slug=municipio)
municipio_id = municipio_row.id
if int(year) >= 2018:
level_0_sql = """SELECT sum(sd.asignado) as asignado,
sum(sd.ejecutado) as ejecutado
from (
select id.asignado, id.ejecutado, id.ingreso_id,
id.sub3tipoingreso_id, i.municipio_id, i.periodo,
i.anio, ssti.origen_id
from core_ingresodetalle as id left join core_ingreso as i
on id.ingreso_id = i.id
left join core_sub3tipoingreso as ssti
on id.sub3tipoingreso_id=ssti.codigo
where i.anio = %s
and i.periodo = %s
and i.municipio_id = %s
and origen_id is not null)
as sd
left join core_origenrecurso as o
on sd.origen_id=o.id"""
cursor = connection.cursor()
cursor.execute(level_0_sql,
[year_data.anio, periodo, municipio_id])
else:
level_0_sql = """SELECT sum(sd.asignado) as asignado,
sum(sd.ejecutado) as ejecutado
from (
select id.asignado, id.ejecutado, id.ingreso_id,
id.subsubtipoingreso_id, i.municipio_id, i.periodo,
i.anio, ssti.subtipoingreso_id, ssti.origen_id
from core_ingresodetalle as id left join core_ingreso as i
on id.ingreso_id = i.id
left join core_subsubtipoingreso as ssti
on id.subsubtipoingreso_id=ssti.codigo
where i.anio = %s
and i.periodo = %s
and i.municipio_id = %s
and id.tipoingreso_id != %s
and origen_id is not null)
as sd
left join core_origenrecurso as o
on sd.origen_id=o.id"""
cursor = connection.cursor()
cursor.execute(level_0_sql,
[year_data.anio, periodo, municipio_id, saldo_caja])
totals = dictfetchall(cursor)
if totals[0][data_source] is not None:
data = {
'label': "Ingresos Totales",
'amount': round(totals[0][data_source] / 1000000, 2)
}
else:
data = {'label': "Ingresos Totales", 'amount': 0.00}
child_l1 = []
if int(year) >= 2018:
level_1_sql = """SELECT SUM(sd.asignado) AS asignado,
SUM(sd.ejecutado) AS ejecutado, o.nombre, o.shortname, o.id
from (
select id.asignado, id.ejecutado, id.ingreso_id,
id.sub3tipoingreso_id, i.municipio_id, i.periodo, i.anio,
ssti.origen_id
from core_ingresodetalle as id
left join core_ingreso as i on id.ingreso_id = i.id
left join core_sub3tipoingreso as ssti
on id.sub3tipoingreso_id=ssti.codigo
where i.anio = %s
and i.periodo = %s
and i.municipio_id = %s
and origen_id is not null)
as sd
left join core_origenrecurso as o
on sd.origen_id=o.id
group by nombre, shortname, id"""
cursor = connection.cursor()
cursor.execute(level_1_sql,
[year_data.anio, periodo, municipio_id])
else:
level_1_sql = """SELECT SUM(sd.asignado) AS asignado,
SUM(sd.ejecutado) AS ejecutado, o.nombre, o.shortname, o.id
from (
select id.asignado, id.ejecutado, id.ingreso_id,
id.subsubtipoingreso_id, i.municipio_id, i.periodo, i.anio,
ssti.subtipoingreso_id, ssti.origen_id
from core_ingresodetalle as id
left join core_ingreso as i on id.ingreso_id = i.id
left join core_subsubtipoingreso as ssti
on id.subsubtipoingreso_id=ssti.codigo
where i.anio = %s
and i.periodo = %s
and i.municipio_id = %s
and id.tipoingreso_id != %s
and origen_id is not null)
as sd
left join core_origenrecurso as o
on sd.origen_id=o.id
group by nombre, shortname, id"""
cursor = connection.cursor()
cursor.execute(level_1_sql,
[year_data.anio, periodo, municipio_id, saldo_caja])
revenuesource_list = dictfetchall(cursor)
for source in revenuesource_list:
source_data = {
'taxonomy':
"income",
'name':
source['id'],
'id':
source['id'],
'label':
source['shortname']
if source['shortname'] else source['nombre'],
'amount':
round(source[data_source] / 1000000, 2)
}
child_l2 = []
if int(year) >= 2018:
level_2_sql = """select sum(sd.asignado) as asignado,
sum(sd.ejecutado) as ejecutado, sd.nombre, sd.codigo,
sd.shortname
from (
select id.asignado, id.ejecutado, id.ingreso_id,
id.sub3tipoingreso_id, i.municipio_id, i.periodo, i.anio,
subti.subtipoingreso_id as codigo, ssti.origen_id,
sti.nombre, sti.shortname
from core_ingresodetalle as id
left join core_ingreso as i
on id.ingreso_id = i.id
left join core_sub3tipoingreso as ssti
on id.sub3tipoingreso_id=ssti.codigo
left join core_subsubtipoingreso as subti
on subti.codigo= ssti.subsubtipoingreso_id
left join core_subtipoingreso as sti
on sti.codigo= subti.subtipoingreso_id
where i.anio = %s
and i.periodo = %s
and i.municipio_id = %s
and ssti.origen_id = '%s') as sd
group by sd.nombre, sd.shortname, sd.codigo"""
cursor = connection.cursor()
cursor.execute(
level_2_sql,
[year_data.anio, periodo, municipio_id, source['id']])
else:
level_2_sql = """select sum(sd.asignado) as asignado,
sum(sd.ejecutado) as ejecutado, sd.nombre, sd.codigo,
sd.shortname
from (
select id.asignado, id.ejecutado, id.ingreso_id,
id.subsubtipoingreso_id, i.municipio_id, i.periodo, i.anio,
ssti.subtipoingreso_id as codigo, ssti.origen_id,
sti.nombre, sti.shortname
from core_ingresodetalle as id
left join core_ingreso as i
on id.ingreso_id = i.id
left join core_subsubtipoingreso as ssti
on id.subsubtipoingreso_id=ssti.codigo
left join core_subtipoingreso as sti
on sti.codigo= ssti.subtipoingreso_id
where i.anio = %s
and i.periodo = %s
and i.municipio_id = %s
and id.tipoingreso_id != %s
and ssti.origen_id = '%s') as sd
group by sd.nombre, sd.shortname, sd.codigo"""
cursor = connection.cursor()
cursor.execute(level_2_sql, [
year_data.anio, periodo, municipio_id, saldo_caja,
source['id']
])
subtype_list = dictfetchall(cursor)
for subtype in subtype_list:
subtype_data = {
'label':
subtype['shortname']
if subtype['shortname'] else subtype['nombre'],
'amount':
round(subtype[data_source] / 1000000, 2)
}
child_l2.append(subtype_data)
source_data['children'] = child_l2
child_l1.append(source_data)
data['children'] = child_l1
else:
if int(year) >= 2018:
level_0_sql = """SELECT sum(sd.asignado) as asignado,
sum(sd.ejecutado) as ejecutado
from (
select id.asignado, id.ejecutado, id.ingreso_id,
id.sub3tipoingreso_id, i.municipio_id, i.periodo,
i.anio, ssti.origen_id
from core_ingresodetalle as id left join core_ingreso as i
on id.ingreso_id = i.id
left join core_sub3tipoingreso as ssti
on id.sub3tipoingreso_id=ssti.codigo
where i.anio = %s
and i.periodo = %s
and origen_id is not null)
as sd
left join core_origenrecurso as o
on sd.origen_id=o.id"""
cursor = connection.cursor()
cursor.execute(level_0_sql, [year_data.anio, periodo])
else:
level_0_sql = """select sum(sd.asignado) as asignado,
sum(sd.ejecutado) as ejecutado
from (
select id.asignado, id.ejecutado, id.ingreso_id,
id.subsubtipoingreso_id, i.municipio_id, i.periodo, i.anio,
ssti.subtipoingreso_id, ssti.origen_id
from core_ingresodetalle as id
left join core_ingreso as i on id.ingreso_id = i.id
left join core_subsubtipoingreso as ssti
on id.subsubtipoingreso_id=ssti.codigo
where i.anio = %s
and i.periodo = %s
and id.tipoingreso_id != %s
and origen_id is not null) as sd
left join core_origenrecurso as o on sd.origen_id=o.id"""
cursor = connection.cursor()
cursor.execute(level_0_sql, [year_data.anio, periodo, saldo_caja])
totals = dictfetchall(cursor)
data = {
'label': "Ingresos Totales",
'amount': round(totals[0][data_source] / 1000000, 2)
}
child_l1 = []
if int(year) >= 2018:
level_1_sql = """SELECT SUM(sd.asignado) AS asignado,
SUM(sd.ejecutado) AS ejecutado, o.nombre, o.shortname, o.id
from (
select id.asignado, id.ejecutado, id.ingreso_id,
id.sub3tipoingreso_id, i.municipio_id, i.periodo, i.anio,
ssti.origen_id
from core_ingresodetalle as id
left join core_ingreso as i on id.ingreso_id = i.id
left join core_sub3tipoingreso as ssti
on id.sub3tipoingreso_id=ssti.codigo
where i.anio = %s
and i.periodo = %s
and origen_id is not null)
as sd
left join core_origenrecurso as o
on sd.origen_id=o.id
group by nombre, shortname, id"""
cursor = connection.cursor()
cursor.execute(level_1_sql, [year_data.anio, periodo])
else:
level_1_sql = """select sum(sd.asignado) as asignado,
sum(sd.ejecutado) as ejecutado, o.nombre, o.shortname, o.id
from (
select id.asignado, id.ejecutado, id.ingreso_id,
id.subsubtipoingreso_id, i.municipio_id, i.periodo, i.anio,
ssti.subtipoingreso_id, ssti.origen_id
from core_ingresodetalle as id
left join core_ingreso as i on id.ingreso_id = i.id
left join core_subsubtipoingreso as ssti
on id.subsubtipoingreso_id=ssti.codigo
where i.anio = %s
and i.periodo = %s
and id.tipoingreso_id != %s
and origen_id is not null) as sd
left join core_origenrecurso as o
on sd.origen_id=o.id
group by nombre, shortname, id"""
cursor = connection.cursor()
cursor.execute(level_1_sql, [year_data.anio, periodo, saldo_caja])
revenuesource_list = dictfetchall(cursor)
for source in revenuesource_list:
source_data = {
'taxonomy':
"income",
'name':
source['id'],
'id':
source['id'],
'label':
source['shortname']
if source['shortname'] else source['nombre'],
'amount':
round(source[data_source] / 1000000, 2)
}
child_l2 = []
if int(year) >= 2018:
level_2_sql = """select sum(sd.asignado) as asignado,
sum(sd.ejecutado) as ejecutado, sd.nombre, sd.codigo,
sd.shortname
from (
select id.asignado, id.ejecutado, id.ingreso_id,
id.sub3tipoingreso_id, i.municipio_id, i.periodo, i.anio,
subti.subtipoingreso_id as codigo, ssti.origen_id,
sti.nombre, sti.shortname
from core_ingresodetalle as id
left join core_ingreso as i
on id.ingreso_id = i.id
left join core_sub3tipoingreso as ssti
on id.sub3tipoingreso_id=ssti.codigo
left join core_subsubtipoingreso as subti
on subti.codigo= ssti.subsubtipoingreso_id
left join core_subtipoingreso as sti
on sti.codigo= subti.subtipoingreso_id
where i.anio = %s
and i.periodo = %s
and ssti.origen_id = '%s') as sd
group by sd.nombre, sd.shortname, sd.codigo"""
cursor = connection.cursor()
cursor.execute(level_2_sql,
[year_data.anio, periodo, source['id']])
else:
level_2_sql = """select sum(sd.asignado) as asignado,
sum(sd.ejecutado) as ejecutado, sd.nombre, sd.codigo,
sd.shortname
from (
select id.asignado, id.ejecutado, id.ingreso_id,
id.subsubtipoingreso_id, i.municipio_id, i.periodo, i.anio,
ssti.subtipoingreso_id as codigo, ssti.origen_id,
sti.nombre, sti.shortname
from core_ingresodetalle as id left join core_ingreso as i
on id.ingreso_id = i.id
left join core_subsubtipoingreso as ssti
on id.subsubtipoingreso_id=ssti.codigo
left join core_subtipoingreso as sti
on sti.codigo= ssti.subtipoingreso_id
where i.anio = %s
and i.periodo = %s
and id.tipoingreso_id != %s
and ssti.origen_id = '%s') as sd
group by sd.nombre, sd.shortname, sd.codigo"""
cursor = connection.cursor()
cursor.execute(
level_2_sql,
[year_data.anio, periodo, saldo_caja, source['id']])
subtype_list = dictfetchall(cursor)
for subtype in subtype_list:
subtype_data = {
'label':
subtype['shortname']
if subtype['shortname'] else subtype['nombre'],
'amount':
round(subtype[data_source] / 1000000, 2)
}
child_l2.append(subtype_data)
source_data['children'] = child_l2
child_l1.append(source_data)
data['children'] = child_l1
return json.dumps(data)
def ago_chart(request, municipio=None, year=None, portada=False):
municipio_list = Municipio.objects.all()
municipio = getVar('municipio', request)
year_list = getYears(Gasto)
periodo_list = getPeriods(Gasto)
year = getVar('year', request)
if not year:
year = year_list[-1]
# obtiene último periodo del año que se quiere ver
year_data = Anio.objects.get(anio=year)
periodo = year_data.periodo
quesumar = 'asignado' if periodo == PERIODO_INICIAL else 'ejecutado'
datacol = 'inicial_asignado' if periodo == PERIODO_INICIAL else 'ejecutado'
# obtiene codigo de tipo gasto de 'mapping' fallback a valor por defecto definido en models
TipoIngreso.TRANSFERENCIAS_CORRIENTES = year_data.mapping.get(
'transferencias_corrientes', TipoIngreso.TRANSFERENCIAS_CORRIENTES)
# recolectando los codigos de transferencias de corrientes de cada año
codigos_trans_corriente = [
amap['transferencias_corrientes'] for amap in
Anio.objects.all().values_list('mapping', flat=True).distinct()
]
municipio_id = None
if municipio:
municipio_row = Municipio.objects.get(slug=municipio)
municipio_id = municipio_row.id
municipio_nombre = municipio_row.nombre
porclasep = None
source_inicial = IngresoDetalle.objects.filter(
ingreso__periodo=PERIODO_INICIAL,
ingreso__municipio__slug=municipio,
tipoingreso__clasificacion=TipoIngreso.CORRIENTE)\
.exclude(tipoingreso=TipoIngreso.TRANSFERENCIAS_CORRIENTES)\
.values('ingreso__anio')\
.order_by('ingreso__anio')\
.annotate(ejecutado=Sum('ejecutado'), asignado=Sum('asignado'))
source_final = IngresoDetalle.objects.filter(
ingreso__periodo=periodo,
ingreso__municipio__slug=municipio,
tipoingreso__clasificacion=TipoIngreso.CORRIENTE)\
.exclude(tipoingreso=TipoIngreso.TRANSFERENCIAS_CORRIENTES)\
.values('ingreso__anio')\
.order_by('ingreso__anio')\
.annotate(ejecutado=Sum('ejecutado'), asignado=Sum('asignado'))
# obtiene valores para este año de las listas
try:
asignado = (
item for item in source_inicial
if item["ingreso__anio"] == int(year)).next()['asignado']
except StopIteration:
asignado = 0
try:
ejecutado = (
item for item in source_final
if item["ingreso__anio"] == int(year)).next()['ejecutado']
except StopIteration:
ejecutado = 0
# obtiene datos comparativo de ingresos de todos los años
inicial = list(
IngresoDetalle.objects.filter(
ingreso__municipio__slug=municipio,
ingreso__periodo=PERIODO_INICIAL,
tipoingreso__clasificacion=TipoIngreso.CORRIENTE).exclude(
tipoingreso__in=codigos_trans_corriente).values(
'ingreso__anio', 'ingreso__periodo').annotate(
asignado=Sum('asignado')).order_by())
final = list(
IngresoDetalle.objects.filter(
ingreso__municipio__slug=municipio,
ingreso__periodo=PERIODO_FINAL,
tipoingreso__clasificacion=TipoIngreso.CORRIENTE).exclude(
tipoingreso__in=codigos_trans_corriente).values(
'ingreso__anio', 'ingreso__periodo').annotate(
ejecutado=Sum('ejecutado')).order_by())
anual2 = glue(inicial=inicial, final=final, key='ingreso__anio')
# obtiene datos comparativo de gastos de todos los años
inicialg = list(
GastoDetalle.objects.filter(
gasto__municipio__slug=municipio,
gasto__periodo=PERIODO_INICIAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE).values(
'gasto__anio', 'gasto__periodo').annotate(
asignado=Sum('asignado')).order_by())
finalg = list(
GastoDetalle.objects.filter(
gasto__municipio__slug=municipio,
gasto__periodo=PERIODO_FINAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE).values(
'gasto__anio', 'gasto__periodo').annotate(
ejecutado=Sum('ejecutado')).order_by())
anual2g = glue(inicial=inicialg, final=finalg, key='gasto__anio')
# obtiene datos de gastos en ditintos rubros
rubrosg_inicial = GastoDetalle.objects.filter(gasto__anio=year, gasto__municipio__slug=municipio,
gasto__periodo=PERIODO_INICIAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE, ). \
values('tipogasto', 'tipogasto__nombre').order_by(
'tipogasto__codigo').annotate(inicial_asignado=Sum('asignado'))
rubrosg_actualizado = GastoDetalle.objects.filter(gasto__anio=year, gasto__municipio__slug=municipio,
gasto__periodo=PERIODO_ACTUALIZADO,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE, ). \
values('tipogasto', 'tipogasto__nombre').order_by('tipogasto__codigo').annotate(
actualizado_asignado=Sum('asignado'), actualizado_ejecutado=Sum('ejecutado'))
rubrosg_final = GastoDetalle.objects.filter(gasto__anio=year, gasto__municipio__slug=municipio,
gasto__periodo=PERIODO_FINAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE, ). \
values('tipogasto', 'tipogasto__nombre').order_by('tipogasto__codigo').annotate(
final_ejecutado=Sum('ejecutado'), final_asignado=Sum('asignado'))
rubrosg_periodo = GastoDetalle.objects.filter(gasto__anio=year, gasto__municipio__slug=municipio,
gasto__periodo=periodo,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE, ). \
values('tipogasto', 'tipogasto__nombre').order_by('tipogasto__codigo').annotate(
ejecutado=Sum('ejecutado'), asignado=Sum('asignado'))
rubrosg = superglue(data=(rubrosg_inicial, rubrosg_final,
rubrosg_actualizado, rubrosg_periodo),
key='tipogasto')
# obtiene datos de ingresos en ditintos rubros de corriente (clasificacion 0)
rubros_inicial = IngresoDetalle.objects. \
filter(ingreso__anio=year,
ingreso__municipio__slug=municipio,
ingreso__periodo=PERIODO_INICIAL,
tipoingreso__clasificacion=TipoIngreso.CORRIENTE). \
exclude(tipoingreso=TipoIngreso.TRANSFERENCIAS_CORRIENTES). \
values('tipoingreso',
'tipoingreso__nombre'). \
order_by('tipoingreso__codigo'). \
annotate(inicial_asignado=Sum('asignado'))
rubros_actualizado = IngresoDetalle.objects. \
filter(ingreso__anio=year,
ingreso__municipio__slug=municipio,
ingreso__periodo=PERIODO_ACTUALIZADO,
tipoingreso__clasificacion=TipoIngreso.CORRIENTE). \
exclude(tipoingreso=TipoIngreso.TRANSFERENCIAS_CORRIENTES). \
values('tipoingreso',
'tipoingreso__nombre'). \
order_by('tipoingreso__codigo'). \
annotate(actualizado_asignado=Sum('asignado'),
actualizado_ejecutado=Sum('ejecutado'))
rubros_final = IngresoDetalle.objects. \
filter(ingreso__anio=year,
ingreso__municipio__slug=municipio,
ingreso__periodo=PERIODO_FINAL,
tipoingreso__clasificacion=TipoIngreso.CORRIENTE). \
exclude(tipoingreso=TipoIngreso.TRANSFERENCIAS_CORRIENTES). \
values('tipoingreso',
'tipoingreso__nombre'). \
order_by('tipoingreso__codigo'). \
annotate(final_asignado=Sum('asignado'),
final_ejecutado=Sum('ejecutado'))
rubros_periodo = IngresoDetalle.objects. \
filter(ingreso__anio=year,
ingreso__municipio__slug=municipio,
ingreso__periodo=periodo,
tipoingreso__clasificacion=TipoIngreso.CORRIENTE). \
exclude(tipoingreso=TipoIngreso.TRANSFERENCIAS_CORRIENTES). \
values('tipoingreso',
'tipoingreso__nombre'). \
order_by('tipoingreso__codigo'). \
annotate(asignado=Sum('asignado'),
ejecutado=Sum('ejecutado'))
rubros = superglue(data=(rubros_inicial, rubros_final,
rubros_actualizado, rubros_periodo),
key='tipoingreso')
# obtiene clase y contador (otros en misma clase) para este año
mi_clase = ClasificacionMunicAno.objects.get(
municipio__id=municipio_id, anio=year)
# mi_clase_count = ClasificacionMunicAno.objects.filter(
# clasificacion__clasificacion=mi_clase.clasificacion, anio=year).count()
# obtiene clase y contador (otros en misma clase) para todos los años
mi_clase_anios = list(
ClasificacionMunicAno.objects.filter(
municipio__slug=municipio).values(
'anio', 'clasificacion__clasificacion').annotate())
mi_clase_anios_count = {}
for aclase in mi_clase_anios:
mi_clase_anios_count[
aclase['anio']] = ClasificacionMunicAno.objects.filter(
clasificacion__clasificacion=aclase[
'clasificacion__clasificacion'],
anio=aclase['anio']).count()
# grafico de ejecutado y asignado a nivel nacional (distintas clases) porcentage
with open("core/charts/ago_otros.sql", "r") as query_file:
sql_tpl = query_file.read()
sql = sql_tpl.format(
quesumar="asignado",
year=year,
periodo=PERIODO_INICIAL,
tipoingreso=TipoIngreso.CORRIENTE,
notipoingreso=TipoIngreso.TRANSFERENCIAS_CORRIENTES,
mi_clase=mi_clase.clasificacion_id)
cursor = connection.cursor()
cursor.execute(sql)
inicial = dictfetchall(cursor)
sql = sql_tpl.format(
quesumar="ejecutado",
year=year,
periodo=periodo,
tipoingreso=TipoIngreso.CORRIENTE,
notipoingreso=TipoIngreso.TRANSFERENCIAS_CORRIENTES,
mi_clase=mi_clase.clasificacion_id)
cursor = connection.cursor()
cursor.execute(sql)
final = dictfetchall(cursor)
sql = sql_tpl.format(
quesumar="asignado",
year=year,
periodo=PERIODO_ACTUALIZADO,
tipoingreso=TipoIngreso.CORRIENTE,
notipoingreso=TipoIngreso.TRANSFERENCIAS_CORRIENTES,
mi_clase=mi_clase.clasificacion_id)
cursor = connection.cursor()
cursor.execute(sql)
actualizado = dictfetchall(cursor)
otros = glue(inicial, final, 'nombre', actualizado=actualizado)
sort_key = "{}".format(quesumar)
otros = sorted(otros, key=itemgetter(sort_key), reverse=True)
with open("core/charts/ago_municipio.sql", "r") as query_file:
sql_tpl = query_file.read()
sql = sql_tpl.format(municipio=municipio, year_list=year_list)
cursor = connection.cursor()
cursor.execute(sql)
source = dictfetchall(cursor)
else:
#
# no municipio
#
otros = None
mi_clase = None
municipio_row = ''
municipio = ''
# obtiene datos comparativo de ingresos de todos los años
inicial = list(
IngresoDetalle.objects.filter(
ingreso__periodo=PERIODO_INICIAL,
tipoingreso__clasificacion=TipoIngreso.CORRIENTE).exclude(
tipoingreso__in=codigos_trans_corriente).values(
'ingreso__anio', 'ingreso__periodo').order_by(
'ingreso__anio', 'ingreso__periodo').annotate(
asignado=Sum('asignado')))
final = list(
IngresoDetalle.objects.filter(
ingreso__periodo=PERIODO_FINAL,
tipoingreso__clasificacion=TipoIngreso.CORRIENTE).exclude(
tipoingreso__in=codigos_trans_corriente).values(
'ingreso__anio', 'ingreso__periodo').order_by(
'ingreso__anio', 'ingreso__periodo').annotate(
ejecutado=Sum('ejecutado')))
anual2 = glue(inicial=inicial, final=final, key='ingreso__anio')
# obtiene datos comparativo de gastos de todos los años
inicialg = list(
GastoDetalle.objects.filter(
gasto__periodo=PERIODO_INICIAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE).values(
'gasto__anio', 'gasto__periodo').order_by(
'gasto__anio',
'gasto__periodo').annotate(asignado=Sum('asignado')))
finalg = list(
GastoDetalle.objects.filter(
gasto__periodo=PERIODO_FINAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE).values(
'gasto__anio', 'gasto__periodo').order_by(
'gasto__anio',
'gasto__periodo').annotate(ejecutado=Sum('ejecutado')))
anual2g = glue(inicial=inicialg, final=finalg, key='gasto__anio')
# obtiene datos de gastos en ditintos rubros
rubrosg_inicial = GastoDetalle.objects. \
filter(gasto__anio=year,
gasto__periodo=PERIODO_INICIAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE). \
values('tipogasto',
'tipogasto__nombre'). \
order_by('tipogasto__codigo'). \
annotate(inicial_asignado=Sum('asignado'))
rubrosg_actualizado = GastoDetalle.objects. \
filter(gasto__anio=year,
gasto__periodo=PERIODO_ACTUALIZADO,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE). \
values('tipogasto',
'tipogasto__nombre'). \
order_by('tipogasto__codigo'). \
annotate(actualizado_asignado=Sum('asignado'),
actualizado_ejecutado=Sum('ejecutado'))
rubrosg_final = GastoDetalle.objects. \
filter(gasto__anio=year,
gasto__periodo=PERIODO_FINAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE). \
values('tipogasto',
'tipogasto__nombre'). \
order_by('tipogasto__codigo'). \
annotate(final_asignado=Sum('asignado'),
final_ejecutado=Sum('ejecutado'))
rubrosg_periodo = GastoDetalle.objects. \
filter(gasto__anio=year,
gasto__periodo=periodo,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE). \
values('tipogasto',
'tipogasto__nombre'). \
order_by('tipogasto__codigo'). \
annotate(ejecutado=Sum('ejecutado'))
rubrosg = superglue(data=(rubrosg_inicial, rubrosg_final,
rubrosg_actualizado, rubrosg_periodo),
key='tipogasto')
# obtiene datos de ingresos en ditintos rubros
rubros_inicial = IngresoDetalle.objects. \
filter(ingreso__anio=year,
ingreso__periodo=PERIODO_INICIAL,
tipoingreso__clasificacion=TipoIngreso.CORRIENTE). \
exclude(tipoingreso=TipoIngreso.TRANSFERENCIAS_CORRIENTES). \
values('tipoingreso',
'tipoingreso__nombre'). \
order_by('tipoingreso__codigo'). \
annotate(inicial_asignado=Sum('asignado'))
rubros_actualizado = IngresoDetalle.objects. \
filter(ingreso__anio=year,
ingreso__periodo=PERIODO_ACTUALIZADO,
tipoingreso__clasificacion=TipoIngreso.CORRIENTE). \
exclude(tipoingreso=TipoIngreso.TRANSFERENCIAS_CORRIENTES). \
values('tipoingreso',
'tipoingreso__nombre'). \
order_by('tipoingreso__codigo'). \
annotate(actualizado_asignado=Sum('asignado'),
actualizado_ejecutado=Sum('ejecutado'))
rubros_final = IngresoDetalle.objects. \
filter(ingreso__anio=year,
ingreso__periodo=PERIODO_FINAL,
tipoingreso__clasificacion=TipoIngreso.CORRIENTE). \
exclude(tipoingreso=TipoIngreso.TRANSFERENCIAS_CORRIENTES). \
values('tipoingreso',
'tipoingreso__nombre'). \
order_by('tipoingreso__codigo'). \
annotate(final_asignado=Sum('asignado'),
final_ejecutado=Sum('ejecutado'))
rubros_periodo = IngresoDetalle.objects. \
filter(ingreso__anio=year,
ingreso__periodo=periodo,
tipoingreso__clasificacion=TipoIngreso.CORRIENTE). \
exclude(tipoingreso=TipoIngreso.TRANSFERENCIAS_CORRIENTES). \
values('tipoingreso',
'tipoingreso__nombre'). \
order_by('tipoingreso__codigo'). \
annotate(asignado=Sum('asignado'),
ejecutado=Sum('ejecutado'))
rubros = superglue(data=(rubros_inicial, rubros_final,
rubros_actualizado, rubros_periodo),
key='tipoingreso')
source_inicial = IngresoDetalle.objects. \
filter(ingreso__periodo=PERIODO_INICIAL,
tipoingreso__clasificacion=TipoGasto.CORRIENTE). \
exclude(tipoingreso=TipoIngreso.TRANSFERENCIAS_CORRIENTES). \
values('ingreso__anio'). \
order_by('ingreso__anio'). \
annotate(ejecutado=Sum('ejecutado'),
asignado=Sum('asignado'))
source_final = IngresoDetalle.objects. \
filter(ingreso__periodo=periodo,
tipoingreso__clasificacion=TipoGasto.CORRIENTE). \
exclude(tipoingreso=TipoIngreso.TRANSFERENCIAS_CORRIENTES). \
values('ingreso__anio'). \
order_by('ingreso__anio'). \
annotate(ejecutado=Sum('ejecutado'), asignado=Sum('asignado'))
# obtiene valores para este año de las listas
try:
asignado = (
item for item in source_inicial
if item["ingreso__anio"] == int(year)).next()['asignado']
except StopIteration:
asignado = 0
try:
ejecutado = (
item for item in source_final
if item["ingreso__anio"] == int(year)).next()['ejecutado']
except StopIteration:
ejecutado = 0
# grafico de ejecutado y asignado a nivel nacional (distintas clases) porcentage
with open("core/charts/ago_porclasep.sql", "r") as query_file:
sql_tpl = query_file.read()
sql = sql_tpl.format(
quesumar="asignado",
year=year,
periodo=PERIODO_INICIAL,
tipoingreso=TipoIngreso.CORRIENTE,
notipoingreso=TipoIngreso.TRANSFERENCIAS_CORRIENTES)
cursor = connection.cursor()
cursor.execute(sql)
inicial = dictfetchall(cursor)
sql = sql_tpl.format(
quesumar="ejecutado",
year=year,
periodo=periodo,
tipoingreso=TipoIngreso.CORRIENTE,
notipoingreso=TipoIngreso.TRANSFERENCIAS_CORRIENTES)
cursor = connection.cursor()
cursor.execute(sql)
final = dictfetchall(cursor)
sql = sql_tpl.format(
quesumar="asignado",
year=year,
periodo=PERIODO_ACTUALIZADO,
tipoingreso=TipoIngreso.CORRIENTE,
notipoingreso=TipoIngreso.TRANSFERENCIAS_CORRIENTES)
cursor = connection.cursor()
cursor.execute(sql)
actualizado = dictfetchall(cursor)
porclasep = glue(inicial,
final,
'clasificacion',
actualizado=actualizado)
with open("core/charts/ago.sql", "r") as query_file:
sql_tpl = query_file.read()
sql = sql_tpl.format(municipio=municipio, year_list=year_list)
cursor = connection.cursor()
cursor.execute(sql)
source = dictfetchall(cursor)
# calcular el porcentaje de los rubros
for row in rubros:
row['asignado_porcentaje'] = percentage(row['asignado'], asignado)
row['ejecutado_porcentaje'] = percentage(row['ejecutado'], ejecutado)
# calcular el porcentaje de los rubrosg
for row in rubrosg:
row['asignado_porcentaje'] = percentage(row['inicial_asignado'],
asignado, 2)
row['ejecutado_porcentaje'] = percentage(row['ejecutado'], ejecutado,
2)
for row in anual2g:
if row['asignado']:
row['ejecutado_porcentaje'] = percentage(row['ejecutado'],
row['asignado'])
data = RawDataPool(series=[{
'options': {
'source': source
},
'terms': [
'anio',
'ejecutado',
'asignado',
]
}])
data_ingreso = RawDataPool(series=[{
'options': {
'source': rubros
},
'terms': [
'tipoingreso__nombre',
datacol,
]
}])
pie = Chart(
datasource=data_ingreso,
series_options=[{
'options': {
'type': 'pie'
},
'terms': {
'tipoingreso__nombre': [datacol]
}
}],
chart_options=chart_options,
)
bar = Chart(datasource=data_ingreso,
series_options=[{
'options': {
'type': 'column',
'colorByPoint': True
},
'terms': {
'tipoingreso__nombre': [datacol]
}
}],
chart_options=chart_options)
data_gasto = RawDataPool(series=[{
'options': {
'source': rubrosg
},
'terms': ['tipogasto__nombre', datacol]
}])
pie2 = Chart(datasource=data_gasto,
series_options=[{
'options': {
'type': 'pie'
},
'terms': {
'tipogasto__nombre': [datacol]
}
}],
chart_options=chart_options)
bar2 = Chart(datasource=data_gasto,
series_options=[{
'options': {
'type': 'column',
'colorByPoint': True,
},
'terms': {
'tipogasto__nombre': [datacol]
}
}],
chart_options=chart_options)
# fusionando anuales y anualesg
anuales = []
for i in range(len(anual2)):
ago = anual2[i].get('asignado', 0) - anual2g[i].get('asignado', 0)
anuales.append({
'anio':
anual2[i].get('ingreso__anio', 0),
'total_ingreso':
anual2[i].get('asignado', 0),
'total_gasto':
anual2g[i].get('asignado', 0),
'diferencia':
ago,
'diferencia_porcentaje':
percentage(ago, anual2[i].get('asignado'))
})
historico_ingreso = historial_ingresos_corrientes(
periodo_list, year, TipoIngreso.TRANSFERENCIAS_CORRIENTES,
municipio_id)
historico_gasto = historial_gastos_corrientes(periodo_list, year,
municipio_id)
# FIXME BS
porclase = None
reporte = request.POST.get("reporte", "")
if "excel" in request.POST.keys() and reporte:
from core.utils import obtener_excel_response
data = {
'charts': (bar, ),
'indicator_name': "Dependencia para asumir gastos corrientes",
'source': source,
'mi_clase': mi_clase,
'municipio': municipio_row,
'year': year,
'ejecutado': ejecutado,
'asignado': asignado,
'year_list': year_list,
'municipio_list': municipio_list,
'anuales': anuales,
'porclase': porclase,
'porclasep': porclasep,
'rubros': rubros,
'rubrosg': rubrosg,
'mostraren': "porcentaje",
'periodo_list': periodo_list,
'historico_ingreso': historico_ingreso,
'historico_gasto': historico_gasto,
'otros': otros
}
return obtener_excel_response(reporte=reporte, data=data)
bubble_data_ingreso = aci_bubbletree_data_ingreso(municipio, year, portada)
bubble_data_gasto = aci_bubbletree_data_gasto(municipio, year, portada)
bar_horizontal = None
# bar horizontal
if otros:
parameters = {
'data':
otros,
'field1':
'nombre',
'field2':
quesumar,
'typechart':
'bar',
'title':
"Ranking de Municipios Categoría '{}'".format(
mi_clase.clasificacion),
'labelX_axis':
'Municipio',
'labelY_axis':
'Recaudación por habitante en córdobas corrientes',
'pointFormat':
'<span>' + quesumar + '</span>:<b>{point.y:.2f}%</b>',
}
bar_horizontal = graphChart(parameters)
elif porclasep:
if periodo == 'I':
periodo_nombre = 'Inicial'
elif periodo == 'A':
periodo_nombre = 'Intermedio'
else:
periodo_nombre = 'Cierre'
titulo = 'Dependencia para asumir gastos ' \
'corrientes {year} periodo {periodo}'.format(year=year,
periodo=periodo_nombre)
parameters = {
'data': porclasep,
'field1': 'clasificacion',
'field2': '{}_porcentaje'.format(quesumar),
'typechart': 'column',
'title': titulo,
'labelX_axis': 'Grupos',
'labelY_axis': 'Porcentaje',
'interval': 10,
'pointFormat': '<span>{series.name}</span>:<b>{point.y:.2f}%</b>',
}
bar_horizontal = graphChart(parameters)
template_name = 'variance_analysis.html'
context = {
'charts': (
pie,
bar,
pie2,
bar2,
bar_horizontal,
),
'source': source,
'indicator_name': "Dependencia para asumir gastos corrientes",
'indicator_subtitle': "Ingresos corrientes propios por rubro",
'indicator_subtitle2': "Gastos corrientes totales por rubro",
'rankin_name':
"Dependencia para asumir gastos corrientes con ingresos propios",
'indicator_description':
"""Mide el grado de dependencia que tiene el municipio
para cubrir los gastos de operación o de funcionamiento con sus propios
recursos corrientes, sin depender de recursos externos al municipio.
Un resultado negativo significa que es dependiente y si es positivo es auto sostenible.
""",
'bubble_data_1': bubble_data_ingreso,
'bubble_data_2': bubble_data_gasto,
'mi_clase': mi_clase,
'municipio': municipio_row,
'year': year,
'ejecutado': ejecutado,
'asignado': asignado,
'year_list': year_list,
'municipio_list': municipio_list,
'anuales': anuales,
'history': zip(anual2, anual2g),
'porclase': porclase,
'porclasep': porclasep,
'rubros': rubros,
'periodo_list': periodo_list,
'historico_ingreso': historico_ingreso,
'historico_gasto': historico_gasto,
'rubrosg': rubrosg,
'mostraren': "porcentaje",
'otros': otros
}
return render(request, template_name, context)
def inversion_minima_porclase(year, portada=False):
periodo = Anio.objects.get(anio=year).periodo
# usar 'asignado' para todo periodo si estamos en portada
if portada:
quesumar = 'asignado'
else:
quesumar = 'ejecutado'
sql_tpl = "SELECT clasificacion,minimo_inversion AS minimo,\
((SELECT SUM({quesumar}) FROM core_IngresoDetalle JOIN core_Ingreso ON core_IngresoDetalle.ingreso_id=core_Ingreso.id JOIN core_TipoIngreso ON core_IngresoDetalle.tipoingreso_id=core_TipoIngreso.codigo \
JOIN lugar_clasificacionmunicano ON core_Ingreso.municipio_id=lugar_clasificacionmunicano.municipio_id AND core_Ingreso.anio=lugar_clasificacionmunicano.anio \
WHERE core_Ingreso.anio={year} AND core_Ingreso.periodo='{periodo}' AND core_tipoingreso.clasificacion={clasificacion} AND tipoingreso_id<>'{tipoingreso}' AND lugar_clasificacionmunicano.clasificacion_id=clase.id) -\
(SELECT SUM({quesumar}) FROM core_GastoDetalle JOIN core_Gasto ON core_GastoDetalle.gasto_id=core_Gasto.id JOIN core_TipoGasto ON core_GastoDetalle.tipogasto_id=core_TipoGasto.codigo \
JOIN lugar_clasificacionmunicano ON core_Gasto.municipio_id=lugar_clasificacionmunicano.municipio_id AND core_Gasto.anio=lugar_clasificacionmunicano.anio \
WHERE core_Gasto.anio={year} AND core_Gasto.periodo='{periodo}' AND core_tipogasto.clasificacion={clasificacion} AND lugar_clasificacionmunicano.clasificacion_id=clase.id)) /\
(SELECT SUM({quesumar}) FROM core_IngresoDetalle JOIN core_Ingreso ON core_IngresoDetalle.ingreso_id=core_Ingreso.id JOIN core_TipoIngreso ON core_IngresoDetalle.tipoingreso_id=core_TipoIngreso.codigo \
JOIN lugar_clasificacionmunicano ON core_Ingreso.municipio_id=lugar_clasificacionmunicano.municipio_id AND core_Ingreso.anio=lugar_clasificacionmunicano.anio \
WHERE core_Ingreso.anio={year} AND core_Ingreso.periodo='{periodo}' AND core_tipoingreso.clasificacion={clasificacion} AND tipoingreso_id<>'{tipoingreso}' AND lugar_clasificacionmunicano.clasificacion_id=clase.id) * 100\
AS {quesumar_as} FROM lugar_clasificacionmunic AS clase WHERE minimo_inversion>0"
#sql = sql_tpl.format(quesumar=quesumar, year=year, periodo=PERIODO_FINAL, clasificacion='0', tipoingreso='FIXME15000000', quesumar_as='ejecutado')
#cursor = connection.cursor()
#cursor.execute(sql)
#final = dictfetchall(cursor)
#sql = sql_tpl.format(quesumar='asignado', year=year, periodo=PERIODO_INICIAL, clasificacion='0', tipoingreso='FIXME15000000', quesumar_as='asignado')
sql = sql_tpl.format(quesumar='asignado',
year=year,
periodo=periodo,
clasificacion='0',
tipoingreso='FIXME15000000',
quesumar_as='asignado')
cursor = connection.cursor()
cursor.execute(sql)
inicial = dictfetchall(cursor)
#porclase = glue(inicial, final, 'clasificacion')
data = RawDataPool(
series=
#[{'options': {'source': porclase },
[{
'options': {
'source': inicial
},
'names':
[u'Categorías de municipios', u'Mínimo por ley', u'Presupuestado'],
'terms': [
'clasificacion',
'minimo',
#'ejecutado',
'asignado',
]
}])
chart = Chart(
datasource=data,
series_options=[{
'options': {
'type': 'column',
},
#'terms':{ 'clasificacion': [ 'asignado', 'ejecutado', 'minimo', ] }
'terms': {
'clasificacion': [
'asignado',
'minimo',
]
}
}],
chart_options={
#grafico 4 de portada
'title': {
'text': u' '
},
'tooltip': {
'pointFormat': '{series.name}: <b>{point.y:.2f}%</b>'
},
})
return {
'charts': (chart, ),
}
def ep_chart(request):
saldo_caja = '39000000'
municipio_list = Municipio.objects.all()
municipio = getVar('municipio', request)
periodo_list = getPeriods(Gasto)
year_list = getYears(Gasto)
year = getVar('year', request)
if not year:
year = year_list[-1]
periodo = Anio.objects.get(anio=year).periodo
quesumar = 'asignado' if periodo == PERIODO_INICIAL else 'ejecutado'
datacol = 'inicial_asignado' if periodo == PERIODO_INICIAL else 'ejecutado'
portada = False
municipio_id = None
saldo_caja = '39000000'
if municipio:
municipio_row = Municipio.objects.get(slug=municipio)
municipio_id = municipio_row.id
municipio_nombre = municipio_row.nombre
porclasep = None
# obtiene clase y contador (otros en misma clase) para este año
mi_clase = ClasificacionMunicAno.objects.get(municipio__slug=municipio,
anio=year)
mi_clase_count = ClasificacionMunicAno.objects.filter(
clasificacion__clasificacion=mi_clase.clasificacion,
anio=year).count()
# obtiene clase y contador (otros en misma clase) para todos los años
mi_clase_anios = list(
ClasificacionMunicAno.objects.filter(
municipio__slug=municipio).values(
'anio', 'clasificacion__clasificacion').annotate())
mi_clase_anios_count = {}
for aclase in mi_clase_anios:
mi_clase_anios_count[
aclase['anio']] = ClasificacionMunicAno.objects.filter(
clasificacion__clasificacion=aclase[
'clasificacion__clasificacion'],
anio=aclase['anio']).count()
# obtiene datos de municipios de la misma clase
with open("core/charts/ep_otros.sql", "r") as query_file:
sql_tpl = query_file.read()
sql = sql_tpl.format(var='ingreso',
quesumar1="asignado",
quesumar2="ejecutado",
mi_clase=mi_clase.clasificacion.id,
year=year,
periodo_inicial=PERIODO_INICIAL,
periodo_final=periodo)
cursor = connection.cursor()
cursor.execute(sql)
ingresos = dictfetchall(cursor)
sql = sql_tpl.format(var='gasto',
quesumar1="asignado",
quesumar2="ejecutado",
mi_clase=mi_clase.clasificacion.id,
year=year,
periodo_inicial=PERIODO_INICIAL,
periodo_final=periodo)
cursor = connection.cursor()
cursor.execute(sql)
gastos = dictfetchall(cursor)
otros = glue(ingresos, gastos, 'nombre')
# obtiene datos de gastos en ditintos rubros
rubrosg_inicial = GastoDetalle.objects. \
filter(gasto__anio=year,
gasto__municipio__id=municipio_id, gasto__periodo=PERIODO_INICIAL,).\
values('subsubtipogasto__clasificacion',). \
order_by('subsubtipogasto__clasificacion'). \
annotate(inicial_asignado=Sum('asignado'))
rubrosg_actualizado = GastoDetalle.objects. \
filter(gasto__anio=year,
gasto__municipio__id=municipio_id,
gasto__periodo=PERIODO_ACTUALIZADO). \
values('subsubtipogasto__clasificacion'). \
order_by('subsubtipogasto__clasificacion'). \
annotate(actualizado_asignado=Sum('asignado'),
actualizado_ejecutado=Sum('ejecutado'))
rubrosg_final = GastoDetalle.objects. \
filter(gasto__anio=year,
gasto__municipio__id=municipio_id,
gasto__periodo=PERIODO_FINAL).\
values('subsubtipogasto__clasificacion'). \
order_by('subsubtipogasto__clasificacion'). \
annotate(final_asignado=Sum('asignado'),
final_ejecutado=Sum('ejecutado'))
rubrosg_periodo = GastoDetalle.objects. \
filter(gasto__anio=year,
gasto__municipio__id=municipio_id,
gasto__periodo=periodo).\
values('subsubtipogasto__clasificacion'). \
order_by('subsubtipogasto__clasificacion'). \
annotate(asignado=Sum('asignado'),
ejecutado=Sum('ejecutado'))
rubrosg = superglue(data=(rubrosg_inicial, rubrosg_final,
rubrosg_actualizado, rubrosg_periodo),
key='subsubtipogasto__clasificacion')
for r in rubrosg:
r['subsubtipogasto__clasificacion'] = CLASIFICACION_VERBOSE[
r['subsubtipogasto__clasificacion']]
# ejecucion del presupuesto de gastos
gastos_asignados = sum(item['inicial_asignado']
for item in rubrosg_inicial)
gastos_ejecutados = sum(item['ejecutado'] for item in rubrosg_periodo)
if gastos_asignados:
ep_gastos = round(
((gastos_ejecutados / gastos_asignados) - 1) * 100, 1)
else:
ep_gastos = 0
# obtiene datos de ingresos en ditintos rubros de corriente (clasificacion 0)
rubros_inicial = IngresoDetalle.objects. \
filter(ingreso__anio=year,
ingreso__municipio__id=municipio_id,
ingreso__periodo=PERIODO_INICIAL). \
exclude(tipoingreso_id=saldo_caja). \
values('tipoingreso__clasificacion'). \
order_by(). \
annotate(inicial_asignado=Sum('asignado'))
rubros_actualizado = IngresoDetalle.objects. \
filter(ingreso__anio=year,
ingreso__municipio__id=municipio_id,
ingreso__periodo=PERIODO_ACTUALIZADO). \
values('tipoingreso__clasificacion'). \
order_by(). \
annotate(actualizado_asignado=Sum('asignado'),
actualizado_ejecutado=Sum('ejecutado'))
rubros_final = IngresoDetalle.objects. \
filter(ingreso__anio=year,
ingreso__municipio__id=municipio_id,
ingreso__periodo=PERIODO_FINAL).\
exclude(tipoingreso_id=saldo_caja).\
values('tipoingreso__clasificacion'). \
order_by(). \
annotate(final_asignado=Sum('asignado'),
final_ejecutado=Sum('ejecutado'))
rubros_periodo = IngresoDetalle.objects. \
filter(ingreso__anio=year,
ingreso__municipio__id=municipio_id,
ingreso__periodo=periodo). \
values('tipoingreso__clasificacion'). \
order_by(). \
annotate(asignado=Sum('asignado'),
ejecutado=Sum('ejecutado'))
rubros = superglue(data=(rubros_inicial, rubros_final,
rubros_actualizado, rubros_periodo),
key='tipoingreso__clasificacion')
for r in rubros:
r['tipoingreso__clasificacion'] = CLASIFICACION_VERBOSE[
r['tipoingreso__clasificacion']]
# calculo de La Ejecución presupuestaria alcanzó el:
# FIXME incial_asignado? o asignado (periodo) ? misma pregunta sobre final_ejecutado.
ingresos_asignados = sum(item['inicial_asignado']
for item in rubros_inicial)
if rubros_final:
ingresos_ejecutados = sum(item['final_ejecutado']
for item in rubros_final)
elif rubros_actualizado:
ingresos_ejecutados = sum(item['actualizado_ejecutado']
for item in rubros_actualizado)
else:
ingresos_ejecutados = 0
if ingresos_asignados:
ep_ingresos = round(
((ingresos_ejecutados / ingresos_asignados) - 1) * 100, 1)
else:
ep_ingresos = 0
# obtiene datos comparativo de todos los años
inicial = list(
IngresoDetalle.objects.filter(
ingreso__municipio__id=municipio_id,
ingreso__periodo=PERIODO_INICIAL).exclude(
tipoingreso_id=saldo_caja).values(
'ingreso__anio', 'ingreso__periodo').annotate(
asignado=Sum('asignado')).order_by())
final = list(
IngresoDetalle.objects.filter(
ingreso__municipio__id=municipio_id,
ingreso__periodo=PERIODO_FINAL).exclude(
tipoingreso_id=saldo_caja).values(
'ingreso__anio', 'ingreso__periodo').annotate(
ejecutado=Sum('ejecutado')).order_by())
anual2 = glue(inicial=inicial, final=final, key='ingreso__anio')
# obtiene datos comparativo de todos los años
inicialg = list(
GastoDetalle.objects.filter(
gasto__municipio__id=municipio_id,
gasto__periodo=PERIODO_INICIAL).values(
'gasto__anio', 'gasto__periodo').annotate(
asignado=Sum('asignado')).order_by())
finalg = list(
GastoDetalle.objects.filter(
gasto__municipio__id=municipio_id,
gasto__periodo=PERIODO_FINAL).values(
'gasto__anio', 'gasto__periodo').annotate(
ejecutado=Sum('ejecutado')).order_by())
anual2g = glue(inicial=inicialg, final=finalg, key='gasto__anio')
with open("core/charts/ep_municipio.sql", "r") as query_file:
sql = query_file.read()
source = IngresoDetalle.objects.raw(sql,
[municipio, municipio, year_list])
else:
#
# no municipio
#
otros = None
mi_clase = None
municipio_row = ''
municipio = ''
# obtiene datos de gastos en ditintos rubros
rubrosg_inicial = GastoDetalle.objects.filter(gasto__anio=year, gasto__periodo=PERIODO_INICIAL,).\
values('subsubtipogasto__clasificacion',).order_by(
'subsubtipogasto__clasificacion').annotate(inicial_asignado=Sum('asignado'))
rubrosg_actualizado = GastoDetalle.objects.filter(gasto__anio=year, gasto__periodo=PERIODO_ACTUALIZADO,).\
values('subsubtipogasto__clasificacion',).order_by('subsubtipogasto__clasificacion').annotate(
actualizado_asignado=Sum('asignado'), actualizado_ejecutado=Sum('ejecutado'))
rubrosg_final = GastoDetalle.objects.filter(gasto__anio=year, gasto__periodo=PERIODO_FINAL,).\
values('subsubtipogasto__clasificacion').order_by('subsubtipogasto__clasificacion').annotate(
final_asignado=Sum('asignado'), final_ejecutado=Sum('ejecutado'))
rubrosg_periodo = GastoDetalle.objects.filter(gasto__anio=year, gasto__periodo=periodo,).\
values('subsubtipogasto__clasificacion').order_by('subsubtipogasto__clasificacion').annotate(
asignado=Sum('asignado'), ejecutado=Sum('ejecutado'))
rubrosg = superglue(data=(rubrosg_inicial, rubrosg_final,
rubrosg_actualizado, rubrosg_periodo),
key='subsubtipogasto__clasificacion')
for r in rubrosg:
r['subsubtipogasto__clasificacion'] = CLASIFICACION_VERBOSE[
r['subsubtipogasto__clasificacion']]
# ejecucion presupuestaria del gasto
gastos_asignados = sum(item['inicial_asignado']
for item in rubrosg_inicial)
gastos_ejecutados = sum(item['ejecutado'] for item in rubrosg_periodo)
if gastos_asignados:
ep_gastos = round((gastos_ejecutados / gastos_asignados) - 1 * 100,
1)
else:
ep_gastos = 0
# obtiene datos de ingresos en ditintos rubros de corriente (clasificacion 0)
rubros_inicial = IngresoDetalle.objects.filter(ingreso__anio=year, ingreso__periodo=PERIODO_INICIAL,).\
values('tipoingreso__clasificacion').order_by().annotate(
inicial_asignado=Sum('asignado'))
rubros_actualizado = IngresoDetalle.objects.filter(ingreso__anio=year, ingreso__periodo=PERIODO_ACTUALIZADO,).\
values('tipoingreso__clasificacion').order_by().annotate(
actualizado_asignado=Sum('asignado'), actualizado_ejecutado=Sum('ejecutado'))
rubros_final = IngresoDetalle.objects.filter(ingreso__anio=year, ingreso__periodo=PERIODO_FINAL,).\
values('tipoingreso__clasificacion').order_by().annotate(
final_asignado=Sum('asignado'), final_ejecutado=Sum('ejecutado'))
rubros_periodo = IngresoDetalle.objects.filter(ingreso__anio=year, ingreso__periodo=periodo,).\
values('tipoingreso__clasificacion').order_by().annotate(
asignado=Sum('asignado'), ejecutado=Sum('ejecutado'))
rubros = superglue(data=(rubros_inicial, rubros_final,
rubros_actualizado, rubros_periodo),
key='tipoingreso__clasificacion')
for r in rubros:
r['tipoingreso__clasificacion'] = CLASIFICACION_VERBOSE[
r['tipoingreso__clasificacion']]
# calculo de La Ejecución presupuestaria de ingresos:
ingresos_asignados = sum(item['inicial_asignado']
for item in rubros_inicial)
if rubros_final:
ingresos_ejecutados = sum(item['final_ejecutado']
for item in rubros_final)
elif rubros_actualizado:
ingresos_ejecutados = sum(item['actualizado_ejecutado']
for item in rubros_actualizado)
else:
ingresos_ejecutados = 0
if ingresos_asignados:
ep_ingresos = round(
(ingresos_ejecutados / ingresos_asignados) - 1 * 100, 1)
else:
ep_ingresos = 0
with open("core/charts/ep_porclasep.sql", "r") as query_file:
sql_tpl = query_file.read()
# the new way... re-haciendo "porclasep"
sql = sql_tpl.format(var='ingreso',
quesumar1="asignado",
quesumar2="ejecutado",
year=year,
periodo_inicial=PERIODO_INICIAL,
periodo_final=periodo)
cursor = connection.cursor()
cursor.execute(sql)
ingresos = dictfetchall(cursor)
sql = sql_tpl.format(var='gasto',
quesumar1="asignado",
quesumar2="ejecutado",
year=year,
periodo_inicial=PERIODO_INICIAL,
periodo_final=periodo)
cursor = connection.cursor()
cursor.execute(sql)
gastos = dictfetchall(cursor)
porclasep = glue(ingresos, gastos, 'clasificacion')
# obtiene datos comparativo de todos los años
inicial = list(
IngresoDetalle.objects.filter(
ingreso__periodo=PERIODO_INICIAL).exclude(
tipoingreso_id=saldo_caja).values(
'ingreso__anio', 'ingreso__periodo').annotate(
asignado=Sum('asignado')).order_by())
final = list(
IngresoDetalle.objects.filter(
ingreso__periodo=PERIODO_FINAL).exclude(
tipoingreso_id=saldo_caja).values(
'ingreso__anio', 'ingreso__periodo').annotate(
ejecutado=Sum('ejecutado')).order_by())
anual2 = glue(inicial=inicial, final=final, key='ingreso__anio')
# obtiene datos comparativo de todos los años
inicialg = list(
GastoDetalle.objects.filter(gasto__periodo=PERIODO_INICIAL).values(
'gasto__anio', 'gasto__periodo').annotate(
asignado=Sum('asignado')).order_by())
finalg = list(
GastoDetalle.objects.filter(gasto__periodo=PERIODO_FINAL).values(
'gasto__anio', 'gasto__periodo').annotate(
ejecutado=Sum('ejecutado')).order_by())
anual2g = glue(inicial=inicialg, final=finalg, key='gasto__anio')
with open("core/charts/ep.sql", "r") as query_file:
sql = query_file.read()
source = IngresoDetalle.objects.raw(sql, [year_list])
for row in anual2g:
if row['asignado']:
row['ejecutado_porcentaje'] = percentage(row['ejecutado'],
row['asignado'])
data = RawDataPool(series=[{
'options': {
'source': source
},
'terms': ['anio', 'ejecutado']
}])
data_ingreso = RawDataPool(series=[{
'options': {
'source': rubros
},
'terms': [
'tipoingreso__clasificacion',
datacol,
]
}])
pie = Chart(datasource=data_ingreso,
series_options=[{
'options': {
'type': 'pie'
},
'terms': {
'tipoingreso__clasificacion': [datacol]
}
}],
chart_options=chart_options)
bar = Chart(datasource=data_ingreso,
series_options=[{
'options': {
'type': 'column',
'colorByPoint': True
},
'terms': {
'tipoingreso__clasificacion': [datacol]
}
}],
chart_options=chart_options)
data_gasto = RawDataPool(series=[{
'options': {
'source': rubrosg
},
'terms': [
'subsubtipogasto__clasificacion',
datacol,
]
}])
pie2 = Chart(datasource=data_gasto,
series_options=[{
'options': {
'type': 'pie'
},
'terms': {
'subsubtipogasto__clasificacion': [datacol]
}
}],
chart_options=chart_options)
bar2 = Chart(datasource=data_gasto,
series_options=[{
'options': {
'type': 'column',
'colorByPoint': True,
},
'terms': {
'subsubtipogasto__clasificacion': [datacol]
}
}],
chart_options=chart_options)
# FIXME BS
# asignado = ejecutado = porclase = None
# asignado y ejecutado de ingresos
asignado = ingresos_asignados
ejecutado = ingresos_ejecutados
gastos_asignados = gastos_asignados
gastos_ejecutados = gastos_ejecutados
porclase = None
index = 0
ep_anual = []
for row in anual2:
ep_anual.append({
'anio':
row['ingreso__anio'],
'ic_asignado':
row['asignado'],
'ic_ejecutado':
row['ejecutado'],
'epi':
calculate_ep(row['ejecutado'], row['asignado']),
'gc_asignado':
anual2g[index]['asignado'],
'gc_ejecutado':
anual2g[index]['ejecutado'],
'ep':
calculate_ep(anual2g[index]['ejecutado'],
anual2g[index]['asignado'])
})
index += 1
bubble_data_ingreso = oim_bubble_chart_data(municipio=municipio, year=year)
bubble_data_gasto = ogm_bubble_chart_data(municipio=municipio, year=year)
reporte = request.POST.get("reporte", "")
if "excel" in request.POST.keys() and reporte:
from core.utils import obtener_excel_response
data = {
'charts': (bar, ),
'ep_ingresos': ep_ingresos,
'ep_gastos': ep_gastos,
'asignado': asignado,
'ejecutado': ejecutado,
'gejecutado': gastos_ejecutados,
'gasignado': gastos_asignados,
'mi_clase': mi_clase,
'municipio': municipio_row,
'year': year,
'year_list': year_list,
'municipio_list': municipio_list,
'anual_ep': ep_anual,
'porclase': porclase,
'periodo_list': periodo_list,
'porclasep': porclasep,
'rubros': rubros,
'rubrosg': rubrosg,
'otros': otros
}
return obtener_excel_response(reporte=reporte, data=data)
template_name = 'ep.html'
context = {
'charts': (pie, bar, pie2, bar2),
'indicator_name': "Ejecución del presupuesto",
'indicator_subtitle': "Ingresos totales",
'indicator_subtitle2': "Gastos totales",
'indicator': "ep",
'indicator_description': """Mide la eficiencia del municipio en
la ejecución del ingreso y el gasto presupuestado inicialmente.
Es decir, evaluamos que tanto cambio el presupuesto con
respecto la ejecución versus lo presupuestado y aprobado en los
procesos de consulta.""",
'bubble_data_1': bubble_data_ingreso,
'bubble_data_2': bubble_data_gasto,
'ep_ingresos': ep_ingresos,
'ep_gastos': ep_gastos,
'mi_clase': mi_clase,
'municipio': municipio_row,
'year': year,
'ejecutado': ejecutado,
'asignado': asignado,
'gejecutado': gastos_ejecutados,
'gasignado': gastos_asignados,
'year_list': year_list,
'municipio_list': municipio_list,
'anual_ep': ep_anual,
'history': zip(anual2, anual2g),
'porclase': porclase,
'porclasep': porclasep,
'rubros': rubros,
'rubrosg': rubrosg,
'periodo_list': periodo_list,
'otros': otros
}
return render(request, template_name, context)
def inversion_categoria_chart(municipio=None, year=None, portada=False):
media_nacional = 0
municipio_list = Municipio.objects.all()
year_list = getYears(Inversion)
periodo_list = getPeriods(Inversion)
if not year:
year = year_list[-1]
periodo = Anio.objects.get(anio=year).periodo
datacol = 'asignado' if periodo == PERIODO_INICIAL else 'ejecutado'
# usar 'asignado' para todo periodo si estamos en portada
if portada:
quesumar = 'asignado'
else:
quesumar = 'asignado' if periodo == PERIODO_INICIAL else 'ejecutado'
ChartError = False
if municipio:
porclase = None
porclasep = None
municipio_row = Municipio.objects.get(slug=municipio)
municipio_id = municipio_row.id
municipio_nombre = municipio_row.nombre
source_ultimos = Proyecto.objects.filter(
inversion__municipio__slug=municipio,
inversion__anio__gt=year_list[1])\
.values('inversion__anio')\
.annotate(ejecutado=Sum('ejecutado'), asignado=Sum('asignado'))
# tabla2, tabla3
cat_inicial = Proyecto.objects.filter(
inversion__municipio__slug=municipio,
inversion__periodo=PERIODO_INICIAL,
inversion__anio=year)\
.values(
'catinversion__nombre', 'catinversion__id',
'catinversion__shortname', 'catinversion__color',
'catinversion__slug')\
.annotate(inicial_asignado=Sum('asignado'))\
.order_by('catinversion')
cat_actualizado = Proyecto.objects.filter(
inversion__municipio__slug=municipio,
inversion__periodo=PERIODO_ACTUALIZADO,
inversion__anio=year)\
.values(
'catinversion__nombre', 'catinversion__id',
'catinversion__shortname', 'catinversion__color',
'catinversion__slug')\
.annotate(
actualizado_asignado=Sum('asignado'),
actualizado_ejecutado=Sum('ejecutado'))\
.order_by('catinversion')
cat_final = Proyecto.objects.filter(
inversion__municipio__slug=municipio,
inversion__periodo=PERIODO_FINAL,
inversion__anio=year)\
.values(
'catinversion__nombre', 'catinversion__id',
'catinversion__shortname', 'catinversion__color',
'catinversion__slug')\
.annotate(
final_ejecutado=Sum('ejecutado'),
final_asignado=Sum('asignado'))\
.order_by('catinversion')
cat_periodo = Proyecto.objects.filter(
inversion__municipio__slug=municipio,
inversion__periodo=periodo,
inversion__anio=year)\
.values(
'catinversion__nombre', 'catinversion__id',
'catinversion__shortname', 'catinversion__color',
'catinversion__slug')\
.annotate(
ejecutado=Sum('ejecutado'),
asignado=Sum('asignado'))\
.order_by('catinversion')
cat2 = superglue(data=(cat_inicial, cat_final),
key='catinversion__nombre')
cat3 = superglue(data=(cat_inicial, cat_final, cat_actualizado,
cat_periodo),
key='catinversion__nombre')
# tabla4
anual_inicial = Proyecto.objects.filter(
inversion__municipio__slug=municipio,
inversion__periodo=PERIODO_INICIAL)\
.values('inversion__anio',
'inversion__periodo')\
.annotate(asignado=Sum('asignado'))\
.order_by('inversion__anio')
anual_actualizado = Proyecto.objects.filter(
inversion__municipio__slug=municipio,
inversion__periodo=PERIODO_ACTUALIZADO)\
.values('inversion__anio',
'inversion__periodo')\
.annotate(asignado=Sum('asignado'))\
.order_by('inversion__anio')
anual_final = Proyecto.objects.filter(
inversion__municipio__slug=municipio,
inversion__periodo=PERIODO_FINAL)\
.values('inversion__anio',
'inversion__periodo')\
.annotate(ejecutado=Sum('ejecutado'))\
.order_by('inversion__anio')
# anual2 = glue(
# inicial=anual_inicial, final=anual_final,
# key='inversion__anio')
anual3 = glue(inicial=anual_inicial,
final=anual_final,
actualizado=anual_actualizado,
key='inversion__anio')
# obtiene datos percapita
percapita_inicial_sql = """SELECT core_inversion.anio
AS inversion__anio,
SUM(asignado)/poblacion AS asignado
FROM core_proyecto
JOIN core_inversion
ON core_proyecto.inversion_id=core_inversion.id
JOIN lugar_poblacion
ON core_inversion.municipio_id=lugar_poblacion.municipio_id
AND core_inversion.anio=lugar_poblacion.anio
WHERE core_inversion.municipio_id=%s
AND core_inversion.periodo=%s
GROUP BY core_inversion.anio,poblacion"""
cursor = connection.cursor()
cursor.execute(percapita_inicial_sql, [municipio_id, PERIODO_INICIAL])
percapita_inicial = dictfetchall(cursor)
percapita_actualizado_sql = """SELECT core_inversion.anio
AS inversion__anio,
SUM(asignado)/poblacion AS asignado
FROM core_proyecto
JOIN core_inversion
ON core_proyecto.inversion_id=core_inversion.id
JOIN lugar_poblacion
ON core_inversion.municipio_id=lugar_poblacion.municipio_id
AND core_inversion.anio=lugar_poblacion.anio
WHERE core_inversion.municipio_id=%s
AND core_inversion.periodo=%s
GROUP BY core_inversion.anio, poblacion"""
cursor = connection.cursor()
cursor.execute(percapita_actualizado_sql,
[municipio_id, PERIODO_ACTUALIZADO])
percapita_actualizado = dictfetchall(cursor)
percapita_final_sql = """SELECT core_inversion.anio AS inversion__anio,
SUM(ejecutado)/poblacion AS ejecutado
FROM core_proyecto
JOIN core_inversion
ON core_proyecto.inversion_id=core_inversion.id
JOIN lugar_poblacion
ON core_inversion.municipio_id=lugar_poblacion.municipio_id
AND core_inversion.anio=lugar_poblacion.anio
WHERE core_inversion.municipio_id=%s
AND core_inversion.periodo=%s
GROUP BY core_inversion.anio,poblacion"""
cursor = connection.cursor()
cursor.execute(percapita_final_sql, [municipio_id, PERIODO_FINAL])
percapita_final = dictfetchall(cursor)
percapita3 = glue(inicial=percapita_inicial,
final=percapita_final,
actualizado=percapita_actualizado,
key='inversion__anio')
# obtiene clase y contador (otros en misma clase) para este año
mi_clase = ClasificacionMunicAno.objects.get(municipio__slug=municipio,
anio=year)
# mi_clase_count = ClasificacionMunicAno.objects.filter(
# clasificacion__clasificacion=mi_clase.clasificacion, anio=year)\
# .count()
# obtiene clase y contador (otros en misma clase) para todos los años
mi_clase_anios = list(
ClasificacionMunicAno.objects.filter(
municipio__slug=municipio).values(
'anio', 'clasificacion__clasificacion'))
mi_clase_anios_count = {}
for aclase in mi_clase_anios:
mi_clase_anios_count[aclase['anio']] = \
ClasificacionMunicAno.objects.filter(
clasificacion__clasificacion=aclase[
'clasificacion__clasificacion'
],
anio=aclase['anio']).count()
filters_municipios = {
'inversion__anio':
year,
'inversion__municipio__clase__anio':
year,
'inversion__municipio__clasificaciones__clasificacion':
mi_clase.clasificacion
}
# obtiene datos de municipios de la misma clase
municipios_inicial = Proyecto.objects. \
filter(**filters_municipios). \
filter(inversion__periodo=PERIODO_INICIAL) \
.values('inversion__municipio__nombre',
'inversion__municipio__slug') \
.order_by('inversion__municipio__nombre') \
.annotate(asignado=Sum('asignado'))
municipios_actualizado = Proyecto.objects. \
filter(**filters_municipios). \
filter(inversion__periodo=PERIODO_ACTUALIZADO) \
.values('inversion__municipio__nombre',
'inversion__municipio__slug') \
.order_by('inversion__municipio__nombre') \
.annotate(asignado=Sum('asignado'))
municipios_final = Proyecto.objects. \
filter(**filters_municipios). \
filter(inversion__periodo=PERIODO_FINAL) \
.values('inversion__municipio__nombre',
'inversion__municipio__slug') \
.order_by('inversion__municipio__nombre') \
.annotate(ejecutado=Sum('ejecutado'))
otros = glue(municipios_inicial,
municipios_final,
'inversion__municipio__nombre',
actualizado=municipios_actualizado)
# inserta porcentages de total de gastos
for row in otros:
try:
total_poblacion = Poblacion.objects. \
get(anio=year,
municipio__slug=row['inversion__municipio__slug']) \
.poblacion
except:
total_poblacion = 0
row['poblacion'] = total_poblacion
row['ejecutado_percent'] = percentage(row['ejecutado'],
total_poblacion)
row['asignado_percent'] = percentage(row['asignado'],
total_poblacion)
sort_key = "{}_percent".format(quesumar)
otros = sorted(otros, key=itemgetter(sort_key), reverse=True)
# source base
source = Proyecto.objects. \
filter(inversion__municipio__slug=municipio,
inversion__anio=year). \
values('catinversion__nombre'). \
annotate(ejecutado=Sum(quesumar)). \
order_by('catinversion__nombre')
tipos_inicial = Proyecto.objects. \
filter(inversion__municipio__slug=municipio,
inversion__anio=year,
inversion__periodo=PERIODO_INICIAL) \
.values('catinversion__nombre') \
.annotate(asignado=Sum('asignado')). \
order_by('catinversion__nombre')
tipos_final = Proyecto.objects. \
filter(inversion__municipio__slug=municipio,
inversion__anio=year,
inversion__periodo=periodo). \
values('catinversion__nombre'). \
annotate(ejecutado=Sum('ejecutado')). \
order_by('catinversion__nombre')
sources = glue(tipos_inicial, tipos_final, 'catinversion__nombre')
source_clase = Proyecto.objects.filter(
inversion__municipio__slug=municipio, inversion__anio=year,
inversion__periodo=periodo,
inversion__municipio__clasificaciones__clasificacion=mi_clase.clasificacion,
inversion__municipio__clase__anio=year)\
.values('catinversion__nombre')\
.annotate(clase=Sum(quesumar))
source_inicial = Proyecto.objects. \
filter(inversion__periodo=PERIODO_INICIAL,
inversion__municipio__slug=municipio). \
values('inversion__anio'). \
annotate(ejecutado=Sum('ejecutado'),
asignado=Sum('asignado')).\
order_by()
source_final = Proyecto.objects. \
filter(inversion__periodo=periodo,
inversion__municipio__slug=municipio). \
values('inversion__anio'). \
annotate(ejecutado=Sum('ejecutado'),
asignado=Sum('asignado')).\
order_by()
# obtiene valores para este año de las listas
try:
asignado = (
item for item in source_inicial
if item["inversion__anio"] == int(year)).next()['asignado']
except StopIteration:
asignado = 0
try:
ejecutado = (
item for item in source_final
if item["inversion__anio"] == int(year)).next()['ejecutado']
except StopIteration:
ejecutado = 0
# obtiene datos para grafico comparativo de tipo de inversions
tipo_inicial = list(
Proyecto.objects.filter(
inversion__municipio__slug=municipio,
inversion__anio=year,
inversion__periodo=PERIODO_INICIAL).values(
'catinversion__nombre').annotate(asignado=Sum('asignado')))
tipo_actualizado = list(
Proyecto.objects.filter(
inversion__municipio__slug=municipio,
inversion__anio=year,
inversion__periodo=PERIODO_ACTUALIZADO).values(
'catinversion__nombre').annotate(asignado=Sum('asignado')))
tipo_final = list(
Proyecto.objects.filter(inversion__municipio__slug=municipio,
inversion__anio=year,
inversion__periodo=PERIODO_FINAL).values(
'catinversion__nombre').annotate(
ejecutado=Sum('ejecutado')))
tipo = glue(inicial=tipo_inicial,
final=tipo_final,
key='catinversion__nombre',
actualizado=tipo_actualizado)
# obtiene datos para grafico comparativo por area
area_inicial = list(
Proyecto.objects.filter(
inversion__municipio__slug=municipio,
inversion__anio=year,
inversion__periodo=PERIODO_INICIAL).values(
'areageografica').annotate(asignado=Sum('asignado')))
area_final = list(
Proyecto.objects.filter(
inversion__municipio__slug=municipio,
inversion__anio=year,
inversion__periodo=PERIODO_FINAL).values(
'areageografica').annotate(ejecutado=Sum('ejecutado')))
area = glue(area_inicial, area_final, 'areageografica')
# obtiene datos para grafico comparativo por fuente
fuente_inicial = list(
InversionFuenteDetalle.objects.filter(
inversionfuente__municipio__slug=municipio,
inversionfuente__anio=year,
inversionfuente__periodo=PERIODO_INICIAL).values(
'fuente__nombre').order_by('fuente__nombre').annotate(
asignado=Sum('asignado')))
fuente_final = list(
InversionFuenteDetalle.objects.filter(
inversionfuente__municipio__slug=municipio,
inversionfuente__anio=year,
inversionfuente__periodo=PERIODO_FINAL).values(
'fuente__nombre').order_by('fuente__nombre').annotate(
ejecutado=Sum('ejecutado')))
fuente = glue(fuente_inicial, fuente_final, 'fuente__nombre')
fuente_actual = list(
InversionFuenteDetalle.objects.filter(
inversionfuente__municipio__slug=municipio,
inversionfuente__anio=year,
inversionfuente__periodo=periodo).values('fuente__nombre').
order_by('fuente__nombre').annotate(ejecutado=Sum(quesumar)))
else:
#
# no municipio
#
otros = None
mi_clase = None
municipio_row = ''
municipio = ''
source = Proyecto.objects.filter(
inversion__anio=year, inversion__periodo=periodo)\
.values('catinversion__nombre')\
.order_by('catinversion__nombre')\
.annotate(ejecutado=Sum(quesumar))
tipos_inicial = Proyecto.objects.filter(
inversion__anio=year, inversion__periodo=PERIODO_INICIAL)\
.values('catinversion__nombre')\
.annotate(asignado=Sum('asignado'))\
.order_by('catinversion__nombre')
tipos_final = Proyecto.objects.filter(
inversion__anio=year, inversion__periodo=periodo)\
.values('catinversion__nombre')\
.annotate(ejecutado=Sum('ejecutado'))\
.order_by('catinversion__nombre')
sources = glue(tipos_inicial, tipos_final, 'catinversion__nombre')
source_clase = None
#source_ultimos = Proyecto.objects.values('inversion__anio').annotate(ejecutado=Sum('ejecutado'), asignado=Sum('asignado'))
source_ultimos = Proyecto.objects.filter(
inversion__anio__gt=year_list[1])\
.values('inversion__anio')\
.annotate(ejecutado=Sum('ejecutado'), asignado=Sum('asignado'))
# tabla2, tabla3
cat_inicial = Proyecto.objects. \
filter(inversion__periodo=PERIODO_INICIAL,
inversion__anio=year) \
.values('catinversion__nombre',
'catinversion__id',
'catinversion__shortname',
'catinversion__color',
'catinversion__slug') \
.annotate(inicial_asignado=Sum('asignado')) \
.order_by('catinversion')
cat_actualizado = Proyecto.objects. \
filter(inversion__periodo=PERIODO_ACTUALIZADO,
inversion__anio=year) \
.values('catinversion__nombre',
'catinversion__id',
'catinversion__shortname',
'catinversion__color',
'catinversion__slug') \
.annotate(actualizado_asignado=Sum('asignado'),
actualizado_ejecutado=Sum('ejecutado')) \
.order_by('catinversion')
cat_final = Proyecto.objects. \
filter(inversion__periodo=PERIODO_FINAL,
inversion__anio=year) \
.values('catinversion__nombre',
'catinversion__id',
'catinversion__shortname',
'catinversion__color',
'catinversion__slug') \
.annotate(final_asignado=Sum('asignado'),
final_ejecutado=Sum('ejecutado')) \
.order_by('catinversion')
cat_periodo = Proyecto.objects. \
filter(inversion__periodo=periodo,
inversion__anio=year) \
.values('catinversion__nombre',
'catinversion__id',
'catinversion__shortname',
'catinversion__color',
'catinversion__slug') \
.annotate(asignado=Sum('asignado'),
ejecutado=Sum('ejecutado'))\
.order_by('catinversion')
# cat2 = superglue(
# data=(cat_inicial, cat_final),
# key='catinversion__nombre')
cat3 = superglue(data=(cat_inicial, cat_final, cat_actualizado,
cat_periodo),
key='catinversion__nombre')
# tabla4
anual_inicial = Proyecto.objects. \
filter(inversion__periodo=PERIODO_INICIAL). \
values('inversion__anio',
'inversion__periodo'). \
annotate(asignado=Sum('asignado')). \
order_by('inversion__anio')
anual_actualizado = Proyecto.objects. \
filter(inversion__periodo=PERIODO_ACTUALIZADO). \
values('inversion__anio',
'inversion__periodo'). \
annotate(asignado=Sum('asignado')). \
order_by('inversion__anio')
anual_final = Proyecto.objects.\
filter(inversion__periodo=PERIODO_FINAL). \
values('inversion__anio',
'inversion__periodo'). \
annotate(ejecutado=Sum('ejecutado')). \
order_by('inversion__anio')
# anual2 = glue(inicial=anual_inicial,
# final=anual_final,
# key='inversion__anio')
anual3 = glue(inicial=anual_inicial,
final=anual_final,
actualizado=anual_actualizado,
key='inversion__anio')
# obtiene datos para grafico comparativo de tipo de inversions
tipo_inicial = list(
Proyecto.objects.filter(inversion__anio=year,
inversion__periodo=PERIODO_INICIAL).
values('catinversion__nombre').order_by(
'catinversion__nombre').annotate(asignado=Sum('asignado')))
tipo_actualizado = list(
Proyecto.objects.filter(
inversion__anio=year,
inversion__periodo=PERIODO_ACTUALIZADO).values(
'catinversion__nombre').annotate(asignado=Sum('asignado')))
tipo_final = list(
Proyecto.objects.filter(inversion__anio=year,
inversion__periodo=PERIODO_FINAL).
values('catinversion__nombre').order_by(
'catinversion__nombre').annotate(ejecutado=Sum('ejecutado')))
tipo = glue(inicial=tipo_inicial,
final=tipo_final,
key='catinversion__nombre',
actualizado=tipo_actualizado)
# obtiene datos para grafico comparativo de area
area_inicial = list(
Proyecto.objects.filter(
inversion__anio=year,
inversion__periodo=PERIODO_INICIAL).values('areageografica').
order_by('areageografica').annotate(asignado=Sum('asignado')))
area_final = list(
Proyecto.objects.filter(
inversion__anio=year, inversion__periodo=PERIODO_FINAL).values(
'areageografica').order_by('areageografica').annotate(
ejecutado=Sum('ejecutado')))
# area = glue(area_inicial, area_final, 'areageografica')
# obtiene datos para grafico comparativo de fuente
fuente_inicial = list(
InversionFuenteDetalle.objects.filter(
inversionfuente__anio=year,
inversionfuente__periodo=PERIODO_INICIAL).values(
'fuente__nombre').order_by('fuente__nombre').annotate(
asignado=Sum('asignado')))
fuente_final = list(
InversionFuenteDetalle.objects.filter(
inversionfuente__anio=year,
inversionfuente__periodo=PERIODO_FINAL).values(
'fuente__nombre').order_by('fuente__nombre').annotate(
ejecutado=Sum('ejecutado')))
fuente = glue(fuente_inicial, fuente_final, 'fuente__nombre')
fuente_actual = list(
InversionFuenteDetalle.objects.filter(
inversionfuente__anio=year,
inversionfuente__periodo=periodo).values('fuente__nombre').
order_by('fuente__nombre').annotate(ejecutado=Sum(quesumar)))
# grafico de ejecutado y asignado a nivel nacional (distintas clases) porcentage
sql_tpl = "SELECT clasificacion,\
((SELECT SUM({quesumar}) FROM core_Proyecto as cp\
JOIN core_Inversion as ci ON cp.inversion_id=ci.id \
JOIN core_CatInversion cci ON cp.catinversion_id=cci.id \
JOIN lugar_clasificacionmunicano lc ON ci.municipio_id=lc.municipio_id \
AND ci.anio=lc.anio \
WHERE ci.anio={year} AND ci.periodo='{periodo}' \
AND lc.clasificacion_id=clase.id) / \
(select sum(lp.poblacion) from lugar_poblacion as lp \
where lp.anio={year} and lp.municipio_id in (select lcc.municipio_id \
from lugar_clasificacionmunicano lcc \
where lcc.clasificacion_id = clase.id and anio={year})))\
AS {quesumar} FROM lugar_clasificacionmunic AS clase ORDER BY clasificacion"
sql = sql_tpl.format(
quesumar="asignado",
year=year,
periodo=PERIODO_INICIAL,
)
cursor = connection.cursor()
cursor.execute(sql)
inicial = dictfetchall(cursor)
sql = sql_tpl.format(
quesumar="ejecutado",
year=year,
periodo=periodo,
)
cursor = connection.cursor()
cursor.execute(sql)
final = dictfetchall(cursor)
sql = sql_tpl.format(
quesumar="asignado",
year=year,
periodo=PERIODO_ACTUALIZADO,
)
cursor = connection.cursor()
cursor.execute(sql)
actualizado = dictfetchall(cursor)
porclasep = glue(inicial,
final,
'clasificacion',
actualizado=actualizado)
# obtener la media nacional por clase:
sql_tpl = "SELECT ((SELECT SUM(asignado) FROM core_Proyecto as cp\
JOIN core_Inversion as ci ON cp.inversion_id=ci.id \
JOIN core_CatInversion cci ON cp.catinversion_id=cci.id \
JOIN lugar_clasificacionmunicano lc ON ci.municipio_id=lc.municipio_id \
AND ci.anio=lc.anio \
WHERE ci.anio={year} AND ci.periodo='{periodo}') / \
(select sum(lp.poblacion) from lugar_poblacion as lp \
where lp.anio={year})) as asignado, \
((SELECT SUM(ejecutado) FROM core_Proyecto as cp\
JOIN core_Inversion as ci ON cp.inversion_id=ci.id \
JOIN core_CatInversion cci ON cp.catinversion_id=cci.id \
JOIN lugar_clasificacionmunicano lc ON ci.municipio_id=lc.municipio_id \
AND ci.anio=lc.anio \
WHERE ci.anio={year} AND ci.periodo='F') / \
(select sum(lp.poblacion) from lugar_poblacion as lp \
where lp.anio={year})) as ejecutado"
sql = sql_tpl.format(year=year, periodo=PERIODO_INICIAL)
cursor = connection.cursor()
cursor.execute(sql)
media_nacional = dictfetchall(cursor)[0]
# para luego obtener valores para este año y nada más? FIXME !
source_inicial = Proyecto.objects. \
filter(inversion__periodo=PERIODO_INICIAL). \
values('inversion__anio'). \
annotate(ejecutado=Sum('ejecutado'),
asignado=Sum('asignado')). \
order_by()
source_final = Proyecto.objects. \
filter(inversion__periodo=periodo,). \
values('inversion__anio'). \
annotate(ejecutado=Sum('ejecutado'),
asignado=Sum('asignado')). \
order_by()
# obtiene valores para este año de las listas
try:
asignado = (
item for item in source_inicial
if item["inversion__anio"] == int(year)).next()['asignado']
except StopIteration:
asignado = 0
try:
ejecutado = (
item for item in source_final
if item["inversion__anio"] == int(year)).next()['ejecutado']
except StopIteration:
ejecutado = 0
# FIXME que es esto: ???
source_anios = glue(source_inicial, source_final, 'inversion__anio')
# conviert R en Rural, etc.
# for d in area:
# d.update((k, AREAGEOGRAFICA_VERBOSE[v]) for k, v in d.iteritems() if k == "areageografica")
#
# chartit!
#
if municipio:
inversion_percapita_anios = RawDataPool(series=[{
'options': {
'source': percapita3
},
'names': [
u'Años',
u'Actualizado',
u'P. Inicial',
u'Ejecutado',
],
'terms': [
'inversion__anio',
'actualizado',
'asignado',
'ejecutado',
],
}], )
inversion_percapita_anios_column = Chart(
datasource=inversion_percapita_anios,
series_options=[{
'options': {
'type': 'column',
'stacking': False
},
'terms': {
'inversion__anio': [
'asignado',
'actualizado',
'ejecutado',
],
},
}],
chart_options={
'title': {
'text':
u'Seguimiento de las Inversiones percápita %s' %
(municipio, )
}
},
)
inversion_comparativo_anios = RawDataPool(series=[{
'options': {
'source': anual3
},
'names': [
u'Años',
u'Actualizado',
u'P. Inicial',
u'Ejecutado',
],
'terms': [
'inversion__anio',
'actualizado',
'asignado',
'ejecutado',
],
}], )
inversion_comparativo_anios_column = Chart(
datasource=inversion_comparativo_anios,
series_options=[{
'options': {
'type': 'column',
'stacking': False
},
'terms': {
'inversion__anio': [
'asignado',
'actualizado',
'ejecutado',
],
},
}],
chart_options={
'title': {
'text': 'Seguimiento de las Inversiones %s' % (municipio, )
}
},
)
inversion_fuente = RawDataPool(series=[{
'options': {
'source': fuente
},
'terms': ['fuente__nombre', 'ejecutado', 'asignado'],
}], )
inversion_fuente_column = Chart(
datasource=inversion_fuente,
series_options=[{
'options': {
'type': 'column',
'stacking': False
},
'terms': {
'fuente__nombre': ['ejecutado', 'asignado'],
},
}],
chart_options={
'title': {
'text': 'Inversions por fuente origen %s %s' % (
year,
municipio,
)
},
'data': {
'table': 'datatable'
},
})
inversion_fuente_actual = RawDataPool(series=[{
'options': {
'source': fuente_actual
},
'terms': ['fuente__nombre', 'ejecutado'],
}], )
inversion_fuente_pie = Chart(
datasource=inversion_fuente_actual,
series_options=[{
'options': {
'type': 'pie',
'stacking': False
},
'terms': {
'fuente__nombre': ['ejecutado'],
},
}],
chart_options={
'title': {
'text': 'Inversions por fuente origen %s %s' % (
year,
municipio,
)
},
'options3d': {
'enabled': 'true',
'alpha': '45',
'beta': '0'
},
'plotOptions': {
'pie': {
'dataLabels': {
'enabled': True,
'format': '{point.percentage:.2f} %'
},
'showInLegend': True,
'depth': 35
}
},
'tooltip': {
'pointFormat': '{series.name}: <b>{point.percentage:.2f}%</b>'
},
'colors': colorscheme
})
# inversion_area = RawDataPool(
# series=[{'options': {'source': area},
# 'terms': ['areageografica', 'ejecutado', 'asignado'],
# }],
# )
# inversion_area_column = Chart(
# datasource=inversion_area,
# series_options=[{'options': {
# 'type': 'column',
# 'stacking': False},
# 'terms': {
# 'areageografica': ['ejecutado', 'asignado'],
# },
# }],
# chart_options={
# 'title': {'text': 'Inversions por area origen %s %s' % (year, municipio,)},
# 'data': {'table': 'datatable'},
# },
# )
tipos = []
for row in tipo:
tipos.append({
'catinversion__nombre': row['catinversion__nombre'],
datacol: row[datacol] / 1000000,
})
parameters = {
'data': tipos,
'field1': 'catinversion__nombre',
'field2': datacol,
'typechart': 'column',
'title': ' ',
'labelX_axis': 'Rubros',
'labelY_axis': 'Millones de C$',
'pointFormat': '<b>{point.y:.2f} M. de C$</b>',
}
bar = graphChart(parameters)
parameters = {
'data': tipos,
'field1': 'catinversion__nombre',
'field2': datacol,
'title': ' ',
'labelX_axis': 'Rubros',
'labelY_axis': 'Millones de C$',
'pointFormat': '',
'format': '{point.percentage: .1f}%',
}
pie = graphPie(parameters)
data_ultimos = DataPool(series=[{
'options': {
'source': source_ultimos,
'categories': 'inversion__anio',
},
'terms': [
'inversion__anio',
'ejecutado',
'asignado',
]
}], )
ultimos = Chart(
datasource=data_ultimos,
series_options=[{
'options': {
'type': 'bar',
'stacking': False
},
'terms': {
'inversion__anio': ['asignado', 'ejecutado']
}
}],
chart_options={
'title': {
'text': u'Inversión por últimos años %s' % (municipio, )
}
},
)
oimdata = DataPool(series=[{
'options': {
'source': source
},
'terms': [
'catinversion__nombre',
'ejecutado',
]
}])
ejecutado_pie = Chart(
datasource=oimdata,
series_options=[{
'options': {
'type': 'pie',
},
'terms': {
'catinversion__nombre': ['ejecutado']
}
}],
chart_options={
'title': {
'text': 'Inversion %s %s %s' % (
quesumar,
municipio,
year,
)
},
'options3d': {
'enabled': 'true',
'alpha': '45',
'beta': '0'
},
'plotOptions': {
'pie': {
'dataLabels': {
'enabled': True,
'format': '{point.percentage:.2f} %'
},
'showInLegend': True,
'depth': 35
}
},
'tooltip': {
'pointFormat': '{series.name}: <b>{point.percentage:.2f}%</b>'
},
})
bar_horizontal = None
# bar horizontal
if otros:
parameters = {
'data':
otros,
'field1':
'inversion__municipio__nombre',
'field2':
'{}_percent'.format(quesumar),
'typechart':
'bar',
'title':
"Ranking de Municipios Categoría '{}'".format(
mi_clase.clasificacion),
'labelX_axis':
'Municipio',
'labelY_axis':
'Gasto por habitante',
'pointFormat':
'<span>Inversion Asignada</span>:<b>{point.y}%</b>',
}
bar_horizontal = graphChart(parameters)
elif porclasep:
parameters = {
'data':
porclasep,
'field1':
'clasificacion',
'field2':
quesumar,
'typechart':
'column',
'title':
'Inversión percápita',
'labelX_axis':
'Grupos',
'labelY_axis':
'M. de C$',
'pointFormat':
'<span>{series.name}</span>:<b>{point.y:.2f} M. de C$</b>',
}
bar_horizontal = graphChart(parameters)
# tabla: get total and percent
total = {}
# sum if not None
total['ejecutado'] = sum(item['ejecutado'] for item in sources
if item['ejecutado'])
total['asignado'] = sum(item['asignado'] for item in sources
if item['asignado'])
for row in sources:
row['ejecutado_percent'] = percentage(row['ejecutado'],
total['ejecutado'])
row['asignado_percent'] = percentage(row['asignado'],
total['asignado'])
# tabla: get total and percent
#source_list = list(source)
#total = source.aggregate(total=Sum('ejecutado'))['total']
# for row in source:
# row['percent'] = round(row['ejecutado'] / total * 100, 1)
actualizado_asignado = sum(
xnumber(row.get('actualizado_asignado')) for row in cat3)
# calculando porcentaje de cada categoria y suma total de los porcentajes
total_asig_porcentaje = 0
total_ejec_porcentaje = 0
total_act_porcentaje = 0
for row in cat3:
row['ini_asig_porcentaje'] = percentage(row['asignado'], asignado)
total_asig_porcentaje += row['ini_asig_porcentaje']
row['act_porcentaje'] = percentage(row.get('actualizado_asignado'),
actualizado_asignado)
total_act_porcentaje += row['act_porcentaje']
row['ejec_porcentaje'] = percentage(row['ejecutado'], ejecutado)
total_ejec_porcentaje += row['ejec_porcentaje']
if source_clase:
total_clase = source_clase.aggregate(total=Sum('clase'))['total']
for row in source_clase:
row['clase_percent'] = round(row['clase'] / total_clase * 100, 1)
for row in sources:
for row2 in source_clase:
if row2['catinversion__nombre'] == row['catinversion__nombre']:
row['clase'] = row2['clase']
row['clase_percent'] = row2['clase_percent']
# tabla: get inversions por año
porano_table = {}
ano_table = {}
filter_municipio = {}
if municipio:
filter_municipio = {'inversion__municipio__slug': municipio}
ys = Proyecto.objects. \
filter(**filter_municipio). \
order_by('catinversion__nombre'). \
values('catinversion__nombre'). \
distinct()
for y in ys:
name = y['catinversion__nombre']
if name:
label = name
porano_table[label] = {}
for ayear in year_list:
periodo_anio = periodo_list[str(ayear)]
quesumar = 'ejecutado' if periodo_anio == 'F' else 'asignado'
filter_municipio['inversion__anio'] = ayear
filter_municipio['inversion__periodo'] = periodo_anio
filter_municipio['catinversion__nombre'] = label
value = Proyecto.objects. \
filter(**filter_municipio). \
order_by(). \
values(quesumar). \
aggregate(total=Sum(quesumar))['total']
porano_table[label][ayear] = {}
porano_table[label][ayear]['raw'] = value or ''
if not ayear in ano_table:
ano_table[ayear] = 0
ano_table[ayear] += value if value else 0
if municipio and year:
periodo = PERIODO_FINAL
quesumar = 'ejecutado'
value = Proyecto.objects. \
filter(inversion__anio=year,
inversion__periodo=periodo,
tipoproyecto__nombre=name,
inversion__municipio__clasificaciones__clasificacion=mi_clase.clasificacion,
inversion__municipio__clase__anio=year). \
aggregate(total=Avg(quesumar))['total']
porano_table[name]['extra'] = value or '...'
for y in ys:
name = y['catinversion__nombre']
if name:
label = name
for ayear in year_list:
if porano_table[label][ayear]['raw']:
porano_table[label][ayear]['percent'] = format(
porano_table[label][ayear]['raw'] / ano_table[ayear],
'.2%')
charts = [pie, bar, bar_horizontal]
porano_table = OrderedDict(sorted(porano_table.iteritems()))
return {
'charts': charts,
'mi_clase': mi_clase,
'year': year,
'porano': porano_table,
'totales': sources,
'cat': cat3,
'anuales': anual3,
'ejecutado': ejecutado,
'ejecutado_porcentaje': total_ejec_porcentaje,
'asignado': asignado,
'asignado_porcentaje': total_asig_porcentaje,
'actualizado_porcentaje': actualizado_asignado,
'porclasep': porclasep,
'periodo': periodo,
'otros': otros,
'year_list': year_list,
'municipio_list': municipio_list,
'periodo_list': periodo_list,
'nacional': media_nacional,
'municipio': municipio_row
}
def gf_chart(request):
# XXX: why this is not a view?
municipio_list = Municipio.objects.all()
municipio = getVar('municipio', request)
periodo_list = getPeriods(Gasto)
year_list = getYears(Gasto)
year = getVar('year', request)
if not year:
year = year_list[-1]
periodo = Anio.objects.get(anio=year).periodo
quesumar = 'asignado' if periodo == PERIODO_INICIAL else 'ejecutado'
datacol = 'asignado' if periodo == PERIODO_INICIAL else 'ejecutado'
asignado_percent = 0
ejecutado_percent = 0
total_nacional_asignado = 0
total_nacional_ejecutado = 0
municipio_id = None
filtro_rubros = {
'gasto__anio': year,
'subsubtipogasto__clasificacion': TipoGasto.CORRIENTE
}
excluir_cuentas_rubros = {}
from collections import OrderedDict # FIXME move up
if municipio:
porclase = None
porclasep = None
municipio_row = Municipio.objects.get(slug=municipio)
municipio_id = municipio_row.id
municipio_nombre = municipio_row.nombre
source_inicial = GastoDetalle.objects. \
filter(gasto__periodo=PERIODO_INICIAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE,
gasto__municipio__slug=municipio). \
order_by('gasto__anio'). \
values('gasto__anio'). \
annotate(ejecutado=Sum('ejecutado'),
asignado=Sum('asignado'))
total_asignado_anio = GastoDetalle.objects. \
filter(gasto__periodo=PERIODO_INICIAL,
gasto__municipio__slug=municipio,
gasto__anio=year). \
order_by('gasto__anio'). \
values('gasto__anio'). \
annotate(asignado=Sum('asignado'))
source_final = GastoDetalle.objects. \
filter(gasto__periodo=periodo,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE,
gasto__municipio__slug=municipio). \
order_by('gasto__anio'). \
values('gasto__anio'). \
annotate(ejecutado=Sum('ejecutado'),
asignado=Sum('asignado'))
total_ejecutado_anio = GastoDetalle.objects. \
filter(gasto__periodo=periodo,
gasto__municipio__slug=municipio,
gasto__anio=year). \
order_by('gasto__anio'). \
values('gasto__anio'). \
annotate(ejecutado=Sum('ejecutado'))
# obtiene valores para este año de las listas
try:
asignado = (item for item in source_inicial
if item["gasto__anio"] == int(year)).next()['asignado']
total_asignado = total_asignado_anio[0]['asignado']
asignado_percent = percentage(asignado, total_asignado)
except StopIteration:
asignado = 0
try:
ejecutado = (
item for item in source_final
if item["gasto__anio"] == int(year)).next()['ejecutado']
total_ejecutado = total_ejecutado_anio[0]['ejecutado']
ejecutado_percent = percentage(ejecutado, total_ejecutado)
except StopIteration:
ejecutado = 0
# obtiene clase y contador (otros en misma clase) para este año
mi_clase = ClasificacionMunicAno.objects.get(municipio__slug=municipio,
anio=year)
mi_clase_count = ClasificacionMunicAno.objects.filter(
clasificacion__clasificacion=mi_clase.clasificacion,
anio=year).count()
# obtiene clase y contador (otros en misma clase) para todos los años
mi_clase_anios = list(
ClasificacionMunicAno.objects.filter(
municipio__slug=municipio).values(
'anio', 'clasificacion__clasificacion').annotate())
mi_clase_anios_count = {}
for aclase in mi_clase_anios:
mi_clase_anios_count[aclase['anio']] = ClasificacionMunicAno.objects. \
filter(clasificacion__clasificacion=aclase['clasificacion__clasificacion'],
anio=aclase['anio']). \
count()
filter_municipio = {
'gasto__anio':
year,
'gasto__municipio__clase__anio':
year,
'subsubtipogasto__clasificacion':
TipoGasto.CORRIENTE,
'gasto__municipio__clasificaciones__clasificacion':
mi_clase.clasificacion
}
# obtiene datos de municipios de la misma clase
municipios_inicial = GastoDetalle.objects. \
filter(**filter_municipio). \
filter(gasto__periodo=PERIODO_INICIAL). \
values('gasto__municipio__id',
'gasto__municipio__nombre',
'gasto__municipio__slug'). \
annotate(inicial_asignado=Sum('asignado')). \
order_by()
municipios_actualizado = GastoDetalle.objects. \
filter(**filter_municipio). \
filter(gasto__periodo=PERIODO_ACTUALIZADO).\
values('gasto__municipio__id',
'gasto__municipio__nombre',
'gasto__municipio__slug').\
annotate(actualizado_asignado=Sum('asignado'),
actualizado_ejecutado=Sum('ejecutado')). \
order_by()
municipios_final = GastoDetalle.objects. \
filter(**filter_municipio). \
filter(gasto__periodo=PERIODO_FINAL). \
values('gasto__municipio__id',
'gasto__municipio__nombre',
'gasto__municipio__slug'). \
annotate(final_asignado=Sum('asignado'),
final_ejecutado=Sum('ejecutado')). \
order_by()
municipios_periodo = GastoDetalle.objects. \
filter(**filter_municipio). \
filter(gasto__periodo=periodo). \
values('gasto__municipio__id',
'gasto__municipio__nombre',
'gasto__municipio__slug'). \
annotate(asignado=Sum('asignado'),
ejecutado=Sum('ejecutado')). \
order_by()
otros = superglue(data=(municipios_inicial, municipios_final,
municipios_actualizado, municipios_periodo),
key='gasto__municipio__nombre')
# inserta porcentages de total de gastos
total = {
'total_asignado': 0,
'total_ejecutado': 0,
'total_asignado_gp': 0,
'total_ejecutado_gp': 0
}
for row in otros:
filter_municipio = {
'gasto__anio': year,
'gasto__municipio__id': row['gasto__municipio__id']
}
total['asignado'] = GastoDetalle.objects. \
filter(**filter_municipio). \
filter(gasto__periodo=PERIODO_INICIAL). \
aggregate(asignado=Sum('asignado'))['asignado']
total['ejecutado'] = GastoDetalle.objects. \
filter(**filter_municipio). \
filter(gasto__periodo=periodo). \
aggregate(ejecutado=Sum('ejecutado'))['ejecutado']
row['asignado_percent'] = percentage(row['asignado'],
total['asignado'])
row['ejecutado_percent'] = percentage(row['ejecutado'],
total['ejecutado'])
total['total_asignado_gp'] += row['asignado']
total['total_ejecutado_gp'] += row['ejecutado'] or 0
total['total_asignado'] += total['asignado']
total['total_ejecutado'] += total['ejecutado'] or 0
# Obteniendo la media nacional
total_nacional_asignado = percentage(total['total_asignado_gp'],
total['total_asignado'], 2)
total_nacional_ejecutado = percentage(total['total_ejecutado_gp'],
total['total_ejecutado'], 2)
sort_key = "{}_percent".format(quesumar)
otros = sorted(otros, key=itemgetter(sort_key), reverse=True)
# indicando filtro por municipio
filtro_rubros['gasto__municipio__id'] = municipio_id
# obtiene datos comparativo de todos los años
inicial = list(
GastoDetalle.objects.filter(
gasto__municipio__slug=municipio,
gasto__periodo=PERIODO_INICIAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE,
).values('gasto__anio', 'gasto__periodo').annotate(
asignado=Sum('asignado')).order_by())
final = list(
GastoDetalle.objects.filter(
gasto__municipio__slug=municipio,
gasto__periodo=PERIODO_FINAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE,
).values('gasto__anio', 'gasto__periodo').annotate(
ejecutado=Sum('ejecutado')).order_by())
anual2 = glue(inicial=inicial, final=final, key='gasto__anio')
clase_sql = "SELECT core_gasto.anio AS gasto__anio,'{periodo}' AS gasto__periodo,SUM({quesumar}) AS clase FROM core_gastodetalle JOIN core_gasto ON core_gastodetalle.gasto_id=core_gasto.id \
JOIN lugar_clasificacionmunicano ON core_gasto.municipio_id=lugar_clasificacionmunicano.municipio_id AND \
core_gasto.anio=lugar_clasificacionmunicano.anio JOIN core_subsubtipogasto ON core_gastodetalle.subsubtipogasto_id=core_subsubtipogasto.codigo \
WHERE core_gasto.periodo='{periodo}' AND core_subsubtipogasto.clasificacion={subsubtipogasto} \
AND lugar_clasificacionmunicano.clasificacion_id=(SELECT clasificacion_id FROM lugar_clasificacionmunicano WHERE municipio_id={municipio} AND lugar_clasificacionmunicano.anio=core_gasto.anio) \
GROUP BY core_gasto.anio"
sql = clase_sql.format(
quesumar='asignado',
municipio=municipio_id,
periodo=PERIODO_INICIAL,
subsubtipogasto=TipoGasto.CORRIENTE,
)
cursor = connection.cursor()
cursor.execute(sql)
inicial_clase = dictfetchall(cursor)
sql = clase_sql.format(
quesumar='ejecutado',
municipio=municipio_id,
periodo=PERIODO_FINAL,
subsubtipogasto=TipoGasto.CORRIENTE,
)
cursor = connection.cursor()
cursor.execute(sql)
final_clase = dictfetchall(cursor)
for row in anual2:
found = False
for row2 in inicial_clase:
if row2['gasto__anio'] == row['gasto__anio']:
found = True
try:
row['clase_inicial'] = row2['clase'] / \
mi_clase_anios_count[row['gasto__anio']]
except KeyError:
row['clase_inicial'] = 0
if not found:
row['clase_inicial'] = 0
for row in anual2:
found = False
for row2 in final_clase:
if row2['gasto__anio'] == row['gasto__anio']:
found = True
try:
row['clase_final'] = row2['clase'] / \
mi_clase_anios_count[row['gasto__anio']]
except KeyError:
row['clase_final'] = 0
if not found:
row['clase_final'] = 0
comparativo_anios = anual2
# comparativo con promedio de clasificacion para un año específico
inicial = list(
GastoDetalle.objects.filter(
gasto__periodo=PERIODO_INICIAL,
gasto__anio=year,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE,
gasto__municipio__slug=municipio).values(
'gasto__periodo').annotate(municipio=Sum('asignado')))
actualizado = list(
GastoDetalle.objects.filter(
gasto__periodo=PERIODO_ACTUALIZADO,
gasto__anio=year,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE,
gasto__municipio__slug=municipio).values(
'gasto__periodo').annotate(municipio=Sum('ejecutado')))
final = list(
GastoDetalle.objects.filter(
gasto__periodo=PERIODO_FINAL,
gasto__anio=year,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE,
gasto__municipio__slug=municipio).values(
'gasto__periodo').annotate(municipio=Sum('ejecutado')))
# obtiene datos para municipios de la misma clase
inicial_clase = GastoDetalle.objects.filter(gasto__anio=year, gasto__periodo=PERIODO_INICIAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE,
gasto__municipio__clasificaciones__clasificacion=mi_clase.clasificacion, gasto__municipio__clase__anio=year).\
values('gasto__periodo').order_by('gasto__periodo').annotate(clase=Sum('asignado'))
actualizado_clase = GastoDetalle.objects.filter(gasto__anio=year, gasto__periodo=PERIODO_ACTUALIZADO,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE,
gasto__municipio__clasificaciones__clasificacion=mi_clase.clasificacion, gasto__municipio__clase__anio=year).\
values('gasto__periodo').order_by('gasto__periodo').annotate(clase=Sum('ejecutado'))
final_clase = GastoDetalle.objects.filter(gasto__anio=year, gasto__periodo=PERIODO_FINAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE,
gasto__municipio__clasificaciones__clasificacion=mi_clase.clasificacion, gasto__municipio__clase__anio=year).\
values('gasto__periodo').order_by('gasto__periodo').annotate(clase=Sum('ejecutado'))
# obtiene totales
total_municipio_inicial = GastoDetalle.objects.filter(gasto__anio=year, gasto__periodo=PERIODO_INICIAL, gasto__municipio__slug=municipio).\
aggregate(total=Sum('asignado'))['total']
total_municipio_final = GastoDetalle.objects.filter(gasto__anio=year, gasto__periodo=PERIODO_FINAL, gasto__municipio__slug=municipio).\
aggregate(total=Sum('ejecutado'))['total']
total_clase_inicial = GastoDetalle.objects.filter(gasto__anio=year, gasto__periodo=PERIODO_INICIAL,
gasto__municipio__clasificaciones__clasificacion=mi_clase.clasificacion, gasto__municipio__clase__anio=year).\
aggregate(total=Sum('asignado'))['total']
total_clase_final = GastoDetalle.objects.filter(gasto__anio=year, gasto__periodo=PERIODO_FINAL,
gasto__municipio__clasificaciones__clasificacion=mi_clase.clasificacion, gasto__municipio__clase__anio=year).\
aggregate(total=Sum('ejecutado'))['total']
# inserta datos para municipio de la misma clase
if inicial:
inicial[0]['clase'] = inicial_clase[0]['clase'] / mi_clase_count
inicial[0]['claseraw'] = inicial_clase[0]['clase']
inicial[0]['clasep'] = inicial_clase[0][
'clase'] / total_clase_inicial * 100
inicial[0]['municipiop'] = inicial[0][
'municipio'] / total_municipio_inicial * 100
if actualizado:
actualizado[0][
'clase'] = actualizado_clase[0]['clase'] / mi_clase_count
actualizado[0]['claseraw'] = actualizado_clase[0]['clase']
actualizado[0]['clasep'] = 0 # Does it need FIXME?
actualizado[0]['municipiop'] = 0 # Does it need FIXME?
if final:
final[0]['clase'] = final_clase[0]['clase'] / mi_clase_count
final[0]['claseraw'] = final_clase[0]['clase']
final[0][
'clasep'] = final_clase[0]['clase'] / total_clase_final * 100
final[0]['municipiop'] = final[0][
'municipio'] / total_municipio_final * 100
comparativo3 = list(chain(inicial, actualizado, final))
comparativo2 = list(chain(
inicial,
final,
))
for d in comparativo3:
d.update((k, PERIODO_VERBOSE[v]) for k, v in d.iteritems()
if k == "gasto__periodo")
gasto_promedio = GastoDetalle.objects.filter(gasto__periodo=PERIODO_FINAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE,
gasto__municipio__clasificaciones__clasificacion=mi_clase.clasificacion, gasto__municipio__clase__anio=year).\
values('gasto__anio').annotate(ejecutado=Sum('ejecutado'), asignado=Sum('asignado'))
for record in source_inicial:
try:
record['ejecutado'] = source_final.filter(
gasto__anio=record['gasto__anio'])[0]['ejecutado']
record['promedio'] = gasto_promedio.filter(
gasto__anio=record['gasto__anio'])[0]['asignado']
except IndexError:
record['promedio'] = 0 # FIXME: really?
pass
source = source_inicial
#source = OrderedDict(sorted(source.items(), key=lambda t: t[0]))
# FIXME. igual que abajo (sin municipio) de donde tomar los datos?
source_barra = GastoDetalle.objects.filter(gasto__periodo=PERIODO_INICIAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE, gasto__municipio__slug=municipio).\
values('gasto__anio').annotate(ejecutado=Sum('ejecutado'), asignado=Sum('asignado'))
source_barra_final = source_barra # FIXME este es un work-around
# chart: porcentage gastos de funcionamiento
source_pgf_asignado = GastoDetalle.objects.filter(
gasto__anio=year,
gasto__municipio__slug=municipio,
gasto__periodo=periodo,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE).aggregate(
asignado=Sum(quesumar))
source_pgf_asignado['nombre'] = 'Funcionamiento'
otros_asignado = GastoDetalle.objects.filter(
gasto__anio=year,
gasto__municipio__slug=municipio,
gasto__periodo=periodo).exclude(
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE).aggregate(
asignado=Sum(quesumar))
otros_asignado['nombre'] = 'Otros'
source_pgf = [source_pgf_asignado, otros_asignado]
else:
#
# no municipio
#
otros = None
mi_clase = None
municipio = ''
# obtiene datos comparativo de todos los años
inicial = list(
GastoDetalle.objects.filter(
gasto__periodo=PERIODO_INICIAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE,
).values('gasto__anio', 'gasto__periodo').annotate(
asignado=Sum('asignado')).order_by())
final = list(
GastoDetalle.objects.filter(
gasto__periodo=PERIODO_FINAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE,
).values('gasto__anio', 'gasto__periodo').annotate(
ejecutado=Sum('ejecutado')).order_by())
anual2 = glue(inicial=inicial, final=final, key='gasto__anio')
# grafico de ejecutado y asignado a nivel nacional (distintas clases)
sql_tpl = "SELECT clasificacion,\
(SELECT SUM(asignado) AS {asignado} FROM core_GastoDetalle JOIN core_Gasto ON core_GastoDetalle.gasto_id=core_Gasto.id JOIN core_SubSubTipoGasto ON core_GastoDetalle.subsubtipogasto_id=core_SubSubTipoGasto.codigo \
JOIN lugar_clasificacionmunicano ON core_Gasto.municipio_id=lugar_clasificacionmunicano.municipio_id AND core_Gasto.anio=lugar_clasificacionmunicano.anio \
WHERE core_Gasto.anio={year} AND core_Gasto.periodo='{periodo}' AND core_subsubtipogasto.clasificacion={subsubtipogasto} AND lugar_clasificacionmunicano.clasificacion_id=clase.id ), \
(SELECT SUM(ejecutado) AS {ejecutado} FROM core_GastoDetalle JOIN core_Gasto ON core_GastoDetalle.gasto_id=core_Gasto.id JOIN core_SubSubTipoGasto ON core_GastoDetalle.subsubtipogasto_id=core_SubSubTipoGasto.codigo \
JOIN lugar_clasificacionmunicano ON core_Gasto.municipio_id=lugar_clasificacionmunicano.municipio_id AND core_Gasto.anio=lugar_clasificacionmunicano.anio \
WHERE core_Gasto.anio={year} AND core_Gasto.periodo='{periodo}' AND core_SubSubTipogasto.clasificacion={subsubtipogasto} AND lugar_clasificacionmunicano.clasificacion_id=clase.id ) \
FROM lugar_clasificacionmunic AS clase ORDER BY clasificacion"
sql = sql_tpl.format(
asignado="inicial_asignado",
ejecutado="inicial_ejecutado",
year=year,
periodo=PERIODO_INICIAL,
subsubtipogasto=TipoGasto.CORRIENTE,
)
cursor = connection.cursor()
cursor.execute(sql)
inicial = dictfetchall(cursor)
sql = sql_tpl.format(
asignado="final_asignado",
ejecutado="final_ejecutado",
year=year,
periodo=PERIODO_FINAL,
subsubtipogasto=TipoGasto.CORRIENTE,
)
cursor = connection.cursor()
cursor.execute(sql)
final = dictfetchall(cursor)
sql = sql_tpl.format(
asignado="actualizado_asignado",
ejecutado="actualizado_ejecutado",
year=year,
periodo=PERIODO_ACTUALIZADO,
subsubtipogasto=TipoGasto.CORRIENTE,
)
cursor = connection.cursor()
cursor.execute(sql)
actualizado = dictfetchall(cursor)
sql = sql_tpl.format(
asignado="asignado",
ejecutado="ejecutado",
year=year,
periodo=periodo,
subsubtipogasto=TipoGasto.CORRIENTE,
)
cursor = connection.cursor()
cursor.execute(sql)
porclase_periodo = dictfetchall(cursor)
#porclase = glue(inicial, final, 'clasificacion', actualizado=actualizado)
porclase = superglue(data=(inicial, final, actualizado,
porclase_periodo),
key='clasificacion')
for d in porclase:
if d['asignado'] and d['ejecutado']:
d['nivel'] = d['ejecutado'] / d['asignado'] * 100
else:
d['nivel'] = 0
# grafico de ejecutado y asignado a nivel nacional (distintas clases) porcentage
sql_tpl = "SELECT clasificacion,\
(SELECT SUM(asignado) FROM core_gastodetalle cgd\
JOIN core_gasto cg ON cgd.gasto_id=cg.id \
JOIN core_subsubtipogasto sstg ON cgd.subsubtipogasto_id=sstg.codigo \
JOIN lugar_clasificacionmunicano lcma ON cg.municipio_id=lcma.municipio_id \
AND cg.anio=lcma.anio \
WHERE cg.anio={year} AND cg.periodo='{periodo}' \
AND sstg.clasificacion={subsubtipogasto} \
AND lcma.clasificacion_id=clase.id) AS {asignado},\
(SELECT SUM(asignado) FROM core_gastodetalle cgd\
JOIN core_gasto cg ON cgd.gasto_id=cg.id \
JOIN core_subsubtipogasto sstg ON cgd.subsubtipogasto_id=sstg.codigo \
JOIN lugar_clasificacionmunicano lcma ON cg.municipio_id=lcma.municipio_id \
AND cg.anio=lcma.anio \
WHERE cg.anio={year} AND cg.periodo='{periodo}' \
AND sstg.clasificacion={subsubtipogasto} \
AND lcma.clasificacion_id=clase.id) /\
(SELECT SUM(asignado) FROM core_gastodetalle as cgd \
JOIN core_gasto as cg ON cgd.gasto_id=cg.id \
JOIN core_subsubtipogasto as sstg ON cgd.subsubtipogasto_id=sstg.codigo \
JOIN lugar_clasificacionmunicano lcma ON cg.municipio_id=lcma.municipio_id \
AND cg.anio=lcma.anio \
WHERE cg.anio={year} \
AND cg.periodo='{periodo}' \
AND lcma.clasificacion_id=clase.id \
HAVING SUM(asignado)>0) * 100 \
AS {asignado}_porcentaje,\
(SELECT SUM(ejecutado) FROM core_gastodetalle cgd\
JOIN core_gasto cg ON cgd.gasto_id=cg.id \
JOIN core_subsubtipogasto sstg ON cgd.subsubtipogasto_id=sstg.codigo \
JOIN lugar_clasificacionmunicano lcma ON cg.municipio_id=lcma.municipio_id \
AND cg.anio=lcma.anio \
WHERE cg.anio={year} \
AND cg.periodo='{periodo}' \
AND sstg.clasificacion={subsubtipogasto} \
AND lcma.clasificacion_id=clase.id) as {ejecutado},\
(SELECT SUM(ejecutado) FROM core_gastodetalle cgd\
JOIN core_gasto cg ON cgd.gasto_id=cg.id \
JOIN core_subsubtipogasto sstg ON cgd.subsubtipogasto_id=sstg.codigo \
JOIN lugar_clasificacionmunicano lcma ON cg.municipio_id=lcma.municipio_id \
AND cg.anio=lcma.anio \
WHERE cg.anio={year} \
AND cg.periodo='{periodo}' \
AND sstg.clasificacion={subsubtipogasto} \
AND lcma.clasificacion_id=clase.id) /\
(SELECT SUM(ejecutado) FROM core_gastodetalle cgd\
JOIN core_gasto cg ON cgd.gasto_id=cg.id \
JOIN core_subsubtipogasto sstg ON cgd.subsubtipogasto_id=sstg.codigo \
JOIN lugar_clasificacionmunicano lcma ON cg.municipio_id=lcma.municipio_id \
AND cg.anio=lcma.anio \
WHERE cg.anio={year} \
AND cg.periodo='{periodo}' \
AND lcma.clasificacion_id=clase.id \
HAVING SUM(ejecutado)>0) * 100 \
AS {ejecutado}_porcentaje\
FROM lugar_clasificacionmunic AS clase ORDER BY clasificacion"
sql = sql_tpl.format(asignado="inicial_asignado",
ejecutado='inicial_ejecutado',
year=year,
periodo=PERIODO_INICIAL,
subsubtipogasto=TipoGasto.CORRIENTE)
cursor = connection.cursor()
cursor.execute(sql)
inicial = dictfetchall(cursor)
sql = sql_tpl.format(asignado="final_asignado",
ejecutado="final_ejecutado",
year=year,
periodo=PERIODO_FINAL,
subsubtipogasto=TipoGasto.CORRIENTE)
cursor = connection.cursor()
cursor.execute(sql)
final = dictfetchall(cursor)
sql = sql_tpl.format(asignado="asignado",
ejecutado="ejecutado",
year=year,
periodo=periodo,
subsubtipogasto=TipoGasto.CORRIENTE)
cursor = connection.cursor()
cursor.execute(sql)
porclasep_periodo = dictfetchall(cursor)
sql = sql_tpl.format(asignado="final_asignado",
ejecutado="final_ejecutado",
year=year,
periodo=PERIODO_FINAL,
subsubtipogasto=TipoGasto.CORRIENTE)
cursor = connection.cursor()
cursor.execute(sql)
final = dictfetchall(cursor)
sql = sql_tpl.format(asignado="actualizado_asignado",
ejecutado="actualizado_ejecutado",
year=year,
periodo=PERIODO_ACTUALIZADO,
subsubtipogasto=TipoGasto.CORRIENTE)
cursor = connection.cursor()
cursor.execute(sql)
actualizado = dictfetchall(cursor)
#porclasep = glue(inicial, final, 'clasificacion', actualizado=actualizado)
porclasep = superglue(data=(inicial, porclasep_periodo, final,
actualizado),
key='clasificacion')
# indicando que cuentas debo exluir
excluir_cuentas_rubros['subsubtipogasto__codigo__in'] = [
TipoGasto.IMPREVISTOS, TipoGasto.TRANSFERENCIAS_CAPITAL
]
source_inicial = GastoDetalle.objects. \
filter(gasto__periodo=PERIODO_INICIAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE). \
order_by('gasto__anio'). \
values('gasto__anio'). \
annotate(ejecutado=Sum('ejecutado'),
asignado=Sum('asignado'))
total_asignado_anio = GastoDetalle.objects. \
filter(gasto__periodo=PERIODO_INICIAL,
gasto__anio=year). \
order_by('gasto__anio'). \
values('gasto__anio'). \
annotate(asignado=Sum('asignado'))
source_final = GastoDetalle.objects. \
filter(gasto__periodo=periodo,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE). \
order_by('gasto__anio'). \
values('gasto__anio'). \
annotate(ejecutado=Sum('ejecutado'),
asignado=Sum('asignado'))
total_ejecutado_anio = GastoDetalle.objects. \
filter(gasto__periodo=periodo,
gasto__anio=year). \
order_by('gasto__anio'). \
values('gasto__anio'). \
annotate(ejecutado=Sum('ejecutado'))
# obtiene valores para este año de las listas
try:
asignado = (item for item in source_inicial
if item["gasto__anio"] == int(year)).next()['asignado']
total_asignado = total_asignado_anio[0]['asignado']
asignado_percent = percentage(asignado, total_asignado)
except StopIteration:
asignado = 0
try:
ejecutado = (
item for item in source_final
if item["gasto__anio"] == int(year)).next()['ejecutado']
total_ejecutado = total_ejecutado_anio[0]['ejecutado']
ejecutado_percent = percentage(ejecutado, total_ejecutado)
except StopIteration:
ejecutado = 0
source = glue(source_inicial, source_final, 'gasto__anio')
# FIXME. en el grafico de periodos... de donde tomar los datos?
source_barra_inicial = GastoDetalle.objects.filter(gasto__periodo=PERIODO_INICIAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE).\
values('gasto__anio').annotate(ejecutado=Sum('ejecutado'), asignado=Sum('asignado'))
source_barra_final = GastoDetalle.objects.filter(gasto__periodo=PERIODO_FINAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE).\
values('gasto__anio').annotate(ejecutado=Sum('ejecutado'), asignado=Sum('asignado'))
# chart: porcentage gastos de funcionamiento
source_pgf_asignado = GastoDetalle.objects.filter(
gasto__anio=year,
gasto__periodo=periodo,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE).aggregate(
asignado=Sum(quesumar))
source_pgf_asignado['nombre'] = 'Funcionamiento'
otros_asignado = GastoDetalle.objects.filter(
gasto__anio=year, gasto__periodo=periodo).exclude(
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE).aggregate(
asignado=Sum(quesumar))
otros_asignado['nombre'] = 'Otros'
source_pgf = [source_pgf_asignado, otros_asignado]
# comparativo con promedio de clasificacion para un año específico
inicial = list(
GastoDetalle.objects.filter(
gasto__periodo=PERIODO_INICIAL,
gasto__anio=year,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE,
).order_by('gasto__periodo').values('gasto__periodo').annotate(
municipio=Sum('asignado')))
actualizado = list(
GastoDetalle.objects.filter(
gasto__periodo=PERIODO_ACTUALIZADO,
gasto__anio=year,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE,
).order_by('gasto__periodo').values('gasto__periodo').annotate(
municipio=Sum('ejecutado')))
final = list(
GastoDetalle.objects.filter(
gasto__periodo=PERIODO_FINAL,
gasto__anio=year,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE,
).order_by('gasto__periodo').values('gasto__periodo').annotate(
municipio=Sum('ejecutado')))
comparativo3 = list(chain(inicial, actualizado, final))
comparativo2 = list(chain(
inicial,
final,
))
for d in comparativo3:
d.update((k, PERIODO_VERBOSE[v]) for k, v in d.iteritems()
if k == "gasto__periodo")
# obtiene datos comparativo de todos los años
final = list(
GastoDetalle.objects.filter(
gasto__periodo=PERIODO_FINAL,
subsubtipogasto__clasificacion=TipoGasto.CORRIENTE,
).values('gasto__anio',
'gasto__periodo').annotate(ejecutado=Sum('ejecutado'),
asignado=Sum('asignado')))
comparativo_anios = final
# obtiene datos de gastos en ditintos rubros de corriente (clasificacion 0)
rubros_inicial = GastoDetalle.objects. \
filter(**filtro_rubros). \
filter(gasto__periodo=PERIODO_INICIAL). \
exclude(**excluir_cuentas_rubros). \
values('codigo__subsubtipogasto__origen_gc__id',
'codigo__subsubtipogasto__origen_gc__nombre'). \
order_by('codigo__subsubtipogasto__origen_gc__orden'). \
annotate(inicial_asignado=Sum('asignado'))
rubros_actualizado = GastoDetalle.objects. \
filter(**filtro_rubros). \
filter(gasto__periodo=PERIODO_ACTUALIZADO). \
exclude(**excluir_cuentas_rubros). \
values('codigo__subsubtipogasto__origen_gc__id',
'codigo__subsubtipogasto__origen_gc__nombre'). \
order_by('codigo__subsubtipogasto__origen_gc__orden'). \
annotate(actualizado_asignado=Sum('asignado'),
actualizado_ejecutado=Sum('ejecutado'))
rubros_final = GastoDetalle.objects. \
filter(**filtro_rubros). \
filter(gasto__periodo=PERIODO_FINAL). \
exclude(**excluir_cuentas_rubros). \
values('codigo__subsubtipogasto__origen_gc__id',
'codigo__subsubtipogasto__origen_gc__nombre'). \
order_by('codigo__subsubtipogasto__origen_gc__orden'). \
annotate(final_asignado=Sum('asignado'),
final_ejecutado=Sum('ejecutado'))
rubros_periodo = GastoDetalle.objects. \
filter(**filtro_rubros). \
filter(gasto__periodo=periodo). \
exclude(**excluir_cuentas_rubros). \
values('codigo__subsubtipogasto__origen_gc__id',
'codigo__subsubtipogasto__origen_gc__nombre'). \
order_by('codigo__subsubtipogasto__origen_gc__orden'). \
annotate(asignado=Sum('asignado'),
ejecutado=Sum('ejecutado'))
# rubros = glue(rubros_inicial, rubros_final, 'subsubtipogasto__codigo', actualizado=rubros_actualizado)
rubros = superglue(data=(rubros_inicial, rubros_final, rubros_actualizado,
rubros_periodo),
key='codigo__subsubtipogasto__origen_gc__id')
#
# chartit!
#
if municipio:
gf_comparativo_anios = RawDataPool(series=[{
'options': {
'source': comparativo_anios
},
'names': [
u'Años', u'gasto__periodo', u'P. Inicial', u'Ejecutado',
u'Categoría Inicial %s' % (mi_clase.clasificacion, ),
u'Categoría Final %s' % (mi_clase.clasificacion, )
],
'terms': [
'gasto__anio', 'gasto__periodo', 'asignado', 'ejecutado',
'clase_inicial', 'clase_final'
],
}], )
gf_comparativo_anios_column = Chart(
datasource=gf_comparativo_anios,
series_options=[{
'options': {
'type': 'column',
'stacking': False
},
'terms': {
'gasto__anio':
['asignado', 'ejecutado', 'clase_inicial', 'clase_final'],
},
}],
chart_options={'title': {
'text': ' '
}},
)
gf_comparativo3 = RawDataPool(
series=[{
'options': {
'source': comparativo3
},
'names': [
u'Gastos', u'Municipio',
u'Categoría %s' % (mi_clase.clasificacion, )
],
'terms': ['gasto__periodo', 'municipio', 'clase'],
}],
#sortf_mapf_mts = (None, lambda i: (datetime.strptime(i[0], '%Y-%m-%d').strftime('%Y'),), False)
)
gf_comparativo3_column = Chart(
datasource=gf_comparativo3,
series_options=[{
'options': {
'type': 'column',
'stacking': False
},
'terms': {
'gasto__periodo': ['municipio', 'clase']
},
}],
chart_options={
'title': {
'text': ' '
},
# 'subtitle': { 'text': u'Municipio de %s y Categoría del Municipio %s' % (municipio_row.nombre, year)},
'yAxis': {
'title': {
'text': u'Millones de córdobas'
}
},
},
)
gf_comparativo2 = RawDataPool(
series=[{
'options': {
'source': comparativo2
},
'names': [
u'Gastos',
u'Municipio',
u'Categoría %s' % (mi_clase.clasificacion, ),
],
'terms': ['gasto__periodo', 'municipiop', 'clasep'],
}],
#sortf_mapf_mts = (None, lambda i: (datetime.strptime(i[0], '%Y-%m-%d').strftime('%Y'),), False)
)
gf_comparativo2_column = Chart(
datasource=gf_comparativo2,
series_options=[{
'options': {
'type': 'column',
'stacking': False
},
'terms': {
'gasto__periodo': ['municipiop', 'clasep']
},
}],
chart_options={
'title': {
'text': ' '
},
'subtitle': {
'text': u' '
},
'tooltip': {
'pointFormat': '{series.name}: <b>{point.y:.2f}%</b>'
},
'yAxis': {
'title': {
'text': u'Millones de córdobas'
}
},
'xAxis': {
'title': {
'text': u'Gastos de funcionamiento'
}
},
},
)
else: # chartit no municipio
gf_nivelejecucion = RawDataPool(series=[{
'options': {
'source': porclase
},
'terms': ['clasificacion', 'ejecutado', 'asignado', 'nivel'],
}], )
gf_nivelejecucion_bar = Chart(
datasource=gf_nivelejecucion,
series_options=[{
'options': {
'type': 'bar',
'stacking': False
},
'terms': {
'clasificacion': ['nivel'],
},
}],
chart_options={
'title': {
'text': u'Nivel de ejecución %s' % (year, )
},
'tooltip': {
'pointFormat': '{series.name}: <b>{point.y:.2f}%</b>'
},
})
gf_comparativo_anios = RawDataPool(series=[{
'options': {
'source': comparativo_anios
},
'names': [u'Año', u'Periodo', u'Ejecutado', 'P. Inicial'],
'terms':
['gasto__anio', 'gasto__periodo', 'ejecutado', 'asignado'],
}], )
gf_comparativo_anios_column = Chart(
datasource=gf_comparativo_anios,
series_options=[{
'options': {
'type': 'column',
'stacking': False
},
'terms': {
'gasto__anio': ['ejecutado', 'asignado'],
},
}],
chart_options={'title': {
'text': ' '
}},
)
gf_comparativo3 = RawDataPool(
series=[{
'options': {
'source': comparativo3
},
'terms': [
'gasto__periodo',
'municipio',
],
}],
#sortf_mapf_mts = (None, lambda i: (datetime.strptime(i[0], '%Y-%m-%d').strftime('%Y'),), False)
)
gf_comparativo3_column = Chart(
datasource=gf_comparativo3,
series_options=[{
'options': {
'type': 'column',
'stacking': False
},
'terms': {
'gasto__periodo': [
'municipio',
]
},
}],
chart_options={'title': {
'text': ' '
}},
)
gf_comparativo2 = RawDataPool(
series=[{
'options': {
'source': comparativo2
},
'terms': [
'gasto__periodo',
'municipio',
],
}],
#sortf_mapf_mts = (None, lambda i: (datetime.strptime(i[0], '%Y-%m-%d').strftime('%Y'),), False)
)
gf_comparativo2_column = Chart(
datasource=gf_comparativo2,
series_options=[{
'options': {
'type': 'column',
'stacking': False
},
'terms': {
'gasto__periodo': [
'municipio',
]
},
}],
chart_options={
'title': {
'text': ' '
},
'tooltip': {
'pointFormat': '{series.name}: <b>{point.y:.2f}%</b>'
},
})
data_pgf = RawDataPool(series=[{
'options': {
'source': source_pgf
},
'terms': [
'nombre',
'asignado',
]
}])
data_rubros = RawDataPool(series=[{
'options': {
'source': rubros
},
'terms': ['subsubtipogasto__nombre', datacol]
}])
pie = Chart(datasource=data_rubros,
series_options=[{
'options': {
'type': 'pie'
},
'terms': {
'subsubtipogasto__nombre': [datacol]
}
}],
chart_options=chart_options)
bar = Chart(datasource=data_rubros,
series_options=[{
'options': {
'type': 'column',
'colorByPoint': True,
},
'terms': {
'subsubtipogasto__nombre': [datacol]
}
}],
chart_options=chart_options)
if municipio:
dataterms = ['gasto__anio', 'asignado', 'ejecutado', 'promedio']
terms = [
'asignado',
'ejecutado',
'promedio',
]
else:
municipio = ''
municipio_row = ''
dataterms = ['gasto__anio', 'asignado', 'ejecutado']
terms = ['asignado', 'ejecutado']
data = RawDataPool(series=[{
'options': {
'source': source
},
'terms': dataterms
}])
gfbar = Chart(
datasource=data,
series_options=[{
'options': {
'type': 'column'
},
'terms': {
'gasto__anio': terms
}
}],
chart_options={
'title': {
'text': u' '
},
'options3d': {
'enabled': 'true',
'alpha': 0,
'beta': 0,
'depth': 50
},
},
#x_sortf_mapf_mts = (None, lambda i: i.strftime('%Y'), False)
)
bar_horizontal = None
if otros:
parameters = {
'data':
otros,
'field1':
'gasto__municipio__nombre',
'field2':
'{}_percent'.format(quesumar),
'typechart':
'bar',
'title':
"Ranking de Municipios Categoría '{}'".format(
mi_clase.clasificacion),
'labelX_axis':
'Municipio',
'labelY_axis':
'Recaudación por habitante en córdobas corrientes',
'pointFormat':
'<span>Presupuesto Inicial</span>:<b>{point.y}</b>',
'interval':
10
}
bar_horizontal = graphChart(parameters)
elif porclasep:
parameters = {
'data': porclasep,
'field1': 'clasificacion',
'field2': '{}_porcentaje'.format(quesumar),
'typechart': 'column',
'title': 'Porcentaje del Gasto Total',
'labelX_axis': 'Grupos',
'labelY_axis': 'Porcentaje',
'pointFormat': '<span>{series.name}</span>:<b>{point.y:.2f}%</b>',
'interval': 10
}
bar_horizontal = graphChart(parameters)
portada = False #FIXME: convert to view
if portada:
charts = (pie, )
elif bar_horizontal:
charts = (bar_horizontal)
else:
charts = (pie, bar)
porano_table = historial_gastos_corrientes(periodo_list, year,
municipio_id)
# Bubble tree data
bubble_source = aci_bubbletree_data_gasto(municipio, year, portada)
reporte = request.POST.get("reporte", "")
if "excel" in request.POST.keys() and reporte:
from core.utils import obtener_excel_response
data = {
'charts': charts,
'municipio': municipio_row,
'municipio_list': municipio_list,
'year_list': year_list,
'otros': otros,
'rubros': rubros,
'anuales': anual2,
'ejecutado': ejecutado,
'asignado': asignado,
'porclase': porclase,
'porclasep': porclasep,
'mi_clase': mi_clase,
'year': year,
'porano': porano_table,
'asignado_percent': asignado_percent,
'ejecutado_percent': ejecutado_percent
}
return obtener_excel_response(reporte=reporte, data=data)
template_name = 'expenses.html'
context = {
'charts':
charts,
'municipio':
municipio_row,
'municipio_list':
municipio_list,
'year_list':
year_list,
'indicator_name':
"Gastos de funcionamiento",
'indicator':
"gf",
'mostraren':
"porcentaje",
'indicator_description':
"Mide el porcentaje del presupuesto de gasto que el Municipio destina,"
" para gastos de funcionamiento de la municipalidad. ",
'otros':
otros,
'rubros':
rubros,
'anuales':
anual2,
'ejecutado':
ejecutado,
'asignado':
asignado,
'porclase':
porclase,
'bubble_data':
bubble_source,
'asignado_percent':
asignado_percent,
'ejecutado_percent':
ejecutado_percent,
'periodo_list':
periodo_list,
'porclasep':
porclasep,
'mi_clase':
mi_clase,
'porano':
porano_table,
'total_nacional_asignado':
total_nacional_asignado,
'total_nacional_ejecutado':
total_nacional_ejecutado,
'year':
year
}
return render(request, template_name, context)