Ejemplo n.º 1
0
    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)
Ejemplo n.º 2
0
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)
Ejemplo n.º 3
0
    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")
Ejemplo n.º 4
0
    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)
Ejemplo n.º 5
0
    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]
Ejemplo n.º 6
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")
Ejemplo n.º 7
0
    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
Ejemplo n.º 8
0
    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
Ejemplo n.º 9
0
    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
Ejemplo n.º 10
0
    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()
Ejemplo n.º 12
0
    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
Ejemplo n.º 13
0
    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
Ejemplo n.º 14
0
    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
Ejemplo n.º 15
0
    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")
Ejemplo n.º 16
0
 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
Ejemplo n.º 17
0
    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
Ejemplo n.º 18
0
    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
Ejemplo n.º 19
0
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))
Ejemplo n.º 20
0
    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()
Ejemplo n.º 21
0
    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
Ejemplo n.º 22
0
    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
Ejemplo n.º 23
0
    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
Ejemplo n.º 24
0
    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()
Ejemplo n.º 25
0
    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
Ejemplo n.º 26
0
    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
Ejemplo n.º 27
0
 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
Ejemplo n.º 28
0
    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")
Ejemplo n.º 29
0
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()
Ejemplo n.º 30
0
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()
Ejemplo n.º 31
0
    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
Ejemplo n.º 32
0
 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
Ejemplo n.º 33
0
 def __init__(self):
     self.con = Conexao()
     return
Ejemplo n.º 34
0
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)
Ejemplo n.º 35
0
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
Ejemplo n.º 36
0
 def __init__(self):
     self.con = Conexao()
     self.sql = processaSql()
Ejemplo n.º 37
0
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
Ejemplo n.º 38
0
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))
Ejemplo n.º 39
0
 def __init__(self, link = 'padrao'):
     self.con = Conexao(link)
Ejemplo n.º 40
0
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)