コード例 #1
0
ファイル: util.py プロジェクト: victoraraujo105/BusRiding
def reinsert_linha(app, linha, visivel=True):
    '''
        Reinsere uma linha que havia sido removida (ou não inicializada).
    '''
    dados = estado.linhas_entradas[linha]
    app.linhas.insert(parent='',
                      index='end',
                      values=campos_linha_formatados(dados),
                      iid=linha)
    t = minutos_dia(dados.horario)
    data_atual = monitoradas.data_atual.replace(second=0, microsecond=0)
    minutos_atual = data_atual.hour * 60 + data_atual.minute

    if t == minutos_atual:
        periodo = range(cte.MAXIMO_NUMERO_DE_DIAS_ATE_RESERVA + 1)
    elif t < minutos_atual:
        periodo = range(1, cte.MAXIMO_NUMERO_DE_DIAS_ATE_RESERVA + 1)
    else:
        periodo = range(cte.MAXIMO_NUMERO_DE_DIAS_ATE_RESERVA)
    estado.linhas_entradas[linha] = cte.ESTRUTURA_LINHA(*dados[:-1], dict())
    onibus_invisiveis = set()
    if not visivel:
        app.linhas.detach(linha)
        onibus_invisiveis.update(estado.linhas_entradas[linha].onibus)
    for d in periodo:
        # para cada dia no período, vamos adicionar um ônibus nessa linha
        partida = (data_atual + dt.timedelta(d)).replace(
            hour=dados.horario.hour, minute=dados.horario.minute)
        onibus = gerar_id_onibus(linha, partida)
        assentos = dados.onibus.get(onibus, dict())
        app.linhas.insert(parent=linha,
                          index='end',
                          values=('-', fm.form_data(partida),
                                  2 * int(dados.fileiras) - len(assentos),
                                  '-'),
                          iid=onibus)
        estado.linhas_entradas[linha].onibus[onibus] = assentos
        if visivel and onibus in estado.onibus_invisiveis:
            app.linhas.detach(onibus)
            onibus_invisiveis.add(onibus)
        elif visivel:
            monitoradas.onibus_visiveis.add(onibus)
    return onibus_invisiveis
