def a_tag(self, grupo_cat=None, con_dnis=True): """Devuelve la informacion del recuento para almacenar en tag rfid.""" valores = [] candidatos = Candidatura.para_recuento(grupo_cat) for candidato in candidatos: resultado = self.get_resultados(candidato.id_umv) valores.append(resultado) ordered_keys = sorted(self.campos_extra.keys()) for key in ordered_keys: valores.append(self.campos_extra[key]) ordered_keys = sorted(self.listas_especiales.keys()) for key in ordered_keys: valores.append(self.listas_especiales[key]) container = Container() # cod_mesa if SMART_PACKING: num_mesa = self.mesa.numero.encode('ascii') try: datos = pack(int(num_mesa), valores) except NameError: # hacemos "upgrade" a chip de 2k datos = pack(int(num_mesa), valores, max_bits=MAXBITS*2) container.datos = datos else: cod_mesa = self.mesa.codigo.encode('ascii') packed = pack(valores) datos = str(len(cod_mesa)).zfill(2).encode() + cod_mesa + packed container.datos = datos documentos = [] for autoridad in self.autoridades: documentos.append(int(autoridad.nro_documento)) if con_dnis: documentos = [] for autoridad in self.autoridades: documentos.append(int(autoridad.nro_documento)) len_documentos = len(documentos) if len_documentos == 1: documentos.append(0) elif len_documentos == 0: documentos = [0, 0] documentos = pack_slow(documentos, BITS_DNI) container.len_docs = len(documentos) container.documentos = documentos struct = struct_recuento_dni else: struct = struct_recuento container.grupo = int(grupo_cat) if grupo_cat is not None else 0 return struct.build(container)
def a_tag(self, grupo_cat=None, con_dnis=True): """Devuelve la informacion del recuento para almacenar en tag rfid.""" valores = [] candidatos = Candidatura.para_recuento(grupo_cat) for candidato in candidatos: resultado = self.get_resultados(candidato.id_umv) valores.append(resultado) ordered_keys = sorted(self.campos_extra.keys()) for key in ordered_keys: valores.append(self.campos_extra[key]) ordered_keys = sorted(self.listas_especiales.keys()) for key in ordered_keys: valores.append(self.listas_especiales[key]) container = Container() # cod_mesa if SMART_PACKING: num_mesa = self.mesa.numero.encode('ascii') try: datos = pack(int(num_mesa), valores) except NameError: # hacemos "upgrade" a chip de 2k datos = pack(int(num_mesa), valores, max_bits=MAXBITS * 2) container.datos = datos else: cod_mesa = self.mesa.codigo.encode('ascii') packed = pack(valores) datos = str(len(cod_mesa)).zfill(2).encode() + cod_mesa + packed container.datos = datos documentos = [] for autoridad in self.autoridades: documentos.append(int(autoridad.nro_documento)) if con_dnis: documentos = [] for autoridad in self.autoridades: documentos.append(int(autoridad.nro_documento)) len_documentos = len(documentos) if len_documentos == 1: documentos.append(0) elif len_documentos == 0: documentos = [0, 0] documentos = pack_slow(documentos, BITS_DNI) container.len_docs = len(documentos) container.documentos = documentos struct = struct_recuento_dni else: struct = struct_recuento container.grupo = int(grupo_cat) if grupo_cat is not None else 0 return struct.build(container)
def _get_datos_fila_blanca(self, categorias): """Devuelve los datos de la fila de votos en blanco. Argumentos: categorias -- las categorias que queremos mostrar en la tabla. """ mostrar_numero = self.config("numero_lista_en_tabla", self.data["cod_datos"]) numero = " " if mostrar_numero else "" # Manejo de la fila que tiene los votos en blanco fila = [numero, _("votos_en_blanco"), 0] # cantidad_blancos no es un booleano por que a veces en algunas # elecciones esta bueno saber cuantas candidaturas en blanco hay cantidad_blancos = 0 # Recorro todas las categorias buscando las candidaturas blancas en # caso de que las haya for categoria in categorias: candidato = Candidatura.get_blanco(categoria.codigo) # el contenido del cuadro va a ser "-" a menos que haya algun # candidato blanco en esta categoria para esta Ubicacion resultado = "-" if candidato is not None: resultado = self.recuento.get_resultados(candidato.id_umv) # muestro la cantidad de blancos cantidad_blancos += 1 fila.append(resultado) # si tengo candidatos blancos tenemos que mostar la fila de blancos. if not cantidad_blancos: fila = None return fila
def audios_cargo_listas(self, data): """Carga los audios de las lista de los cargos.""" listas = [] for datum in data: lista = Candidatura.one(id_umv=datum).to_dict() listas.append(lista) self.audios("cargar_cargo_listas", listas)
def rellenar_de_blanco(self): """Agrega voto en blanco a las categorias que no fueron votadas.""" for categoria in Categoria.many(): if self.candidato_categoria(categoria.codigo) is None: blanco = Candidatura.one(cod_categoria=categoria.codigo, clase="Blanco") if blanco is not None: self.elegir_candidato(blanco)
def listas_especiales(self): codigos = [] especiales = Candidatura.many(clase="Especial", sorted="orden_absoluto") for especial in especiales: if especial.id_candidatura not in codigos: codigos.append(especial.id_candidatura) return codigos
def audios_mostrar_confirmacion(self, data): """Carga los audios de la confirmacion.""" paneles = [] for datum in data: categoria = Categoria.one(datum[0]).to_dict() candidato = Candidatura.one(datum[1]).to_dict() dict_panel = {"categoria": categoria, "candidato": candidato} paneles.append(dict_panel) self.audios("mostrar_confirmacion", paneles)
def audios_cargar_consulta(self, data): """Carga los audios de la consulta popular.""" data_dict = {"cod_categoria": data[0]} candidatos = [] for elem in data[1]: candidato = Candidatura.one(id_umv=elem).to_dict() candidatos.append(candidato) data_dict["candidatos"] = candidatos self.audios("cargar_consulta_popular", data_dict)
def __init__(self): """Constructor de la Pizarra. Es una representacion de la Pizarra Fisica que usan las autoridades de mesa en las elecciones tradicionales. """ self.__resultados = {} candidaturas = Candidatura.seleccionables() for candidatura in candidaturas: self.set_votos_candidato(candidatura.id_umv, 0)
def audios_cargar_listas(self, data): """Carga los audios de las listas.""" listas = [] for datum in data: if datum != COD_LISTA_BLANCO: lista = Lista.one(id_candidatura=datum).to_dict() else: lista = Candidatura.first(clase="Blanco").to_dict() listas.append(lista) self.audios("cargar_listas", listas)
def seleccionar_candidatos(self, seleccion): """Selecciona los candidatos.""" for cod_categoria, cod_candidatos in list(seleccion.items()): muchos_candidatos = len(cod_candidatos) > 1 if muchos_candidatos: self.modulo.seleccion.borrar_categoria(cod_categoria) for cod_candidato in cod_candidatos: cod_candidato = int(cod_candidato) candidato = Candidatura.one(cod_candidato) self.modulo.seleccion.elegir_candidato(candidato, not muchos_candidatos)
def a_human(self): texto = "{} - {}, {}, {} ({})\n".format(self.mesa.descripcion, self.mesa.escuela, self.mesa.municipio, self.mesa.departamento, self.mesa.codigo) for autoridad in self.autoridades: texto += "Autoridad: {}\n".format(autoridad.nro_documento) for categoria in Categoria.many(sorted="posicion", id_grupo=self.grupo_cat): texto += "{}\n".format(categoria.nombre) for lista in Lista.many(sorted='codigo'): candidato = Candidatura.one(cod_categoria=categoria.codigo, cod_lista=lista.codigo) if candidato is not None: votos = self.get_resultados(candidato.id_umv) texto += "\t{} - {} Votos: {}\n".format(lista.nombre, candidato.nombre, votos) candidato = Candidatura.one(cod_categoria=categoria.codigo, clase="Blanco") if candidato is not None: votos = self.get_resultados(candidato.id_umv) texto += "\t{}: {}\n".format(_("votos_en_blanco"), votos) texto += "\n" texto += "\nCampos extra:\n" ordered_keys = sorted(self.campos_extra.keys()) for key in ordered_keys: texto += "{}: {}\n".format(key, self.campos_extra[key]) texto += "\nListas Especiales:\n" ordered_keys = sorted(self.listas_especiales.keys()) for key in ordered_keys: titulo = _("titulo_votos_{}".format(key)) texto += "{}: {}\n".format(titulo, self.listas_especiales[key]) return texto
def a_human(self): texto = "{} - {}, {}, {} ({})\n".format(self.mesa.descripcion, self.mesa.escuela, self.mesa.municipio, self.mesa.departamento, self.mesa.codigo) for autoridad in self.autoridades: texto += "Autoridad: {}\n".format(autoridad.nro_documento) for categoria in Categoria.many(sorted="posicion", id_grupo=self.grupo_cat): texto += "{}\n".format(categoria.nombre) for lista in Lista.many(sorted='codigo'): candidato = Candidatura.one(cod_categoria=categoria.codigo, cod_lista=lista.codigo) if candidato is not None: votos = self.get_resultados(candidato.id_umv) texto += "\t{} - {} Votos: {}\n".format( lista.nombre, candidato.nombre, votos) candidato = Candidatura.one(cod_categoria=categoria.codigo, clase="Blanco") if candidato is not None: votos = self.get_resultados(candidato.id_umv) texto += "\t{}: {}\n".format(_("votos_en_blanco"), votos) texto += "\n" texto += "\nCampos extra:\n" ordered_keys = sorted(self.campos_extra.keys()) for key in ordered_keys: texto += "{}: {}\n".format(key, self.campos_extra[key]) texto += "\nListas Especiales:\n" ordered_keys = sorted(self.listas_especiales.keys()) for key in ordered_keys: titulo = _("titulo_votos_{}".format(key)) texto += "{}: {}\n".format(titulo, self.listas_especiales[key]) return texto
def set_votos_candidato(self, id_umv, votos): """Devuelve la cantidad de votos que tiene una candidatura. Argumentos: id_umv -- el id_umv de una candidatura. votos -- la cantidad de votos que se quiere establecer """ assert type(votos) == int seleccionables = Candidatura.seleccionables() candidato = seleccionables.one(id_umv=id_umv) if candidato is not None: self.__resultados[id_umv] = votos else: raise ValueError
def _get_datos_fila(self, categorias, agrupacion, partido_omitido): """Devuelve los datos de la tabla principal del acta. Argumentos: categorias -- las categorias que queremos mostrar en la tabla. agrupacion -- la agrupacion de la que estamos mostrando la tabla """ # primero vamos a averiguar la indentacion que queremos ponerle a esta # fila en la tabla. clases_a_mostrar = self.config("clases_a_mostrar", self.data["cod_datos"]) mostrar_numero = self.config("numero_lista_en_tabla", self.data["cod_datos"]) indentacion = clases_a_mostrar.index(agrupacion.clase) # si el partido no esta omitido vamos a ponerle profundidad. if not partido_omitido: nombre = " " * indentacion nombre += agrupacion.nombre # sino el nombre pasa de largo y queda el que está. else: nombre = agrupacion.partido.nombre # establecemos el numero de la lista. En alguna eleccion esto puede ser # mas complejo que traer el numero, puede ser la concatenacion de # varios numeros diferentes. if mostrar_numero and hasattr(agrupacion, "numero"): numero = str(agrupacion.numero) else: numero = "" # armamos la base de la fila. fila = [numero, nombre, indentacion] # Recorremos todas las categorias que queremos mostrar en este acta # buscando cuantos votos tiene cada candidato. for categoria in categorias: candidato = Candidatura.one(cod_lista=agrupacion.codigo, cod_categoria=categoria.codigo) # Si el candidato existe vamos a buscar cuantos votos tiene y sino # devolvemos "-" que se transforma en una cruz en el acta if candidato is not None: votos = self.recuento.get_resultados(candidato.id_umv) else: votos = "-" fila.append(votos) return fila, len(numero)
def elegir_candidato(self, candidato, borrar=True): """Guarda un candidato seleccionado. Argumentos: candididato -- un objeto Candidatura. borrar -- Borra todos los candidatos de esa categoria si es True """ # Primero nos fijamos que el candididato no sea None if candidato is not None: # y despues buscamos que ese candidato efectivamente exista seleccionables = Candidatura.seleccionables() encontrado = seleccionables.one(id_umv=candidato.id_umv) if encontrado is not None: if borrar: self.borrar_categoria(candidato.cod_categoria) self.__candidatos.append(candidato) else: raise ValueError else: raise ValueError
def get_resultados(self, id_umv=None): """Devuelve todos los resultados o uno en especifico.""" # si le pedimos uno solo busca los votos de ese candidato. if id_umv is not None: ret = self.pizarra.votos_candidato(id_umv) else: # Sino devolvemos todos votos = self.pizarra.get_votos_actuales() # Si el acta está desglosada devolvemos la categorias que tiene el # acta guardada if self.grupo_cat is not None: categorias_grupo = Categoria.many(id_grupo=self.grupo_cat) cods_categoria = [cat.codigo for cat in categorias_grupo] ret = {} for key in votos.keys(): cand = Candidatura.one(id_umv=key, cod_categoria__in=cods_categoria) if cand is not None: ret[key] = votos[key] else: # no esta desgolsada devolvemos todos los votos. ret = votos return ret
def dict_set_candidaturas(self): """Envia el diccionario con los datos de las categorias.""" candidatos = Candidatura.all().to_dict() return candidatos
def __init__(self, controlador, data, data_key=None, repetir=True): blanco = Candidatura.one(clase="Blanco").to_dict() data.append(blanco) Asistente.__init__(self, controlador, data, data_key, repetir)
def desde_string(cls, tag, mesa=None): """Devuelve una seleccion a partir de la informacion de un tag rfid. """ seleccion = None try: datos_tag = struct_voto.parse(tag) except (RangeError, FieldError, ValueError): # Manejamos que no nos puedan meter cualquier datos_tag = None if datos_tag is not None: ubic = datos_tag.ubicacion.decode("utf-8") if mesa is not None: # verificamos la mesa if mesa.cod_datos != ubic: raise MesaIncorrecta() else: # OJO: Esto trae cualquier mesa del juego de datos. # No importa por que todas las mesas del mismo juego son # compatibles. Pero no nos permite identificar de que mesa es # el voto. mesa = Ubicacion.first(cod_datos=ubic) mesa.usar_cod_datos() seleccion = Seleccion(mesa) seleccion.serial = datos_tag.serial sel_por_cat = {} # recorremos cada uno de los pares de categoria/candidatos en el # tag str_opciones = datos_tag.opciones.decode() opciones = str_opciones.split(",") if len(opciones): for elem in opciones: if len(elem): cod_cat, id_umv = elem.split(":") id_umv = int(id_umv) sel_por_cat[cod_cat] = sel_por_cat.get(cod_cat, 0) + 1 # Buscamos el candidato votado para la categoria en # cuestion candidato = Candidatura.one(id_umv=id_umv, cod_categoria=cod_cat) # y lo elegimos (Si no encontró ninguno lanza un value # error). if candidato is None: raise ValueError() max_selecciones = int( candidato.categoria.max_selecciones) borrar = max_selecciones == 1 seleccion.elegir_candidato(candidato, borrar=borrar) if len(list(sel_por_cat.keys())) != len(Categoria.all()): # caso en el que la canditad de categorias votadas sea # diferente que la cantidad de categorias seleccion = None else: # aca verificamos que la cantidad de candidatos por # categoria sea menor o igual de la cantidad de selecciones # maximas que esperamos for cod_categoria, cantidad in list(sel_por_cat.items()): categoria = Categoria.one(cod_categoria) max_selec = int(categoria.max_selecciones) if categoria is None or cantidad > max_selec: seleccion = None break return seleccion
def desde_tag(cls, tag, con_dnis=True): # Si vamos a guardar los dnis usamos el struct con DNIS, sino no. if con_dnis: struct = struct_recuento_dni else: struct = struct_recuento # Parseamos el tag datos_tag = struct.parse(tag) # Nos fijamos si el tag tiene la data de una categoria o solo de una if SMART_PACKING: try: string_datos = b"" for byte in datos_tag.datos: string_datos += byte num_mesa, valores = unpack(string_datos) except IndexError as e: raise TagMalformado(e) mesa = Ubicacion.first(numero=str(num_mesa)) else: tag = b"" for byte in datos_tag.datos: tag += byte len_cod_mesa = int(tag[:2]) cod_mesa = tag[2:2 + len_cod_mesa] mesa = Ubicacion.first(codigo=cod_mesa.decode("utf-8")) valores = unpack(tag[len_cod_mesa + 2:]) if not mesa: raise MesaNoEncontrada() mesa.usar_cod_datos() recuento = Recuento(mesa) grupo = datos_tag.grupo # Establecemos el grupo del recuento, si viene en 0 lo establecemos en # None recuento.grupo_cat = grupo if grupo else None # Traemos las candidaturas que se guardaron en el recuento candidatos = Candidatura.para_recuento(recuento.grupo_cat) # leemos los valores y los seteamos en los resultados for candidato in candidatos: recuento.pizarra.set_votos_candidato(candidato.id_umv, valores.pop(0)) # extraemos los campos extras (boletas_contadas, total_boletas, etc) ordered_keys = sorted(recuento.campos_extra.keys()) for key in ordered_keys: recuento.campos_extra[key] = valores.pop(0) # extraemos las listas especiales (OBS, IMP, NUL, REC, etc) ordered_keys = sorted(recuento.listas_especiales.keys()) for key in ordered_keys: recuento.listas_especiales[key] = valores.pop(0) # si estan los DNIS los extraemos del tag if con_dnis: dnis = unpack_slow(datos_tag.documentos, BITS_DNI) for dni in dnis: autoridad = Autoridad("", "", 0, dni) recuento.autoridades.append(autoridad) return recuento