def userStatus(status):
update = "UPDATE user SET user_status = '%s' WHERE user_name = '%s'" % (skype.CurrentUserStatus,skype.CurrentUser.Handle)
conn = Connect(host='auditim.tk', user='******', passwd='$passW0rD')
curs = conn.cursor()
curs.execute('use db_auditim')
curs.execute(update)
conn.commit()
def getSpaceGroupData(self):
dbConnection=Connect(host=self.host,user=self.user,passwd=self.passwd,db=self.dbname)
cur=dbConnection.cursor()
cur.execute("select p.pdbCode,p.spaceGroup,count(*) c from PdbInfo as p inner join \
ChainCluster as c on p.uid=c.pdbInfo_uid inner join Interface as i on \
i.pdbCode=p.pdbCode where p.numChainClusters=1 and length(c.memberChains)=1 and p.expMethod='X-RAY DIFFRACTION' group by p.pdbCode;")
self.SpaceGroupData= [i+(self.parseScoresFile(i[0]),) for i in list(cur.fetchall()) if i[0] in self.singleChainList and self.parseScoresFile(i[0])>0 ]
def LINgroup_indexing_traceback():
conn = Connect("localhost","root")
c = conn.cursor()
c.execute("use LINdb_Psy")
c.execute("SELECT Genome_ID, SubjectGenome, LIN FROM LIN")
tmp = c.fetchall()
Genome_ID = [i[0] for i in tmp]
SubjectGenome = [i[1] for i in tmp]
LIN = [i[2] for i in tmp]
df = pd.DataFrame()
df["SubjectGenome"] = SubjectGenome
df["LIN"] = LIN
df.index = Genome_ID
for current_genome_index in range(1,len(Genome_ID)):
sub_table = df.loc[Genome_ID[:current_genome_index],]
subjectgenome = df.get_value(Genome_ID[i],"SubjectGenome")
subjectlin = df.get_value(subjectgenome,"LIN").split(",")
previous_route = ""
current_level = 0
similarity_pool = {}
while current_level < 19:
previous_route, current_level = find_current_step(previous_route=previous_route, current_level=current_level,
similarity_pool=similarity_pool, c=c,
current_genome_index=current_genome_index,
subjectlin=subjectlin)
print len(similarity_pool.keys())
def connect_to_db():
conn = Connect(host="localhost",
user="******",
passwd="mayoproject",
db="MethylDB")
c = conn.cursor()
return conn, c
def handleMessages(msg,status):
print "handleMessages"
if status == 'SENT' or status == 'READ':
conn = Connect(host='auditim.tk', user='******', passwd='$passW0rD')
curs = conn.cursor()
curs.execute('use db_auditim')
curs.execute('insert into history (user_name, chat_id, chat_name, from_name_user, from_name_display, message_status, message_type, message_body, chat_date, chat_timestamp) values (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)', (skype.CurrentUser.Handle, msg.Id, msg.ChatName, msg.FromHandle, msg.FromDisplayName, status, msg.Type, msg.Body, msg.Datetime, msg.Timestamp))
conn.commit()
def userStatus(status):
update = "UPDATE user SET user_status = '%s' WHERE user_name = '%s'" % (
skype.CurrentUserStatus, skype.CurrentUser.Handle)
conn = Connect(host='auditim.tk', user='******', passwd='$passW0rD')
curs = conn.cursor()
curs.execute('use db_auditim')
curs.execute(update)
conn.commit()
class Connect_MySQL:
## Inicializa o banco de dados
# @param host Servidor do banco de dados
# @param user Usuario do banco de dados
# @param passwd Senha do banco de dados
def __init__(self, host, user, passwd):
self.host = host
self.user = user
self.passwd = passwd
self.conecta()
def conecta(self):
self.conn = Connect(self.host,
self.user,
self.passwd,
charset='utf8',
use_unicode=True)
self.curs = self.conn.cursor()
self.curs.execute('CREATE DATABASE IF NOT EXISTS controledeacesso')
self.curs.execute('USE controledeacesso')
self.conn.commit()
## Deleta todas as tabelas se existirem
def dropar_Tabelas(self):
self.curs.execute('DROP TABLE IF EXISTS funcionarios')
self.curs.execute('DROP TABLE IF EXISTS horarios')
self.curs.execute('DROP TABLE IF EXISTS pontos')
self.curs.execute('DROP TABLE IF EXISTS log_porta')
self.curs.execute('DROP TABLE IF EXISTS configuracoes')
self.conn.commit()
## Cria as tabelas do programa na instalação
def criar_Tabelas(self):
self.curs.execute(
"CREATE TABLE IF NOT EXISTS funcionarios (id_funcionario INT NOT NULL AUTO_INCREMENT PRIMARY KEY, nome VARCHAR(100), matricula VARCHAR(40) NOT NULL, rfid VARCHAR(20), ativo BOOLEAN NOT NULL)"
)
self.curs.execute(
"CREATE TABLE IF NOT EXISTS horarios (id_horario INT NOT NULL AUTO_INCREMENT PRIMARY KEY, id_funcionario INT NOT NULL, dia_da_semana INT NOT NULL, hora_inicial TIME NOT NULL, hora_final TIME NOT NULL)"
)
self.curs.execute(
"CREATE TABLE IF Not EXISTS pontos (id_ponto INT NOT NULL AUTO_INCREMENT PRIMARY KEY, id_funcionario INT NOT NULL, id_horario INT NOT NULL, horario_entrada DATETIME NOT NULL, horario_saida DATETIME, presenca INT)"
)
self.curs.execute(
"CREATE TABLE IF NOT EXISTS log_porta (id_log INT NOT NULL AUTO_INCREMENT PRIMARY KEY, id_funcionario INT NOT NULL, horario_entrada DATETIME NOT NULL)"
)
self.curs.execute(
"CREATE TABLE IF NOT EXISTS configuracoes (id_config INT NOT NULL AUTO_INCREMENT PRIMARY KEY, tipo VARCHAR(100) NOT NULL, dado VARCHAR(100) NOT NULL)"
)
self.conn.commit()
## Cria as configurações do programa
# @param config Nome da configuração
# @param dado Dado que vai ser inserido
def criar_Configuracoes(self, config, dado):
sql = "INSERT INTO configuracoes (tipo,dado) VALUES (%s,%s)"
self.curs.execute(sql, (config, dado))
self.conn.commit()
def getSpaceGroup(self,pdb):
dbConnection=Connect(host=self.host,user=self.user,passwd=self.passwd,db=self.dbname)
cur=dbConnection.cursor()
cur.execute("select spaceGroup from PdbInfo where pdbCode='%s'"%(pdb))
try:
self.sg=list(cur.fetchall())[0][0]
except IndexError:
self.sg="NULL"
return self.sg
class Connect_MySQL:
## Inicializa o banco de dados
# @param host Servidor do banco de dados
# @param user Usuario do banco de dados
# @param passwd Senha do banco de dados
def __init__(self, host, user, passwd):
self.host = host
self.user = user
self.passwd = passwd
self.conecta()
def conecta(self):
self.conn = Connect(self.host, self.user, self.passwd, charset="utf8", use_unicode=True)
self.curs = self.conn.cursor()
self.curs.execute("CREATE DATABASE IF NOT EXISTS controledeacesso")
self.curs.execute("USE controledeacesso")
self.conn.commit()
## Deleta todas as tabelas se existirem
def dropar_Tabelas(self):
self.curs.execute("DROP TABLE IF EXISTS funcionarios")
self.curs.execute("DROP TABLE IF EXISTS horarios")
self.curs.execute("DROP TABLE IF EXISTS pontos")
self.curs.execute("DROP TABLE IF EXISTS log_porta")
self.curs.execute("DROP TABLE IF EXISTS configuracoes")
self.conn.commit()
## Cria as tabelas do programa na instalação
def criar_Tabelas(self):
self.curs.execute(
"CREATE TABLE IF NOT EXISTS funcionarios (id_funcionario INT NOT NULL AUTO_INCREMENT PRIMARY KEY, nome VARCHAR(100), matricula VARCHAR(40) NOT NULL, rfid VARCHAR(20), ativo BOOLEAN NOT NULL)"
)
self.curs.execute(
"CREATE TABLE IF NOT EXISTS horarios (id_horario INT NOT NULL AUTO_INCREMENT PRIMARY KEY, id_funcionario INT NOT NULL, dia_da_semana INT NOT NULL, hora_inicial TIME NOT NULL, hora_final TIME NOT NULL)"
)
self.curs.execute(
"CREATE TABLE IF Not EXISTS pontos (id_ponto INT NOT NULL AUTO_INCREMENT PRIMARY KEY, id_funcionario INT NOT NULL, id_horario INT NOT NULL, horario_entrada DATETIME NOT NULL, horario_saida DATETIME, presenca INT)"
)
self.curs.execute(
"CREATE TABLE IF NOT EXISTS log_porta (id_log INT NOT NULL AUTO_INCREMENT PRIMARY KEY, id_funcionario INT NOT NULL, horario_entrada DATETIME NOT NULL)"
)
self.curs.execute(
"CREATE TABLE IF NOT EXISTS configuracoes (id_config INT NOT NULL AUTO_INCREMENT PRIMARY KEY, tipo VARCHAR(100) NOT NULL, dado VARCHAR(100) NOT NULL)"
)
self.conn.commit()
## Cria as configurações do programa
# @param config Nome da configuração
# @param dado Dado que vai ser inserido
def criar_Configuracoes(self, config, dado):
sql = "INSERT INTO configuracoes (tipo,dado) VALUES (%s,%s)"
self.curs.execute(sql, (config, dado))
self.conn.commit()
def handleMessages(msg, status):
print "handleMessages"
if status == 'SENT' or status == 'READ':
conn = Connect(host='auditim.tk',
user='******',
passwd='$passW0rD')
curs = conn.cursor()
curs.execute('use db_auditim')
curs.execute(
'insert into history (user_name, chat_id, chat_name, from_name_user, from_name_display, message_status, message_type, message_body, chat_date, chat_timestamp) values (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)',
(skype.CurrentUser.Handle, msg.Id, msg.ChatName, msg.FromHandle,
msg.FromDisplayName, status, msg.Type, msg.Body, msg.Datetime,
msg.Timestamp))
conn.commit()
def userPLogin():
Notify('AuditIM','Checando se o usuário: '+skype.CurrentUser.FullName+' tem permissão para utilizar o Skype','')
conn = Connect(host='auditim.tk', user='******', passwd='$passW0rD')
curs = conn.cursor()
curs.execute('use db_auditim')
curs.execute('SELECT * FROM user WHERE user_name = %s', (skype.CurrentUser.Handle))
rows = curs.fetchall()
if not rows or rows[0][2]=='N':
Notify('AuditIM','Desculpe, mas o usuário de Skype: "'+skype.CurrentUser.FullName+'" não está autorizado, caso necessário entre em contato com o administrador.','')
skype.Client.Shutdown() #fecha o Skype, fazendo logoff
time.sleep(2)
skype.Client.Start()
time.sleep(2)
Notify('AuditIM','Tente utilizar um usuário permitido, caso não funcione entre em contato com o administrador.','')
def get95CoreEntropies(self,pdb,interface,side,host,user,passwd,dbname):
self.pdb=pdb
self.interface=interface
self.side=side
dbConnection=Connect(host=host,user=user,passwd=passwd,db=dbname)
cur=dbConnection.cursor()
cur.execute("select r.pdbResidueNumber,r.region,r.entropyScore \
from Residue as r inner join Interface as i on i.uid=r.interfaceItem_uid \
where i.pdbCode='%s' and i.interfaceId=%d and r.side=%d and r.region>1;"%(self.pdb,self.interface,self.side))
self.coreEntropyScore= list(cur.fetchall())
if len(self.coreEntropyScore)==0:
raise ValueError('PDB entry not found in the database')
self.coreResidues=[atoi(res[0]) for res in self.coreEntropyScore]
self.coreEntropies=[res[2] for res in self.coreEntropyScore]
return [self.coreResidues,self.coreEntropies]
def getSpaceGroup(self,pdb):
dbConnection=Connect(host=self.host,user=self.user,passwd=self.passwd,db=self.dbname)
cur=dbConnection.cursor()
cur.execute("select spaceGroup,resolution,rfreeValue,expMethod from PdbInfo where pdbCode='%s'"%(pdb))
try:
self.cur=list(cur.fetchall())
self.sg=self.cur[0][0]
self.resolution=self.cur[0][1]
self.rfree=self.cur[0][2]
self.exp=self.cur[0][3]
except IndexError:
self.sg="NULL"
self.resolution=-1.0
self.rfree=-1.0
self.exp="NULL"
return [self.sg,self.resolution,self.rfree,self.exp]
class DatabaseManager(object):
def __init__(self):
self.db = Connect(host=HOST,user=USER,passwd=PWD,db=DB,cursorclass=DictCursor)
self.db.autocommit(True)
@staticmethod
def getInstance():
return SingletonHolder.INSTANCE
def query(self, sql, *params):
cur = self.db.cursor()
sql= escape_string(sql)
cur.execute(sql, *params)
r = ResultSet(cur.fetchall())
cur.close()
return r
def runDataset(self,dataset,interface, side, cifrepo, host, user, passwd, dbname, n, coreSize, sampleSize, outfolder):
p=analyzeSurface()
db=Connect(host=host,user=user,passwd=passwd,db=dbname)
cur = db.cursor()
cur.execute("select pdbCode,chain1 from dc_%s where h1>30 and h2>30 and repchain1=repchain2"%(dataset))
pdblist=cur.fetchall()
pdbl=[pdb[0] for pdb in list(pdblist)]
chains=[pdb[1] for pdb in list(pdblist)]
for pdb in set(pdbl):
try:
p.scanSurface(pdb,chains[pdbl.index(pdb)],interface, side, cifrepo, host, user, passwd, dbname, n, coreSize, sampleSize, outfolder)
except ValueError:
print pdb
pass
except IOError:
print pdb
pass
def gerenciaContatos():
print "gerencia contatos inicio"
contatos = skype.Friends
query = "SELECT * FROM contact WHERE user_name = '%s'" % (skype.CurrentUser.Handle)
conn = Connect(host='auditim.tk', user='******', passwd='$passW0rD')
curs = conn.cursor()
curs.execute('use db_auditim')
curs.execute(query)
rows = curs.fetchall()
for row in rows:
print "contato no banco de dados: ", row[1]
for contato in contatos:
print "contato no Skype: ", contato.Handle
if contato.Handle == row[1]:
if row[3] == 'False':
contato.IsBlocked = ''
else:
contato.IsBlocked = 'True'
print "gerencia contatos fim"
def gerenciaContatos():
print "gerencia contatos inicio"
contatos = skype.Friends
query = "SELECT * FROM contact WHERE user_name = '%s'" % (
skype.CurrentUser.Handle)
conn = Connect(host='auditim.tk', user='******', passwd='$passW0rD')
curs = conn.cursor()
curs.execute('use db_auditim')
curs.execute(query)
rows = curs.fetchall()
for row in rows:
print "contato no banco de dados: ", row[1]
for contato in contatos:
print "contato no Skype: ", contato.Handle
if contato.Handle == row[1]:
if row[3] == 'False':
contato.IsBlocked = ''
else:
contato.IsBlocked = 'True'
print "gerencia contatos fim"
def userPLogin():
Notify(
'AuditIM', 'Checando se o usuário: ' + skype.CurrentUser.FullName +
' tem permissão para utilizar o Skype', '')
conn = Connect(host='auditim.tk', user='******', passwd='$passW0rD')
curs = conn.cursor()
curs.execute('use db_auditim')
curs.execute('SELECT * FROM user WHERE user_name = %s',
(skype.CurrentUser.Handle))
rows = curs.fetchall()
if not rows or rows[0][2] == 'N':
Notify(
'AuditIM', 'Desculpe, mas o usuário de Skype: "' +
skype.CurrentUser.FullName +
'" não está autorizado, caso necessário entre em contato com o administrador.',
'')
skype.Client.Shutdown() #fecha o Skype, fazendo logoff
time.sleep(2)
skype.Client.Start()
time.sleep(2)
Notify(
'AuditIM',
'Tente utilizar um usuário permitido, caso não funcione entre em contato com o administrador.',
'')
from MySQLdb import Connect
conn = Connect(host='localhost', user='******', passwd='python')
curs = conn.cursor()
try:
curs.execute('drop database testpeopledb')
except:
pass # did not exist
curs.execute('create database testpeopledb')
curs.execute('use testpeopledb')
curs.execute('create table people (name char(30), job char(10), pay int(4))')
curs.execute('insert people values (%s, %s, %s)', ('Bob', 'dev', 50000))
curs.execute('insert people values (%s, %s, %s)', ('Sue', 'dev', 60000))
curs.execute('select * from people')
for row in curs.fetchall():
print row
curs.execute('select * from people')
colnames = [desc[0] for desc in curs.description]
while True:
print '-' * 30
row = curs.fetchone()
if not row: break
for (name, value) in zip(colnames, row):
print '%s => %s' % (name, value)
conn.commit() # save inserted records
def build_db():
conn = Connect('localhost', 'root')
c = conn.cursor()
c.execute('CREATE DATABASE IF NOT EXISTS LINdb_Psy')
c.execute('USE LINdb_Psy')
c.execute('CREATE TABLE Genome (Genome_ID int NOT NULL AUTO_INCREMENT,'
'Interest_ID int NOT NULL,'
'Submission_ID int NOT NULL,'
'FilePath text NOT NULL,'
'GenomeName text NOT NULL,'
'PRIMARY KEY (Genome_ID))')
c.execute('CREATE TABLE Interest (Interest_ID int NOT NULL AUTO_INCREMENT,'
'InterestName varchar(255) NOT NULL,'
'Attribute_IDs text NOT NULL,'
'PRIMARY KEY (Interest_ID))')
c.execute('CREATE TABLE Attribute (Attribute_ID int NOT NULL AUTO_INCREMENT,'
'AttributeName varchar(255) NOT NULL,'
'PRIMARY KEY (Attribute_ID))')
c.execute('CREATE TABLE LIN (LIN_ID int NOT NULL AUTO_INCREMENT,'
'Genome_ID int NOT NULL,'
'Scheme_ID int NOT NULL,'
'SubjectGenome int NOT NULL,'
'ANI DOUBLE NOT NULL,'
'LIN text NOT NULL,'
'PRIMARY KEY (LIN_ID))')
c.execute('CREATE TABLE Scheme (Scheme_ID int NOT NULL AUTO_INCREMENT,'
'Cutoff text(255) NOT NULL,'
'LabelNum int NOT NULL,'
'PRIMARY KEY (Scheme_ID))')
c.execute('CREATE TABLE Submission (Submission_ID int NOT NULL AUTO_INCREMENT,'
'User_ID int NOT NULL,'
'Time text NOT NULL,'
'PRIMARY KEY (Submission_ID))')
c.execute(
'CREATE TABLE User (User_ID int NOT NULL AUTO_INCREMENT,FirstName varchar(255) NOT NULL,LastName varchar(255) '
'NOT NULL,Institute varchar(255) NOT NULL,RegistrationDate text NOT NULL,Username varchar(255) NOT NULL,'
'Password text NOT NULL,Email text NOT NULL,PRIMARY KEY (User_ID))')
c.execute(
"CREATE TABLE AttributeValue (AttributeValue_ID int NOT NULL AUTO_INCREMENT,Genome_ID int NOT NULL,"
"Interest_ID int NOT NULL, Attribute_ID int not null,AttributeValue text not null,User_ID int not null,"
"Private boolean not null,PRIMARY KEY (AttributeValue_ID))")
c.execute("CREATE TABLE Genome_to_Attribute (Genome_to_Attribute_ID int NOT NULL AUTO_INCREMENT, "
"Genome_ID INT NOT NULL, Genus text, Species text,Subspecies__Pathovar text, Strain text, Type_strain text,"
" GPS_Coordinates text, Date_of_isolation text,"
"NCBI_Accession text, Country text, Link_to_peer_reviewed_paper text,Host_of_isolation__Environmental_source text,"
"Disease text, Infectious_disease_name text,"
"Host text, PRIMARY KEY (Genome_to_Attribute_ID))")
c.execute(
"CREATE TABLE Description (Description_ID int not null auto_increment, LIN_group text NOT NULL ,"
"Description_Item_ID int not null, DescriptionValue text not null, User_ID INT NOT NULL , PRIMARY KEY (Description_ID))")
c.execute(
"CREATE TABLE Description_Items (Description_Item_ID int not null auto_increment, Description_Item_Name text "
"not null, PRIMARY KEY (Description_Item_ID))")
c.execute(
"CREATE TABLE LIN_to_Description (LIN_to_Description_ID int NOT NULL AUTO_INCREMENT, LIN_group text NOT NULL, "
"Genus text, Species text, Nickname text, Comment text, URL text, PRIMARY KEY(LIN_to_Description_ID))")
### INITIALIZATION
# c.execute("insert into User (LastName, FirstName, Institute, RegistrationDate, Username, Password, Email) values
# ('Tian', 'Long', 'Virginia Tech', '2015-5-17', 'longtian', '123456', '*****@*****.**')")
# Attributes
# General entries
c.execute("INSERT INTO Attribute (AttributeName) values ('Genus')")
c.execute("INSERT INTO Attribute (AttributeName) values ('Species')")
c.execute("INSERT INTO Attribute (AttributeName) values ('Subspecies/Pathovar')")
c.execute("INSERT INTO Attribute (AttributeName) values ('Strain')")
c.execute("INSERT INTO Attribute (AttributeName) values ('Type strain')")
c.execute("INSERT INTO Attribute (AttributeName) values ('GPS Coordinates')")
c.execute("INSERT INTO Attribute (AttributeName) values ('Date of isolation')")
c.execute("INSERT INTO Attribute (AttributeName) values ('NCBI Accession')")
c.execute("INSERT INTO Attribute (AttributeName) values ('Country')")
c.execute("INSERT INTO Attribute (AttributeName) values ('Link to peer-reviewed paper')")
# For Plant pathogen
c.execute("INSERT INTO Attribute (AttributeName) values ('Host of isolation/Environmental source')")
c.execute("INSERT INTO Attribute (AttributeName) VALUES ('Disease')")
# For Virus
c.execute("INSERT INTO Attribute (AttributeName) values ('Infectious disease name')")
c.execute("INSERT INTO Attribute (AttributeName) values ('Host')")
# Interest
c.execute(
"INSERT INTO Interest (InterestName, Attribute_IDs) values ('Plant pathogen','1,2,3,4,5,6,7,8,9,10,11,12')")
c.execute(
"INSERT INTO Interest (InterestName, Attribute_IDs) values ('Human & Animal viruses','1,2,4,5,6,7,9,10,13,14')")
# Scheme
c.execute("INSERT INTO Scheme (Cutoff, LabelNum) values ('70,75,80,85,90,95,96,97,98,99.99999', 10)")
c.execute(
"INSERT INTO Scheme (Cutoff, LabelNum) values ('60,70,80,85,90,95,98,99,99.5,99.6,99.7,99.8,99.9,99.91,99.92,"
"99.93,99.94,99.95,99.96,99.97,99.98,99.99,99.999,99.9999', 24)")
c.execute(
"INSERT INTO Scheme (Cutoff, LabelNum) values ('60,70,75,80,85,90,95,98,98.5,99,99.25,99.5,99.75,99.9,99.925,"
"99.95,99.975,99.99,99.999,99.9999', 20)")
# Description Items
c.execute("INSERT INTO Description_Items (Description_Item_Name) values ('Genus')")
c.execute("INSERT INTO Description_Items (Description_Item_Name) values ('Species')")
c.execute("INSERT INTO Description_Items (Description_Item_Name) values ('Nickname')")
c.execute("INSERT INTO Description_Items (Description_Item_Name) values ('Comment')")
c.execute("INSERT INTO Description_Items (Description_Item_Name) values ('URL')")
# # Enter one genome to start
# Start with Genome of DC3000, which is GCA_000007805.1.fasta
c.execute("insert into User (LastName, FirstName, Institute, RegistrationDate, Username, Password, Email) values "
"('Tian', 'Long', 'Virginia Tech', '2016-10-21', '*****@*****.**', '123456', '*****@*****.**')")
c.execute("INSERT INTO Submission (User_ID, Time) VALUES (1,'2016-11-02')")
c.execute(
"INSERT INTO Genome (Interest_ID, Submission_ID, FilePath, GenomeName) VALUES (1, 1, '/home/linproject/Workspace/Psy_166/init/GCA_000007805.fasta', 'GCA_000007805')")
c.execute(
"INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 1, 'Pseudomonas', 1, False)")
c.execute(
"INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 2, 'syringae', 1, False)")
c.execute(
"INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 3, 'pv. tomato', 1, False)")
c.execute(
"INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 4, 'DC3000', 1, False)")
c.execute(
"INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 5, 'No', 1, False)")
c.execute(
"INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 6, '49.5,-2.5', 1, False)")
c.execute(
"INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 7, 'NA', 1, False)")
c.execute(
"INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 8, 'AE016853', 1, False)")
c.execute(
"INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 9, 'United Kingdom', 1, False)")
c.execute(
"INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 10, '10.1073/pnas.1731982100', 1, False)")
c.execute(
"INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 11, 'Solanum lycopersicum', 1, False)")
c.execute(
"INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 12, 'Plant rot, Speck disease', 1, False)")
c.execute(""
"INSERT INTO LIN (Genome_ID, Scheme_ID, SubjectGenome, ANI, LIN) VALUES (1, 3, 1, 1, '0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0')")
conn.commit()
def extract():
print("{} Descriptor Extractor: [{}]".format(memory_usage_psutil(), color(FEATURE_DETECTOR_ALG.upper(), fontcolor=FONT_COLOR, bold=True)))
# Pega lista de imagens
images_list = make_image_list(DATASET_PATH)
print("{} Images: [{}]".format(memory_usage_psutil(), color(len(images_list), fontcolor=FONT_COLOR, bold=True)))
# Connect to DATABASE
print("{} Connecting to the MySQL database...".format(memory_usage_psutil()), end=' ')
try:
DB_CONN = Connect(DATABASE_SETTINGS["host"], DATABASE_SETTINGS["user"], DATABASE_SETTINGS["password"], DATABASE_SETTINGS["database"])
DB_CURSOR = DB_CONN.cursor()
except Exception as e:
raise e
cprint("OK\n", fontcolor=FONT_COLOR, bold=True)
# Tenta apagar tabela antiga de imagens
print("{} Dropping the existing image table...".format(memory_usage_psutil()), end=' ')
try:
DB_CURSOR.execute("DROP TABLE {};".format(DATABASE_SETTINGS["table"]))
except Exception as e:
pass
cprint("OK\n", fontcolor=FONT_COLOR, bold=True)
print("{} Creating image table...".format(memory_usage_psutil()), end=' ')
try:
DB_CURSOR.execute('''
CREATE TABLE {}
(
_id INT PRIMARY KEY,
_path VARCHAR(255) NOT NULL UNIQUE,
_descriptors JSON
);'''.format(DATABASE_SETTINGS["table"]))
except Exception as e:
raise e
cprint("OK\n", fontcolor=FONT_COLOR, bold=True)
# Instancia classe de extração de descritores
des_extract = DescriptorExtractor()
print("{} Extracting Descriptors".format(memory_usage_psutil()))
for i in tqdm(iterable=range(0, len(images_list)), ncols=90, unit='images'):
# Extract image descriptors
des = des_extract.extract(img_name=images_list[i], feature_detector_alg=FEATURE_DETECTOR_ALG)
# Insert a img to images collection
if des:
if FEATURE_DETECTOR_ALG in BINARY_FEATURE_DETECTOR_ALG_LIST:
try:
DB_CURSOR.execute('''
INSERT INTO {}
VALUES ({}, '{}', '{}')
;
'''.format(
DATABASE_SETTINGS["table"], # Nome da tabela
int(images_list[i].split('/')[-1]), #ID da imagem em INT
images_list[i], # Caminho até a imagem
dumps([to_bit_string(elem) for elem in des]) # bit-string-descriptors em JSON
)
)
except Exception as e:
raise e
elif FEATURE_DETECTOR_ALG in NUMERICAL_FEATURE_DETECTOR_ALG_LIST:
try:
DB_CURSOR.execute('''
INSERT INTO {}
VALUES ({}, '{}', '{}')
;
'''.format(
DATABASE_SETTINGS["table"], # Nome da tabela
i, #int(images_list[i].split('/')[-1]), #ID da imagem em INT
images_list[i], # Caminho até a imagem
dumps([elem for elem in des]) # array-descriptors em JSON
)
)
except Exception as e:
raise e
else:
raise Exception("Algoritmo não foi adicionado à lista de algoritmos válidos!")
des = None
del des
print("{} Descriptors: [{}]".format(memory_usage_psutil(), color(des_extract.size, fontcolor=FONT_COLOR, bold=True)))
print("{} Descriptors per image: [{}]".format(memory_usage_psutil(), color(des_extract.size/len(images_list), fontcolor=FONT_COLOR, bold=True)))
images_list = None
del images_list, des_extract
# Confirma alterações no BD
print("{} Writing data in the database...".format(memory_usage_psutil()), end=' ')
try:
DB_CONN.commit()
except Exception as e:
raise e
cprint("OK\n", fontcolor=FONT_COLOR, bold=True)
# Fecha conexão
print("{} Closing the connection to the database...".format(memory_usage_psutil()), end=' ')
try:
DB_CONN.close()
except Exception as e:
raise e
cprint("OK\n", fontcolor=FONT_COLOR, bold=True)
def connect_to_db():
conn = Connect("127.0.0.1", "LINbase", "Latham@537")
c = conn.cursor()
c.execute("use LINdb_NCBI_RefSeq_test")
return conn, c
def connect_to_db():
conn = Connect("localhost", "root")
c = conn.cursor()
c.execute("use LINdb_NCBI_RefSeq")
return conn, c
def connect_to_db(from_db):
conn = Connect("localhost", "root")
c = conn.cursor()
c.execute("use {0}".format(from_db))
return conn, c
class Model:
def __init__(self):
self._conn = None
self._cursor = None
def connect(self, host, user, password, database):
'''
Método para conectar-se à Base de Dados
Args:
host : str
Nome do host da Base de Dados
user : str
Usuário da Base de Dados
password : str
Senha da Base de Dados
database : str
Nome do Database a ser utilizado
'''
try:
self._conn = Connect(host, user, password, database)
self._cursor = self._conn.cursor()
except Exception as e:
raise e
else:
print("Connecting to '{}' database...".format(database))
def close(self):
'''
Método para fechar a conexão com a Base de Dados
'''
try:
self._conn.close()
except Exception as e:
raise e
else:
print("Closing connection...")
def drop_table(self, table):
'''
Método para deletar uma tabela da Base de Dados
Args:
table : str
Nome da tabela da Base de Dados
'''
try:
self._cursor.execute(f"DROP TABLE {table};")
except:
pass
else:
print("Dropping '{}' table...".format(table))
def commit(self):
'''
Método para escrever os dados na Base de Dados
'''
try:
self._conn.commit()
except Exception as e:
raise e
else:
pass
def select(self, columns=[], tables=[], value=None):
'''
Método para ler dados da Base de Dados
Args:
columns : list
Lista de colunas a serem selecionadas
tables : list
Lista de tabelas
value : str
Valor a ser usado com a cláusula WHERE
Returns
n_rows : int
Quantidade de linhas retornadas
'''
columns = [columns] if not isinstance(columns, list) else columns
tables = [tables] if not isinstance(tables, list) else tables
try:
n_rows = self._cursor.execute(
'''SELECT {} FROM {} WHERE {}={};'''.format(
', '.join(map(lambda item: str(item), columns)),
', '.join(map(lambda item: str(item), tables)), columns[1],
self._add_aspas(value)))
except Exception as e:
raise e
else:
return n_rows
def select_all(self):
'''
Método para ler todos os dados da Base de Dados
Returns
self._cursor.fetchall() : tuple
Dados lidos da Base de Dados
'''
try:
ret = self._cursor.execute('''
SELECT Point.pointLAT,
Point.pointLNG,
Point.pointStreetName,
Point.pointHouseNumber,
Suburb.suburbName,
City.cityName,
Point.pointPostalCode,
State.stateUF,
Country.countryName
FROM Point
LEFT JOIN Suburb
ON Point.suburbID = Suburb.id
LEFT JOIN City
ON Suburb.cityID = City.id
LEFT JOIN State
ON City.stateID = State.id
LEFT JOIN Country
ON State.countryID = Country.id;
''')
except:
return None
else:
return self._cursor.fetchall()
def _add_aspas(self, item):
'''
Método para formatar dados: se o item é uma String,
são adicionadas aspas ('') no item.
Args:
item : str | int | float
Item a ser formatado
Returns
str(item) : str
Item formatado
'''
if isinstance(item, str):
return f"'{item.lower()}'"
return str(item)
def insert(self, table=None, columns=[], values=[]):
'''
Método para inserir dados na Base de Dados.
Se a coluna for do tipo UNIQUE (countryName, stateUF, cityName, suburbName),
é testado se o dado já existe na Base de Dados. Se já existir, o ID do dado
é retornado; se o dado não existir, o dado é adicionado à Base de Dados e
seu ID é retornado.
Args:
table : str
Tabela onde os dados serão inseridos
columns : list
Lista de colunas
values : list
Lista de valores correspondentes às colunas
Returns
_id | self._cursor.lastrowid : int
ID do dado adicionado ou do dado já existente
'''
columns = [columns] if not isinstance(columns, list) else columns
values = [values] if not isinstance(values, list) else values
# Busca o ID e o valor Único da tabela na base de dados para
# verificar se já existe (countryName, stateUF, cityName, suburbName)
n_rows = self.select(columns=['id', columns[0]],
tables=table,
value=values[0])
if n_rows > 0: # Se o valor já existe, retorna o ID
_data = self._cursor.fetchall()[0]
# Testa se os valores são iguais
_id, _value = _data
if values[0] == _value:
return _id
# Se o valor não existe, insere ele
try:
ret = self._cursor.execute(
'''INSERT INTO {} ({}) VALUES ({});'''.format(
table, ', '.join(map(lambda item: str(item), columns)),
', '.join(map(lambda item: self._add_aspas(item),
values))))
except Exception as e:
raise e
else:
return self._cursor.lastrowid # retorna o ID da nova inserção
def create_tables(self):
'''
Método para criar as tabelas
'''
try:
self._cursor.execute('''
CREATE TABLE IF NOT EXISTS Country (
id INT NOT NULL AUTO_INCREMENT,
countryName VARCHAR(50) NOT NULL UNIQUE,
PRIMARY KEY (id)
);
''')
self._cursor.execute('''
CREATE TABLE IF NOT EXISTS State (
id INT NOT NULL AUTO_INCREMENT,
stateUF VARCHAR(5) NOT NULL UNIQUE,
countryID INT NOT NULL,
PRIMARY KEY (id),
FOREIGN KEY (countryID) REFERENCES Country(id)
);
''')
self._cursor.execute('''
CREATE TABLE IF NOT EXISTS City (
id INT NOT NULL AUTO_INCREMENT,
cityName VARCHAR(50) NOT NULL UNIQUE,
stateID INT NOT NULL,
PRIMARY KEY (id),
FOREIGN KEY (stateID) REFERENCES State(id)
);
''')
self._cursor.execute('''
CREATE TABLE IF NOT EXISTS Suburb (
id INT NOT NULL AUTO_INCREMENT,
suburbName VARCHAR(100) NOT NULL UNIQUE,
cityID INT NOT NULL,
PRIMARY KEY (id),
FOREIGN KEY (cityID) REFERENCES City(id)
);
''')
self._cursor.execute('''
CREATE TABLE IF NOT EXISTS Point (
id INT NOT NULL AUTO_INCREMENT,
pointLAT FLOAT,
pointLNG FLOAT,
pointStreetName VARCHAR(100),
pointHouseNumber VARCHAR(20),
pointPostalCode VARCHAR(20),
suburbID INT(11) NOT NULL,
PRIMARY KEY (id),
FOREIGN KEY (suburbID) REFERENCES Suburb(id)
);
''')
except Exception as e:
raise e
else:
print("Creating tables...")
def connectMySql(self):
dbConnection=Connect(host=self.host,user=self.user,passwd=self.passwd,db=self.dbname)
self.cur=dbConnection.cursor()
def image_search(query_path, hist_comp_method=4, top_n_results=4):
global QUERY_HISTOGRAM
global MATCHED_IMAGES
QUERY_HISTOGRAM = {}
MATCHED_IMAGES = {}
# Instancia classe de extração de descritores
des_extract = DescriptorExtractor()
bit_string_vector = des_extract.extract(
img_name=query_path, feature_detector_alg=FEATURE_DETECTOR_ALG)
# Percorre lista de descritores da imagem
for bit_string_des in bit_string_vector:
# Explora recursivamente a VocabTree
explore(VOCAB_TREE.tree, bit_string_des, len(bit_string_vector))
bit_string_vector = None
del bit_string_vector, des_extract
# global MATCHED_IMAGES
# print("[{}] MATCHED_IMAGES: {}".format(len(MATCHED_IMAGES), MATCHED_IMAGES))
# Percorre lista de imagens que podem ser semelhantes
for d_image in MATCHED_IMAGES.keys():
# Percorre lista de nodos pelos quais os descritores da Query passaram
for node in QUERY_HISTOGRAM.keys():
# Testa se imagem passou pelo nodo em quastão
if d_image in VOCAB_TREE.inverted_file[node].keys():
# Se sim, adiciona qi ao histograma
MATCHED_IMAGES[d_image].append(
VOCAB_TREE.inverted_file[node][d_image])
else:
# Semão, adiciona 0 ao histograma
MATCHED_IMAGES[d_image].append(0)
# Mostra lista de imagens
# print("\n\nd_images: ")
# Percorre chaves do dicionário de imagens possivelmente semelhantes
for key in MATCHED_IMAGES.keys():
# Normaliza histograma da imagem da base de dados
MATCHED_IMAGES[key] = np.array(tuple(
MATCHED_IMAGES[key])) / np.linalg.norm(
np.array(tuple(MATCHED_IMAGES[key])), ord=1)
MATCHED_IMAGES[key] = MATCHED_IMAGES[key].astype('float32')
# Mostra histrograma
# print("\n\n[{}] {} ~> {}".format(MATCHED_IMAGES[key].size, key, MATCHED_IMAGES[key]))
# Normaliza histograma da query
q_values = np.array(tuple(QUERY_HISTOGRAM.values())) / np.linalg.norm(
np.array(tuple(QUERY_HISTOGRAM.values())), ord=1)
q_values = q_values.astype('float32')
# Mostra histograma da query
# print("\n\n[{}] {} ~> {}".format(q_values.size, "query", q_values))
# CALCULA SCORE
score = []
for _image_id in MATCHED_IMAGES.keys():
if q_values.size != MATCHED_IMAGES[_image_id].size:
raise Exception(
"Query histogram and database image histogram are different!")
# Compara histogramas
s = compare_hist(q_values, MATCHED_IMAGES[_image_id], hist_comp_method)
score.append((s, _image_id))
q_values = None
del q_values
# Ordena score
score.sort()
del score[top_n_results:]
image_list = []
# Connect to DATABASE
try:
DB_CONN = Connect(DATABASE_SETTINGS["host"], DATABASE_SETTINGS["user"],
DATABASE_SETTINGS["password"],
DATABASE_SETTINGS["database"])
DB_CURSOR = DB_CONN.cursor()
except Exception as e:
raise e
for _s, _image_id in score:
try:
DB_CURSOR.execute('''
SELECT _path
FROM {}
WHERE _id = {}
;
'''.format(DATABASE_SETTINGS["table"], _image_id))
query_image_path = DB_CURSOR.fetchall()[0][0].split('/')[-1]
image_list.append((_s, query_image_path))
except Exception as e:
raise Exception("Error to read image path from database!!")
# Fecha conexão
try:
DB_CONN.close()
except Exception as e:
raise e
return image_list
from MySQLdb import Connect
conn = Connect(host='localhost', user='******', passwd='python')
curs = conn.cursor()
try:
curs.execute('drop database testpeopledb')
except:
pass # did not exist
curs.execute('create database testpeopledb')
curs.execute('use testpeopledb')
curs.execute('create table people (name char(30), job char(10), pay int(4))')
curs.execute('insert people values (%s, %s, %s)', ('Bob', 'dev', 50000))
curs.execute('insert people values (%s, %s, %s)', ('Sue', 'dev', 60000))
curs.execute('select * from people')
for row in curs.fetchall():
print row
curs.execute('select * from people')
colnames = [desc[0] for desc in curs.description]
while True:
print '-' * 30
row = curs.fetchone()
if not row: break
for (name, value) in zip(colnames, row):
print '%s => %s' % (name, value)
conn.commit() # save inserted records
class Connect_Db:
## Inicializa o banco de dados
# @param host Servidor do banco de dados
# @param user Usuario do banco de dados
# @param passwd Senha do banco de dados
def __init__(self,db_dados):
self.host=db_dados['host']
self.user=db_dados['user']
self.passwd=db_dados['passwd']
self.conecta()
def __del__(self):
self.curs.close()
self.conn.close()
def conecta(self):
self.conn = Connect(self.host, self.user, self.passwd,charset='utf8',use_unicode=True)
self.curs = self.conn.cursor()
self.curs.execute('USE controledeacesso')
## Cria um funcionario na tabela funcionarios.
# @param nome Nome do funcionario
# @param matricula Matricula do funcionario
# @param rfid RFID do funcionario. Não é obrigatoria
def criar_Funcionario(self,nome,matricula,rfid=None):
if not ( (isinstance(nome, str) or isinstance(nome, unicode)) and (isinstance(matricula, str) or isinstance(matricula, unicode))):
return False
sql="INSERT INTO funcionarios (ativo,nome,matricula,rfid) VALUES (true,%s,%s,"
try:
if (rfid != None):
sql=sql+"%s)"
self.curs.execute(sql,(nome,matricula,rfid))
else:
sql=sql+"NULL)"
self.curs.execute(sql,(nome,matricula))
except Exception:
raise
self.conn.commit()
return True
## Atualiza informações do usuario
# @param id_funcionario Id do funcionario
# @param nome Nome do funcionario
# @param matricula Matricula do funcionario
# @param rfid RFID do funcionario
def atualizar_Funcionario(self,id_funcionario, nome=None, matricula=None, rfid=None):
sql="UPDATE funcionarios SET "
lista=[]
if nome != None:
sql=sql+"nome=%s,";
lista.append(nome)
if matricula != None:
sql=sql+"matricula=%s,";
lista.append(matricula)
sql=sql+"rfid=%s,";
lista.append(rfid)
lista.append(id_funcionario)
sql=sql[0:-1] + " WHERE id_funcionario=%s"
self.curs.execute(sql,tuple(lista))
self.conn.commit()
## Retorna o Id do funcionario com o nome igual o da entrada
# @param nome Nome do funcionario
def obter_Id_Funcionario_por_Nome(self, nome):
if not (isinstance(nome, str) or isinstance(nome, unicode)):
return False
self.curs.execute("SELECT id_funcionario FROM funcionarios WHERE nome=%s AND ativo=true",(nome))
linhas = self.curs.fetchall()
self.conn.commit()
return linhas[0][0] if len(linhas)>0 else False
## Retorna o Id do funcionario com a matricula igual a da entrada
# @param matricula Matricula do funcionario
def obter_Id_Funcionario_por_Matricula(self, matricula):
if not (isinstance(matricula, str) or isinstance(matricula, unicode)):
return False
self.curs.execute("SELECT id_funcionario FROM funcionarios WHERE matricula=%s AND ativo=true",(matricula))
linhas = self.curs.fetchall()
self.conn.commit()
return linhas[0][0] if len(linhas)>0 else False
## Retorna o Id do funcionario com a matricula igual a da entrada
# @param matricula Matricula do funcionario
def obter_Id_Funcionario_por_Rfid(self, rfid):
if not (isinstance(rfid, str) or isinstance(rfid, unicode)):
return False
self.curs.execute("SELECT id_funcionario FROM funcionarios WHERE rfid=%s AND ativo=true",(rfid))
linhas = self.curs.fetchall()
self.conn.commit()
return linhas[0][0] if len(linhas)>0 else False
## Cria um horario para um funcionario
# @param id_funcionario Id do funcionario
# @param dia_da_semana Dia da semana no formato INT
# @param hora_inicial Hora inicial no formato HH:MM:SS
# @param hora_final Hora final no formato HH:MM:SS
def criar_Horario(self,id_funcionario,dia_da_semana,hora_inicial,hora_final):
if not isinstance(id_funcionario, long):
return False
if not isinstance(dia_da_semana, int):
return False
if not (isinstance(hora_inicial, str) or isinstance(hora_inicial, unicode)):
return False
if not (isinstance(hora_final, str) or isinstance(hora_final, unicode)):
return False
sql="INSERT INTO horarios (id_funcionario,dia_da_semana,hora_inicial,hora_final) VALUES (%s,%s,%s,%s)"
self.curs.execute(sql,(id_funcionario,dia_da_semana,hora_inicial,hora_final))
self.conn.commit()
return True
## Remove um dos horarios de um funcionario
# @param id_horario Id do horario
def remover_Horario(self,id_horario):
self.curs.execute("DELETE FROM horarios WHERE id_horario=%s ",(id_horario))
self.conn.commit()
## Obtem as configurações do programa
# @param config Nome da configuração
def obter_Configuracoes(self,config):
if not (isinstance(config, str) or isinstance(config, unicode)):
return False
self.curs.execute("SELECT dado FROM configuracoes WHERE tipo=%s",(config))
linhas = self.curs.fetchall()
self.conn.commit()
return linhas[0][0] if len(linhas)>0 else False
## Atualiza as configurações do programa
# @param config Nome da configuração
# @param dado Dado que vai ser inserido
def atualizar_Configuracoes(self,config,dado):
if not (isinstance(config, str) or isinstance(config, unicode)):
return False
if not (isinstance(dado, str) or isinstance(dado, unicode)):
return False
sql="UPDATE configuracoes SET dado=%s WHERE tipo=%s"
self.curs.execute(sql,(dado,config))
self.conn.commit()
return True
## Obtem todos os funcionarios cadastrados
def obter_Funcionarios(self):
self.curs.execute("SELECT id_funcionario,nome FROM funcionarios WHERE ativo=true")
linhas = self.curs.fetchall()
result = []
for i in range(len(linhas)):
if len(linhas[i])==2:
result.append({'id_funcionario':linhas[i][0],'nome':linhas[i][1]})
self.conn.commit()
return result if len(result)>0 else False
## Verifica se algun dos dados ja existem
def verifica_Ja_Existe(self,nome=None,matricula=None,rfid=None,id_funcionario=None):
if nome:
sql="SELECT count(*) FROM funcionarios WHERE nome=%s AND ativo=true"
tup=(nome)
if id_funcionario!=None:
sql=sql+" AND id_funcionario!=%s"
tup=(nome,id_funcionario)
self.curs.execute(sql,tup)
nome = self.curs.fetchall()
nome = nome[0][0]
if nome==0:
nome = None
else:
nome = True
if matricula:
sql="SELECT count(*) FROM funcionarios WHERE matricula=%s AND ativo=true"
tup=(matricula)
if id_funcionario!=None:
sql=sql+" AND id_funcionario!=%s"
tup=(matricula,id_funcionario)
self.curs.execute(sql,tup)
matricula = self.curs.fetchall()
matricula = matricula[0][0]
if matricula==0:
matricula = None
else:
matricula = True
if rfid:
sql="SELECT count(*) FROM funcionarios WHERE rfid=%s AND ativo=true"
tup=(rfid)
if id_funcionario!=None:
sql=sql+" AND id_funcionario!=%s"
tup=(rfid,id_funcionario)
self.curs.execute(sql,tup)
rfid = self.curs.fetchall()
rfid = rfid[0][0]
if rfid==0:
rfid = None
else:
rfid = True
temp=nome or matricula or rfid;
if temp==None:
temp=False
self.conn.commit()
return {'nome':nome,'matricula':matricula,'rfid':rfid,'existe':temp}
## Remove um funcionario do banco de dados e os horarios dele
# @param id_funcionario Id do funcionario
def remover_Funcionario(self,id_funcionario):
if not (isinstance(id_funcionario, long) or isinstance(id_funcionario, int)):
return False
self.curs.execute("UPDATE funcionarios set ativo=false WHERE id_funcionario=%s",(id_funcionario))
self.remover_Horario_Funcionario(id_funcionario)
self.conn.commit()
return True
## Remove todos os horarios de um funcionario
# @param id_funcionario Id do funcionario
def remover_Horario_Funcionario(self,id_funcionario):
self.curs.execute("DELETE FROM horarios WHERE id_funcionario=%s",(id_funcionario))
self.conn.commit()
## Obtem todos os horarios cadastrados
def obter_Horarios(self):
sql="SELECT funcionarios.nome, horarios.dia_da_semana, horarios.hora_inicial, horarios.hora_final FROM horarios INNER JOIN funcionarios ON funcionarios.id_funcionario=horarios.id_funcionario ORDER BY horarios.dia_da_semana ASC,horarios.hora_inicial ASC"
self.curs.execute(sql)
linhas = self.curs.fetchall()
self.conn.commit()
return linhas if len(linhas)>0 else False
## Retorna todos os horarios de um funcionario
# @param id_funcionario Id do funcionario
def buscar_Horarios_de_Funcionario(self,id_funcionario):
self.curs.execute("SELECT id_horario, dia_da_semana, hora_inicial,hora_final FROM horarios WHERE id_funcionario=%s ORDER BY dia_da_semana ASC, hora_inicial ASC",(id_funcionario))
linhas = self.curs.fetchall()
l=[]
if len(linhas)>0:
for i in linhas:
l.append({'id_horario':i[0],'dia_da_semana':i[1],'hora_inicial':i[2],'hora_final':i[3]})
return l if len(l)>0 else False
## Retorna todas as informações do funcionario
# @param id_funcionario Id do funcionario
def obter_Funcionario(self,id_funcionario):
self.curs.execute("SELECT id_funcionario,nome,matricula,rfid,ativo FROM funcionarios WHERE id_funcionario=%s",(id_funcionario))
linhas = self.curs.fetchall()
l={}
if len(linhas)>0:
i=linhas[0]
l={'id_funcionario':i[0],'nome':i[1],'matricula':i[2],'rfid':i[3],'ativo':i[4]}
return l if len(linhas)>0 else False
## Retorna os funcionarios esperados para o horario
# @param dia_da_semana Dia da semana no formato INT
# @param limite_inferior Limite inferior para busca. Formato HH:MM:SS
# @param limite_superior Limite superior para a busca. Formato HH:MM:SS
def buscar_Funcionarios_Esperados(self,dia_da_semana,limite_inferior,limite_superior):
#Adicionado campo horarios.id_horario
self.curs.execute("SELECT funcionarios.nome, funcionarios.id_funcionario, horarios.hora_inicial, horarios.hora_final, horarios.id_horario FROM horarios INNER JOIN funcionarios ON horarios.id_funcionario=funcionarios.id_funcionario WHERE horarios.dia_da_semana=%s AND curtime() >= subtime(horarios.hora_inicial,%s) AND curtime() <= addtime(horarios.hora_final,%s)",(dia_da_semana,limite_inferior,limite_superior))
linhas = self.curs.fetchall()
l={}
if len(linhas)>0:
for i in linhas:
l[str(i[1])]={'nome':i[0],'hora_inicial':i[2],'hora_final':i[3],'id_horario':i[4]}
self.conn.commit()
return l if len(l)>0 else False
## Retorna os funcionarios logados
# @param dia_da_semana Dia da semana no formato INT
# @param limite_inferior Limite inferior para busca. Formato HH:MM:SS
# @param limite_superior Limite superior para a busca. Formato HH:MM:SS
def buscar_Funcionarios_Esperados_Logados(self,dia_da_semana,limite_inferior,limite_superior):
self.curs.execute("SELECT pontos.id_funcionario FROM pontos INNER JOIN horarios ON horarios.id_horario=pontos.id_horario WHERE horarios.dia_da_semana=%s AND curtime() >= subtime(horarios.hora_inicial,%s) AND curtime() <= addtime(horarios.hora_final,%s) AND (pontos.presenca=-1)",(dia_da_semana,limite_inferior,limite_superior))
linhas = self.curs.fetchall()
l=[]
for i in linhas:
l.append(str(i[0]))
self.conn.commit()
return l if len(l)>0 else False
## Verifica se existe ponto aberto de um funcionario
# @param id_funcionario Id do funcionario
def buscar_Ponto_Aberto_de_Funcionario(self,id_funcionario):
self.curs.execute("SELECT pontos.horario_entrada,horarios.hora_inicial,horarios.hora_final FROM pontos INNER JOIN horarios on pontos.id_horario = horarios.id_horario WHERE pontos.presenca=-1 AND pontos.id_funcionario=%s ORDER BY pontos.id_ponto DESC",(id_funcionario)) #Otimizado por ORDER BY
linhas = self.curs.fetchall()
l=False
if len(linhas)>0:
i=linhas[0]
l={'horario_entrada':i[0],'hora_inicial':datetime.datetime.combine(i[0].date(),(datetime.datetime.min+i[1]).time()),'hora_final':datetime.datetime.combine(i[0].date(),(datetime.datetime.min+i[2]).time())}
self.conn.commit()
return l
## Cria o ponto de saida de um funcionario
# @param id_funcionario Id do funcionario
# @param horario_saida Horario de saida no formato YYYY-MM-DD HH:MM:SS
# @presenca 0 para falta. 1 para presença. 2 para ponto nao fechado
def finaliza_Ponto(self,id_funcionario,horario_saida,presenca):
sql="UPDATE pontos SET horario_saida=%s, presenca=%s WHERE id_funcionario=%s AND presenca=-1"
self.curs.execute(sql,(horario_saida,presenca,id_funcionario))
self.conn.commit()
return True
## Retorna o horario mais proximo de um funcionario
# @param id_funcionario Id do funcionario
# @param dia_da_semana Dia da semana no formato INT
# @param limite_inferior Limite inferior para busca. Formato HH:MM:SS
# @param limite_superior Limite superior para a busca. Formato HH:MM:SS
def buscar_Horario_Mais_Proximo_de_Funcionario(self,id_funcionario,dia_da_semana,limite_inferior,limite_superior):
sql="SELECT id_horario FROM horarios WHERE (id_funcionario=%s AND dia_da_semana=%s AND curtime()>SUBTIME(time(hora_inicial),time(%s)) AND curtime()<ADDTIME(time(hora_inicial),time(%s))) ORDER BY ABS(SUBTIME(%s,curtime())) LIMIT 1"
self.curs.execute(sql,(id_funcionario,dia_da_semana,limite_inferior,limite_superior,limite_inferior))
linhas = self.curs.fetchall()
self.conn.commit()
return linhas[0][0] if len(linhas)>0 else False
## Cria o ponto de entrada de um funcionario
# @param id_funcionario Id do funcionario
# @param id_horario Id do horario do funcionario
def criar_Ponto(self,id_funcionario,id_horario,presenca=-1):
sql="INSERT INTO pontos (id_funcionario,id_horario,horario_entrada,presenca) VALUES (%s,%s,now(),%s)"
self.curs.execute(sql,(id_funcionario,id_horario,presenca))
self.conn.commit()
return True
## Cria o ponto de falta de um funcionario
# @param id_funcionario Id do funcionario
# @param id_horario Id do horario do funcionario
def criar_Ponto_Falta(self,id_funcionario,id_horario,entrada_data,entrada_hora):
sql="INSERT INTO pontos (id_funcionario,id_horario,horario_entrada,presenca) VALUES (%s,%s,concat(%s,' ',%s),0)"
self.curs.execute(sql,(id_funcionario,id_horario,entrada_data,entrada_hora))
self.conn.commit()
return True
## Adiciona no log da porta o funcionario que entrou e o horario
# @param id_funcionario Id do funcionario
def adicionar_Log_Porta(self,id_funcionario):
sql="INSERT INTO log_porta (id_funcionario,horario_entrada) VALUES (%s,now())"
self.curs.execute(sql,(id_funcionario))
self.conn.commit()
## Obtem o log da porta dentro de um periodo de tempo
# @param data_inicial Data inicial do log. Formato YYYY-MM-DD HH:MM:SS
# @param data_final Data final do log. Formato YYYY-MM-DD HH:MM:SS
# @return Nome,Matricula,Horario_entrada
def obter_Log_Porta(self,data_inicial,data_final):
self.curs.execute("SELECT funcionarios.nome,funcionarios.matricula,log_porta.horario_entrada FROM log_porta INNER JOIN funcionarios on log_porta.id_funcionario = funcionarios.id_funcionario WHERE (log_porta.horario_entrada >= %s AND log_porta.horario_entrada <= %s )",(data_inicial,data_final))
linhas = self.curs.fetchall()
return linhas if len(linhas)>0 else None
## Obtem o log dos pontos dentro de um periodo de tempo
# @param data_inicial Data inicial do log. Formato YYYY-MM-DD HH:MM:SS
# @param data_final Data final do log. Formato YYYY-MM-DD HH:MM:SS
# @param presentes Mostrar presença de funcionarios
# @param faltas Mostrar falta de funcionarios
# @param atrazos Mostrar atrazos de funcionarios
# @return Nome,Matricula,Horario_entrada,Horario_saida,Presenca
def obter_Log_Pontos(self,data_inicial,data_final):
sql="SELECT funcionarios.nome,funcionarios.matricula,pontos.horario_entrada,pontos.horario_saida,SUBTIME(TIME(pontos.horario_saida),TIME(pontos.horario_entrada)),pontos.presenca FROM pontos INNER JOIN funcionarios on pontos.id_funcionario = funcionarios.id_funcionario WHERE (pontos.horario_entrada >= %s AND pontos.horario_entrada <= %s)"
self.curs.execute(sql,(data_inicial,data_final))
linhas = self.curs.fetchall()
return linhas if len(linhas)>0 else None
## Obtem os pontos que não foram dados
# @param data_inicial Data inicial no formato YYYY-MM-DD HH:MM:SS
# @param data_final Data final no formato YYYY-MM-DD HH:MM:SS
# @param dia_da_semana Dia da semana inteiro
# @param limite_superior_ent Limite superior de entrada no formato HH:MM:SS
def obter_Pontos_Faltando(self,data_inicial,data_final,dia_da_semana=None,limite_superior_ent=None):
sql='SELECT id_horario_2,id_funcionario, hora_inicial,dia_da_semana FROM (SELECT pontos2.id_horario AS id_horario_1,horarios.id_horario AS id_horario_2, horarios.id_funcionario,horarios.hora_inicial,horarios.dia_da_semana FROM (SELECT pontos.* FROM pontos where horario_entrada>=%s and horario_entrada<=%s) AS pontos2 right join horarios on pontos2.id_horario=horarios.id_horario'
dados=(data_inicial,data_final)
if dia_da_semana!=None:
sql=sql+" where horarios.dia_da_semana=%s "
dados=(data_inicial,data_final,dia_da_semana)
if limite_superior_ent!=None:
sql=sql+"and SUBTIME(curtime(),time(horarios.hora_inicial))<=time(%s)"
dados=(data_inicial,data_final,dia_da_semana,limite_superior_ent)
sql=sql+") AS tabelaTemp where id_horario_1 IS NULL"
self.curs.execute(sql,dados)
linhas = self.curs.fetchall()
return linhas if len(linhas)>0 else False
## Seta o funcionario como presente
# @param id_funcionario Id do funcionario
# @param horario_entrada Horario de entrada do funcionario
# @param limite_superior_entrada Tempo limite de entrada do funcionario
def atualiza_Ponto(self, id_funcionario, horario_entrada, limite_inferior_entrada, limite_superior_entrada):
sql="UPDATE pontos SET horario_entrada=%s, presenca=%s WHERE id_funcionario=%s AND presenca=0 AND NOW() >= subtime(pontos.horario_entrada,%s) AND NOW() <= addtime(pontos.horario_entrada,%s)"
self.curs.execute(sql,(horario_entrada,-1,id_funcionario, limite_inferior_entrada, limite_superior_entrada))
self.conn.commit()
return True
## Fecha todos os pontos ainda abertos ate o dia anterior
def fecha_pontos_abertos(self):
sql="UPDATE pontos SET presenca=%s WHERE presenca=-1 AND subtime(NOW(),'1 0:0:0') > pontos.horario_entrada"
self.curs.execute(sql,(2))
self.conn.commit()
return True
## Procura ponto recente de funcionario
# @param id_funcionario Id do funcionario
# @param presenca1 Tipo de presenca a ser procurada
# @param presenca2 Tipo de presenca a ser procurada
def procura_ponto_recente(self, id_funcionario, presenca1=-1, presenca2=0):
#sql="SELECT pontos.id_ponto FROM pontos INNER JOIN horarios ON pontos.id_horario = horarios.id_horario WHERE pontos.id_funcionario = %s AND DATEDIFF(CURDATE(), pontos.horario_entrada) < 1 AND (TIMEDIFF(CURTIME(), horarios.hora_final) < ADDTIME((SELECT dado FROM configuracoes WHERE tipo='tol_sai_dep'), '00:05:00' ) AND ( pontos.presenca = %s OR pontos.presenca = %s )"
sql="SELECT pontos.id_ponto FROM pontos INNER JOIN horarios ON pontos.id_horario = horarios.id_horario WHERE pontos.id_funcionario = %s AND DATEDIFF(CURDATE(), pontos.horario_entrada) < 1 AND TIMEDIFF(CURTIME(), horarios.hora_final) < '02:00:00' AND ( pontos.presenca = %s OR pontos.presenca = %s )" #EU ODEIO O WINDOWS
self.curs.execute(sql,(id_funcionario, presenca1, presenca2))
linhas = self.curs.fetchall()
l=False
if len(linhas)>0:
l=linhas[0][0]
self.conn.commit()
return l
## Fecha ponto ao deslogar o usuario
# @param id_ponto Id do ponto
def fecha_ponto_ao_deslogar_usuario(self, id_ponto):
sql="UPDATE pontos SET presenca=%s WHERE pontos.id_ponto = %s"
self.curs.execute(sql,(2, id_ponto))
self.conn.commit()
return True