Ejemplo n.º 1
0
class Agenda(object):
    __dato = {}
    __persistencia = Persistencia("marcos.json")

    def abrir(self):
        self.__dato = self.__persistencia.preparar()
        if (self.__dato == "Error al leer el archivo"):
            return False
        return True

    def guardar(self, nombre, tel, email):
        self.__dato[nombre] = {email: tel}
        print self.__dato
        self.__persistencia.grabar(self.__dato)
        return self.__dato

    def buscar(self, nombre):
        return self.__dato.get(nombre, "error nombre no ingresado")

    def eliminar(self, nombre):
        try:
            self.__dato.pop(nombre)
        except ValueError:
            return False
        self.__persistencia.grabar(self.__dato)
        return True
Ejemplo n.º 2
0
	def __init__(self):
		self.jogoIniciado = False
		self.partidaIniciada = False
		self.salvouNoRanking = False
		self.tamX =800 
		self.tamY = 600 
		self.persistencia = Persistencia()
		self.ranking = self.persistencia.lerArquivo()
Ejemplo n.º 3
0
class TestPersistencia(unittest.TestCase):
    def setUp(self):
        self.tablero = TableroCelular(4, 5)
        self.tablero.rellenar_matriz_al_azar(6)
        self.tablero2 = TableroCelular(5,6)
        self.tablero.rellenar_matriz_al_azar(15)
        self.persistencia = Persistencia()


    def test_cargar_y_guardar_mostrar_matriz(self):
        print('TEST-GUARDADO-1')
        self.persistencia.guardar('juego.s', self.tablero.matriz, 'tablero1')
        print('TEST-GUARDADO-2')
        self.persistencia.guardar('tablero.s', self.tablero2.matriz, 'tablero2')
        print('TEST-CARGAR-MATRIZ')
        print('Clave tablero1')
        print(self.persistencia.cargar('juego.s', 'tablero1'))
        print('Clave tablero2')
        print(self.persistencia.cargar('tablero.s', 'tablero2'))
Ejemplo n.º 4
0
    def menu(self):
        while True:
            try:
                numero1 = self.leer_entero('Ingrese modo de juego: \n'
                                           '1- Modo normal \n'
                                           '2- Modo vida estatica \n'
                                           '3- Salir \n')
                self.persistencia = Persistencia()
                self.tablero = TableroCelular(0, 0)

                if numero1 == 1:
                    '''MODO NORMAL'''
                    self.creacion_de_tableros()
                elif numero1 == 2:
                    while True:
                        try:
                            '''MODO VIDA ESTATICA'''
                            cargar = self.leer_entero(
                                'Desea cargar algun modo de vida estatico pasado?: \n'
                                '1- si \n'
                                '2- no,continuar \n')
                            if cargar == 2:
                                self.modo_estatico()
                                return self.menu()
                            elif cargar == 1:
                                direccion = self.leer_teclado(
                                    'Ingrese ruta del archivo sin comillas: ')
                                clave = self.leer_teclado(
                                    'Ingrese posicion de guardado sin comillas: '
                                )
                                lista_posicion_tablero = self.persistencia.cargar_vida_estatica(
                                    direccion, clave)
                                self.modo_estatico_cargado(
                                    lista_posicion_tablero[0],
                                    lista_posicion_tablero[1])
                            else:
                                raise NumeroNoEstaEnMenu
                        except PatronesMayoresALaDimencion:
                            print("Ingresar patron mas chico")
                        except (KeyboardInterrupt, EOFError):
                            condicion = self.leer_entero(
                                'Desea guardar el ultimo punto del modo de vida estatico? 1-Si 2-Salir'
                            )
                            if condicion == 1:
                                ruta = self.leer_teclado(
                                    'Ingrese la ruta del archivo sin comillas:'
                                )
                                clave = self.leer_teclado(
                                    'Ingrese la clave para guardar el tablero sin comillas:'
                                )
                                self.persistencia.guardar_vida_estatica_tupla(
                                    ruta, self.posicion_tupla_actual,
                                    self.tablero.matriz, clave)
                                return self.menu()
                            elif condicion == 2:
                                return self.menu()
                        except NumeroNoEstaEnMenu:
                            print('Por favor, elegí 1 o 2.')
                        except FileNotFoundError:
                            print(
                                'Archivo no encontrado. Ingresar ruta valida.')
                        except TypeError:
                            print('Ingrese una posición de carga valida.')
                        except KeyError:
                            print(
                                'Ingresar una clave valida en un archivo correcto.'
                            )
                        except PermissionError:
                            print('Ingrese una ruta valida.')

                elif numero1 == 3:
                    print('El Programa se cerro correctamente!')
                    break
                else:
                    raise NumeroNoEstaEnMenu
            except (NumeroNoEstaEnMenu):
                print('Por favor, ingrese un numero del 1 al 3.')
            except (KeyboardInterrupt, EOFError):
                print('Error atrapado de Ctrl-C')
