def apurar_votos(tcr, id_apuracao):
print(
f'Iniciada apuração: {tcr.turnoCargo.cargo.nome} ==========================================================='
)
votos = db.query(VotoEncriptado)\
.filter(VotoEncriptado.id_turno_cargo_regiao == tcr.id_turno_cargo_regiao)\
.all()
for voto_enc in votos:
voto = mf.cria_voto(voto_enc, id_apuracao)
db.create(voto)
db.commit()
sql = '''UPDATE candidato c
SET qt_votos = (SELECT count(*) FROM voto_apurado va
WHERE id_turno_cargo_regiao = :idTurnoCargoRegiao
AND id_apuracao = :idApuracao
AND va.id_candidato = c.id_candidato)
WHERE c.id_turno_cargo_regiao = :idTurnoCargoRegiao'''
db.native(sql, {
'idTurnoCargoRegiao': tcr.id_turno_cargo_regiao,
'idApuracao': id_apuracao
})
db.commit()
print(
f'Finalizada apuração: {tcr.turnoCargo.cargo.nome} ========================================================='
)
def cargos_por_eleicao_e_usuario(id_eleicao, user):
id_turno = valida_usuario_votou_e_retorna_turno_aberto(id_eleicao, user)
sql = '''SELECT DISTINCT id_turno_cargo_regiao, c.nome, c.max_votos FROM turno t
JOIN turno_cargo tc ON t.id_turno = tc.id_turno
JOIN cargo c ON tc.id_cargo = c.id_cargo
JOIN turno_cargo_regiao tcr ON tc.id_turno_cargo = tcr.id_turno_cargo
WHERE ((tcr.id_estado IS NULL AND tcr.id_cidade IS NULL)
OR (tcr.id_estado = :idEstado AND tcr.id_cidade IS NULL)
OR (tcr.id_estado = :idEstado AND tcr.id_cidade = :idCidade))
AND t.id_turno = :idTurno'''
resultado = db.native(
sql, {
'idTurno': id_turno,
'idEstado': user.eleitor.cidade.id_estado,
'idCidade': user.eleitor.id_cidade
})
cargos = []
for r in resultado:
for v in range(r['max_votos']):
cargos.append({
'idTurnoCargoRegiao': r['id_turno_cargo_regiao'],
'nomeCargo': r['nome'],
'index_voto': v + 1
})
return cargos
def busca_candidatos(id_turno_cargo_regiao):
candidatos = db.native(query_busca_candidato(), {
'idTcr': id_turno_cargo_regiao
}).fetchall()
if not candidatos:
return []
return [json_candidato(c) for c in candidatos]
def verifica_eleito_maioria_simples(tcr, segundo_turno, id_apuracao):
candidatos = [
c for c in tcr.candidatos if c.id_candidato_principal is None
]
candidatos.sort(key=lambda c: c.qt_votos, reverse=True)
if tcr.possui_segundo_turno and candidatos:
sql_total_votos = '''SELECT count(*) FROM voto_apurado
WHERE id_turno_cargo_regiao = :idTurnoCargoRegiao
AND id_apuracao = :idApuracao
AND id_candidato IS NOT NULL'''
total_votos = db.native(
sql_total_votos, {
'idTurnoCargoRegiao': tcr.id_turno_cargo_regiao,
'idApuracao': id_apuracao
}).first()[0]
if candidatos[0].qt_votos > (int(total_votos / 2)):
candidatos[0].situacao = 'Eleito'
else:
candidatos[0].situacao = 'Segundo Turno'
candidatos[1].situacao = 'Segundo Turno'
adiciona_turno_cargo_regiao_segundo_turno(tcr, candidatos[:2],
segundo_turno)
elif candidatos:
for i in range(tcr.qtd_cadeiras):
candidatos[i].situacao = 'Eleito'
db.commit()
def consulta_eleicao_por_usuario(user):
sql = '''SELECT DISTINCT e.id_eleicao, e.titulo, t.inicio, t.termino, t.turno, et IS NOT NULL AS votou
FROM eleicao e
JOIN turno t ON e.id_eleicao = t.id_eleicao
JOIN turno_cargo tc ON t.id_turno = tc.id_turno
JOIN turno_cargo_regiao tcr ON tc.id_turno_cargo = tcr.id_turno_cargo
LEFT JOIN eleitor_turno et ON t.id_turno = et.id_turno AND et.id_eleitor = :idEleitor
WHERE t.inicio IS NOT NULL AND t.termino IS NOT NULL AND e.confirmada
AND ((tcr.id_estado IS NULL AND tcr.id_cidade IS NULL)
OR (tcr.id_estado = :idEstado AND tcr.id_cidade IS NULL)
OR (tcr.id_estado = :idEstado AND tcr.id_cidade = :idCidade))
ORDER BY t.inicio DESC'''
resultado = db.native(
sql, {
'idEstado': user.eleitor.cidade.id_estado,
'idCidade': user.eleitor.id_cidade,
'idEleitor': user.eleitor.id_eleitor
})
eleicoes = []
for r in resultado:
eleicoes.append({
'idEleicao': r['id_eleicao'],
'titulo': r['titulo'],
'inicio': str(r['inicio']),
'termino': str(r['termino']),
'turno': r['turno'],
'votou': r['votou']
})
return eleicoes
def get_partidos(id_tcr):
sql_partidos = 'SELECT partido.id_partido, sum(qt_votos) ' \
'FROM partido JOIN candidato ON partido.id_partido = candidato.id_partido ' \
'WHERE id_turno_cargo_regiao = :idTcr ' \
'GROUP BY partido.id_partido'
partidos = db.native(sql_partidos, {'idTcr': id_tcr}).fetchall()
return [SimpleNamespace(id_partido=p[0], votos=p[1]) for p in partidos]
def get_qt_votos_validos(id_tcr, id_apuracao):
sql_qt_votos_validos = "SELECT count(*) FROM voto_apurado " \
"WHERE id_partido IS NOT NULL AND id_turno_cargo_regiao = :idTcr " \
"AND id_apuracao = :idApuracao"
return db.native(sql_qt_votos_validos, {
'idTcr': id_tcr,
'idApuracao': id_apuracao
}).first()[0]
def consulta_turno_aberto_por_eleicao(id_eleicao):
sql = '''SELECT t.id_turno FROM turno t
JOIN eleicao e ON t.id_eleicao = e.id_eleicao
LEFT JOIN apuracao a ON a.id_turno = t.id_turno
WHERE now() BETWEEN t.inicio AND t.termino
AND e.confirmada
AND a IS NULL
AND t.id_eleicao = :idEleicao'''
result = db.native(sql, {'idEleicao': id_eleicao}).first()
id_turno = result['id_turno'] if result is not None else None
return id_turno
def votar(id_eleicao):
sql = '''select e.id_eleitor as id_pessoa from pessoa p
join eleitor e on p.id_pessoa = e.id_pessoa
where p.nome like '%Teste%'
and not exists(select 1 from eleitor_turno et
where e.id_eleitor = et.id_eleitor and et.id_turno = :idTurno)
limit 500'''
id_turno = voto_business.consulta_turno_aberto_por_eleicao(id_eleicao)
result = db.native(sql, {'idTurno': id_turno}).fetchall()
id_eleitores = [r[0] for r in result]
# Thread(target=cria_votos, kwargs={'id_eleitores': id_eleitores[:1000], 'id_turno': id_turno}).start()
cria_votos(id_eleitores, id_turno)
def verifica_integridade_votos(id_turno):
sql = '''SELECT COUNT(*) FROM (
SELECT DISTINCT id_eleitor FROM (SELECT id_eleitor, id_candidato, id_turno_cargo_regiao
FROM voto_encriptado
ORDER BY id_eleitor, id_turno_cargo_regiao) ve
WHERE ve.id_turno_cargo_regiao IN(SELECT id_turno_cargo_regiao
FROM turno_cargo_regiao
JOIN turno_cargo tc ON turno_cargo_regiao.id_turno_cargo = tc.id_turno_cargo
WHERE tc.id_turno = :idTurno)
GROUP BY ve.id_eleitor
HAVING md5(string_agg(ve.id_candidato, '')) NOT IN (SELECT et.hash FROM eleitor_turno et))
AS votos_alterados'''
votos_alterados = db.native(sql, {'idTurno': id_turno}).first()[0]
if votos_alterados > 0:
msg = f'{votos_alterados} votos desta eleição foram alterados!'
raise ValidationException(msg, [msg])
def valida_usuario_votou_e_retorna_turno_aberto(id_eleicao, user):
id_turno = consulta_turno_aberto_por_eleicao(id_eleicao)
if id_turno is None:
msg = 'Não há nenhum turno em andamento para esta eleição'
raise ValidationException(msg, [msg])
sql_votou = 'SELECT EXISTS(SELECT 1 FROM eleitor_turno ' \
' WHERE id_eleitor = :idEleitor ' \
' AND id_turno = :idTurno) AS votou'
votou = db.native(sql_votou, {
'idTurno': id_turno,
'idEleitor': user.eleitor.id_eleitor
}).first()['votou']
if votou:
msg = 'Voce já votou nesta eleição'
raise ValidationException(msg, [msg])
return id_turno
def verifica_total_cadeiras_preenchidas(id_tcr, partidos, quociente_eleitoral):
total_cadeiras_preenchidas = 0
for partido in partidos:
partido.cadeiras = int(partido.votos / quociente_eleitoral)
sql_candidatos_elegiveis = 'SELECT count(*) FROM candidato ' \
'WHERE candidato.id_turno_cargo_regiao = :idTcr ' \
'AND candidato.id_partido = :idPartido ' \
'AND candidato.qt_votos >= :quocienteEleitoral'
params = {
'idTcr': id_tcr,
'idPartido': partido.id_partido,
'quocienteEleitoral': quociente_eleitoral * 0.1
}
qt_candidatos_elegiveis = db.native(sql_candidatos_elegiveis,
params).first()[0]
if qt_candidatos_elegiveis < partido.cadeiras:
total_cadeiras_preenchidas += qt_candidatos_elegiveis
partido.cadeiras = qt_candidatos_elegiveis
else:
total_cadeiras_preenchidas += partido.cadeiras
partido.qt_candidatos_elegiveis = qt_candidatos_elegiveis
return total_cadeiras_preenchidas
def cria_votos(id_eleitores, id_turno):
for id_eleitor in id_eleitores:
hash_voto = ''
print(f'Voto de {id_eleitor}')
cands = [-1, 23, 25, 27, 29]
shuffle(cands)
if cands[0] != -1:
cand = db.query(Candidato).get(cands[0])
id_candidato = c.enc(cand.id_candidato)
id_partido = c.enc(cand.id_partido)
else:
id_candidato = c.enc(-1)
id_partido = c.enc(-1)
id_eleitor_enc = c.enc(id_eleitor)
id_turno_cargo_regiao = 9
id_cidade = 1
hash_voto += str(id_candidato)
sql = 'INSERT INTO voto_encriptado(id_turno_cargo_regiao, id_cidade, id_candidato, id_partido, id_eleitor)' \
'VALUES(:idTurnoCargoRegiao, :idCidade, :idCandidato, :idPartido, :idEleitor)'
db.native(sql, {'idTurnoCargoRegiao': id_turno_cargo_regiao,
'idCidade': id_cidade,
'idCandidato': id_candidato,
'idPartido': id_partido,
'idEleitor': id_eleitor_enc})
cands = [-1, 31, 33, 35]
shuffle(cands)
if cands[0] != -1:
cand = db.query(Candidato).get(cands[0])
id_candidato = c.enc(cand.id_candidato)
id_partido = c.enc(cand.id_partido)
else:
id_candidato = c.enc(-1)
id_partido = c.enc(-1)
id_turno_cargo_regiao = 10
id_cidade = 1
hash_voto += str(id_candidato)
sql = 'INSERT INTO voto_encriptado(id_turno_cargo_regiao, id_cidade, id_candidato, id_partido, id_eleitor)' \
'VALUES(:idTurnoCargoRegiao, :idCidade, :idCandidato, :idPartido, :idEleitor)'
db.native(sql, {'idTurnoCargoRegiao': id_turno_cargo_regiao,
'idCidade': id_cidade,
'idCandidato': id_candidato,
'idPartido': id_partido,
'idEleitor': id_eleitor_enc})
cand = randint(43, 142)
cand = cand if bool(randint(0, 1)) else -1
if cand != -1:
cand = db.query(Candidato).get(cand)
id_candidato = c.enc(cand.id_candidato)
id_partido = c.enc(cand.id_partido)
else:
id_candidato = c.enc(-1)
id_partido = c.enc(-1)
id_turno_cargo_regiao = 12
id_cidade = 1
hash_voto += str(id_candidato)
sql = 'INSERT INTO voto_encriptado(id_turno_cargo_regiao, id_cidade, id_candidato, id_partido, id_eleitor)' \
'VALUES(:idTurnoCargoRegiao, :idCidade, :idCandidato, :idPartido, :idEleitor)'
db.native(sql, {'idTurnoCargoRegiao': id_turno_cargo_regiao,
'idCidade': id_cidade,
'idCandidato': id_candidato,
'idPartido': id_partido,
'idEleitor': id_eleitor_enc})
insert_eleitor_turno(id_eleitor, id_turno, senha_util.encrypt_md5(hash_voto))
db.commit()
def insert_eleitor_turno(id_eleitor, id_turno, hash_voto):
sql = 'INSERT INTO eleitor_turno(id_eleitor, id_turno, hash, hora_voto) VALUES(:idEleitor, :idTurno, :hash, now())'
db.native(sql, {'idEleitor': id_eleitor, 'idTurno': id_turno, 'hash': hash_voto})
def remove_status_eleito(tcr):
sql = """UPDATE candidato SET situacao = 'Não Eleito' WHERE id_turno_cargo_regiao = :idTcr"""
db.native(sql, {'idTcr': tcr.id_turno_cargo_regiao})
db.commit()