コード例 #2
0
ファイル: util.py プロジェクト: victoraraujo105/BusRiding
def adicionar_linha(app):
    '''
        Adiciona uma linha com base nos campos de texto.
    '''
    # lemos todos os campos de texto
    campos = [
        dest.atualizar_destino(),
        date.update(app),
        vg.atualizar_vagas(),
        it.atualizar_inteira()
    ]

    for campo in campos:
        if popup.campos_invalidos[campo]():
            return
    # aqui, todos os campos de texto possuem valores válidos, então vamos criar a linha

    linhas = app.linhas
    destino = monitoradas.destino.get()
    tempo_exibido = monitoradas.tempo_exibido
    vagas = monitoradas.vagas.get()
    inteira = monitoradas.inteira.get()
    linha = gerar_id_linha(destino, tempo_exibido)
    # antes de inseri-la graficamente, temos que verificar se ela já existe
    if linha in estado.linhas_entradas:
        # Linha desabilitada. Deseja reabilitá-la?
        if linha not in estado.linhas_visiveis:
            texto = 'Linha desabilitada, deseja reabilitá-la?.'
            resposta = messagebox.askyesno(title='Linha existe',
                                           message=texto,
                                           default='yes')
            if resposta:
                app.linhas.reattach(linha, '', 0)
                estado.linhas_visiveis.add(linha)
                onibus_filhos_visiveis = set(app.linhas.get_children(linha))
                estado.onibus_invisiveis -= onibus_filhos_visiveis
                monitoradas.onibus_visiveis.update(onibus_filhos_visiveis)
                ctrl.update_action(app, 'Restaurar')

                monitoradas.historico_redo.clear()
                monitoradas.historico_undo.append(['show', [0], [linha]])
                app.linhas.selection_set(linha)
                app.contador_linhas['text'] = fm.form_cont_linhas(
                    len(estado.linhas_visiveis))
                app.contador_onibus['text'] = fm.form_cont_onibus(
                    len(monitoradas.onibus_visiveis))
                # nova ação: reabilitar
        else:
            app.linhas.see(linha)
            app.linhas.selection_set(linha)
        return
    h = minutos_dia(tempo_exibido)
    estado.linhas_possiveis.discard((destino, h))
    estado.horarios_linhas[h] = estado.horarios_linhas.get(h, set()).union(
        {linha})

    dest.add_destino(app)
    ctrl.update_action(app, 'add')
    linhas.insert(parent='',
                  index=0,
                  values=(destino, fm.form_tempo(tempo_exibido), vagas,
                          inteira),
                  iid=linha)
    estado.linhas_visiveis.add(linha)
    app.contador_linhas['text'] = fm.form_cont_linhas(
        len(estado.linhas_visiveis))

    estado.linhas_entradas[linha] = cte.ESTRUTURA_LINHA(
        destino, tempo_exibido,
        int(vagas) // 2, round(float(inteira) * 100 - 300), dict())

    data_atual = monitoradas.data_atual.replace(second=0, microsecond=0)
    for d in range(cte.MAXIMO_NUMERO_DE_DIAS_ATE_RESERVA + 1):
        partida = (data_atual + dt.timedelta(d)).replace(
            hour=tempo_exibido.hour, minute=tempo_exibido.minute)
        if data_atual <= partida <= data_atual + dt.timedelta(
                cte.MAXIMO_NUMERO_DE_DIAS_ATE_RESERVA):
            onibus = gerar_id_onibus(linha, partida)
            linhas.insert(parent=linha,
                          index='end',
                          values=('-', fm.form_data(partida), vagas, '-'),
                          iid=onibus)
            monitoradas.onibus_visiveis.add(onibus)
            estado.linhas_entradas[linha].onibus[onibus] = dict()
            app.contador_onibus['text'] = fm.form_cont_onibus(
                len(monitoradas.onibus_visiveis))

    app.contador_linhas['text'] = fm.form_cont_linhas(
        len(estado.linhas_visiveis))
    app.contador_onibus['text'] = fm.form_cont_onibus(
        len(monitoradas.onibus_visiveis))

    historico_undo = monitoradas.historico_undo
    historico_redo = monitoradas.historico_redo
    historico_redo.clear()
    historico_undo.append(['add', [[estado.linhas_entradas[linha], list()]]])
    linhas.selection_set(linha)
コード例 #3
0
ファイル: util.py プロジェクト: victoraraujo105/BusRiding
def editar_linha(app):
    '''
        Edita informações sobre uma linha.
    '''
    selecao = app.linhas.selection()
    if len(selecao) != 1 or app.linhas.parent(selecao[0]) != '':
        texto = 'Selecione uma única linha.'
        messagebox.showwarning(title='Impossível Editar', message=texto)
        return
    [linha] = selecao
    dados_linha = estado.linhas_entradas[linha]
    # a condição a seguir é True sse existe algum ônibus com reservas na linha selecionada.
    if any(len(x) != 0 for x in dados_linha.onibus.values()):
        texto = 'Linha possui reservas.'
        messagebox.showwarning(title='Impossível Editar', message=texto)
        return

    campos = [
        dest.atualizar_destino(),
        date.update(app),
        vg.atualizar_vagas(),
        it.atualizar_inteira()
    ]

    for campo in campos:
        if popup.campos_invalidos[campo]():
            return

    destino_alterada = monitoradas.destino.get()
    tempo_exibido = monitoradas.tempo_exibido
    vagas_alterada = monitoradas.vagas.get()
    inteira_alterada = monitoradas.inteira.get()
    linha_alterada = gerar_id_linha(destino_alterada, tempo_exibido)

    h = minutos_dia(estado.linhas_entradas[linha].horario)

    if linha_alterada in estado.linhas_entradas:
        if linha_alterada in estado.linhas_visiveis:
            if linha != linha_alterada:
                texto = 'Linha já existe.'
                messagebox.showwarning(title='Impossível Editar',
                                       message=texto)
            elif dados_linha[2:4] != [
                    int(vagas_alterada) // 2,
                    round(float(inteira_alterada) * 100 - 300)
            ]:
                dados_linha_alterada = estado.linhas_entradas[
                    linha] = cte.ESTRUTURA_LINHA(
                        *dados_linha[:2],
                        int(vagas_alterada) // 2,
                        round(float(inteira_alterada) * 100 - 300),
                        dados_linha[-1])
                app.linhas.item(
                    linha,
                    values=campos_linha_formatados(dados_linha_alterada))

                app.linhas.selection_set(linha_alterada)
                monitoradas.historico_redo.clear()
                monitoradas.historico_undo.append(
                    ['change', dados_linha, dados_linha_alterada, False])
                app.contador_linhas['text'] = fm.form_cont_linhas(
                    len(estado.linhas_visiveis))
                app.contador_onibus['text'] = fm.form_cont_onibus(
                    len(monitoradas.onibus_visiveis))

        else:
            texto = 'Linha desabilitada, deseja reabilitá-la?'
            resposta = messagebox.askyesno(title='Impossível Editar',
                                           message=texto,
                                           default='no')
            if resposta:
                app.linhas.reattach(linha_alterada, '',
                                    app.linhas.index(linha))
                app.linhas.item(linha_alterada,
                                open=app.linhas.item(linha, 'open'))
                estado.linhas_visiveis.add(linha_alterada)
                onibus_filhos_visiveis = set(
                    app.linhas.get_children(linha_alterada))
                estado.onibus_invisiveis -= onibus_filhos_visiveis
                monitoradas.onibus_visiveis.update(onibus_filhos_visiveis)
                ctrl.update_action(app, 'Restaurar')
                estado.horarios_linhas[h].remove(linha)
                app.linhas.delete(linha)
                estado.linhas_visiveis.remove(linha)
                for onibus in estado.linhas_entradas[linha].onibus:
                    monitoradas.onibus_visiveis.discard(onibus)
                    estado.onibus_invisiveis.discard(onibus)

                monitoradas.historico_redo.clear()
                monitoradas.historico_undo.append([
                    'change', estado.linhas_entradas[linha],
                    estado.linhas_entradas[linha_alterada], True
                ])
                estado.linhas_possiveis.add((dados_linha.destino.title(), h))
                del estado.linhas_entradas[linha]
                app.linhas.selection_set(linha_alterada)
                app.contador_linhas['text'] = fm.form_cont_linhas(
                    len(estado.linhas_visiveis))
                app.contador_onibus['text'] = fm.form_cont_onibus(
                    len(monitoradas.onibus_visiveis))
        return
    h_alt = tempo_exibido.hour * 60 + tempo_exibido.minute
    estado.linhas_possiveis.remove((destino_alterada, h_alt))
    estado.linhas_possiveis.add((dados_linha.destino.title(), h))
    estado.horarios_linhas[h].remove(linha)
    estado.horarios_linhas[h_alt] = estado.horarios_linhas.get(
        h_alt, set()).union({linha_alterada})
    dest.add_destino(app)
    ctrl.update_action(app, 'change')
    indice = app.linhas.index(linha)
    app.linhas.insert(parent='',
                      index=indice,
                      values=(destino_alterada, fm.form_tempo(tempo_exibido),
                              vagas_alterada, inteira_alterada),
                      iid=linha_alterada,
                      open=app.linhas.item(linha, 'open'))
    app.linhas.delete(linha)
    estado.linhas_visiveis.remove(linha)
    estado.linhas_visiveis.add(linha_alterada)

    onibus_filhos = dict()

    data_atual = monitoradas.data_atual.replace(second=0, microsecond=0)
    for d in range(cte.MAXIMO_NUMERO_DE_DIAS_ATE_RESERVA + 1):
        partida = (data_atual + dt.timedelta(d)).replace(
            hour=tempo_exibido.hour, minute=tempo_exibido.minute)
        if data_atual <= partida <= data_atual + dt.timedelta(
                cte.MAXIMO_NUMERO_DE_DIAS_ATE_RESERVA):
            onibus = gerar_id_onibus(linha_alterada, partida)
            app.linhas.insert(parent=linha_alterada,
                              index='end',
                              values=('-', fm.form_data(partida),
                                      vagas_alterada, '-'),
                              iid=onibus)
            monitoradas.onibus_visiveis.add(onibus)
            onibus_filhos[onibus] = dict()

    estado.linhas_entradas[linha_alterada] = cte.ESTRUTURA_LINHA(
        destino_alterada, tempo_exibido,
        int(vagas_alterada) // 2, round(float(inteira_alterada) * 100 - 300),
        onibus_filhos)

    for onibus in estado.linhas_entradas[linha].onibus:
        monitoradas.onibus_visiveis.discard(onibus)
        estado.onibus_invisiveis.discard(onibus)

    monitoradas.historico_redo.clear()
    monitoradas.historico_undo.append([
        'change', estado.linhas_entradas[linha],
        estado.linhas_entradas[linha_alterada], False
    ])

    del estado.linhas_entradas[linha]
    app.contador_linhas['text'] = fm.form_cont_linhas(
        len(estado.linhas_visiveis))
    app.contador_onibus['text'] = fm.form_cont_onibus(
        len(monitoradas.onibus_visiveis))

    ctrl.update_action(app, 'change')
    app.linhas.selection_set(linha_alterada)
コード例 #4
0
def adicionar_linha(app, indice, linha, data_atual=monitoradas.data_atual):
    '''
        Altera o estado da aplicação (incluindo a interface gráfica) para incluir a linha especificada no argumento.
    '''
    destino = linha.campus.title()
    if destino not in estado.destinos:
        # adicionamos o destino da linha do argumento, caso ele não exista
        estado.destinos.append(destino)
        estado.linhas_possiveis.update({(destino, t) for t in range(1440)})
        estado.destinos.sort()  # mantemos a ordenação
        app.entrada_destino['values'] = estado.destinos
        monitoradas.destino.set(estado.destinos[0])
    t = minutos_dia(linha.horario)
    estado.horarios_linhas[t] = estado.horarios_linhas.get(
        t, set()).union({linha.id})
    # incluimos a linha na interface gráfica
    estado.linhas_possiveis.discard((destino, t))
    app.linhas.insert(parent='',
                      index=indice,
                      values=(destino, fm.form_tempo(linha.horario), 2 *
                              linha.fileiras, it.inteira_termo(linha.inteira)),
                      iid=linha.id)
    estado.linhas_visiveis.add(linha.id)
    app.contador_linhas['text'] = fm.form_cont_linhas(
        len(estado.linhas_visiveis))

    estado.linhas_entradas[linha.id] = cte.ESTRUTURA_LINHA(
        destino, linha.horario, linha.fileiras, linha.inteira, dict())

    minutos_atual = minutos_dia(data_atual)

    # calculamos o período de dias em que haverá ônibus partindo
    if t == minutos_atual:
        periodo = range(cte.MAXIMO_NUMERO_DE_DIAS_ATE_RESERVA + 1)
    elif t < minutos_atual:
        # aqui, o horário da linha é menor que o horário atual,
        # então não vamos criar um ônibus para o dia de hoje, pois ele já partiu
        periodo = range(1, cte.MAXIMO_NUMERO_DE_DIAS_ATE_RESERVA + 1)
    else:
        # aqui, o horário da linha é maior que o horário atual,
        # então vamos incluir o dia de hoje
        periodo = range(cte.MAXIMO_NUMERO_DE_DIAS_ATE_RESERVA)

    for d in periodo:
        # para cada dia no período calculado, vamos adicionar um ônibus
        # note que d = 0 representa o dia de hoje, d = 1 é amanhã, etc.
        partida = (data_atual + dt.timedelta(d)
                   ).replace(hour=linha.horario.hour, minute=linha.horario.minute)
        onibus = gerar_id_onibus(linha.id, partida)
        app.linhas.insert(parent=linha.id, index='end', values=(
            '-', fm.form_data(partida), 2*linha.fileiras, '-'), iid=onibus)
        monitoradas.onibus_visiveis.add(onibus)
        # todos os assentos estão livres
        estado.linhas_entradas[linha.id].onibus[onibus] = dict()
        app.contador_onibus['text'] = fm.form_cont_onibus(
            len(monitoradas.onibus_visiveis))

    app.contador_linhas['text'] = fm.form_cont_linhas(
        len(estado.linhas_visiveis))
    app.contador_onibus['text'] = fm.form_cont_onibus(
        len(monitoradas.onibus_visiveis))
コード例 #5
0
    def gerar(event=None):
        '''
            Gera as linhas conforme a quantidade indicada pelo spin_linhas.
            É executado quando o usuário clica no botão de gerar, ou aperta ENTER.
        '''
        if not atualizar_num():
            # aqui, atualizar_num retornou False, o que significa que a entrada é inválida
            messagebox.showwarning(title='Entrada Inválida',
                                   message='Valor inválido!',
                                   parent=configuracoes)
            return

        from random import choice, randrange, sample
        ocupar = monitoradas.ocupar_assentos.get()
        # Uma sequência em que o valor assento_coordenadas(i, j) indica o número do assento na linha i e coluna j.
        # Note que para cada linha, há 4 colunas (índice j varia de 0 a 3).
        # As colunas 0 e 3 são adjacentes à janela e as colunas 1 e 2 são adjacentes ao corredor.
        # Essa sequência pode ser vista ao tentar reservar um assento.
        def assento_coordenadas(i, j): return 2*i + j + \
            1 if j <= 1 else 2*(num_fileiras + i + 2) - j
        dados = []
        data_atual = monitoradas.data_atual
        minutos_atual = data_atual.hour*60 + data_atual.minute
        # termo(monitoradas.indice_linhas_geradas) é o número de linhas indicado pelo spin_linhas
        # note que minutes[:termo(monitoradas.indice_linhas_geradas)] seleciona
        # justamente a quantidade de linhas que queremos!
        # como minutes foi permutado aleatoriamente, os horários em minutes escolhidos
        # pelo slicing são aleatórios e diferentes entre si
        for destino, t in sample(estado.linhas_possiveis, termo(monitoradas.indice_linhas_geradas)):
            estado.linhas_possiveis.discard((destino, t))
            # t é uma quantidade de minutos da lista minutes, que usaremos para calcular o horário dessa linha que
            # iremos cadastrar!
            interval = dt.timedelta(minutes=t)
            horario = data_atual.replace(hour=0, minute=0) + interval
            if data_atual > horario:
                horario += dt.timedelta(1)
            linha = gerar_id_linha(destino, horario)

            indice_vagas = choice(range(cte.MAXIMO_NUMERO_DE_FILEIRAS))
            num_fileiras = indice_vagas + 1
            vagas = vg.vagas_termo(indice_vagas)
            indice_inteira = choice(range(301))
            inteira = it.inteira_termo(indice_inteira)

            estado.horarios_linhas[t] = estado.horarios_linhas.get(
                t, set()).union({linha})

            app.linhas.insert(parent='',
                              index=0,
                              values=(destino, fm.form_tempo(
                                  horario), vagas, inteira),
                              iid=linha)
            estado.linhas_entradas[linha] = cte.ESTRUTURA_LINHA(
                destino, horario, num_fileiras, indice_inteira, dict())
            estado.linhas_visiveis.add(linha)

            reservas = list()

            # calculamos o período de dias em que haverá ônibus partindo
            if t == minutos_atual:
                periodo = range(cte.MAXIMO_NUMERO_DE_DIAS_ATE_RESERVA + 1)
            elif t < minutos_atual:
                # aqui, o horário da linha é menor que o horário atual,
                # então não vamos criar um ônibus para o dia de hoje, pois ele já partiu
                periodo = range(1, cte.MAXIMO_NUMERO_DE_DIAS_ATE_RESERVA + 1)
            else:
                # aqui, o horário da linha é maior que o horário atual,
                # então vamos incluir o dia de hoje
                periodo = range(cte.MAXIMO_NUMERO_DE_DIAS_ATE_RESERVA)

            for d in periodo:
                # para cada dia no período calculado, vamos adicionar um ônibus
                # note que d = 0 representa o dia de hoje, d = 1 é amanhã, etc.
                partida = data_atual + dt.timedelta(d)
                onibus = gerar_id_onibus(linha, partida)
                assentos_disponiveis = randrange(vagas+1) if ocupar else vagas
                app.linhas.insert(parent=linha, index='end', values=(
                    '-', fm.form_data(partida), assentos_disponiveis, '-'), iid=onibus)
                estado.linhas_entradas[linha].onibus[onibus] = dict()
                if assentos_disponiveis < vagas:
                    # nesse caso, significa que o usuário pediu para "Ocupar assentos"
                    # e o valor aleatorio assentos disponíveis é menor que a quantidade de vagas
                    # então, devemos fazer algumas reservas aleatórias!
                    # primeiro, vamos escolher quais assentos serão escolhíveis
                    # (afinal, metade dos assentos serão disponíveis, então vamos escolher qual metade)
                    shift = choice(range(2))
                    # os assentos escolhíveis respeitam as condições impostas pela pandemia
                    # basicamente, selecionamos (i, (i + shift) % 2) e (i, 2 + (i + shift) % 2) para todo i
                    # por exemplo,
                    # i = 0, shift = 0 -> selecionamos (0, 0) e (0, 2)
                    # i = 1, shift = 0 -> selecionamos (1, 1) e (1, 3)
                    # i = 2, shift = 0 -> selecionamos (2, 0) e (2, 2)
                    # Note que a primeira posição é um assento da seção da esquerda
                    # e a segunda posição é um assento da seção da direita
                    # e selecionamos dois assentos por linha
                    assentos_visiveis = {assento_coordenadas(i, 2 * j + (i + shift) % 2) for j in range(2)
                                         for i in range(num_fileiras)}
                    # a função sample seleciona aleatoriamente números de assentos escolhíveis para
                    # fazermos reserva
                    for assento in sample(assentos_visiveis, vagas - assentos_disponiveis):
                        # a variável assento é um número de assento escolhível aleatório
                        # devemos reservar esse assento!
                        passagem = choice([2]*3+[1]*2+[0])
                        estado.linhas_entradas[linha].onibus[onibus][assento] = passagem
                        reserva = gerar_id_reserva(onibus, assento, passagem)
                        estado.reservas.add(reserva)
                        reservas.insert(0, reserva)
                        app.reservas.insert(parent='',
                                            index=0,
                                            values=campos_reserva_formatados(
                                                reserva),
                                            iid=reserva)
                monitoradas.onibus_visiveis.add(onibus)

            dados.append([estado.linhas_entradas[linha], reservas])

        ctrl.update_action(app, 'add')

        historico_undo = monitoradas.historico_undo
        historico_redo = monitoradas.historico_redo
        historico_redo.clear()
        historico_undo.append(['add', dados])

        app.contador_linhas['text'] = fm.form_cont_linhas(
            len(estado.linhas_visiveis))
        app.contador_onibus['text'] = fm.form_cont_onibus(
            len(monitoradas.onibus_visiveis))
        app.contador_reservas['text'] = fm.form_cont_reservas(
            len(estado.reservas))
        configuracoes.destroy()
コード例 #6
0
ファイル: history.py プロジェクト: victoraraujo105/BusRiding
def mudar(app, dados_anterior, dados_alterada, existia):
    app.abas.select(app.aba_linhas)
    linha_anterior = gerar_id_linha(*dados_anterior[:2])
    linha_alterada = gerar_id_linha(*dados_alterada[:2])
    if linha_anterior == linha_alterada:
        app.linhas.item(linha_anterior,
                        values=campos_linha_formatados(dados_alterada))
        app.linhas.selection_set(linha_alterada)
        app.contador_linhas['text'] = fm.form_cont_linhas(
            len(estado.linhas_visiveis))
        app.contador_onibus['text'] = fm.form_cont_onibus(
            len(monitoradas.onibus_visiveis))
        return 1
    indice = app.linhas.index(linha_anterior)
    expanded = app.linhas.item(linha_anterior, 'open')
    t = minutos_dia(dados_anterior.horario)
    estado.horarios_linhas[t].remove(linha_anterior)
    estado.linhas_visiveis.remove(linha_anterior)
    onibus_filhos = dados_anterior.onibus.keys()
    monitoradas.onibus_visiveis -= onibus_filhos
    estado.onibus_invisiveis -= onibus_filhos
    del estado.linhas_entradas[linha_anterior]
    app.linhas.delete(linha_anterior)
    estado.linhas_possiveis.add((dados_anterior.destino.title(), t))

    if existia:
        app.linhas.reattach(linha_alterada, '', indice)
        app.linhas.item(linha_alterada, open=expanded)
        estado.linhas_visiveis.add(linha_alterada)
        onibus_filhos_visiveis = set(app.linhas.get_children(linha_alterada))
        estado.onibus_invisiveis -= onibus_filhos_visiveis
        monitoradas.onibus_visiveis.update(onibus_filhos_visiveis)
    else:
        t = minutos_dia(dados_alterada.horario)
        assentos = dados_alterada.fileiras * 2
        estado.horarios_linhas[t] = estado.horarios_linhas.get(t, set()).union(
            {linha_alterada})
        app.linhas.insert(parent='',
                          index=indice,
                          values=campos_linha_formatados(dados_alterada),
                          iid=linha_alterada,
                          open=expanded)
        estado.linhas_visiveis.add(linha_alterada)
        estado.linhas_possiveis.remove((dados_alterada.destino.title(), t))

        estado.linhas_entradas[linha_alterada] = cte.ESTRUTURA_LINHA(
            *dados_alterada[:-1], dict())

        data_atual = monitoradas.data_atual.replace(second=0, microsecond=0)
        for d in range(cte.MAXIMO_NUMERO_DE_DIAS_ATE_RESERVA + 1):
            partida = (data_atual + dt.timedelta(d)).replace(
                hour=dados_alterada.horario.hour,
                minute=dados_alterada.horario.minute)
            if data_atual <= partida <= data_atual + dt.timedelta(
                    cte.MAXIMO_NUMERO_DE_DIAS_ATE_RESERVA):
                onibus = gerar_id_onibus(linha_alterada, partida)
                app.linhas.insert(parent=linha_alterada,
                                  index='end',
                                  values=('-', fm.form_data(partida), assentos,
                                          '-'),
                                  iid=onibus)
                monitoradas.onibus_visiveis.add(onibus)
                estado.linhas_entradas[linha_alterada].onibus[onibus] = dict()

    app.contador_onibus['text'] = fm.form_cont_onibus(
        len(monitoradas.onibus_visiveis))
    app.contador_linhas['text'] = fm.form_cont_linhas(
        len(estado.linhas_visiveis))
    app.linhas.selection_set(linha_alterada)

    return 1
コード例 #7
0
ファイル: history.py プロジェクト: victoraraujo105/BusRiding
def recadastrar_linhas(app, dados):
    actions = 0
    reservas_changed = False

    app.linhas.selection_set(*[])
    app.reservas.selection_set(*[])

    for dados_linha, reservas in dados:
        linha = gerar_id_linha(*dados_linha[:2])

        estado.linhas_entradas[linha] = cte.ESTRUTURA_LINHA(
            *dados_linha[:-1], dict())

        for reserva in reservas:
            estado.reservas.add(reserva)
            app.reservas.insert(parent='',
                                index=0,
                                values=campos_reserva_formatados(reserva),
                                iid=reserva)
            reservas_changed = True

        app.contador_reservas['text'] = fm.form_cont_reservas(
            len(estado.reservas))

        t = minutos_dia(dados_linha.horario)
        estado.linhas_possiveis.remove((dados_linha.destino.title(), t))

        estado.horarios_linhas[t] = estado.horarios_linhas.get(t, set()).union(
            {linha})
        estado.linhas_visiveis.add(linha)
        app.contador_linhas['text'] = fm.form_cont_linhas(
            len(estado.linhas_visiveis))

        app.linhas.insert(parent='',
                          index=0,
                          values=campos_linha_formatados(dados_linha),
                          iid=linha)

        data_atual = monitoradas.data_atual.replace(second=0, microsecond=0)
        minutos_atual = data_atual.hour * 60 + data_atual.minute

        if t == minutos_atual:
            periodo = range(cte.MAXIMO_NUMERO_DE_DIAS_ATE_RESERVA + 1)
        elif t < minutos_atual:
            periodo = range(1, cte.MAXIMO_NUMERO_DE_DIAS_ATE_RESERVA + 1)
        else:
            periodo = range(cte.MAXIMO_NUMERO_DE_DIAS_ATE_RESERVA)

        for d in periodo:
            partida = (data_atual + dt.timedelta(d)).replace(
                hour=dados_linha.horario.hour,
                minute=dados_linha.horario.minute)
            onibus = gerar_id_onibus(linha, partida)
            assentos = dados_linha.onibus.get(onibus, dict())
            app.linhas.insert(
                parent=linha,
                index='end',
                values=('-', fm.form_data(partida),
                        2 * int(dados_linha.fileiras) - len(assentos), '-'),
                iid=onibus)
            monitoradas.onibus_visiveis.add(onibus)
            app.contador_onibus['text'] = fm.form_cont_onibus(
                len(monitoradas.onibus_visiveis))
            estado.linhas_entradas[linha].onibus[onibus] = assentos

        app.linhas.selection_add(linha)
        app.reservas.selection_add(*reservas)

        actions += 1

    if not reservas_changed:
        app.abas.select(app.aba_linhas)

    return actions