def get(self, contato_id):
conexao = Conexao("agenda")
id_usuario = self.get_secure_cookie("cookieagenda").decode("utf-8")
contato = conexao.busca_contato(id_usuario, contato_id)
self.render("atualiza_contato.html", contato=contato)
class processaSql:
con = None
def __init__(self):
self.con = Conexao()
return
def getDadosPullRequestSql(self, id):
qb = self.con.qb('prod_t1')
return qb.table('repositorio_pull').where('repositorioPullId', id)
def getContributorSql(self, login):
qb = self.con.qb('prod_t1')
return qb.table('contributor').where('contributorLogin', login)
def getRepositorioSql(self, id):
qb = self.con.qb('prod_t1')
return qb.table('repositorio').where('repositorioId', id)
def getCommitSql(self, sha):
qb = self.con.qb('prod_t1')
return qb.table('repositorio_branch_commit').where('repositorioBranchCommitSha', sha)
def getBranchSql(self, name):
qb = self.con.qb('prod_t1')
return qb.table('repositorio_branch').where('repositorioBranchNome', name)
def delete(self, contato_id):
conexao = Conexao("agenda")
id_usuario = self.get_secure_cookie("cookieagenda").decode("utf-8")
conexao.deleta_contato(id_usuario, contato_id)
self.write("ok")
def put(self, contato_id):
conexao = Conexao("agenda")
id_usuario = self.get_secure_cookie("cookieagenda").decode("utf-8")
json_data = json.loads(self.request.body.decode("utf-8"))
print(json_data)
contato = Contato(contato_id, json_data["nome"], json_data["telefone"],
json_data["email"], json_data["complemento"])
conexao.atualizar_contato(id_usuario, contato)
self.render("atualiza_contato.html", contato=contato)
def consultar_ultimo_id(self):
conn = Conexao()
conexao = conn.conectar()
cursor = conexao.cursor()
try:
resultset = cursor.execute('SELECT MAX(id) FROM aluno').fetchone()
except Error as e:
print(f"O erro '{e}' ocorreu.")
cursor.close()
conexao.close()
return resultset[0]
def post(self):
conexao = Conexao("agenda")
nome = self.get_argument("usuario")
senha = self.get_argument("senha")
usuario = conexao.busca_usuario(nome, senha)
if usuario:
self.set_secure_cookie("cookieagenda", str(usuario["_id"]))
self.redirect("/")
else:
self.render("autenticar.html", teste="invalido")
def consultar(self):
conn = Conexao()
conexao = conn.conectar()
cursor = conexao.cursor()
try:
resultset = cursor.execute(
'SELECT * FROM aluno ORDER BY nome').fetchall()
except Error as e:
print(f"O erro '{e}' ocorreu.")
cursor.close()
conexao.close()
return resultset
def consultar_detalhes(self, id_aluno):
conn = Conexao()
conexao = conn.conectar()
cursor = conexao.cursor()
try:
resultset = cursor.execute('SELECT * FROM aluno WHERE id = ?',
(id_aluno, )).fetchone()
except Error as e:
print(f"O erro '{e}' ocorreu.")
cursor.close()
conexao.close()
return resultset
def buscar(self, name):
conn = Conexao()
conexao = conn.conectar()
cursor = conexao.cursor()
try:
resultset = cursor.execute(
'SELECT * FROM aluno WHERE nome LIKE ' % ' ORDER BY nome',
(name, )).fetchall()
except Error as e:
print(f"O erro '{e}' ocorreu.")
cursor.close()
conexao.close()
return resultset
def post(self):
conexao = Conexao("agenda")
nome = self.get_argument("nomecontato")
telefone = self.get_argument("telefone")
email = self.get_argument("email")
complemento = self.get_argument("complemento")
contato = Contato(nome_contato=nome,
telefone=telefone,
email=email,
complemento=complemento)
id_usuario = self.get_secure_cookie("cookieagenda").decode("utf-8")
conexao.inserir_contato(id_usuario, contato)
self.redirect("/")
def main():
classifyDocuments = ClassifyDocuments()
classifyDocuments.inicio = strftime("%Y-%m-%d %H:%M:%S", gmtime())
print("Início do script")
print(classifyDocuments.inicio)
sys.path.append(os.path.abspath("../"))
from conexao import Conexao
classifyDocuments.conexao = Conexao()
classifyDocuments.preparar_dados_temporarios()
lista = [
'opiniao', 'com_sem_opiniao', 'saude', 'educacao', 'seguranca',
'vale_paranhana'
]
#lista = ['opiniao', 'seguranca', 'vale_paranhana']
#lista = ['saude', 'educacao', 'seguranca', 'vale_paranhana']
#lista = ['vale_paranhana']
#lista = ['opiniao']
classifyDocuments.obterUltimoLote()
for item in lista:
classifyDocuments.aplicar_classificador(item)
print("Início do script")
print(classifyDocuments.inicio)
print("Fim do script")
classifyDocuments.fim = strftime("%Y-%m-%d %H:%M:%S", gmtime())
print(classifyDocuments.fim)
classifyDocuments.atualizarExperimentosEmLote()
classifyDocuments.remover_dados_temporarios()
def busca_pedidos(self, busca):
import datetime
conecta = Conexao()
c = conecta.conecta.cursor()
try:
c.execute(
""" SELECT pedidos.*, clientes.nome, status_pedido.status_pedido FROM pedidos
INNER JOIN clientes ON pedidos.cliente = clientes.id_cliente
INNER JOIN status_pedido ON pedidos.status = status_pedido.cod_status_pedido
""")
self.cod_pedido = []
self.cliente = []
self.status_pedido = []
self.data_entrega = []
self.entrada = []
self.saldo_devedor = []
self.valor_total = []
for linha in c.fetchall():
self.cod_pedido.append(linha[0])
self.cliente.append(linha[7])
self.status_pedido.append(linha[8])
self.data_entrega.append(
datetime.date.strftime(linha[2], "%d-%m-%Y"))
self.entrada.append(linha[4])
self.saldo_devedor.append(linha[5])
self.valor_total.append(linha[6])
except mysql.connector.Error as err:
print err
def buscar_usuarios_selecionado(self, cod):
conecta = Conexao()
c = conecta.conecta.cursor()
try:
c.execute(
""" SELECT * FROM usuarios WHERE id_user = '******' """.format(
cod))
for linha in c.fetchall():
self.id_usuario = linha[0]
self.usuario = linha[1]
self.senha = linha[2]
self.nome_usuario = linha[3]
self.sobremone = linha[4]
self.telefone = linha[5]
self.cpf = linha[6]
self.endereco = linha[7]
self.num = linha[8]
self.bairro = linha[9]
self.comeplemento = linha[10]
self.cep = linha[11]
self.referencia = linha[12]
self.cidade = linha[13]
self.estado = int(linha[14])
self.nivel = linha[15]
self.status = linha[16]
c.close()
except mysql.connector.Error as err:
print err
def cadastro_usuarios(self):
conecta = Conexao()
c = conecta.conecta.cursor()
try:
c.execute(
""" INSERT INTO usuarios (id_user, usuario, nome, sobrenome, telefone, cpf, endereco, num, bairro,
complemento, cep, referencia, cidade, estado, nivel, status)
VALUES ('{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}', '{}',
'{}', '{}', '{}', '{}', '{}', '{}', '{}')
ON DUPLICATE KEY UPDATE usuario='{}', nome='{}', sobrenome='{}', telefone='{}', cpf='{}',
endereco='{}', num='{}', bairro='{}', complemento='{}', cep='{}', referencia='{}', cidade='{}', estado='{}',
nivel='{}', status='{}'
""".format(self.id_usuario, self.usuario, self.nome_usuario,
self.sobremone, self.telefone, self.cpf, self.endereco,
self.num, self.bairro, self.comeplemento, self.cep,
self.referencia, self.cidade, self.estado, self.nivel,
self.status, self.usuario, self.nome_usuario,
self.sobremone, self.telefone, self.cpf, self.endereco,
self.num, self.bairro, self.comeplemento, self.cep,
self.referencia, self.cidade, self.estado, self.nivel,
self.status))
conecta.conecta.commit()
c.close()
# print self.id_usuario
# print self.estado
# print self.id_usuario
except mysql.connector.Error as err:
print err
def post(self):
conexao = Conexao("agenda")
usuario = self.get_argument("nomeusuario")
senha = self.get_argument("senhausuario")
usuarios = conexao.busca_nome_usuario(usuario)
print("AQUI")
if usuarios:
print("usuario existe")
self.render("cadastro.html")
else:
print("usuario ok")
novo_usuario = Usuario(nome_usuario=usuario, senha=senha)
conexao.inserir_usuario(novo_usuario)
self.redirect("/autenticar")
def conectar(self):
data = "%d/%d/%d" % (datetime.today().day, datetime.today().month,
datetime.today().year)
hora = "%d:%d" % (datetime.today().hour, datetime.today().minute)
self.conexao = Conexao(self.nome_de_guerra,
data=data,
hora_inicio=hora)
self.esta_conectado = True
def consultar_por_matricula(self, matri):
conn = Conexao()
conexao = conn.conectar()
cursor = conexao.cursor()
sql = """SELECT e.id, e.nome, e.idade, e.cpf, e.matricula, e.email, e.endereco
FROM aluno as e
WHERE matricula = ?"""
resultset = None
try:
resultset = cursor.execute(sql, (matri, )).fetchall()
except Error as e:
print(f"O erro '{e}' ocorreu.")
cursor.close()
conexao.close()
return resultset
def consultar_por_matricula(self, matri):
conn = Conexao()
conexao = conn.conectar()
cursor = conexao.cursor()
sql = """SELECT n.fk_aluno_id, n.fk_disciplina_id, n.av1, n.av2, n.av3, n.media
FROM nota as n
WHERE fk_aluno_id = ?"""
resultset = None
try:
resultset = cursor.execute(sql, (matri, )).fetchall()
except Error as e:
print(f"O erro '{e}' ocorreu.")
cursor.close()
conexao.close()
return resultset
def append_conexoes(camada, num):
peso = 0.0
for neuronio in camada:
for j in range(num):
peso = round(random.uniform(0.0, 1.0), 3)
if (peso == 0.0): # no pode ser exatamente 0
peso = 0.1
elif (peso == 1.0): # nem exatamente 1
peso = 0.90
neuronio.conexoes.append(Conexao(peso))
def busca_cpf(self, cpf):
try:
conexao = Conexao().get_connection()
cursor = conexao.cursor()
busca = "select * from pessoas where cpf = '{0}'".format(cpf)
cursor.execute(busca)
pessoas = cursor.fetchall()
if len(pessoas) >= 1:
return True
else:
return False
except (Exception, psycopg2.DatabaseError) as error:
print("Oppss! Algum erro aconteceu :/", error)
finally:
if (conexao):
cursor.close()
conexao.close()
def excluir(self, id_aluno):
try:
conn = Conexao()
conexao = conn.conectar()
cursor = conexao.cursor()
sql = 'DELETE FROM aluno WHERE id = (?)'
cursor.execute(sql, [id_aluno])
conexao.commit()
cursor.close()
conexao.close()
return True
except sqlite3.OperationalError as e:
print("Erro na exclusão de aluno: {}".format(e))
return False
except sqlite3.IntegrityError as e:
print("Erro de integridade: {}".format(e))
return False
def combobox_nivel(self):
conecta = Conexao()
c = conecta.conecta.cursor()
try:
c.execute(""" SELECT * FROM nivel_acesso """)
self.lst_nivel = []
for linha in c.fetchall():
self.lst_nivel.append(linha[1])
except mysql.connector.Error as err:
print err
def cadastrar(self, nome, idade, cpf, matricula, email, endereco):
try:
conn = Conexao()
conexao = conn.conectar()
cursor = conexao.cursor()
sql = 'INSERT INTO aluno (nome,idade,cpf,matricula,email,endereco) VALUES (?,?,?,?,?,?)'
cursor.execute(sql, (nome, idade, cpf, matricula, email, endereco))
conexao.commit()
cursor.close()
conexao.close()
return True
except sqlite3.OperationalError as e:
print("Erro no cadastro de aluno: {}".format(e))
return False
except sqlite3.IntegrityError as e:
print("Erro de integridade: {}".format(e))
return False
def busca_pessoa_cpf(self, cpf):
try:
conexao = Conexao().get_connection()
cursor = conexao.cursor()
busca = "select * from pessoas where cpf like '%{0}%' and status = 1".format(
cpf)
cursor.execute(busca)
pessoas = cursor.fetchall()
for i in pessoas:
print("Nome: ", i[1])
print("CPF: ", i[0])
print("E-mail: ", i[2])
except (Exception, psycopg2.DatabaseError) as error:
print("Oppss! Algum erro aconteceu :/", error)
finally:
if (conexao):
cursor.close()
conexao.close()
def atualizar(self, fk_aluno_id, fk_disciplina_id, av1, av2, av3, media):
try:
conn = Conexao()
conexao = conn.conectar()
cursor = conexao.cursor()
sql = 'UPDATE nota SET fk_aluno_id = ?, fk_disciplina_id = ?, av1 = ?, av2 = ?, av3 = ?, media = ? WHERE fk_aluno_id = (?)'
cursor.execute(
sql, (fk_aluno_id, fk_disciplina_id, av1, av2, av3, media))
conexao.commit()
cursor.close()
conexao.close()
return True
except sqlite3.OperationalError as e:
print("Erro na atualização de aluno: {}".format(e))
return False
except sqlite3.IntegrityError as e:
print("Erro de integridade: {}".format(e))
return False
def cadastrar(self, fk_aluno_id, fk_disciplina_id, av1, av2, av3, media):
try:
conn = Conexao()
conexao = conn.conectar()
cursor = conexao.cursor()
sql = 'INSERT INTO nota (fk_aluno_id,fk_disciplina_id,av1,av2,av3,media) VALUES (?,?,?,?,?,?)'
cursor.execute(
sql, (fk_aluno_id, fk_disciplina_id, av1, av2, av3, media))
conexao.commit()
cursor.close()
conexao.close()
return True
except sqlite3.OperationalError as e:
print("Erro no cadastro de aluno: {}".format(e))
return False
except sqlite3.IntegrityError as e:
print("Erro de integridade: {}".format(e))
return False
def alterar_senha(self):
conecta = Conexao()
c = conecta.conecta.cursor()
try:
c.execute(
""" UPDATE usuarios SET senha='{}' WHERE id_user='******' """.
format(self.senha, self.id_usuario))
conecta.conecta.commit()
# print self.senha
# print self.id_usuario
except mysql.connector.Error as err:
print err
def consultar(self):
try:
conexao = Conexao().conexaoDatabase()
cursor = conexao.cursor()
select = f"SELECT * FROM aluno;"
cursor.execute(select)
aluno = cursor.fetchall()
if len(aluno):
return aluno
else:
return "Nenhum registro foi encontrado"
except (Exception, psycopg2.Error) as error:
print("\nFalha ao consultar o registro\n", error)
finally:
if (conexao):
cursor.close()
conexao.close()
print("A conexão com PostgreSQL foi encerrada\n")
class BuscaDados:
server = ".\SQLEXPRESS"
database = "STAGE_AREA"
username = "******"
password = "******"
string_conexao = 'Driver={SQL Server Native Client 11.0};Server=' + server + ';Database=' + database + ';Trusted_Connection=yes;'
con = Conexao(string_conexao)
sql = "SELECT * FROM STG_LOJAS "
rs = con.consultar("SELECT * FROM STG_LOJAS")
for linha in rs:
print(linha.EMPRESA_USUARIA)
con.fechar()
class Contato(object):
def __init__(self):
self.con = Conexao()
def criar_contato(self):
self.cursor = self.con.cursor()
try:
self.nome = raw_input("Entre com um nome: ")
self.endereco = raw_input("Entre com o endereco: ")
self.cursor.execute("INSERT INTO contato (nome, endereco) VALUES ('{0}', '{1}')".format(self.nome, self.endereco))
self.con.salvar_no_banco() # salvar as alteracoes no banco
print "Dados {0} || {1} inseridos com sucesso".format(self.nome, self.endereco)
except MySQLdb.IntegrityError:
logging.warn("Falha ao tentar inserir os valores: {0}, {1}".format(self.nome, self.endereco))
finally:
self.cursor.close()
def listar_contatos(self):
self.cursor = self.con.cursor()
print "Buscando dados.:"
dados = self.cursor.execute("SELECT * FROM contato")
if dados:
for linha in self.cursor.fetchall():
print "ID: {0}\nNome: {1}\nEndereco: {2}\n\n".format(linha[0], linha[1], linha[2])
else:
print "Nenhum dado encontrado"
self.cursor.close()
## TODO Implementar os metodos exluir e editar, e fazer verificacao de entrada.
def fechar_agenda(self):
self.con.fechar_conexao()
def atualizar(self, id_aluno, nome, idade, cpf, matricula, email,
endereco):
try:
conn = Conexao()
conexao = conn.conectar()
cursor = conexao.cursor()
sql = 'UPDATE aluno SET nome = ?, idade = ?, cpf = ?, matricula = ?, email = ?, endereco = ? WHERE id = (?)'
cursor.execute(
sql, (nome, idade, cpf, matricula, email, endereco, id_aluno))
conexao.commit()
cursor.close()
conexao.close()
return True
except sqlite3.OperationalError as e:
print("Erro na atualização de aluno: {}".format(e))
return False
except sqlite3.IntegrityError as e:
print("Erro de integridade: {}".format(e))
return False
def cad_pedido(self):
conecta = Conexao()
c = conecta.conecta.cursor()
try:
c.execute(
""" INSERT INTO pedidos VALUES ('{}', '{}', '{}', '{}', '{}', '{}', '{}') """
.format(self.cod_pedido, self.cliente, self.data_entrega,
self.status_pedido, self.entrada, self.saldo_devedor,
self.valor_total))
conecta.conecta.commit()
c.close()
except mysql.connector.Error as err:
print err
def __init__(self):
self.con = Conexao()
return
import sys
sys.path.append("./negocio")
sys.path.append("./persistencia")
from cliente import Cliente #negocio
from dependente import Dependente #negocio
from clienteDAO import ClienteDAO #persistencia
from dependenteDAO import DependenteDAO #persistencia
from conexao import Conexao #persistencia
# http://initd.org/psycopg/
conexao = Conexao("trabalho")
clienteDAO = ClienteDAO(conexao)
vetCliente = clienteDAO.listaTodos()
cliente = vetCliente[5]
print str(cliente.id) + ":" + cliente.nome
for dep in cliente.vetDependente:
print str(dep.id) + ":" + dep.nome
novoCliente = Cliente("Novo Igor", "Novo Quiosque", 1111111)
novoCliente.adicionarDependente(Dependente("dep 1 de 10", "trans"))
clienteDAO.inserir(novoCliente)
novoDependente = Dependente("deve dar erro", "hercules")
novoDependente.cliente = novoCliente
DependenteDAO(conexao).inserir(novoDependente)
from conexao import Conexao from modelos import DecEixoYPesq conexao = Conexao() conexao.user = "******" conexao.psw = "1234" conexao.host = "localhost" conexao.port = "3306" # Qual base de dados? adicionar_na_base_dados = 'cli_apres' # Qual o id do Dec id_dec = 1 # Quais os ids dos itens do Dec lista_id_itens = [1, 2, 3, 4, 5, 6, 7, 8, 9] # Ative apenas quando não quiser manter os registros anteriores remover_registros_anteriores = False # Define quais serão os criterios da busca # Criterios | Lig/Des | 1ª / 2ª adicionar_alvo = True # 1 / 1 adicionar_6_primeiros = True # 0 / 5 adicionar_3_primeiros = True # 50 / 20 adicionar_6_ultimos = False # 20 / 0 adicionar_3_ultimos = False # 10 / 0 # Ids dos três/seis primeiros itens id_dec_1_item = 1
def __init__(self):
self.con = Conexao()
self.sql = processaSql()
class processaDados:
con = None
sql = None
def __init__(self):
self.con = Conexao()
self.sql = processaSql()
def getDadosPullRequest(self, data):
pullRequest = data['pull_request']
id = pullRequest['id']
name = pullRequest['title']
merged = 'M' if pullRequest['merged'] == True else 'N'
retorno = {
'titulo': name,
'id' : id
}
dadosPullRequest = self.con.execLinha(self.sql.getDadosPullRequestSql(id))
#Pull Request already exists
if len(dadosPullRequest) > 0 :
retorno['repositorioPullCod'] = dadosPullRequest['repositorioPullCod']
CrudUtil('prod_t1').update('repositorio_pull', {'repositorioPullCod': dadosPullRequest['repositorioPullCod']}, {
'repositorioPullStatus': merged
})
else:
user = self.getDadosUser(pullRequest['user'])
repo = self.getDadosRepo(data['repository'])
repositorioPullCod = CrudUtil('prod_t1').insert('repositorio_pull', {
'repositorioCod': repo['repositorioCod'],
'contributorCod': user['contributorCod'],
'repositorioPullId': pullRequest['id'],
'repositorioPullTitulo': pullRequest['title'],
'repositorioPullMensagem': pullRequest['body'],
'repositorioPullUrl': pullRequest['url'],
'repositorioPullMesclavel': 'S' if pullRequest['mergeable'] == 'true' else 'N',
'repositorioPullComentarios': pullRequest['comments'],
'repositorioPullCommits': pullRequest['commits'],
'repositorioPullAdicoes': pullRequest['additions'],
'repositorioPullRemocoes': pullRequest['deletions'],
'repositorioPullArquivosAlterados': pullRequest['changed_files'],
'repositorioPullData': pullRequest['created_at'][0:10],
'repositorioPullDataMerged': None if type(pullRequest['merged_at']) != str else pullRequest['merged_at'][0:10],
'repositorioPullStatus': merged,
})
retorno['repositorioPullCod'] = repositorioPullCod
return retorno
def getDadosUser(self, userData):
if 'login' in userData:
login = userData['login']
id = userData['id']
retorno = {
'login' : login,
'id' : id
}
contributor = self.con.execLinha(self.sql.getContributorSql(login))
else:
userName = userData['name']
email = userData['email']
retorno = {
'userName' : userName,
'email' : email
}
contributor = self.con.execLinha(self.sql.getContributorSql(userName))
#User already exists
if len(contributor) > 0:
retorno['contributorCod'] = contributor['contributorCod']
retorno['contributorNome'] = contributor['contributorNome']
else:
urlUserAPI = userData['url'] if 'url' in userData else 'https://api.github.com/users/'. userData['userName']
dadosUser = self.getDadosApi(urlUserAPI)
contributorCod = CrudUtil('prod_t1').insert('contributor', {
'contributorNome' : dadosUser['name'],
'contributorLogin': dadosUser['login'],
'contributorId': dadosUser['id'],
'contributorEmail': dadosUser['email'],
'contributorAvatar': dadosUser['avatar_url'],
'contributorUrl': dadosUser['html_url'],
'contributorLocation': dadosUser['location'],
'contributorUltimaAtualizacao': dadosUser['updated_at'][0:10],
})
retorno['contributorCod'] = contributorCod
retorno['contributorNome'] = dadosUser['name']
return retorno
def getDadosRepo(self, repoData):
id = repoData['id']
name = repoData['name']
fullName = repoData['full_name']
retorno = {
'repositorioNome' : name,
'repositorioFullName': fullName,
'repositorioId': id,
}
repositorio = self.con.execLinha(self.sql.getRepositorioSql(id))
#Repo already exists
if len(repositorio) > 0:
retorno['repositorioCod'] = repositorio['repositorioCod']
retorno['repositorioNome'] = repositorio['repositorioNome']
else:
urlRepoAPI = 'https://api.github.com/repos/'+ repoData['full_name']
dadosRepo = self.getDadosApi(urlRepoAPI)
dadosOwner = self.getDadosUser(dadosRepo['owner'])
repositorioCod = CrudUtil('prod_t1').insert('repositorio', {
'repositorioOwnerCod' : dadosOwner['contributorCod'],
'repositorioId' : dadosRepo['id'],
'repositorioNome' : dadosRepo['name'],
'repositorioFullName' : dadosRepo['full_name'],
'repositorioDescricao' : dadosRepo['description'],
'repositorioPrivado' : 'S' if dadosRepo['private'] == True else 'N',
'repositorioUrl' : dadosRepo['html_url'],
'repositorioUrlTeam' : dadosRepo['teams_url'],
'repositorioUrlBranches' : dadosRepo['branches_url'],
'repositorioDataCriacao' : dadosRepo['created_at'][0:10],
'repositorioDataUltimaAtualizacao' : dadosRepo['updated_at'][0:10],
})
retorno['repositorioCod'] = repositorioCod
return retorno
def getStatsPull(self, commitsUrl):
commits = self.getDadosApi(commitsUrl)
files = 0
add = 0
deleted = 0
for commit in commits:
dados = self.getDadosApi(commit['url'])
files += len(dados['files'])
add += dados['stats']['additions']
deleted += dados['stats']['deletions']
return {
'files' : files,
'add' : add,
'del' : deleted
}
def getBranches(self, repositorioCod, branches_url):
dadosBranches = self.getDadosApi(branches_url)
branches = {}
for branch in dadosBranches:
branches[branch['name']] = self.setBranches(repositorioCod, branch)
return branches
def setBranches(self, repositorioCod, dados):
name = dados['name']
retorno = {
'branchNome': name
}
branch = self.con.execLinha(self.sql.getBranchSql(name))
if len(branch) > 0:
retorno['repositorioBranchCod'] = branch['repositorioBranchCod']
repositorioBranchCod = branch['repositorioBranchCod']
else:
repositorioBranchCod = CrudUtil('prod_t1').insert('repositorio_branch', {
'repositorioCod' : repositorioCod,
'repositorioBranchNome': name,
'repositorioBranchStatus': "A"
})
retorno['repositorioBranchCod'] = repositorioBranchCod
retorno['commits'] = {
dados['commit']['sha'] : self.getBranchCommits(repositorioBranchCod, dados['commit'])
}
return retorno
def getBranchCommits(self, repositorioBranchCod, dados):
sha = dados['sha']
retorno = {
'sha': sha
}
commit = self.con.execLinha(self.sql.getCommitSql(sha))
#commitexists
if len(commit) > 0:
print str(commit)
retorno['repositorioBranchCommitCod'] = commit['repositorioBranchCommitCod']
else:
dadosCommit = self.getDadosApi(dados['url'])
contributor = self.getDadosUser(dadosCommit['author'])
commitDataHora = dadosCommit['commit']['author']['date']
repositorioBranchCommitCod = CrudUtil('prod_t1').insert('repositorio_branch_commit', {
'repositorioBranchCod' : repositorioBranchCod,
'contributorCod' : contributor['contributorCod'],
'repositorioBranchCommitSha': sha,
'repositorioBranchCommitMensagem' : dadosCommit['commit']['message'],
'repositorioBranchCommitUrl' : dadosCommit['html_url'],
'repositorioBranchCommitComentarios' : dadosCommit['commit']['comment_count'],
'repositorioBranchCommitAdicoes' : dadosCommit['stats']['additions'],
'repositorioBranchCommitRemocoes' : dadosCommit['stats']['deletions'],
'repositorioBranchCommitArquivos' : len(dadosCommit['files']),
'repositorioBranchCommitData' : commitDataHora[0:10] +' '+ commitDataHora[11:-4]
})
retorno['repositorioBranchCommitCod'] = repositorioBranchCommitCod
return retorno
def enviaNotificacao(self, usuarioCod, titulo, descricao, warnLevel, link):
camposValores = {
'usuarioCod': 2,#remetente
'notificacaoUsuarioCod': usuarioCod,#destinatario
'notificacaoTitulo': titulo,
'notificacaoDesc': descricao,
'notificacaoWarnLevel': warnLevel,
'notificacaoDataHora': str(datetime.datetime.now())[0:-7],
'notificacaoLink': link,
}
#t1
repositorioCod = CrudUtil('prod_t1').insert('_notificacao', camposValores)
#s2(only in production
#repositorioCod = CrudUtil('prod_s2').insert('_notificacao', camposValores)
def getDadosApi(self, url, auth = True):
if auth == True:
user = configs['apiKeys']['github']['user']
password = configs['apiKeys']['github']['password']
r = requests.get(url, auth=(user, password))
else:
r = requests.get(url)
if r.status_code == 200 and r.headers['Content-Type'] == 'application/json; charset=utf-8':
response = r.json()
else:
raise Exception("Github API access failed. \nRequest headers: \n"+ str(r.headers))
return response
class CrudUtil():
con = None
def __init__(self, link = 'padrao'):
self.con = Conexao(link)
def insert(self, tabela, camposValores):
try:
self.con.qb().begin_transaction()
id = self.con.qb().table(tabela).insert_get_id(camposValores)
self.con.qb().commit()
return id
except Exception as e:
self.con.qb().rollback()
raise Exception("Database transaction failed. Details: "+ str(e))
def update(self, tabela, where, camposValores):
try:
self.con.qb().begin_transaction()
id = self.con.qb().table(tabela).where(where).update(camposValores)
self.con.qb().commit()
return id
except Exception as e:
self.con.qb().rollback()
raise Exception("Database transaction failed. Details: " + str(e))
def delete(self, tabela, where):
try:
self.con.qb().begin_transaction()
id = self.con.qb().table(tabela).where(where).delete()
self.con.qb().commit()
return id
except Exception as e:
self.con.qb().rollback()
raise Exception("Database transaction failed. Details: " + str(e))
def __init__(self, link = 'padrao'):
self.con = Conexao(link)
from conexao import Conexao
from modelos import PesqMain, PesqComple, PesqPerf, Employees
from datetime import date
import random
# Dados...
conexao = Conexao()
conexao.user = "******"
conexao.psw = "1234"
conexao.host = "localhost"
conexao.port = "3306"
base_dados_exemplo = 'employees'
adicionar_na_base_dados = 'sdd_dom_apres'
ver_registros_add = False
remover_add_tabelas = False
# Adiciona a partir do registro 11001, remove todos os registros anteriores
adicionar_do_inicio = True
add_quantos_registros = 20 # `None` para todos os registros
# Adiciona a partir de um determinado intervalo, ideal para manter os regitros atuais
adicionar_entre_os_ids = False
id_inicial = 1
id_final = 20
def retornar_cpf():
return str(random.randint(100, 999)) + "." + str(random.randint(100, 999)) + "." + str(random.randint(100, 999)) + "-" + str(random.randint(10, 99))
def retornar_valor(alternativas):
alternativa = random.randint(1, 82)
