def aci_chart(request): municipio_list = Municipio.objects.all() year_list = getYears(Ingreso) municipio = request.GET.get('municipio', '') if municipio: with open("core/charts/aci_municipio.sql", "r") as query_file: sql = query_file.read() source = IngresoDetalle.objects.raw(sql, [ municipio, municipio, municipio, municipio, municipio, municipio, year_list ]) else: municipio = '' with open("core/charts/aci.sql", "r") as query_file: sql = query_file.read() source = IngresoDetalle.objects.raw(sql, [year_list]) data = RawDataPool(series=[{ 'options': { 'source': source }, 'terms': [ 'anio', 'ejecutado', 'asignado', ] }]) bar = Chart( datasource=data, series_options=[{ 'options': { 'type': 'bar', }, 'terms': { 'anio': ['asignado', 'ejecutado'] } }], chart_options={ 'title': { 'text': u'Ahorro corriente para inversiones %s ' % (municipio, ) }, }, #x_sortf_mapf_mts = (None, lambda i: i.strftime('%Y'), False) ) return render_to_response('agochart.html',{'charts': (bar, ), 'municipio_list': municipio_list},\ context_instance=RequestContext(request))
def info(request): # return the municipios with their clasificacion y partido politico ultimo_periodo = Periodo.objects. \ order_by('-desde'). \ all()[0] municipios = Municipio.objects. \ filter(periodomunic__periodo__id=ultimo_periodo.id). \ all(). \ values('id', 'nombre', 'depto__nombre', 'slug', 'periodomunic__partido'). \ order_by('depto_id') for row in municipios: row['clasificacion'] = ClasificacionMunicAno.objects. \ values_list('clasificacion__clasificacion', flat=True). \ filter(anio=ultimo_periodo.hasta, municipio_id=row['id']). \ first() return {'municipios': (municipios), 'year_list': getYears(Ingreso)}
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 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 aci_bubbletree_data_gasto(municipio=None, year=None, portada=False, total=0): year_list = getYears(Gasto) periodo = Anio.objects.get(anio=year).periodo if not year: year = year_list[-1] amount_column = 'asignado' if periodo == PERIODO_INICIAL else 'ejecutado' if municipio: amount = GastoDetalle.objects.filter( gasto__anio=year, gasto__municipio__slug=municipio, gasto__periodo=periodo, subsubtipogasto__clasificacion=TipoGasto.CORRIENTE) \ .aggregate(total=Sum(amount_column)) tipos = GastoDetalle.objects.filter( gasto__anio=year, gasto__municipio__slug=municipio, gasto__periodo=periodo, subsubtipogasto__clasificacion=TipoGasto.CORRIENTE) \ .values('tipogasto', 'tipogasto__nombre', 'tipogasto__shortname') \ .order_by('tipogasto__codigo') \ .annotate(amount=Sum(amount_column)) else: amount = GastoDetalle.objects.filter( gasto__anio=year, gasto__periodo=periodo, subsubtipogasto__clasificacion=TipoGasto.CORRIENTE) \ .aggregate(total=Sum(amount_column)) tipos = GastoDetalle.objects.filter( gasto__anio=year, gasto__periodo=periodo, subsubtipogasto__clasificacion=TipoGasto.CORRIENTE) \ .values('tipogasto', 'tipogasto__nombre', 'tipogasto__shortname') \ .order_by('tipogasto__codigo') \ .annotate(amount=Sum(amount_column)) data = { 'label': "Gasto Corriente", 'amount': round(xnumber(amount['total']) / 1000000, 2) } children = [] for idx, child in enumerate(tipos): if municipio: subtipos = GastoDetalle.objects.filter( gasto__anio=year, gasto__municipio__slug=municipio, gasto__periodo=periodo, subsubtipogasto__codigo=child['tipogasto']) \ .values('subtipogasto', 'subtipogasto__nombre', 'subtipogasto__shortname') \ .order_by('subtipogasto__codigo') \ .annotate(amount=Sum(amount_column)) else: subtipos = GastoDetalle.objects.filter( gasto__anio=year, gasto__periodo=periodo, subsubtipogasto__codigo=child['tipogasto']) \ .values('subtipogasto', 'subtipogasto__nombre', 'subtipogasto__shortname') \ .order_by('subtipogasto__codigo') \ .annotate(amount=Sum(amount_column)) grandchildren = [] for ix, grandchild in enumerate(subtipos): if grandchild['subtipogasto__shortname']: label = grandchild['subtipogasto__shortname'] else: label = grandchild['subtipogasto__nombre'] grandchild_data = { 'id': '{}.{}'.format(idx, ix), 'name': '{}.{}'.format(idx, ix), 'label': label, 'amount': round(xnumber(grandchild['amount']) / 1000000, 2) } grandchildren.append(grandchild_data) if child['tipogasto__shortname']: label = child['tipogasto__shortname'] else: label = child['tipogasto__nombre'] child_data = { 'taxonomy': "expense", 'id': idx, 'name': idx, 'label': label, 'amount': round(xnumber(child['amount']) / 1000000, 2), 'children': grandchildren } children.append(child_data) data['children'] = children 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 old_gpersonal_chart(request): municipio_list = Municipio.objects.all() year_list = getYears(Gasto) municipio = request.GET.get('municipio', '') year = request.GET.get('year', None) if not year: year = list(year_list)[-2] if municipio: source_barra = GastoDetalle.objects.filter( gasto__municipio__slug=municipio, gasto__periodo=PERIODO_INICIAL, tipogasto=TipoGasto.PERSONAL) source_ejecutado = GastoDetalle.objects.filter( gasto__municipio__slug=municipio, gasto__periodo=PERIODO_INICIAL, tipogasto=TipoGasto.PERSONAL).exclude(gasto__year=year) # chart: porcentage gastos de personal source_pgp_asignado = GastoDetalle.objects.filter( gasto__municipio__slug=municipio, gasto__year=year, gasto__periodo=PERIODO_INICIAL, tipogasto=TipoGasto.PERSONAL).aggregate(asignado=Sum('asignado')) source_pgp_asignado['nombre'] = 'Personal' otros_asignado = GastoDetalle.objects.filter( gasto__municipio__slug=municipio, gasto__year=year, gasto__periodo=PERIODO_INICIAL).exclude( tipogasto=TipoGasto.PERSONAL).aggregate( asignado=Sum('asignado')) otros_asignado['nombre'] = 'Otros' source_pgp = [source_pgp_asignado, otros_asignado] else: municipio = '' source_barra = GastoDetalle.objects.filter( gasto__periodo=PERIODO_INICIAL, tipogasto=TipoGasto.PERSONAL) source_ejecutado = GastoDetalle.objects.filter( gasto__periodo=PERIODO_INICIAL, tipogasto=TipoGasto.PERSONAL).exclude(gasto__year=year) # chart: porcentage gastos de personal source_pgp_asignado = GastoDetalle.objects.filter( gasto__year=year, gasto__periodo=PERIODO_INICIAL, tipogasto=TipoGasto.PERSONAL).aggregate(asignado=Sum('asignado')) source_pgp_asignado['nombre'] = 'Personal' otros_asignado = GastoDetalle.objects.filter( gasto__year=year, gasto__periodo=PERIODO_INICIAL).exclude( tipogasto=TipoGasto.PERSONAL).aggregate( asignado=Sum('asignado')) otros_asignado['nombre'] = 'Otros' source_pgp = [source_pgp_asignado, otros_asignado] data_pgf = RawDataPool(series=[{ 'options': { 'source': source_pgp }, 'terms': [ 'nombre', 'asignado', ] }]) pie = Chart( datasource=data_pgf, series_options=[{ 'options': { 'type': 'pie', }, 'terms': { 'nombre': ['asignado'] } }], chart_options={ 'title': { 'text': 'Gastos de personal %s %s ' % ( 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>' }, }, ) data_ejecutado = PivotDataPool( series=[{ 'options': { 'source': source_ejecutado, 'categories': 'gasto__anio', 'legend_by': 'subtipogasto__nombre', }, 'terms': { 'sum_ejecutado': Sum('ejecutado'), } }], #sortf_mapf_mts = (None, lambda i: (datetime.strptime(i[0], '%Y-%m-%d').strftime('%Y'),), False) ) chart_ejecutado = PivotChart( datasource=data_ejecutado, series_options=[{ 'options': { 'type': 'area', 'stacking': True }, 'terms': ['sum_ejecutado'] }], chart_options={ 'title': { 'text': 'Gastos ejecutados personal: %s' % (municipio, ) } }, ) data = PivotDataPool( series=[{ 'options': { 'source': source_barra, 'categories': 'gasto__anio', 'legend_by': 'subtipogasto__nombre', }, 'terms': { 'sum_asignado': Sum('asignado'), } }], #sortf_mapf_mts = (None, lambda i: (datetime.strptime(i[0], '%Y-%m-%d').strftime('%Y'),), False) ) chart = PivotChart( datasource=data, series_options=[{ 'options': { 'type': 'area', 'stacking': True }, 'terms': ['sum_asignado'] }], chart_options={ 'title': { 'text': 'Gastos asignados personal: %s' % (municipio, ) } }, ) return render_to_response('gpersonal.html',{'charts': (chart, chart_ejecutado, pie), 'municipio_list': municipio_list, 'year_list': year_list},\ context_instance=RequestContext(request))
def inversion_area_chart(municipio=None): municipio_list = Municipio.objects.all() year_list = getYears(Inversion) if municipio: source = Proyecto.objects.filter(inversion__municipio__slug=municipio, inversion__periodo=PERIODO_INICIAL) q = Q() for y in list(year_list)[-3:]: q |= Q(inversion__anio=y) source_barra = Proyecto.objects.filter( q, inversion__municipio__slug=municipio, inversion__periodo=PERIODO_INICIAL) else: municipio = '' source = Proyecto.objects.filter(inversion__periodo=PERIODO_INICIAL) q = Q() for y in list(year_list)[-3:]: q |= Q(inversion__anio=y) source_barra = Proyecto.objects.filter( q, inversion__periodo=PERIODO_INICIAL) data_barra = PivotDataPool( series=[{ 'options': { 'source': source_barra, 'categories': 'inversion__anio', 'legend_by': ['areageografica'], }, 'terms': { 'sum_ejecutado': Sum('ejecutado'), 'sum_asignado': Sum('asignado'), } }], #sortf_mapf_mts = (None, lambda i: (datetime.strptime(i[0], '%Y-%m-%d').strftime('%Y'),), False) ) barra = PivotChart( datasource=data_barra, series_options=[{ 'options': { 'type': 'bar', }, 'terms': ['sum_ejecutado'] }], chart_options={ 'title': { 'text': u'Inversión por área %s' % (municipio, ) } }, ) data = PivotDataPool( series=[{ 'options': { 'source': source, 'categories': 'inversion__anio', 'legend_by': ['areageografica'], }, 'terms': { 'sum_ejecutado': Sum('ejecutado'), 'sum_asignado': Sum('asignado'), } }], #sortf_mapf_mts = (None, lambda i: (datetime.strptime(i[0], '%Y-%m-%d').strftime('%Y'),), False) ) chart = PivotChart( datasource=data, series_options=[{ 'options': { 'type': 'bar', }, 'terms': ['sum_ejecutado'] }], chart_options={ 'title': { 'text': u'Inversión por área %s' % (municipio, ) } }, ) return { 'charts': ( chart, barra, ), 'municipio_list': municipio_list }
def fuentes_chart(municipio=None, year=None, portada=False): municipio_list = Municipio.objects.all() year_list = getYears(InversionFuente) periodo = Anio.objects.get(anio=year).periodo # usar 'asignado' para todo periodo si estamos en portada if portada: quesumar = 'asignado' else: quesumar = 'asignado' if periodo == PERIODO_INICIAL else 'ejecutado' if not year: year = year_list[-1] if municipio: source = InversionFuenteDetalle.objects.filter(inversionfuente__municipio__slug=municipio, inversionfuente__anio=year, inversionfuente__periodo=periodo).\ values('fuente').annotate(ejecutado=Sum('ejecutado'), asignado=Sum('asignado')).order_by('fuente__nombre') source_portada = InversionFuenteDetalle.objects.filter(inversionfuente__municipio__slug=municipio, inversionfuente__anio=year, inversionfuente__periodo=periodo).\ values('fuente__tipofuente__nombre').annotate(ejecutado=Sum('ejecutado'), asignado=Sum('asignado')).order_by('fuente__tipofuente__nombre') else: municipio = '' source = InversionFuenteDetalle.objects.filter(inversionfuente__anio=year, inversionfuente__periodo=periodo).\ values('fuente').annotate(ejecutado=Sum('ejecutado'), asignado=Sum('asignado')).order_by('fuente__nombre') source_portada = InversionFuenteDetalle.objects.filter(inversionfuente__anio=year, inversionfuente__periodo=periodo).\ values('fuente__tipofuente__nombre').annotate(ejecutado=Sum('ejecutado'), asignado=Sum('asignado')).order_by('fuente__tipofuente__nombre') data = DataPool(series=[{ 'options': { 'source': source }, 'terms': [ 'fuente__nombre', 'ejecutado', 'asignado', ] }]) data_portada = DataPool(series=[{ 'options': { 'source': source_portada }, 'terms': [ 'fuente__tipofuente__nombre', 'ejecutado', 'asignado', ] }]) asignado = Chart(datasource=data, series_options=[{ 'options': { 'type': 'pie' }, 'terms': { 'fuente__nombre': [quesumar] } }], chart_options={ 'title': { 'text': u' ' }, 'plotOptions': { 'pie': { 'dataLabels': { 'enabled': True, 'format': '{point.percentage:.2f} %' }, 'showInLegend': True, 'depth': 35 } }, 'options3d': { 'enabled': 'true', 'alpha': '45', 'beta': '0' }, 'tooltip': { 'pointFormat': '{series.name}: <b>{point.percentage:.2f}%</b>' }, }) asignado_portada = Chart( datasource=data_portada, series_options=[{ 'options': { 'type': 'pie' }, 'terms': { 'fuente__tipofuente__nombre': [quesumar] } }], chart_options={ 'title': { 'text': u' ' }, 'plotOptions': { 'pie': { 'dataLabels': { 'enabled': True, 'format': '{point.percentage:.2f} %' }, 'showInLegend': True, 'depth': 35 } }, 'options3d': { 'enabled': 'true', 'alpha': '45', 'beta': '0' }, 'tooltip': { 'pointFormat': '{series.name}: <b>{point.percentage:.2f}%</b>' }, }) return { 'charts': (asignado, asignado_portada), 'year_list': year_list, 'municipio_list': municipio_list }
def inversion_minima_sector_chart(municipio=None, year=None, portada=False): municipio_list = Municipio.objects.all() year_list = getYears(Inversion) if not year: year = list(year_list)[-2] periodo = Anio.objects.get(anio=year).periodo # usar 'asignado' para todo periodo si estamos en portada if portada: quesumar = 'asignado' else: quesumar = 'ejecutado' if municipio: source_asignado = Proyecto.objects.filter( inversion__anio=year, inversion__periodo=periodo, catinversion__minimo__gt=0, inversion__municipio__slug=municipio).values( 'catinversion__nombre').annotate(asignado=Sum('asignado')) source = CatInversion.objects.filter(minimo__gt=0).values( 'nombre', 'minimo', ) total_asignado = Proyecto.objects.filter( inversion__anio=year, inversion__periodo=periodo, inversion__municipio__slug=municipio).aggregate( total=Sum('asignado'))['total'] else: municipio = '' source_asignado = Proyecto.objects.filter( inversion__anio=year, inversion__periodo=periodo, catinversion__minimo__gt=0).values( 'catinversion__nombre').annotate(asignado=Sum('asignado')) source = CatInversion.objects.filter(minimo__gt=0).values( 'nombre', 'minimo', ) total_asignado = (Proyecto.objects.filter( inversion__anio=year, inversion__periodo=periodo).aggregate( total=Sum('asignado'))['total'] or 0) / 100 for record in source: try: record[ 'asignado'] = 0 if not source_asignado else source_asignado.filter( catinversion__nombre=record['nombre'] )[0][quesumar] / total_asignado except IndexError: record['asignado'] = 0 data = RawDataPool(series=[{ 'options': { 'source': source }, 'names': [u'Sector priorizado', u'Mínimo por ley', u'Presupuestado'], 'terms': ['nombre', 'minimo', 'asignado'] }]) chart = Chart( datasource=data, series_options=[{ 'options': { 'type': 'column', }, 'terms': { 'nombre': [ 'asignado', 'minimo', ] }, }], chart_options={ # grafico 5 de portada Arto 12 'title': { 'text': u' ' }, 'tooltip': { 'pointFormat': '{series.name}: <b>{point.y:.2f}%</b>' }, }) return { 'charts': (chart, ), 'year_list': year_list, 'municipio_list': municipio_list }
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_chart(municipio=None): municipio_list = Municipio.objects.all() periodo_list = getPeriods(Inversion) year_list = getYears(Inversion) if municipio: source = Proyecto.objects.filter(inversion__periodo=PERIODO_INICIAL, inversion__municipio__slug=municipio). \ values('inversion__anio').annotate(ejecutado=Sum('ejecutado'), asignado=Sum('asignado')) source_ultimos = Proyecto.objects.filter(inversion__periodo=PERIODO_INICIAL, inversion__municipio__slug=municipio, \ inversion__anio__gt=list(year_list)[-3]). \ values('inversion__anio').annotate(ejecutado=Sum('ejecutado'), asignado=Sum('asignado')) else: municipio = '' source = Proyecto.objects.filter(inversion__periodo=PERIODO_INICIAL). \ values('inversion__anio').annotate(ejecutado=Sum('ejecutado'), asignado=Sum('asignado')) source_ultimos = Proyecto.objects.filter(inversion__periodo=PERIODO_INICIAL, inversion__anio__gt=list(year_list)[-3]). \ values('inversion__anio').annotate(ejecutado=Sum('ejecutado'), asignado=Sum('asignado')) data_ultimos = DataPool(series=[{ 'options': { 'source': source_ultimos, 'categories': 'inversion__anio', }, 'terms': [ 'inversion__anio', 'ejecutado', 'asignado', ] }], ) chart_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, ) } }, #x_sortf_mapf_mts = (None, lambda i: i.strftime('%Y'), False) ) data = DataPool(series=[{ 'options': { 'source': source, 'categories': 'inversion__anio', }, 'terms': [ 'inversion__anio', 'ejecutado', 'asignado', ] }], ) chart = Chart( datasource=data, series_options=[{ 'options': { 'type': 'bar', 'stacking': False }, 'terms': { 'inversion__anio': ['asignado', 'ejecutado'] } }], chart_options={ 'title': { 'text': u'Inversión por años %s' % (municipio, ) } }, #x_sortf_mapf_mts = (None, lambda i: i.strftime('%Y'), False) ) return {'charts': (chart, chart_ultimos), 'municipio_list': municipio_list}
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)