Ejemplo n.º 5
0
class Menu(object):
    def menu(self):
        while True:
            try:
                numero1 = self.leer_entero('Ingrese modo de juego: \n'
                                           '1- Modo normal \n'
                                           '2- Modo vida estatica \n'
                                           '3- Salir \n')
                self.persistencia = Persistencia()
                self.tablero = TableroCelular(0, 0)

                if numero1 == 1:
                    '''MODO NORMAL'''
                    self.creacion_de_tableros()
                elif numero1 == 2:
                    while True:
                        try:
                            '''MODO VIDA ESTATICA'''
                            cargar = self.leer_entero(
                                'Desea cargar algun modo de vida estatico pasado?: \n'
                                '1- si \n'
                                '2- no,continuar \n')
                            if cargar == 2:
                                self.modo_estatico()
                                return self.menu()
                            elif cargar == 1:
                                direccion = self.leer_teclado(
                                    'Ingrese ruta del archivo sin comillas: ')
                                clave = self.leer_teclado(
                                    'Ingrese posicion de guardado sin comillas: '
                                )
                                lista_posicion_tablero = self.persistencia.cargar_vida_estatica(
                                    direccion, clave)
                                self.modo_estatico_cargado(
                                    lista_posicion_tablero[0],
                                    lista_posicion_tablero[1])
                            else:
                                raise NumeroNoEstaEnMenu
                        except PatronesMayoresALaDimencion:
                            print("Ingresar patron mas chico")
                        except (KeyboardInterrupt, EOFError):
                            condicion = self.leer_entero(
                                'Desea guardar el ultimo punto del modo de vida estatico? 1-Si 2-Salir'
                            )
                            if condicion == 1:
                                ruta = self.leer_teclado(
                                    'Ingrese la ruta del archivo sin comillas:'
                                )
                                clave = self.leer_teclado(
                                    'Ingrese la clave para guardar el tablero sin comillas:'
                                )
                                self.persistencia.guardar_vida_estatica_tupla(
                                    ruta, self.posicion_tupla_actual,
                                    self.tablero.matriz, clave)
                                return self.menu()
                            elif condicion == 2:
                                return self.menu()
                        except NumeroNoEstaEnMenu:
                            print('Por favor, elegí 1 o 2.')
                        except FileNotFoundError:
                            print(
                                'Archivo no encontrado. Ingresar ruta valida.')
                        except TypeError:
                            print('Ingrese una posición de carga valida.')
                        except KeyError:
                            print(
                                'Ingresar una clave valida en un archivo correcto.'
                            )
                        except PermissionError:
                            print('Ingrese una ruta valida.')

                elif numero1 == 3:
                    print('El Programa se cerro correctamente!')
                    break
                else:
                    raise NumeroNoEstaEnMenu
            except (NumeroNoEstaEnMenu):
                print('Por favor, ingrese un numero del 1 al 3.')
            except (KeyboardInterrupt, EOFError):
                print('Error atrapado de Ctrl-C')

    def creacion_de_tableros(self):
        while True:
            try:

                numero2 = self.leer_entero(
                    'Elija una opción para crear el tablero: \n'
                    '1- Patron al azar \n'
                    '2- Crear tablero manualmente \n'
                    '3- Cargar tablero \n'
                    '4- Volver al menu \n')

                if numero2 == 1:
                    '''MODO NORMAL - PATRON AL AZAR'''
                    fila = self.leer_entero(
                        'Ingrese el tamaño de la fila de la matriz:')
                    columna = self.leer_entero(
                        'Ingrese el tamaño de la columna de la matriz:')
                    while True:
                        try:
                            self.tablero = TableroCelular(fila, columna)
                            cantidad_de_celulas = self.leer_entero(
                                'Ingrese la cantidad de celulas vivas:')
                            self.tablero.rellenar_matriz_al_azar(
                                cantidad_de_celulas)

                            # MODO

                            self.modo_normal()

                            break
                        except IndexError:
                            print(
                                'La cantidad de celdas vivas tiene que ser hasta '
                                + str(
                                    len(self.tablero.matriz) *
                                    len(self.tablero.matriz)))

                elif numero2 == 2:
                    '''MODO NORMAL - CREAR MANUALMENTE'''
                    fila = self.leer_entero(
                        'Ingrese el tamaño de la fila de la matriz:')
                    columna = self.leer_entero(
                        'Ingrese el tamaño de la columna de la matriz:')
                    self.tablero = TableroCelular(fila, columna)
                    while True:
                        '''COMENZAR JUEGO'''
                        numero2_2_1 = self.leer_entero('Ingrese accion: \n'
                                                       '1- Modificar celda \n'
                                                       '2- Comenzar juego \n')
                        if numero2_2_1 == 1:
                            try:
                                fila = self.leer_entero('Ingrese fila: ')
                                columna = self.leer_entero('Ingrese columna: ')
                                estado = self.leer_teclado(
                                    'Ingrese estado "*" viva o "-" muerta (Sin comillas): '
                                )
                                self.tablero.rellenar_matriz_manualmente(
                                    fila, columna, estado)
                            except IndexError:
                                print(
                                    'Ingrese fila o columna correcta entre 0 y '
                                    + str(len(self.tablero.matriz) - 1))
                            except ValorCelularNoValido:
                                print(
                                    'Ingresar - o * en el valor_de_la_matriz')

                                # MODO

                        elif numero2_2_1 == 2:
                            self.modo_normal()
                            break
                        else:
                            raise NumeroNoEstaEnMenu

                elif numero2 == 3:
                    '''MODO NORMAL - CARGAR'''
                    while True:
                        try:
                            direccion = self.leer_teclado(
                                'Ingrese ruta del archivo sin comillas: ')
                            clave = self.leer_teclado(
                                'Ingrese posicion de guardado sin comillas: ')
                            self.tablero.matriz = self.persistencia.cargar(
                                direccion, clave)

                            # MODO

                            self.modo_normal()
                            break
                        except FileNotFoundError:
                            print(
                                'Archivo no encontrado. Ingresar ruta valida.')
                        except TypeError:
                            print('Ingrese una posición de carga valida.')
                        except KeyError:
                            print(
                                'Ingresar una clave valida en un archivo correcto.'
                            )
                        except PermissionError:
                            print('Ingrese una ruta valida.')
                elif numero2 == 4:
                    break
                else:
                    raise NumeroNoEstaEnMenu
            except NumeroNoEstaEnMenu:
                print('Por favor, ingrese un numero del 1 al 4.')

    def modo_normal(self):
        while True:
            try:
                self.tablero.imprimir_tablero()
                numero_de_modo_normal = self.leer_entero(
                    'Ingrese una accion: \n'
                    '1- Siguiente paso \n'
                    '2- Modificar tablero \n'
                    '3- Guardar tablero \n'
                    '4- Volver \n')

                if numero_de_modo_normal == 1:
                    '''MODO NORMAL - SIGUIENTE PASO'''
                    self.tablero.mutar_celulas_modo_normal()
                elif numero_de_modo_normal == 2:
                    '''MODIFICAR TABLERO'''
                    while True:
                        try:
                            fila = self.leer_entero(
                                'Ingrese posicion de fila:')
                            columna = self.leer_entero(
                                'Ingrese posicion de columna:')
                            valor = self.leer_teclado(
                                'Ingrese "*" o "-"(Sin comillas):')
                            self.tablero.rellenar_matriz_manualmente(
                                fila, columna, valor)
                            break
                        except IndexError:
                            print(
                                "Por favor ingrese un numero de fila comprendido entre 0 y "
                                + str(len(self.tablero.matriz)) +
                                "y columna comprendido entre 0 y " +
                                str(len(self.tablero.matriz[0])))
                        except Exception:
                            print(Exception)

                elif numero_de_modo_normal == 3:
                    '''GUARDAR TABLERO'''
                    while True:
                        try:
                            tablero = self.tablero.matriz
                            ruta = self.leer_teclado(
                                'Ingrese la ruta del archivo sin comillas:')
                            clave = self.leer_teclado(
                                'Ingrese la clave para guardar el tablero sin comillas:'
                            )
                            self.persistencia.guardar(ruta, tablero, clave)
                            break
                        except Exception:
                            print('Fallo la ruta del teclado')

                elif numero_de_modo_normal == 4:
                    break
                else:
                    raise NumeroNoEstaEnMenu
            except NumeroNoEstaEnMenu:
                print('Por favor ingrese un numero del 1 al 4')

    def modo_estatico(self):
        fila = self.leer_entero('Ingrese el tamaño de la fila de la matriz:')
        columna = self.leer_entero(
            'Ingrese el tamaño de la columna de la matriz:')
        patrones = self.leer_entero('Cantidad de celdas vivas:')

        self.tablero = TableroCelular(fila, columna)

        dimencion_de_tablero = fila * columna

        lista_tuplas = []

        cantidad_tableros = 0

        if (patrones <= dimencion_de_tablero):
            for x in combinations(range(dimencion_de_tablero), patrones):
                self.posicion_tupla_actual = x
                self.tablero.matriz = self.tablero.matriz_nueva(fila, columna)
                self.tablero.contador_vidas_estaticas = 0
                self.tablero.diccionario_de_celdas = {}
                encontro = True
                contador = 0
                for posicion_tupla in x:  # este for rellena los vivos con las combinaciones
                    coordenadas = (posicion_tupla //
                                   len(self.tablero.matriz[0]),
                                   posicion_tupla %
                                   len(self.tablero.matriz[0]))
                    self.tablero.rellenar_matriz_manualmente(
                        coordenadas[0], coordenadas[1], '*')

                self.tablero.mutar_celulas()

                if self.tablero.matriz_antigua == self.tablero.matriz:
                    self.tablero.imprimir_tablero()
                    cantidad_tableros += 1
                    print('--------------------------------------')

            if cantidad_tableros > 0:
                print('Se encontraron ' + str(cantidad_tableros) +
                      ' tableros estáticos.')
            else:
                print('No se encontraron tableros estáticos.')

        else:
            raise PatronesMayoresALaDimencion

    def modo_estatico_cargado(self, posicion_tupla_guardada, tablero):

        empezar = False
        self.tablero.matriz = tablero
        fila = len(self.tablero.matriz)
        columna = len(self.tablero.matriz[0])
        contador_vivos = 0
        patrones = len(posicion_tupla_guardada)
        dimencion_de_tablero = fila * columna

        cantidad_tableros = 0

        if (patrones <= dimencion_de_tablero):
            for x in combinations(range(dimencion_de_tablero), patrones):
                self.tablero.matriz = self.tablero.matriz_nueva(fila, columna)
                self.tablero.contador_vidas_estaticas = 0
                self.tablero.diccionario_de_celdas = {}
                if x == posicion_tupla_guardada:
                    empezar = True
                for posicion_tupla in x:  # este for rellena los vivos con las combinaciones
                    coordenadas = (posicion_tupla //
                                   len(self.tablero.matriz[0]),
                                   posicion_tupla %
                                   len(self.tablero.matriz[0]))
                    self.tablero.rellenar_matriz_manualmente(
                        coordenadas[0], coordenadas[1], '*')

                if empezar:
                    self.tablero.mutar_celulas()

                    if self.tablero.matriz_antigua == self.tablero.matriz:
                        self.tablero.imprimir_tablero()
                        cantidad_tableros += 1
                        print('--------------------------------------')

            if cantidad_tableros > 0:
                print('Se encontraron ' + str(cantidad_tableros) +
                      ' tableros estáticos.')
            else:
                print('No se encontraron tableros estáticos.')

        else:
            raise PatronesMayoresALaDimencion

    def leer_teclado(self, texto):
        while True:
            try:
                ingresado = str(input(texto))
                break
            except (EOFError, KeyboardInterrupt):
                print('Error atrapado de Ctrl-C')
        return ingresado

    def leer_entero(self, texto):
        while True:
            try:
                ingresado = eval(input(texto))
                if type(ingresado) == int:
                    return ingresado
                else:
                    raise Exception
            except (Exception, ValueError):
                print('Por favor ingrese un numero entero')
            except (EOFError, KeyboardInterrupt):
                print('Error atrapado de Ctrl-C')
    def resolucoes(self, buffer, arquivo, arq1, criticas, contarq, data_e_hora,
                   arqres, perc):
        print(
            'ARQUIVO========================================================>',
            arquivo, '(CARGOS)', perc, '%')
        ################# PROCESSA CABEÇALHO DO DIARIO ################
        diario_pattern = re.compile('Ano\s([A-Z]*)\s•\sN\w\s([0-9]*)')
        diario_edicao = diario_pattern.search(buffer)

        diario_suplemento_pattern = re.compile(
            'Diário Oficial do Município do Rio de Janeiro\s\|\s\w*\s\w*\s\|\s\w*\s\w*\s\|\s(Suplemento)'
        )
        diario_suplemento = diario_suplemento_pattern.search(buffer)
        if diario_suplemento:
            tipo = 'SUPLEMENTAR'  #Suplemento
        else:
            tipo = 'NORMAL'  #Normal

        util = Util()
        diario = Diario()
        if (diario_edicao.group(1)):
            diario.anoromano = '{: <6}'.format(((diario_edicao.group(1))))
            diario.ano = (util.converteRomano(diario_edicao.group(1)))
            diario.numero = '{:0>6}'.format((diario_edicao.group(2)))
            diario.tipo = '{: <12}'.format((tipo))
            if (diario.ano < 26):
                print("Diário anterior a 2013:",
                      "Ano:",
                      diario.ano,
                      "Arquivo:",
                      arquivo.upper(),
                      file=criticas)
        else:
            diario.anoromano = 'XXXXXX'
            diario.ano = 'XXXXXX'
            diario.numero = 'XXXXXX'
            diario.tipo = 'XXXXXXXXXXXX'

        print('', file=arq1)
        print('(PUC-RIO/TECMF)   ::PROCESSAMENTO DO DIÁRIO::',
              'ANO:',
              diario.ano,
              'No.:',
              diario.numero,
              'TIPO:',
              diario.tipo,
              '* RIO DE JANEIRO * ARQUIVO:',
              arquivo.upper(),
              'SEQ.:',
              '{:0>4}'.format(contarq),
              '                                             ',
              data_e_hora,
              file=arq1)
        print('', file=arq1)

        #############################################################

        resolucao_pattern = re.compile(
            r'^(\*RESOLUÇÕES|RESOLUÇÕES|RESOLUÇOES|RESOLUÇÃO|RESOLUÇAO|PORTARIAS|DECRETO RIO|PORTARIA)\s*(.)*\s*“P”.*',
            re.M)
        contador = 1
        cont = -1
        inicio = []
        bloco = []
        servidor = []
        tamanho = len(buffer)
        for resolucao in resolucao_pattern.finditer(buffer):
            inicio.append(resolucao.start())
            contador = contador + 1
        inicio.append(tamanho)

        for i in range(len(inicio) - 1):
            bloco.append(inicio[i + 1] - inicio[i])
            buffer_local = buffer[inicio[i]:inicio[i] + bloco[i]]

            ###### Resolução #####
            resolucao1_pattern = re.compile(
                r'^(?P<resolucao1>\*RESOLUÇÕES|RESOLUÇÕES|RESOLUÇOES|RESOLUÇÃO|RESOLUÇAO|PORTARIAS|DECRETO RIO|PORTARIA)\s*(.)*\s*“P”(?P<detalhe_resolucao1>.*)',
                re.M)
            resolucao1 = resolucao1_pattern.search(buffer_local)
            if (resolucao1):
                Tipo = '{: <11}'.format(resolucao1.group('resolucao1'))
                Detalhe = resolucao1.group('detalhe_resolucao1')
            else:
                #print('Não casou resolucao1')
                Tipo = 'SEM TIPO'
                Detalhe = 'SEM DETALHE'
            #####################

            #### Gestor #####
            gestor_pattern = re.compile(
                r'(?P<gestor>[O|A]*\s(SECRETÁRI[O|A]+|PROCURADOR[A]*|PREFEITO[A]*|COORDENADOR[A]*)[A-ZÁÚÍÃÓÇÊÉ\s-]+)'
            )
            gestor = gestor_pattern.search(buffer_local)
            if (gestor):
                Gestor = gestor.group('gestor')
            else:
                Gestor = 'SEM GESTOR'
            #print('-----FIM DO BLOCO-----')
            ###### Fim Gestor

        ################################# RESOLUÇÕES COMPOSTAS #############################
            persistencia = Persistencia()
            if ((resolucao1.group('resolucao1') == '*RESOLUÇÕES')
                    or (resolucao1.group('resolucao1') == 'RESOLUÇÕES')
                    or (resolucao1.group('resolucao1') == 'RESOLUÇOES')
                    or (resolucao1.group('resolucao1') == 'RESOLUCOES')
                    or (resolucao1.group('resolucao1') == 'PORTARIAS')):

                servidor = LayoutAtos.atos_nomeacoes(self, buffer_local,
                                                     Detalhe)
                util = Util()
                ato = Ato()

                for i in range(len(servidor)):
                    ato.numero = '{:0>4}'.format(servidor[i].numero)
                    ato.nome = '{: <50}'.format((servidor[i].nome).replace(
                        '\n', ' ').replace('  ', ' ').strip(" "))
                    ato.diaResolucao = '{:0>2}'.format(
                        servidor[i].diaResolucao)
                    ato.mesResolucao = '{:0>2}'.format(
                        servidor[i].mesResolucao)
                    ato.anoResolucao = servidor[i].anoResolucao
                    ato.dataResolucao = ato.diaResolucao + '/' + ato.mesResolucao + '/' + ato.anoResolucao
                    ato.dia = '{:0>2}'.format(servidor[i].dia)
                    ato.mes = util.retornaMes(servidor[i].mes.replace(' ', ''))
                    ato.ano = servidor[i].ano
                    ato.dataEfeito = ato.dia + '/' + ato.mes + '/' + ato.ano
                    ato.matricula = '{: <12}'.format(
                        servidor[i].matricula.replace('.', ''))
                    #ato.cargo = '{: <48}'.format(servidor[i].cargo.upper()).replace('\n', ' ')
                    ato.cargo = '{: <48}'.format(
                        (servidor[i].cargo.upper()).replace('\n', ' ').replace(
                            '  ', ' ').replace('- ', '').strip(" "))
                    ato.CPF = '{: <13}'.format(
                        servidor[i].CPF)  #vER ESTA REGRA!!!!!
                    ato.tipocargo = servidor[i].tipocargo
                    ato.simbolo = '{: <6}'.format(servidor[i].simbolo.replace(
                        '\n', ''))
                    print(ato.CPF,
                          Tipo,
                          ato.numero,
                          ato.dataResolucao,
                          'NOMEAR   ',
                          ato.matricula,
                          ato.nome,
                          ato.dataEfeito,
                          ato.cargo,
                          ato.simbolo,
                          ato.tipocargo,
                          file=arq1)
                    persistencia.insert(ato.matricula, ato.nome,
                                        ato.dataResolucao, 'NOMEAR',
                                        ato.dataEfeito, ato.cargo,
                                        ato.tipocargo, ato.simbolo)

                servidor = LayoutAtos.atos_designacoes(self, buffer_local,
                                                       Detalhe)
                ato = Ato()
                for i in range(len(servidor)):
                    ato.numero = '{:0>4}'.format(servidor[i].numero)
                    ato.nome = '{: <50}'.format((servidor[i].nome).replace(
                        '\n', ' ').replace('  ', ' ').strip(" "))
                    ato.diaResolucao = '{:0>2}'.format(
                        servidor[i].diaResolucao)
                    ato.mesResolucao = '{:0>2}'.format(
                        servidor[i].mesResolucao)
                    ato.anoResolucao = servidor[i].anoResolucao
                    ato.dataResolucao = ato.diaResolucao + '/' + ato.mesResolucao + '/' + ato.anoResolucao
                    ato.dia = '{:0>2}'.format(servidor[i].dia)
                    ato.mes = util.retornaMes(servidor[i].mes.replace(' ', ''))
                    ato.ano = servidor[i].ano
                    ato.dataEfeito = ato.dia + '/' + ato.mes + '/' + ato.ano
                    ato.matricula = '{: <12}'.format(
                        servidor[i].matricula.replace('.', ''))
                    ato.cargo = '{: <48}'.format(
                        (servidor[i].cargo.upper()).replace('\n', ' ').replace(
                            '  ', ' ').replace('- ', '').strip(" "))
                    ato.CPF = '{: <13}'.format(
                        servidor[i].CPF)  #vER ESTA REGRA!!!!!
                    ato.tipocargo = servidor[i].tipocargo
                    ato.simbolo = '{: <6}'.format(servidor[i].simbolo.replace(
                        '\n', ''))
                    print(ato.CPF,
                          Tipo,
                          ato.numero,
                          ato.dataResolucao,
                          'DESIGNAR ',
                          ato.matricula,
                          ato.nome,
                          ato.dataEfeito,
                          ato.cargo,
                          ato.simbolo,
                          ato.tipocargo,
                          file=arq1)
                    persistencia.insert(ato.matricula, ato.nome,
                                        ato.dataResolucao, 'DESIGNAR',
                                        ato.dataEfeito, ato.cargo,
                                        ato.tipocargo, ato.simbolo)

                servidor = LayoutAtos.atos_dispensas(self, buffer_local,
                                                     Detalhe)
                ato = Ato()
                util = Util()
                for i in range(len(servidor)):
                    ato.numero = '{:0>4}'.format(servidor[i].numero)
                    ato.nome = '{: <50}'.format((servidor[i].nome).replace(
                        '\n', ' ').replace('  ', ' ').strip(" "))
                    ato.diaResolucao = '{:0>2}'.format(
                        servidor[i].diaResolucao)
                    ato.mesResolucao = '{:0>2}'.format(
                        servidor[i].mesResolucao)
                    ato.anoResolucao = servidor[i].anoResolucao
                    ato.dataResolucao = ato.diaResolucao + '/' + ato.mesResolucao + '/' + ato.anoResolucao
                    ato.dia = '{:0>2}'.format(servidor[i].dia)
                    ato.mes = util.retornaMes(servidor[i].mes.replace(' ', ''))
                    ato.ano = servidor[i].ano
                    ato.dataEfeito = ato.dia + '/' + ato.mes + '/' + ato.ano
                    ato.matricula = '{: <12}'.format(
                        servidor[i].matricula.replace('.', ''))
                    #ato.cargo = '{: <48}'.format(servidor[i].cargo.upper()).replace('\n', ' ')
                    ato.cargo = '{: <48}'.format(
                        (servidor[i].cargo.upper()).replace('\n', ' ').replace(
                            '  ', ' ').replace('- ', '').strip(" "))
                    ato.CPF = '{: <13}'.format(
                        servidor[i].CPF)  #vER ESTA REGRA!!!!!
                    ato.tipocargo = servidor[i].tipocargo
                    ato.simbolo = '{: <6}'.format(servidor[i].simbolo.replace(
                        '\n', ''))
                    print(ato.CPF,
                          Tipo,
                          ato.numero,
                          ato.dataResolucao,
                          'DISPENSAR',
                          ato.matricula,
                          ato.nome,
                          ato.dataEfeito,
                          ato.cargo,
                          ato.simbolo,
                          ato.tipocargo,
                          file=arq1)
                    persistencia.insert(ato.matricula, ato.nome,
                                        ato.dataResolucao, 'DISPESAR',
                                        ato.dataEfeito, ato.cargo,
                                        ato.tipocargo, ato.simbolo)

                servidor = LayoutAtos.atos_exoneracoesTeste(
                    self, buffer_local, Detalhe)
                ato = Ato()
                util = Util()
                for i in range(len(servidor)):
                    ato.numero = '{:0>4}'.format(servidor[i].numero)
                    ato.nome = '{: <50}'.format((servidor[i].nome).replace(
                        '\n', ' ').replace('  ', ' ').strip(" "))
                    ato.diaResolucao = '{:0>2}'.format(
                        servidor[i].diaResolucao)
                    ato.mesResolucao = '{:0>2}'.format(
                        servidor[i].mesResolucao)
                    ato.anoResolucao = servidor[i].anoResolucao
                    ato.dia = '{:0>2}'.format(servidor[i].dia)
                    ato.mes = util.retornaMes(servidor[i].mes)
                    ato.ano = servidor[i].ano
                    ato.dataEfeito = ato.dia + '/' + ato.mes + '/' + ato.ano
                    ato.dataResolucao = ato.diaResolucao + '/' + ato.mesResolucao + '/' + ato.anoResolucao
                    ato.matricula = '{: <12}'.format(
                        servidor[i].matricula.replace('.', ''))
                    #ato.cargo = '{: <48}'.format(servidor[i].cargo.upper()).replace('\n', ' ')
                    ato.cargo = '{: <48}'.format(
                        (servidor[i].cargo.upper()).replace('\n', ' ').replace(
                            '  ', ' ').replace('- ', '').strip(" "))
                    ato.CPF = '{: <13}'.format(
                        servidor[i].CPF)  #vER ESTA REGRA!!!!!
                    ato.tipocargo = servidor[i].tipocargo
                    ato.simbolo = '{: <6}'.format(servidor[i].simbolo.replace(
                        '\n', ''))
                    print(ato.CPF,
                          Tipo,
                          ato.numero,
                          ato.dataResolucao,
                          'EXONERAR ',
                          ato.matricula,
                          ato.nome,
                          ato.dataEfeito,
                          ato.cargo,
                          ato.simbolo,
                          ato.tipocargo,
                          file=arq1)
                    persistencia.insert(ato.matricula, ato.nome,
                                        ato.dataResolucao, 'EXONERAR',
                                        ato.dataEfeito, ato.cargo,
                                        ato.tipocargo, ato.simbolo)

    ######################## RESOLUÇÃO SIMPLES ###########################

            elif ((resolucao1.group('resolucao1') == 'RESOLUÇÃO')
                  or (resolucao1.group('resolucao1') == 'RESOLUÇAO')
                  or (resolucao1.group('resolucao1') == 'RESOLUCAO')
                  or (resolucao1.group('resolucao1') == 'DECRETO RIO')
                  or (resolucao1.group('resolucao1') == 'PORTARIA')):
                servidor = LayoutAtos.atos_nomeacao(self, buffer_local,
                                                    Detalhe)
                for i in range(len(servidor)):
                    ato = Ato()
                    ato.nome = '{: <50}'.format((servidor[i].nome).replace(
                        '\n', ' ').replace('  ', ' ').strip(" "))
                    ato.numero = '{:0>4}'.format(servidor[i].numero)
                    ato.diaResolucao = '{:0>2}'.format(
                        servidor[i].diaResolucao)
                    ato.mesResolucao = '{:0>2}'.format(
                        servidor[i].mesResolucao)
                    ato.anoResolucao = servidor[i].anoResolucao
                    ato.dataResolucao = ato.diaResolucao + '/' + ato.mesResolucao + '/' + ato.anoResolucao
                    ato.dia = '{:0>2}'.format(servidor[i].dia)
                    ato.mes = util.retornaMes(servidor[i].mes)
                    ato.ano = servidor[i].ano
                    ato.dataEfeito = ato.dia + '/' + ato.mes + '/' + ato.ano
                    ato.matricula = '{: <12}'.format(
                        servidor[i].matricula.replace('.', ''))
                    #ato.cargo = '{: <48}'.format(servidor[i].cargo.upper()).replace('\n', ' ')
                    ato.cargo = '{: <48}'.format(
                        (servidor[i].cargo.upper()).replace('\n', ' ').replace(
                            '  ', ' ').replace('- ', '').strip(" "))
                    ato.CPF = '{: <13}'.format(
                        servidor[i].CPF)  #vER ESTA REGRA!!!!!
                    ato.tipocargo = servidor[i].tipocargo
                    ato.simbolo = '{: <6}'.format(servidor[i].simbolo.replace(
                        '\n', ''))
                    print(ato.CPF,
                          Tipo,
                          ato.numero,
                          ato.dataResolucao,
                          'NOMEAR   ',
                          ato.matricula,
                          ato.nome,
                          ato.dataEfeito,
                          ato.cargo,
                          ato.simbolo,
                          ato.tipocargo,
                          file=arq1)
                    persistencia.insert(ato.matricula, ato.nome,
                                        ato.dataResolucao, 'NOMEAR',
                                        ato.dataEfeito, ato.cargo,
                                        ato.tipocargo, ato.simbolo)

                servidor = LayoutAtos.atos_dispensar(self, buffer_local,
                                                     Detalhe)
                for i in range(len(servidor)):
                    ato = Ato()
                    ato.nome = '{: <50}'.format((servidor[i].nome).replace(
                        '\n', ' ').replace('  ', ' ').strip(" "))
                    ato.numero = '{:0>4}'.format(servidor[i].numero)
                    ato.diaResolucao = '{:0>2}'.format(
                        servidor[i].diaResolucao)
                    ato.mesResolucao = '{:0>2}'.format(
                        servidor[i].mesResolucao)
                    ato.anoResolucao = servidor[i].anoResolucao
                    ato.dataResolucao = ato.diaResolucao + '/' + ato.mesResolucao + '/' + ato.anoResolucao
                    ato.dia = '{:0>2}'.format(servidor[i].dia)
                    ato.mes = util.retornaMes(servidor[i].mes)
                    ato.ano = servidor[i].ano
                    ato.dataEfeito = ato.dia + '/' + ato.mes + '/' + ato.ano
                    ato.matricula = '{: <12}'.format(
                        servidor[i].matricula.replace('.', ''))
                    #ato.cargo = '{: <48}'.format(servidor[i].cargo.upper()).replace('\n', ' ')
                    ato.cargo = '{: <48}'.format(
                        (servidor[i].cargo.upper()).replace('\n', ' ').replace(
                            '  ', ' ').replace('- ', '').strip(" "))
                    ato.CPF = '{: <13}'.format(
                        servidor[i].CPF)  #vER ESTA REGRA!!!!!
                    ato.tipocargo = servidor[i].tipocargo
                    ato.simbolo = '{: <6}'.format(servidor[i].simbolo.replace(
                        '\n', ''))
                    print(ato.CPF,
                          Tipo,
                          ato.numero,
                          ato.dataResolucao,
                          'DISPENSAR',
                          ato.matricula,
                          ato.nome,
                          ato.dataEfeito,
                          ato.cargo,
                          ato.simbolo,
                          ato.tipocargo,
                          file=arq1)
                    persistencia.insert(ato.matricula, ato.nome,
                                        ato.dataResolucao, 'DISPENSAR',
                                        ato.dataEfeito, ato.cargo,
                                        ato.tipocargo, ato.simbolo)

                servidor = LayoutAtos.atos_exonerar(self, buffer_local,
                                                    Detalhe)
                for i in range(len(servidor)):
                    ato = Ato()
                    ato.nome = '{: <50}'.format((servidor[i].nome).replace(
                        '\n', ' ').replace('  ', ' ').strip(" "))
                    ato.numero = '{:0>4}'.format(servidor[i].numero)
                    ato.diaResolucao = '{:0>2}'.format(
                        servidor[i].diaResolucao)
                    ato.mesResolucao = '{:0>2}'.format(
                        servidor[i].mesResolucao)
                    ato.anoResolucao = servidor[i].anoResolucao
                    ato.dataResolucao = ato.diaResolucao + '/' + ato.mesResolucao + '/' + ato.anoResolucao
                    ato.dia = '{:0>2}'.format(servidor[i].dia)
                    ato.mes = util.retornaMes(servidor[i].mes)
                    ato.ano = servidor[i].ano
                    ato.dataEfeito = ato.dia + '/' + ato.mes + '/' + ato.ano
                    ato.matricula = '{: <12}'.format(
                        servidor[i].matricula.replace('.', ''))
                    #ato.cargo = '{: <48}'.format(servidor[i].cargo.upper()).replace('\n', ' ')
                    ato.cargo = '{: <48}'.format(
                        (servidor[i].cargo.upper()).replace('\n', ' ').replace(
                            '  ', ' ').replace('- ', '').strip(" "))
                    ato.CPF = '{: <13}'.format(
                        servidor[i].CPF)  #vER ESTA REGRA!!!!!
                    ato.tipocargo = servidor[i].tipocargo
                    ato.simbolo = '{: <6}'.format(servidor[i].simbolo.replace(
                        '\n', ''))
                    print(ato.CPF,
                          Tipo,
                          ato.numero,
                          ato.dataResolucao,
                          'EXONERAR ',
                          ato.matricula,
                          ato.nome,
                          ato.dataEfeito,
                          ato.cargo,
                          ato.simbolo,
                          ato.tipocargo,
                          file=arq1)
                    persistencia.insert(ato.matricula, ato.nome,
                                        ato.dataResolucao, 'EXONERAR',
                                        ato.dataEfeito, ato.cargo,
                                        ato.tipocargo, ato.simbolo)

                servidor = LayoutAtos.atos_designar(self, buffer_local,
                                                    Detalhe, arqres)
                for i in range(len(servidor)):
                    ato = Ato()
                    ato.nome = '{: <50}'.format((servidor[i].nome).replace(
                        '\n', ' ').replace('  ', ' ').strip(" "))
                    #print(ato.nome)
                    ato.numero = '{:0>4}'.format(servidor[i].numero)
                    ato.diaResolucao = '{:0>2}'.format(
                        servidor[i].diaResolucao)
                    ato.mesResolucao = '{:0>2}'.format(
                        servidor[i].mesResolucao)
                    ato.anoResolucao = servidor[i].anoResolucao
                    ato.dataResolucao = ato.diaResolucao + '/' + ato.mesResolucao + '/' + ato.anoResolucao
                    ato.dia = '{:0>2}'.format(servidor[i].dia)
                    ato.mes = util.retornaMes(servidor[i].mes)
                    ato.ano = servidor[i].ano
                    ato.dataEfeito = ato.dia + '/' + ato.mes + '/' + ato.ano
                    ato.matricula = '{: <12}'.format(
                        servidor[i].matricula.replace('.', ''))
                    #ato.cargo = '{: <48}'.format(servidor[i].cargo.upper()).replace('\n', ' ')
                    ato.cargo = '{: <48}'.format(
                        (servidor[i].cargo.upper()).replace('\n', ' ').replace(
                            '  ', ' ').replace('- ', '').strip(" "))
                    ato.CPF = '{: <13}'.format(
                        servidor[i].CPF)  #vER ESTA REGRA!!!!!
                    ato.tipocargo = servidor[i].tipocargo
                    ato.simbolo = '{: <6}'.format(servidor[i].simbolo.replace(
                        '\n', ''))
                    print(ato.CPF,
                          Tipo,
                          ato.numero,
                          ato.dataResolucao,
                          'DESIGNAR ',
                          ato.matricula,
                          ato.nome,
                          ato.dataEfeito,
                          ato.cargo,
                          ato.simbolo,
                          ato.tipocargo,
                          file=arq1)
                    persistencia.insert(ato.matricula, ato.nome,
                                        ato.dataResolucao, 'DESIGNAR',
                                        ato.dataEfeito, ato.cargo,
                                        ato.tipocargo, ato.simbolo)
