def definirDia():
intencao = "negar"
contador = 0
perguntaPadrao = " para qual dia gostaria marcar?"
pergunta = perguntaPadrao
while intencao == "negar" and contador < 10:
frase = input(pergunta)
dia = ""
if frase is None or len(frase) == 0:
continue
if (Entidades.contemDiaSemana(frase)):
dif = Entidades.getDiferencaSemana(frase, semana)
dia = int(diaHoje) + dif
else:
dia = Entidades.descobreDia(frase)
if dia is None:
pergunta = "Não intendi direito, para qual dia voce gostaria de marcar?"
continue
if agenda.disponibilidadeDia(int(mesHoje), int(dia)) is not True:
pergunta = "Esse dia esta cheio, por favor poderia escolher outro dia?"
continue
frase = input("para o dia " + str(dia) +
" temos horario gostaria de marcar para esse dia?")
intencao = classificador.getIntencao(frase)
if (intencao == "negar"):
pergunta = "Qual o outro dia que gostaria de marcar então?"
contador = contador + 1
return dia
def updateColunasEntidadesBycAppl(self):
altEntidades = 0
altColunas = 0
returnEntidades = Entidades.Entidades(
self.db, cAppl=self.cAppl).selectEntidadesBycodigoAplicacao()
if not returnEntidades[0]:
return [0, "CE - Não existem Entidades para esta Aplicação."]
entidades = returnEntidades[1]
for entidade in entidades:
processaEntidade = self.processaEntidade(entidade)
if not processaEntidade[0]:
return [
0, "CE - Ocorreu um erro no processamento da Entidade.",
processaEntidade[1]
]
altEntidades += 1
altColunas = altColunas + processaEntidade[1]
ckListCE = self.checkList.updateCheckListColunasEntidades()
if not ckListCE[0]:
return ckListCE
self.db.commit()
return [
1,
('Colunas das Entidades Atualizadas>>>' + '\n' + ' Entidades = ' +
str(altEntidades) + '\n' + ' Colunas = ' + str(altColunas) +
'\n')
]
def loadDB(self, model):
colunas = Colunas.Colunas(self.db, cAppl=self.cAppl, model=model)
returnCode = colunas.insertColunas()
if returnCode[0]:
self.retCode.append(returnCode[1])
entidades = Entidades.Entidades(self.db,
cAppl=self.cAppl,
iderwin=self.iderwin,
model=model)
returnCode = entidades.insertEntidades()
if returnCode[0]:
self.retCode.append(returnCode[1])
colunasEntidades = ColunasEntidades.ColunasEntidades(
self.db, cAppl=self.cAppl, model=model)
returnCode = colunasEntidades.insertColunasEntidades()
if returnCode[0]:
self.retCode.append(returnCode[1])
primaryKeys = PrimaryKeys.PrimaryKeys(self.db,
cAppl=self.cAppl,
model=model)
returnCode = primaryKeys.insertPrimaryKeys()
if returnCode[0]:
self.retCode.append(returnCode[1])
foreignKeys = ForeignKeys.ForeignKeys(self.db,
cAppl=self.cAppl,
model=model)
returnCode = foreignKeys.insertForeignKeys()
if returnCode[0]:
self.retCode.append(returnCode[1])
return [1, self.retCode]
return returnCode
def insertPrimaryKeys(self):
lidos = 0
gravados = 0
entidades = Entidades.Entidades(self.db, cAppl=self.cAppl)
colunas = Colunas.Colunas(self.db, cAppl=self.cAppl)
orca = OrigemColunasAplicacao.OrigemColunasAplicacao(self.db)
lisAuto = Datatypes.Datatypes(self.db).getDatatypesNumerics()
lisAuto.append('TIMESTAMP')
generate = lambda ent: ent['Do_Not_Generate']==False
nomeFisico = lambda line: line['User_Formatted_Physical_Name']
isPk = lambda line: line['pk']==True
isFk = lambda line: line['fk']<>[]
isAuto = lambda line: line['dataType'].split('(')[0] in lisAuto
isTimestamp = lambda line: line['dataType'].split('(')[0] == 'TIMESTAMP'
for nomeFisicoEntidade in map(nomeFisico, filter(generate, self.model.getEntidades(''))):
returnEntidade = entidades.selectEntidadesByNomeFisico(nomeFisicoEntidade)
if not returnEntidade[0]:
return [0,"CE - CodigoEntidade de %s nao encontrado na Tabela Entidades." % (nomeFisicoEntidade)]
entidade = returnEntidade[1][0]
lisCols = self.model.getEntidadeColunas(nomeFisicoEntidade)
pks = filter(isPk, lisCols)
lenPk = len(pks)
qtdPk = 0
for pk in pks:
lidos += 1
qtdPk += 1
columnName = pk['nomeFisico']
returnCodigoColuna = colunas.selectColunasByColumnName(columnName)
if not returnCodigoColuna[0]:
return [0,"PK - CodigoColuna de %s nao encontrado na Tabela Colunas." % columnName \
, returnCodigoColuna[1]]
coluna = returnCodigoColuna[1][0]
codigoInsercao = 1
if not isFk(pk) and qtdPk == lenPk and isAuto(pk):
codigoInsercao = 3
if isTimestamp(pk):
orca.insertOrigemColunasAplicacao(self.cAppl, coluna.id)
try:
self.primarykeys.insert(codigoAplicacao = self.cAppl
,codigoEntidade = entidade.id
,codigoColuna = coluna.id
,codigoInsercao = codigoInsercao)
gravados = gravados +1
except:
return [0,"PK - Ocorreu um erro no Insert da Tabela PrimaryKeys.", sys.exc_info()[1]]
self.db.commit()
return [1,('Primary Keys >>>'
+ '\n' + ' Lidos = ' + str(lidos)
+ '\n' + ' Gravados = ' + str(gravados)
+ '\n')]
def definirHorario(dia):
perguntaPadrao = "Em que horario gostaria de marcar?"
pergunta = perguntaPadrao
intencao = "negar"
while intencao == "negar":
frase = input(pergunta)
if Entidades.possuiPeriodo(frase):
listaPeriodo = Entidades.getListaPeriodo(frase)
pergunta = agenda.montarHorasPorPeriodo(listaPeriodo, dia, mesHoje)
continue
else:
pergunta = "Não temos horario nesse período "
listaPeriodo = Entidades.getListaPeriodo(frase)
pergunta = agenda.getPeriodoForaDaLista(listaPeriodo, dia, mesHoje)
if Entidades.temHora(frase):
horas = Entidades.getHoras(frase)
if len(horas) == 1:
if agenda.verificaData(
str(mesHoje) + ":" + str(dia) + ":" + str(horas[0])):
frase = input("voce gostaria de marcar as " +
str(horas[0]) + " horas?")
intencao = classificador.getIntencao(frase)
if intencao == "confirmar":
return horas[0]
else:
pergunta = "Não temos disponibilidade para esse horario"
continue
else:
pergunta = "em que horario voce gostaria de marcar? "
for hora in horas:
pergunta += str(hora) + "h "
else:
pergunta = "Não intendi direito, por favor me diga um horario que gostaria de marcar"
continue
def __init__(self, db, cAppl=0, model=None):
self.db = db
self.cAppl = cAppl
self.model = model
self.entidades = Entidades.Entidades(self.db, cAppl=self.cAppl)
self.coluna = Colunas.Colunas(self.db, cAppl=self.cAppl)
self.primaryKeys = PrimaryKeys.PrimaryKeys(self.db)
self.OrigemColunasAplicacao = OrigemColunasAplicacao.OrigemColunasAplicacao(
self.db)
self.regra = Regras.Regras(self.db).getRegras(1)
self.checkList = CheckList.CheckList(self.db, cAppl=self.cAppl)
self.colunasEntidades = self.db.colunasEntidades
self.datatypes = self.db.datatypes
self.colunas = self.db.colunas
def updateColunasEntidadesByCodigoEntidade(self, codigoEntidade):
altEntidades = 0
altColunas = 0
returnEntidades = Entidades.Entidades(
self.db).selectEntidadesByEntidadeId(codigoEntidade)
if not returnEntidades[0]:
return [0, "CE - Não existem Entidades para esta Aplicação."]
entidade = returnEntidades[1][0]
procEntidade = self.processaEntidade(entidade)
if not procEntidade[0]:
return [
0, "CE - Ocorreu um erro no processamento da Entidade.",
procEntidade[1]
]
altEntidades += 1
altColunas = altColunas + procEntidade[1]
self.db.commit()
return [
1,
('updateColunasEntidades >>>' + '\n' + 'Entidades = ' +
str(altEntidades) + '\n' + 'Colunas = ' + str(altColunas) +
'\n')
]
def __init__(self
, db
, cAppl=None
, entidadeId=None
, objetivo=None
, pgmid=None
, servico=None
, tppgm=None
, userName=None
):
self.cAppl = cAppl or 0
self.entidadeId = entidadeId or 0
self.objetivo = objetivo or 'OBJETIVO'
self.pgmid = pgmid.upper() or 'XXX'
self.servico = servico.upper() or 'SERVICO'
self.tppgm = tppgm or 0
self.userName = userName.upper() or 'USER ADMIN'
self.aplicacao = Aplicacao(db, self.cAppl)
self.empresa = Empresa(db, self.aplicacao.getEmpresaId())
self.Entidade = Entidades(db, cAppl=self.cAppl)
self.entidade = self.Entidade.selectEntidadesByEntidadeId(self.entidadeId)[1][0]
self.parametros = db.parametros
self.parms = db(self.parametros).select()[0]
def insertForeignKeys(self):
lidos = 0
gravados = 0
entidades = Entidades.Entidades(self.db, cAppl=self.cAppl)
colunas = Colunas.Colunas(self.db, cAppl=self.cAppl)
generate = lambda ent: ent['Do_Not_Generate'] == False
nomeFisico = lambda line: line['User_Formatted_Physical_Name']
isFk = lambda line: line['fk'] <> []
nomeFisicoEntidades = map(
nomeFisico, filter(generate, self.model.getEntidades('')))
for nomeFisicoEntidade in nomeFisicoEntidades:
returnEntidade = entidades.selectEntidadesByNomeFisico(
nomeFisicoEntidade)
if not returnEntidade[0]:
return [
0,
"CE - CodigoEntidade de %s nao encontrado na Tabela Entidades."
% (nomeFisicoEntidade)
]
codigoEntidade = returnEntidade[1][0].id
lisCols = self.model.getEntidadeColunas(nomeFisicoEntidade)
fks = filter(isFk, lisCols)
for fk in fks:
lidos = lidos + 1
colunaForeignKey = fk['nomeFisico']
colunaReferenciada = fk['fk'][0][0]
nomeFisicoEntRef = fk['fk'][0][1]
if not nomeFisicoEntRef in nomeFisicoEntidades:
continue
else:
returnEntidadeReferenciada = entidades.selectEntidadesByNomeFisico(
nomeFisicoEntRef)
if not returnEntidadeReferenciada[0]:
return [0,"CodigoEntidade de " + nomeFisico + " nao encontrado na Tabela Entidades." \
, returnEntidadeReferenciada[1]]
codigoEntidadeReferenciada = returnEntidadeReferenciada[1][
0].id
returnColuna = colunas.selectColunasByColumnName(
colunaForeignKey)
if not returnColuna[0]:
return [0,"FK1 - CodigoColuna de " + colunaForeignKey + " nao encontrado na Tabela Colunas." \
, returnColuna[1]]
codigoColuna = returnColuna[1][0].id
if colunaForeignKey == colunaReferenciada:
codigoColunaReferenciada = codigoColuna
else:
returnColunaReferenciada = colunas.selectColunasByColumnName(
colunaReferenciada)
if not returnColunaReferenciada[0]:
return [0,"FK2 - CodigoColuna de " + colunaReferenciada + " nao encontrado na Tabela Colunas." \
, returnColunaReferenciada[1]]
codigoColunaReferenciada = returnColunaReferenciada[1][
0].id
try:
self.foreignkeys.insert(
codigoEntidade=codigoEntidade,
codigoColuna=codigoColuna,
codigoEntidadeReferenciada=
codigoEntidadeReferenciada,
codigoColunaReferenciada=codigoColunaReferenciada,
ativo=True)
gravados = gravados + 1
except:
return [
0,
"Ocorreu um erro no Insert da Tabela ForeignKeys.",
sys.exc_info()[1]
]
self.db.commit()
return [
1,
('Foreign Keys >>>' + '\n' + ' Lidos = ' + str(lidos) + '\n' +
' Gravados = ' + str(gravados) + '\n')
]
if erro > 2:
print("Perdeu suas chances:")
print("Resposta: \n", answer)
terminarPartida = True #terminar partida após 3 erros
break
print("\n\n ----------- Errado-------------")
tocar(answer)
attempt = list(input("tente novamente: "))
if terminarPartida == True: #terminar partida após 3 erros
break
print("\n\n ---------------Acertou!!-------------")
lista = answer
limpar_tela() ## limpar tela após acertar
pontuacao = ((len(lista)) - 1) * 10
jogador = Entidades.jogadores(nome, pais, pontuacao)
ranking.insert(jogador)
print("Dados da partida:")
print(jogador)
asr = input("\n Quer outra partida? sim / nao \n")
# FIM DA RODADA E MOSTRA DO RESULTADOS
print("__________RANKING________")
ranking.emOrdem(ranking.getRoot())
print("\n---------VENCEDOR DA RODADA-----------")
vencedor = ranking.maxx(ranking.getRoot()) #FOLHA A DIREITA
print(vencedor)
print("---- PARABENS------")
]
stationFields = ['station_id', 'install_dockcount']
trip = pd.read_csv('data/trip.csv', sep=',',
names=tripFields) # read data trips
# startTimes = [ utils.strToDatetime(date_str).timestamp() for date_str in trip[:25000].starttime.values ]
# utils.plotHistogram(startTimes,'Tempos de chegada')
# tripDurations = [ float(milisec.replace('.','')) for milisec in trip[:25000].tripduration.values ] # get 25000 tripduration in milisec
# utils.plotHistogram(tripDurations,'Tempo de viagens')
# simulation
env = simpy.Environment()
e1 = Entidades.Estacao(env, 'CBD-06', simpy.Resource(env, capacity=5))
cont = 0
usuarios = list()
for registry in trip[:7].values:
cont += 1
nomeUsuario = 'Usuario' + str(cont)
tempoChegada = utils.strToDatetime(registry[0]).timestamp()
tempoViagem = utils.strSecToMilisec(registry[3])
print(nomeUsuario, tempoChegada, tempoViagem, sep=',')
usuarios.append(
Entidades.Usuario(env, nomeUsuario, tempoChegada, tempoViagem))
for usuario in usuarios:
env.process(e1.emprestaBicicleta(usuario))
class cabecalhoPGM(object):
def __init__(self
, db
, cAppl=None
, entidadeId=None
, objetivo=None
, pgmid=None
, servico=None
, tppgm=None
, userName=None
):
self.cAppl = cAppl or 0
self.entidadeId = entidadeId or 0
self.objetivo = objetivo or 'OBJETIVO'
self.pgmid = pgmid.upper() or 'XXX'
self.servico = servico.upper() or 'SERVICO'
self.tppgm = tppgm or 0
self.userName = userName.upper() or 'USER ADMIN'
self.aplicacao = Aplicacao(db, self.cAppl)
self.empresa = Empresa(db, self.aplicacao.getEmpresaId())
self.Entidade = Entidades(db, cAppl=self.cAppl)
self.entidade = self.Entidade.selectEntidadesByEntidadeId(self.entidadeId)[1][0]
self.parametros = db.parametros
self.parms = db(self.parametros).select()[0]
def montaCabecalho(self):
dic = {}
dic['@ANALISTA'] = utl.remover_acentos(self.aplicacao.getAnalista()
+ '/' + self.empresa.getNome()).upper()
dic['@APPLID'] = self.aplicacao.getApplId().upper()
dic['@APPLNAME'] = utl.remover_acentos(self.aplicacao.getApplName()).upper()
dic['@AUTHOR'] = utl.remover_acentos(self.userName
+ '/' + self.aplicacao.getContratante()).upper()
dic['@DATE'] = date.today().strftime('%d/%m/%Y')
dic['@EMPRESA'] = utl.remover_acentos(self.empresa.getDescricao()).upper()
dic['@ENTIDADE0'] = self.entidade.nomeExterno + ' - ' + self.entidade.nomeFisico
dic['@ENTIDADE1'] = self.entidade.nomeAmigavel.upper()[:45]
dic['@ENTIDADE2'] = self.entidade.nomeAmigavel.upper()[45:]
dic['@GRUPO'] = self.aplicacao.getGrupo()
dic['@OBJETIVO'] = self.objetivo.upper()
dic['@PGMID'] = str(self.pgmid)
dic['@SERVICO'] = self.servico.upper()
dic['@TPPGM'] = str(self.tppgm)
query = db((db.tools.ferramenta == 'ADS_IDMS')
& (db.parametros.tool == db.tools.id)).select()[0]
template = os.path.join(query.parametros.drive + ':'
,os.sep
,query.parametros.web2py
,'applications'
,query.parametros.application
,'Templates'
,query.tools.ferramenta
,'cabecPgm.CBL')
with open(template) as f:
templ=str(f.read())
return utl.change(dic, templ)
def index():
if request.vars:
idaplicacao = int(request.vars.aplicacao_id or 0)
else:
idaplicacao = int(session.aplicacao_id or 0)
if session.aplicacao_id <> idaplicacao:
session.aplicacao_id = idaplicacao
redirect(URL('index'))
else:
cl = db(db[checkList].codigoAplicacao == idaplicacao).select()
if cl:
idcheckList = cl[0].id
else:
idcheckList = 0
form = SQLFORM(checkList, idcheckList, hidden=dict(codigoAplicacao=\
idaplicacao))
form.vars.usuarioConfirmacao = auth.user.id
form.vars.dataConfirmacao = datetime.datetime.today()
if form.accepts(request.vars, session):
if request.vars.has_key('delete_this_record') and \
request.vars.delete_this_record == 'on':
session.flash = 'CheckList Excluido'
redirect(URL('index'))
else:
if idcheckList:
if request.vars.aplicacao and not \
request.vars.entidades and not \
request.vars.colunas and not \
request.vars.regrasColunas and not \
request.vars.origemColunas:
ents = Entidades.Entidades(db, cAppl=idaplicacao)
rets = ents.updateEntidadesXprogramas()
msgerrors = {}
idx = 0
for line in rets[1].split('\n'):
if line:
idx += 1
msgerrors[idx] = line
session.labelErrors = \
'Atualização dos:'
session.msgsErrors = msgerrors
session.flash = 'CheckList Alterado'
redirect(URL('index', args=(idcheckList)))
else:
response.flash = 'CheckList Incluído'
if session.flash:
response.flash = session.flash
session.flash = None
if session.labelErrors:
form.labelErrors = session.labelErrors
session.labelErrors = None
if session.msgsErrors:
form.errors = session.msgsErrors
session.msgsErrors = None
query = db[checkList].codigoAplicacao<0 if not idcheckList else \
db[checkList].codigoAplicacao==idaplicacao
return dict(listdetail.index(['CheckList',
'<br/>Aplicacao:',
str(utl.Select(db,
name='aplicacao_id',
table='aplicacoes',
fields=['id','descricao'],
filtro='' if (auth.user) and \
(auth.has_membership(1,\
auth.user.id, \
'Administrador')) \
else db['aplicacoes'].\
empresa==auth.user.\
empresa, \
value=session.aplicacao_id or 0))],
'checkList', checkList,
query,
form, fields=[],
noDetail=['codigoAplicacao'],
scroll=[],
width_label='45%',
width_field='55%',
optionDelete=False,
buttonClear=False,
buttonSubmit=True))