Ejemplo n.º 7
0
 def setUp(self):
     self.tablero = TableroCelular(4, 5)
     self.tablero.rellenar_matriz_al_azar(6)
     self.tablero2 = TableroCelular(5,6)
     self.tablero.rellenar_matriz_al_azar(15)
     self.persistencia = Persistencia()
Ejemplo n.º 8
0
#!/usr/bin/env python
# -*- coding: utf8 -*-

from Persistencia import Persistencia
from Pessoa import Pessoa


persistencia = Persistencia()
persistencia.recuperaLista()

def lerPessoa():
    codigo = int(input('Codigo : '))
    nome = input('Nome : ')
    status = bool(input('Status : '))
    altura = float(input('Altura : '))
    return Pessoa(codigo, nome, status, altura)

def incluir():        
    persistencia.gravaPessoa(lerPessoa())

def alterar():
    codigoQuery = int(input('Digite o código da pessoa a ser alterada:'))
    if (persistencia.existePessoa(codigoQuery)):
        persistencia.atualizaPessoa(lerPessoa())
    else:
        print('Pessoa inexistente')
        
def excluir():
    codigoQuery = int(input('Digite o código da pessoa a ser excluida:'))
    if (persistencia.existePessoa(codigoQuery)):
        persistencia.excluiPessoa(Pessoa(codigoQuery))
Ejemplo n.º 9
0
class Gerenciador(object):
	def __init__(self):
		self.jogoIniciado = False
		self.partidaIniciada = False
		self.salvouNoRanking = False
		self.tamX =800 
		self.tamY = 600 
		self.persistencia = Persistencia()
		self.ranking = self.persistencia.lerArquivo()
		
	def iniciarJogo (self):
		if (self.jogoIniciado == True):
			raise ExcecaoJogo("Um jogo ja foi iniciado")
		self.jogoIniciado = True

		self.nave = None
		self.listaTiros = []
		self.listaNaves = []
#		self.ranking = self.persistencia.lerArquivo()
		self.salvouNoRanking = False

	def moverNavesInimigas(self):
		for naveInimiga in self.listaNaves:
			naveInimiga.moverAleatorio()

		
	def moverTiros (self):
		for tiro in self.listaTiros:
			tiro.mover()
			if tiro.posY < 0: #neste caso o tamnho da nave
				self.listaTiros.remove(tiro)

	def iniciarPartida(self):
		if (self.partidaIniciada == True):
			raise ExcecaoJogo("Uma partida ja foi iniciada")
		if (self.jogoIniciado == False):
			raise ExcecaoJogo("Jogo não iniciado")
		self.partidaIniciada = True
		self.nave = Nave(self.tamX, self.tamY)

	
	def jogoComecou(self):
		return self.jogoIniciado
	
	def getTamanhoTela(self):
		return (self.tamX, self.tamY)
	
	def getPosNave (self):
		return self.nave.getPos()
	
	def moverNave(self, deslocamentoX, deslocamentoY):
		if (self.jogoIniciado == False):
			raise ExcecaoJogo("Jogo não iniciado")
		if (self.partidaIniciada == False):
			raise ExcecaoJogo("Partida não iniciada")
		self.nave.moverNave(deslocamentoX, deslocamentoY)
	
	def atacarInimigo(self):
		if (self.jogoIniciado == False):
			raise ExcecaoJogo("Jogo não iniciado")
		if (self.partidaIniciada == False):
			raise ExcecaoJogo("Partida não iniciada")
		posNave = self.getPosNave()
		self.listaTiros.append(Tiro(posNave[0],posNave[1]))
		
	def adicionarNomeNoRanking(self, Nome):
		pontuacaoEnome = (Nome, self.getPontuacao())
		self.adicionarNoRanking(pontuacaoEnome)
		self.ranking.sort(self.funcaoOrdenacaoRanking)
		self.ranking.reverse()

	def funcaoOrdenacaoRanking(self,a,b):
		if (a[1] == b[1]):
			return (-1) * cmp(a[0], b[0])
		return cmp(a[1], b[1])
		
	def getRanking(self):
		return self.ranking

		
	def adicionarNoRanking(self, pontuacaoENome):
		if (self.jogoIniciado == False):
			raise ExcecaoJogo("Jogo não iniciado")
		if (self.partidaIniciada == True):
			raise ExcecaoJogo("Partida em andamento")
		if(pontuacaoENome[1] == 0):
			raise ExcecaoJogo("Você precisa ter pontuação maior que zero")
		if (not(pontuacaoENome in self.ranking)):
			self.ranking.append(pontuacaoENome)			
			self.ranking.sort()
			self.ranking.reverse()
			if (len(self.ranking )> 10):
				self.ranking.remove(self.ranking[10])
			#salvar em arquivo
			self.persistencia.gravarArquivo( self.ranking )
		
				
	def sairDaPartida(self):
		if (self.jogoIniciado == False):
			raise ExcecaoJogo("Jogo não iniciado")
		if (self.partidaIniciada == False):
			raise ExcecaoJogo("Partida não iniciada")
		self.partidaIniciada = False
		tamanhoRanking = len(self.ranking)
		#retorna true se for para adicionar no ranking
		if ((tamanhoRanking == 0)):
			return True
		elif (self.nave.pontuacao >= (self.ranking[tamanhoRanking-1])[1]):
			return True
		elif (tamanhoRanking < 10):
			return True

		return False
				
	def sairDoJogo(self):
		if (self.jogoIniciado == False):
			raise ExcecaoJogo("Jogo não iniciado")
		if (self.partidaIniciada == True):
			raise ExcecaoJogo("Voce precisa terminar a partida antes de sair")
		self.jogoIniciado = False

	def getNivel(self):
		if (self.jogoIniciado == False):
			raise ExcecaoJogo("Jogo não iniciado")
		if (self.partidaIniciada == False):
			raise ExcecaoJogo("Partida não iniciada")

		return self.nave.getNivel()
		
		
	def ganharVida(self):
		if (self.jogoIniciado == False):
			raise ExcecaoJogo("Jogo não iniciado")
		if (self.partidaIniciada == False):
			raise ExcecaoJogo("Partida não iniciada")	
		
		self.nave.ganharVida()
		nivel = self.nave.getNivel()
		if (nivel >= 6):
			tamanhoRanking = len(self.ranking)
			#retorna true se for para adicionar no ranking
			if (tamanhoRanking == 0):
				self.partidaIniciada = False
				return True
			elif (self.nave.pontuacao >= (self.ranking[tamanhoRanking-1])[1]):
				self.partidaIniciada = False
				return True
			elif (tamanhoRanking < 10):
				self.partidaIniciada = False
				return True
			else:
				return False
		
		return False

	def perderVida(self):
		if (self.jogoIniciado == False):
			raise ExcecaoJogo("Jogo não iniciado")
		if (self.partidaIniciada == False):
			raise ExcecaoJogo("Partida não iniciada")
		vidasAcabaram = self.nave.perderVida()
		if (vidasAcabaram == True):
			return self.sairDaPartida()
		return False
	
	def partidaFoiIniciada(self):
		return self.partidaIniciada
	
	def criarNaveInimiga(self):
		if (self.jogoIniciado == False):
			raise ExcecaoJogo("Jogo não iniciado")
		if (self.partidaIniciada == False):
			raise ExcecaoJogo("Partida não iniciada")
		escolhaPosX = random.choice
		listaPosicoes = range(0, self.tamX)
		naveInimiga = NaveInimigaComum(escolhaPosX(listaPosicoes), 50 , self.tamX, self.tamY)
		self.listaNaves.append(naveInimiga)
		
	def destruirNaveInimiga(self, nave):
		if (self.jogoIniciado == False):
			raise ExcecaoJogo("Jogo não iniciado")
		if (self.partidaIniciada == False):
			raise ExcecaoJogo("Partida não iniciada")
		if (nave in self.listaNaves):
			self.listaNaves.remove(nave)
			self.nave.pontuar()
		
	def getListaNaves(self):
		return self.listaNaves
		
	def getPontuacao(self):
		if (self.jogoIniciado == False):
			raise ExcecaoJogo("Jogo não iniciado")
		return self.nave.getPontuacao()
	
	def getListaTiros(self):
		return self.listaTiros
	
	def getVida(self):
		return self.nave.getVida()