def __init__(self):
"""
Inicialisação dos campos no menu
"""
self.problema = None
self.JP = JanelaProblema()
self.ge_dic_param_sis = dict()
self.Pr = Parametros()
self.ge_dic_param_sis = self.Pr.carrega_parametros()
if not self.ge_dic_param_sis:
self.problema = 'Dicionario de parametros vazio ou não localizado'
logging.error(self.problema)
self.JP.msgerro(janela=None,
texto_primario="Parametros",
texto_secundario=self.problema)
exit(1)
try:
self.lg = LogSistema(dic_param_sis=self.ge_dic_param_sis)
except IOError as problema_lg:
logging.error(problema_lg)
self.JP.msgerro(janela=None,
texto_primario="Log",
texto_secundario=problema_lg)
exit(1)
self.caminho_src = abspath(dirname(__file__))
self.builder = Gtk.Builder()
try:
self.caminho_tela = '/'.join([
self.caminho_src, 'glade',
self.ge_dic_param_sis['AMBIENTE_TELA']
])
self.builder.add_objects_from_file(self.caminho_tela,
["w00_principal"])
except Exception as problema_tl:
logging.error(problema_tl)
self.JP.msgerro(janela=None,
texto_primario="Telas do sistema",
texto_secundario=problema_tl)
exit(1)
self.builder.connect_signals(self)
self.w00 = self.builder.get_object("w00_principal")
# self.w00.set_title("Controle de Solicitação de Taxi")
# self.w00.maximize()
self.w00.set_visible(True)
self.w00.show_all()
Gtk.main()
def __init__(self, **kwarg):
self.ge_dic_param_sis = dict()
self.JP = JanelaProblema()
if kwarg['dic_param_sis']:
self.ge_dic_param_sis = kwarg['dic_param_sis']
else:
msg = 'Esta faltando os parametros do sistema'
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Pesquisa de Condomínio",
texto_secundario=msg)
exit(1)
class PesqCondominio:
def __init__(self, **kwarg):
self.ge_dic_param_sis = dict()
self.JP = JanelaProblema()
if kwarg['dic_param_sis']:
self.ge_dic_param_sis = kwarg['dic_param_sis']
else:
msg = 'Esta faltando os parametros do sistema'
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Pesquisa de Condomínio",
texto_secundario=msg)
exit(1)
def pesquisar_condominios(self):
"""
Faz a leitura de todos os condomínios cadastrados no banco
:return: lista de dicionarios com todos os campos por ordem de a01_nome
"""
lst_dic = []
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
cur.execute("""SELECT * FROM a01_condominio ORDER BY a01_nome ASC ;""")
except psycopg2.Error as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Pesquisa de Condomínio",
texto_secundario=msg)
exit(1)
return False
try:
registros = cur.fetchall()
except Exception as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Pesquisa de Condomínio",
texto_secundario=msg)
exit(1)
return False
if not registros:
lst_dic = []
return lst_dic
cur.close()
conn.close()
del conn, cur
for registro in registros:
lst_dic.append(dict(registro))
return lst_dic
class PesqCondominio:
def __init__(self, **kwarg):
self.ge_dic_param_sis = dict()
self.JP = JanelaProblema()
if kwarg['dic_param_sis']:
self.ge_dic_param_sis = kwarg['dic_param_sis']
else:
msg = 'Esta faltando os parametros do sistema'
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Pesquisa de Condomínio",
texto_secundario=msg)
exit(1)
def pesquisar_condominios(self):
"""
Faz a leitura de todos os condomínios cadastrados no banco
:return: lista de dicionarios com todos os campos por ordem de a01_nome
"""
lst_dic = []
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
cur.execute(
"""SELECT * FROM a01_condominio ORDER BY a01_nome ASC ;""")
except psycopg2.Error as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Pesquisa de Condomínio",
texto_secundario=msg)
exit(1)
return False
try:
registros = cur.fetchall()
except Exception as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Pesquisa de Condomínio",
texto_secundario=msg)
exit(1)
return False
if not registros:
lst_dic = []
return lst_dic
cur.close()
conn.close()
del conn, cur
for registro in registros:
lst_dic.append(dict(registro))
return lst_dic
def __init__(self, **kwarg):
self.ge_dic_param_sis = dict()
self.JP = JanelaProblema()
if kwarg['dic_param_sis']:
self.ge_dic_param_sis = kwarg['dic_param_sis']
else:
msg = 'Esta faltando os parametros do sistema'
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Pesquisa de Condomínio",
texto_secundario=msg)
exit(1)
def __init__(self, **kwarg):
# self.ge_dic_dados = dict()
self.ge_dic_param_sis = dict()
self.ge_selecionado = False
self.ge_id_condominio = 0
self.ge_id_portaria = 0
self.col_cb02_a01_id_condominio = 0
self.col_cb02_a01_nome = 1
self.col_tv02_a02_id_condominio = 0
self.col_tv02_a02_id_portaria = 1
self.col_tv02_a02_nome_portaria = 2
self.col_tv02_dados_portaria = 3
self.JP = JanelaProblema()
self.CBD = ComboBoxDados()
if kwarg['dic_param_sis']:
self.ge_dic_param_sis = kwarg['dic_param_sis']
else:
msg = 'Esta faltando os parametros do sistema'
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
exit(1)
self.ge_selecionado = False
self.PC = PesqCondominio(dic_param_sis=self.ge_dic_param_sis)
self.builder = Gtk.Builder()
try:
self.Caminho = '/'.join([
abspath(dirname(__file__)), 'glade',
self.ge_dic_param_sis['AMBIENTE_TELA']
])
self.builder.add_objects_from_file(self.Caminho, ["w02_portaria"])
except Exception as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
exit(1)
self.builder.connect_signals(self)
self.w02 = self.builder.get_object("w02_portaria")
self.w02.set_title("Cadastro de Portaria")
# ----------------------
self.cb02_a02_id_condominio = self.builder.get_object(
"cb02_a02_id_condominio")
self.lst_cb02 = Gtk.ListStore(str, str)
self.cb02_a02_id_condominio.set_model(self.lst_cb02)
self.desenha_cb02(cb=self.cb02_a02_id_condominio, lista=self.lst_cb02)
registros = self.PC.pesquisar_condominios()
# registros = self.carregar_condominio()
self.preencher_combo_condominio(lista=self.lst_cb02, res=registros)
# --------------------------
# self.set_dado_combo(combobox=self.cb02_a02_id_condominio,
# text=1,
# coluna=self.col_cb02_a01_id_condominio)
# --------------------------
self.l02_a02_nome_portaria = self.builder.get_object(
"l02_a02_nome_portaria")
self.l02_a02_nome_portaria.set_markup(
"<b>{a}</b>".format(a=self.l02_a02_nome_portaria.get_text()))
self.e02_a02_nome_portaria = self.builder.get_object(
"e02_a02_nome_portaria")
self.l02_a02_endereco = self.builder.get_object("l02_a02_endereco")
self.l02_a02_endereco.set_markup(
"{a}".format(a=self.l02_a02_endereco.get_text()))
self.e02_a02_endereco = self.builder.get_object("e02_a02_endereco")
self.l02_a02_numero = self.builder.get_object("l02_a02_numero")
self.l02_a02_numero.set_markup(
"{a}".format(a=self.l02_a02_numero.get_text()))
self.e02_a02_numero = self.builder.get_object("e02_a02_numero")
self.tv02_a02 = self.builder.get_object("tv02_a02")
self.lst_tv02 = Gtk.ListStore(str, str, str, str)
self.desenha_tv02(tv=self.tv02_a02)
self.tv02_a02.set_model(self.lst_tv02)
self.w02.set_visible(True)
self.w02.show_all()
class CadPortaria:
def __init__(self, **kwarg):
# self.ge_dic_dados = dict()
self.ge_dic_param_sis = dict()
self.ge_selecionado = False
self.ge_id_condominio = 0
self.ge_id_portaria = 0
self.col_cb02_a01_id_condominio = 0
self.col_cb02_a01_nome = 1
self.col_tv02_a02_id_condominio = 0
self.col_tv02_a02_id_portaria = 1
self.col_tv02_a02_nome_portaria = 2
self.col_tv02_dados_portaria = 3
self.JP = JanelaProblema()
self.CBD = ComboBoxDados()
if kwarg['dic_param_sis']:
self.ge_dic_param_sis = kwarg['dic_param_sis']
else:
msg = 'Esta faltando os parametros do sistema'
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
exit(1)
self.ge_selecionado = False
self.PC = PesqCondominio(dic_param_sis=self.ge_dic_param_sis)
self.builder = Gtk.Builder()
try:
self.Caminho = '/'.join([
abspath(dirname(__file__)), 'glade',
self.ge_dic_param_sis['AMBIENTE_TELA']
])
self.builder.add_objects_from_file(self.Caminho, ["w02_portaria"])
except Exception as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
exit(1)
self.builder.connect_signals(self)
self.w02 = self.builder.get_object("w02_portaria")
self.w02.set_title("Cadastro de Portaria")
# ----------------------
self.cb02_a02_id_condominio = self.builder.get_object(
"cb02_a02_id_condominio")
self.lst_cb02 = Gtk.ListStore(str, str)
self.cb02_a02_id_condominio.set_model(self.lst_cb02)
self.desenha_cb02(cb=self.cb02_a02_id_condominio, lista=self.lst_cb02)
registros = self.PC.pesquisar_condominios()
# registros = self.carregar_condominio()
self.preencher_combo_condominio(lista=self.lst_cb02, res=registros)
# --------------------------
# self.set_dado_combo(combobox=self.cb02_a02_id_condominio,
# text=1,
# coluna=self.col_cb02_a01_id_condominio)
# --------------------------
self.l02_a02_nome_portaria = self.builder.get_object(
"l02_a02_nome_portaria")
self.l02_a02_nome_portaria.set_markup(
"<b>{a}</b>".format(a=self.l02_a02_nome_portaria.get_text()))
self.e02_a02_nome_portaria = self.builder.get_object(
"e02_a02_nome_portaria")
self.l02_a02_endereco = self.builder.get_object("l02_a02_endereco")
self.l02_a02_endereco.set_markup(
"{a}".format(a=self.l02_a02_endereco.get_text()))
self.e02_a02_endereco = self.builder.get_object("e02_a02_endereco")
self.l02_a02_numero = self.builder.get_object("l02_a02_numero")
self.l02_a02_numero.set_markup(
"{a}".format(a=self.l02_a02_numero.get_text()))
self.e02_a02_numero = self.builder.get_object("e02_a02_numero")
self.tv02_a02 = self.builder.get_object("tv02_a02")
self.lst_tv02 = Gtk.ListStore(str, str, str, str)
self.desenha_tv02(tv=self.tv02_a02)
self.tv02_a02.set_model(self.lst_tv02)
self.w02.set_visible(True)
self.w02.show_all()
def on_b02_fechar_clicked(self, widget):
"""
:param:
:return:
"""
# tela = widget.get_parent_window()
# tela.destroy()
# self.w02.destroy()
self.w02.destroy()
def on_b02_salvar_clicked(self, widget):
"""
executa as rotina para salvar e validas os campos de tela
:param:
:return:
"""
# dados_salvos = False
dic_dados = self.validar_campos()
if not dic_dados:
return False
if self.ge_selecionado:
dados_salvos = self.alterar(dic_dados=dic_dados)
else:
dados_salvos = self.incluir(dic_dados=dic_dados)
if dados_salvos:
id_condominio = self.ge_id_condominio
self.limpar_tela()
self.ge_id_condominio = id_condominio
res = self.pesquisar_portarias(id_condominio=self.ge_id_condominio)
self.mostrar_dados_tv02(lista=self.lst_tv02, res=res)
else:
msg = "Problemas ao salvar informações"
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
def on_b02_excluir_clicked(self, widget):
"""
Apaga portaria selecionada
:return:
"""
apagado = False
dic_dados = self.validar_campos()
if not dic_dados:
return False
if self.ge_selecionado:
apagado = self.apagar_portaria(
id_portaria=dic_dados['a02_id_portaria'])
else:
msg = "Selecione uma portaria para apagar"
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
if apagado:
id_condominio = self.ge_id_condominio
self.limpar_tela()
res = self.pesquisar_portarias(id_condominio=id_condominio)
self.mostrar_dados_tv02(lista=self.lst_tv02, res=res)
else:
msg = "Problemas ao Apagar Portaria"
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
exit(1)
def on_cb02_a02_id_condominio_changed(self, widget):
"""
Prepara dados para ser mostrado no combobox bem como item selecionado do combo
:param widget:
:return:
"""
try:
id_condominio = self.CBD.get_dado_combo(
comboboxm=widget, col_traz=self.col_cb02_a01_id_condominio)
res = self.pesquisar_portarias(id_condominio=id_condominio)
self.lst_tv02.clear()
if res:
self.mostrar_dados_tv02(lista=self.lst_tv02, res=res)
self.ge_id_condominio = id_condominio
except AttributeError:
pass
def validar_campos(self):
"""
Validação dos campos para salvar no banco de e dados
:return: Se retorna dic_dados = False então tem problemas nos dados
Se retorna dic_dados com valors em um dicionario em pode salvar no banco de dados
"""
dic_dados = dict()
valido = True
numerovalido = re.compile(r'[0-9]')
if self.ge_id_condominio == 0:
valido = False
else:
dic_dados['a02_id_condominio'] = self.ge_id_condominio
dic_dados['a02_id_portaria'] = self.ge_id_portaria
if len(str(self.e02_a02_nome_portaria.get_text().strip())) == 0:
dic_dados = {}
self.e02_a02_nome_portaria.set_icon_from_icon_name(
Gtk.EntryIconPosition.PRIMARY, "dialog-error")
self.e02_a02_nome_portaria.grab_focus()
valido = False
else:
dic_dados['a02_nome_portaria'] = str(
self.e02_a02_nome_portaria.get_text().strip())
self.e02_a02_nome_portaria.set_icon_from_icon_name(
Gtk.EntryIconPosition.PRIMARY, None)
if len(str(self.e02_a02_endereco.get_text().strip())) > 0:
dic_dados['a02_endereco'] = str(
self.e02_a02_endereco.get_text().strip())
else:
dic_dados['a02_endereco'] = None
if len(str(self.e02_a02_numero.get_text().strip())) > 0:
wcampo = numerovalido.sub('',
self.e02_a02_numero.get_text().strip())
if len(wcampo) > 0:
dic_dados = {}
self.e02_a02_numero.set_icon_from_icon_name(
Gtk.EntryIconPosition.PRIMARY, "dialog-error")
self.e02_a02_numero.grab_focus()
valido = False
else:
dic_dados['a02_numero'] = self.e02_a02_numero.get_text()
self.e02_a02_numero.set_icon_from_icon_name(
Gtk.EntryIconPosition.PRIMARY, None)
if valido is False:
dic_dados = False
return dic_dados
def limpar_tela(self):
"""
Limpeza de campos de tela e variaveis de trabalho
"""
# self.ge_dic_dados = dict()
self.ge_selecionado = False
self.ge_id_condominio = 0
self.ge_id_portaria = 0
self.e02_a02_nome_portaria.set_text('')
self.e02_a02_endereco.set_text('')
self.e02_a02_numero.set_text('')
self.e02_a02_nome_portaria.set_icon_from_icon_name(
Gtk.EntryIconPosition.PRIMARY, None)
self.e02_a02_endereco.set_icon_from_icon_name(
Gtk.EntryIconPosition.PRIMARY, None)
self.e02_a02_numero.set_icon_from_icon_name(
Gtk.EntryIconPosition.PRIMARY, None)
def alterar(self, dic_dados):
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
except psycopg2.ProgrammingError as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
return False
cur = conn.cursor()
try:
sql = """
UPDATE a02_portarias SET
a02_nome_portaria = %s,
a02_endereco = %s,
a02_numero = %s
WHERE a02_id_condominio = %s
AND a02_id_portaria = %s;
""", (
dic_dados['a02_nome_portaria']
if "a02_nome_portaria" in dic_dados else None,
dic_dados['a02_endereco']
if "a02_endereco" in dic_dados else None,
dic_dados['a02_numero'] if "a02_numero" in dic_dados else 0,
dic_dados['a02_id_condominio']
if "a02_id_condominio" in dic_dados else 0,
dic_dados['a02_id_portaria']
if "a02_id_portaria" in dic_dados else 0,
)
cur.execute(sql)
except psycopg2.DatabaseError as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
return False
conn.commit()
cur.close()
del conn, cur
return True
def incluir(self, dic_dados):
"""
inclução dos dados no banco de dados
retorna True caso a inclução no banco de dados seja bem sucedida
returna False caso a inclução no banco dee dados seja mal sucedida
:param dic_dados: dicionario de dados validos
:return boolean:
"""
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
except psycopg2.ProgrammingError as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
return False
cur = conn.cursor()
sql = """
INSERT INTO a02_portarias
(
a02_id_condominio,
a02_nome_portaria,
a02_endereco,
a02_numero
) VALUES(
%s,
%s,
%s,
%s
);
""", (
dic_dados['a02_id_condominio']
if "a02_id_condominio" in dic_dados else 0,
dic_dados['a02_nome_portaria']
if "a02_nome_portaria" in dic_dados else None,
dic_dados['a02_endereco'] if "a02_endereco" in dic_dados else None,
dic_dados['a02_numero'] if "a02_numero" in dic_dados else 0,
)
try:
cur.execute(sql)
except psycopg2.DatabaseError as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
return False
conn.commit()
cur.close()
del conn, cur
return True
def apagar_portaria(self, id_portaria):
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
except psycopg2.ProgrammingError as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
return False
cur = conn.cursor()
try:
sql = """
DELETE from a02_portarias WHERE a02_id_portaria = %s;
""", (id_portaria, )
cur.execute(sql)
except psycopg2.DatabaseError as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
return False
conn.commit()
cur.close()
del conn, cur
return True
def mostrar_dados_tv02(self, lista, res):
lista.clear()
for i in res:
lista.append([
str(i['a02_id_condominio']),
str(i['a02_id_portaria']),
str(i['a02_nome_portaria']),
str(i['dados_portaria']),
])
def desenha_cb02(self, cb, lista):
"""
DESENHA AS COLUNAS DO COMBO QUE IRÁ CONTER OS TIPOS DISPONIVEL
:param cb:
:param lista:
:return:
"""
cb.set_model(lista)
cb.set_active(self.col_cb02_a01_id_condominio)
cell_a01_id_condominio = Gtk.CellRendererText()
cb.pack_start(cell_a01_id_condominio, True)
cb.add_attribute(cell_a01_id_condominio, "text",
self.col_cb02_a01_id_condominio)
cell_a01_id_condominio.set_visible(False)
cell_a01_nome = Gtk.CellRendererText()
cb.pack_start(cell_a01_nome, True)
cb.add_attribute(cell_a01_nome, "text", self.col_cb02_a01_nome)
cell_a01_nome.set_visible(True)
def desenha_tv02(self, tv):
tv.set_rules_hint(True)
tv.set_grid_lines(3)
# TV_PEN.set_has_tooltip(True)
tv.set_property("headers-visible", True)
cell_tv02_a02_id_condominio = Gtk.CellRendererText()
col_tv02_a02_id_condominio = Gtk.TreeViewColumn(
"ID.Condominio",
cell_tv02_a02_id_condominio,
text=self.col_tv02_a02_id_condominio)
col_tv02_a02_id_condominio.set_visible(False)
tv.append_column(col_tv02_a02_id_condominio)
cell_tv02_a02_id_portaria = Gtk.CellRendererText()
col_tv02_a02_id_portaria = Gtk.TreeViewColumn(
"ID.Portaria",
cell_tv02_a02_id_portaria,
text=self.col_tv02_a02_id_portaria)
col_tv02_a02_id_portaria.set_visible(False)
tv.append_column(col_tv02_a02_id_portaria)
cel_tv02_a02_nome_portaria = Gtk.CellRendererText()
col_tv02_a02_nome_portaria = Gtk.TreeViewColumn(
"Nome",
cel_tv02_a02_nome_portaria,
text=self.col_tv02_a02_nome_portaria)
col_tv02_a02_nome_portaria.set_visible(True)
tv.append_column(col_tv02_a02_nome_portaria)
col_tv02_a02_nome_portaria.connect("clicked", self.clicado_col_tv02,
tv, self.col_tv02_a02_nome_portaria)
col_tv02_a02_nome_portaria.set_reorderable(True)
cel_tv02_dados_portaria = Gtk.CellRendererText()
col_tv02_dados_portaria = Gtk.TreeViewColumn(
"Endereço",
cel_tv02_dados_portaria,
text=self.col_tv02_dados_portaria)
col_tv02_dados_portaria.set_visible(True)
tv.append_column(col_tv02_dados_portaria)
col_tv02_dados_portaria.connect("clicked", self.clicado_col_tv02, tv,
self.col_tv02_dados_portaria)
col_tv02_dados_portaria.set_reorderable(True)
tv.set_enable_search(True)
tv.set_headers_clickable(True)
def clicado_col_tv02(self, widget, tv, coluna):
"""
habilita pesquisa de tv
"""
tv.set_enable_search(True)
widget.set_sort_column_id(coluna)
tv.set_search_column(coluna)
def pesquisar_portarias(self, id_condominio=0):
lst_dic_dados = []
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
cur.execute(
""" select a02_id_condominio,
a02_id_portaria,
a02_nome_portaria,
concat(a02_endereco, ', ', a02_numero) as dados_portaria
from a01_condominio, a02_portarias
WHERE a01_id_condominio = a02_portarias.a02_id_condominio
and a01_id_condominio = %s
order by upper(a02_nome_portaria);
""", (id_condominio, ))
registros = cur.fetchall()
except psycopg2.ProgrammingError as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
return False
for registro in registros:
lst_dic_dados.append(dict(registro))
if not registros:
return False
cur.close()
del conn, cur, registros
return lst_dic_dados
def on_tv02_a02_key_press_event(self, widget, event):
keyval = Gdk.keyval_name(event.keyval)
if keyval == 'Return' or keyval == 'KP_Enter':
selection = widget.get_selection()
modelx, iterx = selection.get_selected()
self.limpar_tela()
try:
id_condominio = str(
modelx.get_value(iterx, self.col_tv02_a02_id_condominio))
id_portaria = str(
modelx.get_value(iterx, self.col_tv02_a02_id_portaria))
self.ge_id_condominio = id_condominio
self.ge_id_portaria = id_portaria
except ValueError:
return False
finally:
self.ge_selecionado = True
dic_portaria = self.consulta_portaria(id_condominio=id_condominio,
id_portaria=id_portaria)
if len(dic_portaria) != 0:
self.mostrar_dados_tela(dic_portaria=dic_portaria)
# self.ge_dic_dados = dic_portaria
self.ge_selecionado = True
else:
self.limpar_tela()
def preencher_combo_condominio(self, lista, res):
lista.clear()
for i in res:
lista.append([
str(i['a01_id_condominio']),
str(i['a01_nome']) if i['a01_nome'] else None,
])
def consulta_portaria(self, id_condominio, id_portaria):
dic_dados = {}
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
cur.execute(
""" SELECT *
FROM a02_portarias
WHERE a02_id_condominio = %s
AND a02_id_portaria = %s;
;
""", (id_condominio, id_portaria))
registros = cur.fetchall()
except psycopg2.ProgrammingError as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
return False
for registro in registros:
dic_dados = dict(registro)
if not registros:
return False
cur.close()
del conn, cur, registros
return dic_dados
def mostrar_dados_tela(self, dic_portaria):
for key, value in dic_portaria.items():
if key == 'a02_nome_portaria':
if value is not None:
self.e02_a02_nome_portaria.set_text(str(value))
else:
self.e02_a02_nome_portaria.set_text('')
if key == 'a02_endereco':
if value is not None:
self.e02_a02_endereco.set_text(str(value))
else:
self.e02_a02_endereco.set_text('')
if key == 'a02_numero':
if value > 0:
self.e02_a02_numero.set_text(str(value))
else:
self.e02_a02_numero.set_text('')
class MenuPrinc:
def __init__(self):
"""
Inicialisação dos campos no menu
"""
self.problema = None
self.JP = JanelaProblema()
self.ge_dic_param_sis = dict()
self.Pr = Parametros()
self.ge_dic_param_sis = self.Pr.carrega_parametros()
if not self.ge_dic_param_sis:
self.problema = 'Dicionario de parametros vazio ou não localizado'
logging.error(self.problema)
self.JP.msgerro(janela=None,
texto_primario="Parametros",
texto_secundario=self.problema)
exit(1)
try:
self.lg = LogSistema(dic_param_sis=self.ge_dic_param_sis)
except IOError as problema_lg:
logging.error(problema_lg)
self.JP.msgerro(janela=None,
texto_primario="Log",
texto_secundario=problema_lg)
exit(1)
self.caminho_src = abspath(dirname(__file__))
self.builder = Gtk.Builder()
try:
self.caminho_tela = '/'.join([
self.caminho_src, 'glade',
self.ge_dic_param_sis['AMBIENTE_TELA']
])
self.builder.add_objects_from_file(self.caminho_tela,
["w00_principal"])
except Exception as problema_tl:
logging.error(problema_tl)
self.JP.msgerro(janela=None,
texto_primario="Telas do sistema",
texto_secundario=problema_tl)
exit(1)
self.builder.connect_signals(self)
self.w00 = self.builder.get_object("w00_principal")
# self.w00.set_title("Controle de Solicitação de Taxi")
# self.w00.maximize()
self.w00.set_visible(True)
self.w00.show_all()
Gtk.main()
def on_mnu_cad_condominio_activate(self, widget):
"""
Chama o cadastro de condominios
:param widget:
:return:
"""
titulo = widget.get_label().strip('_')
CadCondominio(dic_param_sis=self.ge_dic_param_sis, titulo=titulo)
def on_mnu_cad_portaria_activate(self, widget):
"""
Chama o cadatro de portarias
:param widget:
:return:
"""
titulo = widget.get_label().strip('_')
CadPortaria(dic_param_sis=self.ge_dic_param_sis, titulo=titulo)
def on_mnu_cad_bloco_activate(self, widget):
"""
Chama o cadastro de blocos
:param widget:
:return:
"""
titulo = widget.get_label().strip('_')
CadBloco(dic_param_sis=self.ge_dic_param_sis, titulo=titulo)
def on_w00_principal_delete_event(self):
"""
Saida do sistema
:return:
"""
Gtk.main_quit()
def on_w00_principal_destroy(self, widget):
"""
Saida do sistema
:return:
"""
Gtk.main_quit()
def on_w00_principal_destroy_event(self):
"""
Saida do sistema
:return:
"""
Gtk.main_quit()
def __init__(self, **kwarg):
logging.info('entrei no cadbloco')
#
# rotina para salvar em string quem chamou e quem foi chamada
#
# import traceback
# stack = traceback.extract_stack()
# chamador_filename, chamador_codeline, chamador_funcName, chamador_text = stack[-2]
# print(inspect.getframeinfo(inspect.currentframe())[2])
# print(chamador_filename, chamador_codeline, chamador_funcName, chamador_text)
# chamado_filename, chamado_codeline, chamado_funcName, chamado_text = stack[-1]
# print(inspect.getframeinfo(inspect.currentframe())[2])
# print(chamado_filename, chamado_codeline, chamado_funcName, chamado_text)
self.col_a01_id_condominio = 0
self.col_a01_nome = 1
self.col_a03_id_condominio = 0
self.col_a03_id_bloco = 1
self.col_a03_nome_bloco = 2
self.ge_dic_dados = dict()
self.ge_dic_param_sis = dict()
self.ge_selecionado = False
self.ge_titulo = None
self.ge_a03_id_bloco = 0
self.JP = JanelaProblema()
if kwarg['dic_param_sis']:
self.ge_dic_param_sis = kwarg['dic_param_sis']
else:
msg = 'Esta faltando os parametros do sistema'
logging.error(msg)
self.JP.msgerro(janela=None,
texto_secundario=msg)
exit(1)
if kwarg['titulo']:
self.ge_titulo = kwarg['titulo']
else:
msg = 'Esta faltando o parametro Título do sistema'
logging.error(msg)
self.JP.msgerro(janela=None,
texto_secundario=msg)
exit(1)
self.CBD = ComboBoxDados()
self.PC = PesqCondominio(dic_param_sis=self.ge_dic_param_sis)
self.PB = PesqBloco(dic_param_sis=self.ge_dic_param_sis)
self.ge_a01_id_condominio = None
self.ge_selecionado = False
self.builder = Gtk.Builder()
try:
self.caminho = '/'.join([abspath(dirname(__file__)), 'glade', self.ge_dic_param_sis['AMBIENTE_TELA']])
self.builder.add_objects_from_file(self.caminho, ["w03_bloco"])
except Exception as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_secundario=msg)
exit(1)
self.builder.connect_signals(self)
self.w03 = self.builder.get_object("w03_bloco")
self.w03.set_title(self.ge_titulo)
self.l03_a03_id_condominio = self.builder.get_object("l03_a03_id_condominio")
self.l03_a03_id_condominio.set_markup("<b>{a}</b>".format(a=self.l03_a03_id_condominio.get_text()))
self.cb03_a03_id_condominio = self.builder.get_object("cb03_a03_id_condominio")
# PREPARAÇÃO DO cb03_a03_id_condominio
self.lst_cb03_a03_id_condominio = Gtk.ListStore(str, str)
self.desenha_cb03_a03_id_condominio(cb=self.cb03_a03_id_condominio, lista=self.lst_cb03_a03_id_condominio)
registros = self.PC.pesquisar_condominios()
self.preencher_combo_condominio(lista=self.lst_cb03_a03_id_condominio, lst_dic_condominio=registros)
# ----------------------
self.l03_e03_a03_nome_bloco = self.builder.get_object("l03_e03_a03_nome_bloco")
self.l03_e03_a03_nome_bloco.set_markup("<b>{a}</b>".format(a=self.l03_e03_a03_nome_bloco.get_text()))
self.e03_a03_nome_bloco = self.builder.get_object("e03_a03_nome_bloco")
# PREPARAÇÃO DO TREEVIEW
self.tv03_a03 = self.builder.get_object("tv03_a03")
self.lst_tv03 = Gtk.ListStore(str, str, str)
self.tv03_a03.set_model(self.lst_tv03)
self.desenha_tv03(tv=self.tv03_a03)
# res = self.pesquisar_bloco()
# self.preencher_bloco(lista=self.lst_tv03, res=res)
# -------------------------------------------------------------------
self.w03.set_visible(True)
self.w03.show_all()
class CadBloco:
def __init__(self, **kwarg):
logging.info('entrei no cadbloco')
#
# rotina para salvar em string quem chamou e quem foi chamada
#
# import traceback
# stack = traceback.extract_stack()
# chamador_filename, chamador_codeline, chamador_funcName, chamador_text = stack[-2]
# print(inspect.getframeinfo(inspect.currentframe())[2])
# print(chamador_filename, chamador_codeline, chamador_funcName, chamador_text)
# chamado_filename, chamado_codeline, chamado_funcName, chamado_text = stack[-1]
# print(inspect.getframeinfo(inspect.currentframe())[2])
# print(chamado_filename, chamado_codeline, chamado_funcName, chamado_text)
self.col_a01_id_condominio = 0
self.col_a01_nome = 1
self.col_a03_id_condominio = 0
self.col_a03_id_bloco = 1
self.col_a03_nome_bloco = 2
self.ge_dic_dados = dict()
self.ge_dic_param_sis = dict()
self.ge_selecionado = False
self.ge_titulo = None
self.ge_a03_id_bloco = 0
self.JP = JanelaProblema()
if kwarg['dic_param_sis']:
self.ge_dic_param_sis = kwarg['dic_param_sis']
else:
msg = 'Esta faltando os parametros do sistema'
logging.error(msg)
self.JP.msgerro(janela=None,
texto_secundario=msg)
exit(1)
if kwarg['titulo']:
self.ge_titulo = kwarg['titulo']
else:
msg = 'Esta faltando o parametro Título do sistema'
logging.error(msg)
self.JP.msgerro(janela=None,
texto_secundario=msg)
exit(1)
self.CBD = ComboBoxDados()
self.PC = PesqCondominio(dic_param_sis=self.ge_dic_param_sis)
self.PB = PesqBloco(dic_param_sis=self.ge_dic_param_sis)
self.ge_a01_id_condominio = None
self.ge_selecionado = False
self.builder = Gtk.Builder()
try:
self.caminho = '/'.join([abspath(dirname(__file__)), 'glade', self.ge_dic_param_sis['AMBIENTE_TELA']])
self.builder.add_objects_from_file(self.caminho, ["w03_bloco"])
except Exception as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_secundario=msg)
exit(1)
self.builder.connect_signals(self)
self.w03 = self.builder.get_object("w03_bloco")
self.w03.set_title(self.ge_titulo)
self.l03_a03_id_condominio = self.builder.get_object("l03_a03_id_condominio")
self.l03_a03_id_condominio.set_markup("<b>{a}</b>".format(a=self.l03_a03_id_condominio.get_text()))
self.cb03_a03_id_condominio = self.builder.get_object("cb03_a03_id_condominio")
# PREPARAÇÃO DO cb03_a03_id_condominio
self.lst_cb03_a03_id_condominio = Gtk.ListStore(str, str)
self.desenha_cb03_a03_id_condominio(cb=self.cb03_a03_id_condominio, lista=self.lst_cb03_a03_id_condominio)
registros = self.PC.pesquisar_condominios()
self.preencher_combo_condominio(lista=self.lst_cb03_a03_id_condominio, lst_dic_condominio=registros)
# ----------------------
self.l03_e03_a03_nome_bloco = self.builder.get_object("l03_e03_a03_nome_bloco")
self.l03_e03_a03_nome_bloco.set_markup("<b>{a}</b>".format(a=self.l03_e03_a03_nome_bloco.get_text()))
self.e03_a03_nome_bloco = self.builder.get_object("e03_a03_nome_bloco")
# PREPARAÇÃO DO TREEVIEW
self.tv03_a03 = self.builder.get_object("tv03_a03")
self.lst_tv03 = Gtk.ListStore(str, str, str)
self.tv03_a03.set_model(self.lst_tv03)
self.desenha_tv03(tv=self.tv03_a03)
# res = self.pesquisar_bloco()
# self.preencher_bloco(lista=self.lst_tv03, res=res)
# -------------------------------------------------------------------
self.w03.set_visible(True)
self.w03.show_all()
#
# curframe = inspect.currentframe()
# print('--->', curframe.f_lineno)
#
# (frame, filename, line_number,function_name, lines, index) = inspect.getouterframes(inspect.currentframe())[1]
# print('1->',frame, '\n1->',filename, '\n1->',line_number, '\n1->',function_name, '\n1->',lines, '\n1->',index)
#
# calframe = inspect.getouterframes(curframe, 2)
# print(calframe)
#
# print('caller name:', calframe[1][3])
def desenha_tv03(self, tv):
"""
desenha as colunas do treeview
:param tv:recebe o objeto do treeview
:return:
"""
tv.set_rules_hint(True)
tv.set_grid_lines(3)
# TV_PEN.set_has_tooltip(True)
tv.set_property("headers-visible", True)
cell_tv03_a03_id_condominio = Gtk.CellRendererText()
col_tv03_a03_id_condominio = Gtk.TreeViewColumn("ID.Condominio",
cell_tv03_a03_id_condominio,
text=self.col_a03_id_condominio)
col_tv03_a03_id_condominio.set_visible(False)
tv.append_column(col_tv03_a03_id_condominio)
cell_tv03_a03_id_bloco = Gtk.CellRendererText()
col_tv03_col_a03_id_bloco = Gtk.TreeViewColumn("ID.Bloco",
cell_tv03_a03_id_bloco,
text=self.col_a03_id_bloco)
col_tv03_col_a03_id_bloco.set_visible(False)
tv.append_column(col_tv03_col_a03_id_bloco)
cell_tv03_a03_nome_bloco = Gtk.CellRendererText()
col_tv03_col_a03_nome_bloco = Gtk.TreeViewColumn("ID.Bloco",
cell_tv03_a03_nome_bloco,
text=self.col_a03_nome_bloco)
col_tv03_col_a03_nome_bloco.set_visible(True)
tv.append_column(col_tv03_col_a03_nome_bloco)
tv.set_enable_search(True)
tv.set_headers_clickable(True)
def desenha_cb03_a03_id_condominio(self, cb, lista):
"""
Desenha as colunas do cb03_a03_id_condomini
:param cb: combobox
:param lista: liststore definição das colunas
:return:
"""
cb.set_model(lista)
cb.set_active(self.col_a01_id_condominio)
cell_a01_id_condominio = Gtk.CellRendererText()
cb.pack_start(cell_a01_id_condominio, True)
cb.add_attribute(cell_a01_id_condominio, "text", self.col_a01_id_condominio)
cell_a01_id_condominio.set_visible(False)
cell_a01_nome = Gtk.CellRendererText()
cb.pack_start(cell_a01_nome, True)
cb.add_attribute(cell_a01_nome, "text", self.col_a01_nome)
cell_a01_nome.set_visible(True)
def preencher_combo_condominio(self, lista, lst_dic_condominio):
"""
Colocra as informações nas colunas determinadas
:param lista: definição das coluna para preencher
:param lst_dic_condominio:
:return:
"""
lista.clear()
for i in lst_dic_condominio:
lista.append([
str(i['a01_id_condominio']),
str(i['a01_nome']) if i['a01_nome'] else None,
])
def on_b03_fechar_clicked(self, widget):
"""
libera o CadBloco - apagar da tela
:param:
:return:
"""
tela = widget.get_parent_window()
tela.destroy()
# self.w03.destroy()
def on_b03_salvar_clicked(self, widget):
"""
Manda executar a validação dos campos da tela bem como verifica se
os dados devem ser alterados ou incluidos
:param:
:return:
"""
dic_dados = self.validar_campos()
if not dic_dados:
return False
if dic_dados:
if self.ge_selecionado:
dados_salvo = self.alterar(dic_dados=dic_dados)
else:
dados_salvo = self.incluir(dic_dados=dic_dados)
if dados_salvo:
self.limpar_tela()
res = self.PB.pesquisar_blocos(id_condominio=self.ge_a01_id_condominio)
self.mostrar_dados_tv03(lista=self.lst_tv03, res=res)
else:
msg = "Problemas ao Dicionário não encontrado"
logging.error(msg)
self.JP.msgerro(janela=self.w03,
# texto_primario="class:{} - def:{} - linha:{}".format(str(self.__class__.__name__),
# str(sys._getframe(0).f_code.co_name),
# str(sys._getframe(0).f_lineno)),
texto_secundario=msg)
exit(1)
def on_cb03_a03_id_condominio_changed(self, widget):
"""
verifica qual opção do combobox foi selecionado
:param widget:
:return:
"""
try:
self.ge_a01_id_condominio = self.CBD.get_dado_combo(comboboxm=widget,
col_traz=self.col_a01_id_condominio)
res = self.PB.pesquisar_blocos(id_condominio=self.ge_a01_id_condominio)
if res:
self.mostrar_dados_tv03(lista=self.lst_tv03, res=res)
except ValueError:
pass
def on_tv03_a03_key_press_event(self, widget, event):
keyval = Gdk.keyval_name(event.keyval)
if keyval == 'Return' or keyval == 'KP_Enter':
selection = widget.get_selection()
modelx, iterx = selection.get_selected()
self.limpar_tela()
try:
id_bloco = str(modelx.get_value(iterx, self.col_a03_id_bloco))
self.ge_a03_id_bloco = id_bloco
except ValueError:
self.ge_selecionado = True
return False
finally:
self.ge_selecionado = True
dic_bloco = self.consulta_bloco(id_bloco=id_bloco)
if len(dic_bloco) != 0:
self.mostrar_dados_tela(dic_dados_bloco=dic_bloco)
self.ge_selecionado = True
else:
self.limpar_tela()
def mostrar_dados_tv03(self, lista, res):
"""
Coloca os dados recebidos em 'res'
:param lista:
:param res:lista de dicionarios com os dados do bloco para ser encaixado no treeview
:return:
"""
lista.clear()
for i in res:
lista.append([
str(i['a03_id_condominio']),
str(i['a03_id_bloco']),
str(i['a03_nome_bloco']),
])
def limpar_tela(self):
"""
Limpar todos os campo para que da classe bem como as entradas da tela
:return:
"""
self.ge_selecionado = False
self.ge_a03_id_bloco = 0
self.e03_a03_nome_bloco.set_text('')
self.e03_a03_nome_bloco.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, None)
def validar_campos(self):
"""
Valida todos os campos
:return:retrna um dicionario de dados com os dados validados ou retorna Falso no caso de dados inválidos
"""
dic_dados = dict()
valido = True
# numerovalido = re.compile(r'[0-9]')
dic_dados['a03_id_bloco'] = self.ge_a03_id_bloco
dic_dados['a03_id_condominio'] = self.ge_a01_id_condominio
if len(str(self.e03_a03_nome_bloco.get_text().strip())) == 0:
self.e03_a03_nome_bloco.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, "dialog-error")
self.e03_a03_nome_bloco.grab_focus()
valido = False
else:
dic_dados['a03_nome_bloco'] = str(self.e03_a03_nome_bloco.get_text().strip())
self.e03_a03_nome_bloco.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, None)
if not valido:
dic_dados = False
return dic_dados
def incluir(self, dic_dados):
"""
Incluir novos blocos no banco de dados
:param dic_dados: dicionario de dados validados para salvar no banco de dados
:return: retorn Falso quando não foi possivel salvar e True quando foi ṕossivel salvar os dados
"""
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
except psycopg2.ProgrammingError as msg:
logging.error(msg)
self.JP.msgerro(janela=self.w03,
texto_primario="Problema na rotina de Incluir",
# texto_primario="class:{} - def:{} - linha:{}".format(str(self.__class__.__name__),
# str(sys._getframe(0).f_code.co_name),
# str(sys._getframe(0).f_lineno)),
texto_secundario=msg)
return False
cur = conn.cursor()
try:
cur.execute(
"""
INSERT INTO a03_blocos
(
a03_id_condominio,
a03_nome_bloco
) VALUES(
%s,
%s
);
""", (
dic_dados['a03_id_condominio'] if "a03_id_condominio" in dic_dados else 0,
dic_dados['a03_nome_bloco'] if "a03_nome_bloco" in dic_dados else None,
)
)
except (psycopg2.DatabaseError, psycopg2.ProgrammingError) as msg:
logging.error(msg)
self.JP.msgerro(janela=self.w03,
texto_primario='Problma ao Incluir dados novos',
# texto_primario="class:{} - def:{} - linha:{}".format(str(self.__class__.__name__),
# str(sys._getframe(0).f_code.co_name),
# str(sys._getframe(0).f_lineno)),
texto_secundario=msg)
return False
conn.commit()
cur.close()
del conn, cur
return True
def alterar(self, dic_dados):
"""
:param dic_dados:
:return:
"""
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
except psycopg2.ProgrammingError as msg:
logging.error(msg)
self.JP.msgerro(janela=self.w03,
texto_primario='Problema ao Alterar Dados',
# texto_primario="class:{} - def:{} - linha:{}".format(str(self.__class__.__name__),
# str(sys._getframe(0).f_code.co_name),
# str(sys._getframe(0).f_lineno)),
texto_secundario=msg)
return False
cur = conn.cursor()
try:
cur.execute("""
UPDATE a03_blocos SET
a03_id_condominio = %s,
a03_nome_bloco = %s
WHERE a03_id_bloco = %s;
""", (
dic_dados['a03_id_condominio'] if "a03_id_condominio" in dic_dados else '0',
dic_dados['a03_nome_bloco'] if "a03_nome_bloco" in dic_dados else None,
dic_dados['a03_id_bloco'] if "a03_id_bloco" in dic_dados else '0',
)
)
except psycopg2.DatabaseError as msg:
logging.error(msg)
self.JP.msgerro(janela=self.w03,
texto_primario='Problema ao Atualisar dados',
# texto_primario="class:{} - def:{} - linha:{}".format(str(self.__class__.__name__),
# str(sys._getframe(0).f_code.co_name),
# str(sys._getframe(0).f_lineno)),
texto_secundario=msg)
return False
conn.commit()
cur.close()
del conn, cur
return True
def consulta_bloco(self, id_bloco):
dic_dados = {}
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
cur.execute(""" SELECT *
from a03_blocos
WHERE a03_id_bloco = %s;
""", (id_bloco,)
)
registros = cur.fetchall()
except psycopg2.ProgrammingError as msg:
logging.error(msg)
self.JP.msgerro(janela=self.w03,
texto_primario='Problemas ao Carregar Blocos',
# texto_primario="class:{} - def:{} - linha:{}".format(str(self.__class__.__name__),
# str(sys._getframe(0).f_code.co_name),
# str(sys._getframe(0).f_lineno)),
texto_secundario=msg)
return False
for registro in registros:
dic_dados = dict(registro)
if not registros:
return False
cur.close()
del conn, cur, registros
return dic_dados
def mostrar_dados_tela(self, dic_dados_bloco):
for key, value in dic_dados_bloco.items():
if key == 'a03_nome_bloco':
if value is not None:
self.e03_a03_nome_bloco.set_text(str(value))
else:
self.e03_a03_nome_bloco.set_text('')
def __init__(self, **kwarg):
self.col_a01_id_condominio = 0
self.col_a01_nome = 1
self.col_a01_endereco = 2
self.col_a01_numero = 3
self.col_a01_bairro = 4
self.col_a01_cidade = 5
self.ge_dic_dados = dict()
# self.ge_dic_param_sis = dict()
self.ge_selecionado = False
self.ge_a01_id_condominio = None
self.JP = JanelaProblema()
if kwarg['dic_param_sis']:
self.ge_dic_param_sis = kwarg['dic_param_sis']
else:
msg = 'Esta faltando os parametros do sistema'
logging.error(msg)
self.JP.msgerro(janela=None, texto_primario="PARAMETROS", texto_secundario=msg)
exit(1)
if kwarg['titulo']:
self.ge_titulo = kwarg['titulo']
else:
msg = 'Esta faltando titulo da tela'
logging.error(msg)
self.JP.msgerro(janela=None, texto_primario="PARAMETROS", texto_secundario=msg)
exit(1)
self.builder = Gtk.Builder()
try:
self.caminho = '/'.join([abspath(dirname(__file__)), 'glade', self.ge_dic_param_sis['AMBIENTE_TELA']])
self.builder.add_objects_from_file(self.caminho, ["w01_condominio"])
except Exception as msg:
logging.error(msg)
self.JP.msgerro(janela=None, texto_primario=self.ge_titulo, texto_secundario=msg)
exit(1)
self.builder.connect_signals(self)
self.w01 = self.builder.get_object("w01_condominio")
self.w01.set_title("Cadastro de Condiminio")
self.l01_a01_nome = self.builder.get_object("l01_a01_nome")
self.l01_a01_nome.set_markup("<b>{a}</b>".format(a=self.l01_a01_nome.get_text()))
self.e01_a01_nome = self.builder.get_object("e01_a01_nome")
self.l01_a01_endereco = self.builder.get_object("l01_a01_endereco")
self.l01_a01_endereco.set_markup("<b>{a}</b>".format(a=self.l01_a01_endereco.get_text()))
self.e01_a01_endereco = self.builder.get_object("e01_a01_endereco")
self.l01_a01_numero = self.builder.get_object("l01_a01_numero")
self.l01_a01_numero.set_markup("<b>{a}</b>".format(a=self.l01_a01_numero.get_text()))
self.e01_a01_numero = self.builder.get_object("e01_a01_numero")
self.l01_a01_bairro = self.builder.get_object('l01_a01_bairro')
self.l01_a01_bairro.set_markup("<b>{a}</b>".format(a=self.l01_a01_bairro.get_text()))
self.e01_a01_bairro = self.builder.get_object('e01_a01_bairro')
self.l01_a01_cidade = self.builder.get_object('l01_a01_cidade')
self.l01_a01_cidade.set_markup("<b>{a}</b>".format(a=self.l01_a01_cidade.get_text()))
self.e01_a01_cidade = self.builder.get_object('e01_a01_cidade')
self.b01_excluir = self.builder.get_object('b01_excluir')
# PREPARAÇÃO DO TREEVIEW
self.tv01_a01 = self.builder.get_object("tv01_a01")
self.lst_tv01 = Gtk.ListStore(str, str, str)
self.tv01_a01.set_model(self.lst_tv01)
self.desenha_tv01(tv=self.tv01_a01)
res = self.pesquisar_condominio()
if res:
self.preencher_condominio(lista=self.lst_tv01, res=res)
# -------------------------------------------------------------------
self.w01.set_visible(True)
self.w01.show_all()
class CadCondominio:
def __init__(self, **kwarg):
self.col_a01_id_condominio = 0
self.col_a01_nome = 1
self.col_a01_endereco = 2
self.col_a01_numero = 3
self.col_a01_bairro = 4
self.col_a01_cidade = 5
self.ge_dic_dados = dict()
# self.ge_dic_param_sis = dict()
self.ge_selecionado = False
self.ge_a01_id_condominio = None
self.JP = JanelaProblema()
if kwarg['dic_param_sis']:
self.ge_dic_param_sis = kwarg['dic_param_sis']
else:
msg = 'Esta faltando os parametros do sistema'
logging.error(msg)
self.JP.msgerro(janela=None, texto_primario="PARAMETROS", texto_secundario=msg)
exit(1)
if kwarg['titulo']:
self.ge_titulo = kwarg['titulo']
else:
msg = 'Esta faltando titulo da tela'
logging.error(msg)
self.JP.msgerro(janela=None, texto_primario="PARAMETROS", texto_secundario=msg)
exit(1)
self.builder = Gtk.Builder()
try:
self.caminho = '/'.join([abspath(dirname(__file__)), 'glade', self.ge_dic_param_sis['AMBIENTE_TELA']])
self.builder.add_objects_from_file(self.caminho, ["w01_condominio"])
except Exception as msg:
logging.error(msg)
self.JP.msgerro(janela=None, texto_primario=self.ge_titulo, texto_secundario=msg)
exit(1)
self.builder.connect_signals(self)
self.w01 = self.builder.get_object("w01_condominio")
self.w01.set_title("Cadastro de Condiminio")
self.l01_a01_nome = self.builder.get_object("l01_a01_nome")
self.l01_a01_nome.set_markup("<b>{a}</b>".format(a=self.l01_a01_nome.get_text()))
self.e01_a01_nome = self.builder.get_object("e01_a01_nome")
self.l01_a01_endereco = self.builder.get_object("l01_a01_endereco")
self.l01_a01_endereco.set_markup("<b>{a}</b>".format(a=self.l01_a01_endereco.get_text()))
self.e01_a01_endereco = self.builder.get_object("e01_a01_endereco")
self.l01_a01_numero = self.builder.get_object("l01_a01_numero")
self.l01_a01_numero.set_markup("<b>{a}</b>".format(a=self.l01_a01_numero.get_text()))
self.e01_a01_numero = self.builder.get_object("e01_a01_numero")
self.l01_a01_bairro = self.builder.get_object('l01_a01_bairro')
self.l01_a01_bairro.set_markup("<b>{a}</b>".format(a=self.l01_a01_bairro.get_text()))
self.e01_a01_bairro = self.builder.get_object('e01_a01_bairro')
self.l01_a01_cidade = self.builder.get_object('l01_a01_cidade')
self.l01_a01_cidade.set_markup("<b>{a}</b>".format(a=self.l01_a01_cidade.get_text()))
self.e01_a01_cidade = self.builder.get_object('e01_a01_cidade')
self.b01_excluir = self.builder.get_object('b01_excluir')
# PREPARAÇÃO DO TREEVIEW
self.tv01_a01 = self.builder.get_object("tv01_a01")
self.lst_tv01 = Gtk.ListStore(str, str, str)
self.tv01_a01.set_model(self.lst_tv01)
self.desenha_tv01(tv=self.tv01_a01)
res = self.pesquisar_condominio()
if res:
self.preencher_condominio(lista=self.lst_tv01, res=res)
# -------------------------------------------------------------------
self.w01.set_visible(True)
self.w01.show_all()
def on_tv01_a01_key_press_event(self, widget, event):
keyval = Gdk.keyval_name(event.keyval)
if keyval == 'Return' or keyval == 'KP_Enter':
selection = widget.get_selection()
modelx, iterx = selection.get_selected()
self.limpar_tela()
try:
id_condominio = str(modelx.get_value(iterx, self.col_a01_id_condominio))
self.ge_a01_id_condominio = id_condominio
except ValueError:
return False
finally:
self.ge_selecionado = True
self.b01_excluir.set_sensitive(True)
dic_condominio = self.consulta_condominio(id_condominio=id_condominio)
if len(dic_condominio) != 0:
self.mostrar_dados(dic_dados=dic_condominio)
self.ge_dic_dados = dic_condominio
self.ge_selecionado = True
else:
self.limpar_tela()
def on_b01_fechar_clicked(self, button):
tela = button.get_parent_window()
tela.destroy()
def on_b01_exluir_clicked(self, button):
button.set_sensitive(True)
if not self.ge_selecionado:
msg = "Você deverá selecionar o condomínio antes de exclui-lo"
self.JP.msgwarning(janela=self.w01, texto_primario="ATENÇÃO", texto_secundario=msg)
return False
msg = "Deseja realmente apagar todas as informações deste Condominio?" \
"Cuidado isto não tem volta a menos que suas copias de segurança estejam em dia."
resposta = self.JP.msgquestion(janela=self.w01, texto_primario="Excluir condomínio", texto_secundario=msg)
if resposta:
self.apagar(id_condominio=self.ge_dic_dados['a01_id_condominio'])
res = self.pesquisar_condominio()
self.preencher_condominio(lista=self.lst_tv01, res=res)
self.limpar_tela()
self.e01_a01_nome.grab_focus()
def on_b01_salvar_clicked(self, button):
button.set_sensitive(True)
if not self.validar_campos():
return False
if self.ge_selecionado:
dados_salvo = self.alterar(dic_dados=self.ge_dic_dados)
else:
dados_salvo = self.incluir(dic_dados=self.ge_dic_dados)
if dados_salvo:
self.limpar_tela()
res = self.pesquisar_condominio()
self.preencher_condominio(lista=self.lst_tv01, res=res)
else:
msg = "Problemas ao salvar informações"
logging.error(msg)
self.JP.msgerro(janela=self.w01, texto_primario=self.ge_titulo)
exit(1)
self.e01_a01_nome.grab_focus()
def apagar(self, id_condominio):
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
except (psycopg2.ProgrammingError, psycopg2.OperationalError) as msg:
logging.error(msg)
self.JP.msgerro(janela=self.w01, texto_primario=self.ge_titulo, texto_secundario=msg)
return False
cur = conn.cursor()
try:
cur.execute(
"""
DELETE FROM a01_condominio WHERE a01_id_condominio = %s;
""", (
id_condominio,
)
)
except psycopg2.DatabaseError as msg:
logging.error(msg)
self.JP.msgerro(janela=self.w01, texto_primario=self.ge_titulo, texto_secundario=msg)
return False
conn.commit()
cur.close()
del conn, cur
return True
def limpar_tela(self):
"""
Limpeza de campos de tela e variaveis de trabalho
"""
self.ge_selecionado = False
self.ge_dic_dados = {}
self.ge_a01_id_condominio = None
self.e01_a01_nome.set_text('')
self.e01_a01_bairro.set_text('')
self.e01_a01_cidade.set_text('')
self.e01_a01_endereco.set_text('')
self.e01_a01_numero.set_text('')
self.e01_a01_nome.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, None)
self.e01_a01_bairro.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, None)
self.e01_a01_cidade.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, None)
self.e01_a01_endereco.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, None)
self.e01_a01_numero.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, None)
def validar_campos(self):
"""
Validar campos para salvar no banco de dados
retorna True para valido
retorna False para invalido
:return: boolean
"""
valido = True
numerovalido = re.compile(r'[0-9]')
self.ge_dic_dados['a01_id_condominio'] = self.ge_a01_id_condominio
if len(str(self.e01_a01_nome.get_text().strip())) == 0:
self.ge_dic_dados = {}
self.e01_a01_nome.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, "dialog-error")
self.e01_a01_nome.grab_focus()
valido = False
else:
self.ge_dic_dados['e01_a01_nome'] = str(self.e01_a01_nome.get_text().strip())
self.e01_a01_nome.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, "")
if len(str(self.e01_a01_endereco.get_text().strip())) == 0:
self.ge_dic_dados = {}
self.e01_a01_endereco.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, "dialog-error")
self.e01_a01_endereco.grab_focus()
valido = False
else:
self.ge_dic_dados['e01_a01_endereco'] = str(self.e01_a01_endereco.get_text().strip())
self.e01_a01_endereco.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, "")
if len(str(self.e01_a01_bairro.get_text().strip())) == 0:
self.ge_dic_dados = {}
self.e01_a01_bairro.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, "dialog-error")
self.e01_a01_bairro.grab_focus()
valido = False
else:
self.ge_dic_dados['e01_a01_bairro'] = str(self.e01_a01_bairro.get_text().strip())
self.e01_a01_bairro.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, "")
if len(str(self.e01_a01_cidade.get_text().strip())) == 0:
self.ge_dic_dados = {}
self.e01_a01_cidade.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, "dialog-error")
self.e01_a01_cidade.grab_focus()
valido = False
else:
self.ge_dic_dados['e01_a01_cidade'] = str(self.e01_a01_cidade.get_text().strip())
self.e01_a01_cidade.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, "")
wcampo = numerovalido.sub('', self.e01_a01_numero.get_text().strip())
if len(wcampo) > 0 or self.e01_a01_numero.get_text() == "":
self.ge_dic_dados = {}
self.e01_a01_numero.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, "dialog-error")
self.e01_a01_numero.grab_focus()
valido = False
else:
self.ge_dic_dados['e01_a01_numero'] = self.e01_a01_numero.get_text()
self.e01_a01_numero.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, "")
return valido
def consulta_condominio(self, id_condominio):
dic_dados = {}
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
cur.execute(""" SELECT *
FROM a01_condominio
WHERE a01_id_condominio = %s;
""", (id_condominio,)
)
registros = cur.fetchall()
except psycopg2.ProgrammingError as msg:
logging.error(msg)
self.JP.msgerro(janela=self.w01, texto_primario=self.ge_titulo, texto_secundario=msg)
return False
for registro in registros:
dic_dados = dict(registro)
if not registros:
return False
cur.close()
del conn, cur, registros
return dic_dados
def alterar(self, dic_dados):
"""
Alteração dos dados no banco de dados
retorna True caso a alteração no bano de dados seja bem sucedida
returna False caso a alteração no bano dee dados seja mal sucidida
:param dic_dados: dicionario de dados validos
:return boolean:
"""
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
except psycopg2.ProgrammingError as msg:
logging.error(msg)
self.JP.msgerro(janela=self.w01, texto_primario=self.ge_titulo, texto_secundario=msg)
return False
cur = conn.cursor()
try:
cur.execute("""
UPDATE a01_condominio SET
a01_nome = %s,
a01_endereco = %s,
a01_numero = %s,
a01_cidade = %s,
a01_bairro = %s
WHERE a01_id_condominio = %s;
""", (
str(dic_dados['e01_a01_nome']),
str(dic_dados['e01_a01_endereco']),
str(dic_dados['e01_a01_numero']),
str(dic_dados['e01_a01_cidade']),
str(dic_dados['e01_a01_bairro']),
str(dic_dados['a01_id_condominio']),
)
)
except psycopg2.DatabaseError as msg:
logging.error(msg)
self.JP.msgerro(janela=self.w01, texto_primario=self.ge_titulo, texto_secundario=msg)
return False
conn.commit()
cur.close()
del conn, cur
return True
def incluir(self, dic_dados):
"""
inclução dos dados no banco de dados
retorna True caso a inclução no banco de dados seja bem sucedida
returna False caso a inclução no banco dee dados seja mal sucidida
:param dic_dados: dicionario de dados validos
:return boolean:
"""
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
except psycopg2.ProgrammingError as msg:
logging.error(msg)
self.JP.msgerro(janela=self.w01, texto_primario=self.ge_titulo, texto_secundario=msg)
return False
cur = conn.cursor()
try:
cur.execute(
"""
INSERT INTO a01_condominio
(
a01_nome,
a01_endereco,
a01_numero,
a01_cidade,
a01_bairro
) VALUES(
%s,
%s,
%s,
%s,
%s
);
""", (
dic_dados['e01_a01_nome'],
dic_dados['e01_a01_endereco'],
dic_dados['e01_a01_numero'],
dic_dados['e01_a01_cidade'],
dic_dados['e01_a01_bairro']
# dic_motorista['t03_rt'] if "t03_rt" in dic_motorista else '0'
)
)
except psycopg2.DatabaseError as msg:
logging.error(msg)
self.JP.msgerro(janela=self.w01, texto_primario=self.ge_titulo, texto_secundario=msg)
return False
conn.commit()
cur.close()
del conn, cur
return True
def mostrar_dados(self, dic_dados):
"""
Mostra as informações na tela com informaçãos ou limpando os campos
:param dic_dados:dicionário com dados carregados do banco de dados
:return:
"""
if 'a01_nome' in dic_dados.keys():
self.e01_a01_nome.set_text(str(dic_dados['a01_nome']))
else:
self.e01_a01_nome.set_text('')
if 'a01_endereco' in dic_dados.keys():
self.e01_a01_endereco.set_text(str(dic_dados['a01_endereco']))
else:
self.e01_a01_endereco.set_text('')
if 'a01_numero' in dic_dados.keys():
if int(dic_dados['a01_numero']) > 0:
self.e01_a01_numero.set_text(str(dic_dados['a01_numero']))
else:
self.e01_a01_numero.set_text('')
else:
self.e01_a01_numero.set_text('')
if 'a01_bairro' in dic_dados.keys():
if str(dic_dados['a01_bairro']) is not None:
self.e01_a01_bairro.set_text(str(dic_dados['a01_bairro']))
else:
self.e01_a01_bairro.set_text('')
else:
self.e01_a01_bairro.set_text('')
if 'a01_cidade' in dic_dados.keys():
if str(dic_dados['a01_cidade']) is not None:
self.e01_a01_cidade.set_text(str(dic_dados['a01_cidade']))
else:
self.e01_a01_cidade.set_text('')
else:
self.e01_a01_cidade.set_text('')
def desenha_tv01(self, tv):
"""
Desenha treeview inclui as colunas de informações
:param tv:
:return:
"""
tv.set_rules_hint(True)
tv.set_grid_lines(3)
# TV_PEN.set_has_tooltip(True)
tv.set_property("headers-visible", True)
cell_tv01_a01_id_condominio = Gtk.CellRendererText()
col_a01_id_condominio = Gtk.TreeViewColumn("ID.Condominio", cell_tv01_a01_id_condominio,
text=self.col_a01_id_condominio)
col_a01_id_condominio.set_visible(False)
tv.append_column(col_a01_id_condominio)
cel_tv01_a01_nome = Gtk.CellRendererText()
col_01_a01_nome = Gtk.TreeViewColumn("Nome", cel_tv01_a01_nome, text=self.col_a01_nome)
col_01_a01_nome.set_visible(True)
tv.append_column(col_01_a01_nome)
col_01_a01_nome.connect("clicked", self.clicado_col_tv01, tv, self.col_a01_nome)
col_01_a01_nome.set_reorderable(True)
cel_tv01_a01_endereco = Gtk.CellRendererText()
col_a01_endereco = Gtk.TreeViewColumn("Endereço", cel_tv01_a01_endereco, text=self.col_a01_endereco)
col_a01_endereco.set_visible(True)
tv.append_column(col_a01_endereco)
col_a01_endereco.connect("clicked", self.clicado_col_tv01, tv, self.col_a01_endereco)
col_a01_endereco.set_reorderable(True)
tv.set_enable_search(True)
tv.set_headers_clickable(True)
def clicado_col_tv01(self, widget, tv, coluna):
tv.set_enable_search(True)
widget.set_sort_column_id(coluna)
tv.set_search_column(coluna)
def pesquisar_condominio(self):
lst_dic_dados = []
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
cur.execute(""" SELECT a01_id_condominio,
a01_nome,
concat(a01_endereco, ',',
a01_numero, ', ',
a01_bairro, ', ',
a01_cidade ) as end_completo
FROM a01_condominio ORDER BY UPPER(a01_nome);
"""
)
registros = cur.fetchall()
except (psycopg2.ProgrammingError, psycopg2.OperationalError) as msg:
logging.error(msg)
self.JP.msgerro(janela=self.w01, texto_primario=self.ge_titulo, texto_secundario=msg)
return False
for registro in registros:
lst_dic_dados.append(dict(registro))
if not registros:
return False
cur.close()
del conn, cur, registros
return lst_dic_dados
def preencher_condominio(self, lista, res):
lista.clear()
for i in res:
lista.append([
str(i['a01_id_condominio']),
str(i['a01_nome']),
str(i['end_completo']),
])
def __init__(self, **kwarg):
# self.ge_dic_dados = dict()
self.ge_dic_param_sis = dict()
self.ge_selecionado = False
self.ge_id_condominio = 0
self.ge_id_portaria = 0
self.col_cb02_a01_id_condominio = 0
self.col_cb02_a01_nome = 1
self.col_tv02_a02_id_condominio = 0
self.col_tv02_a02_id_portaria = 1
self.col_tv02_a02_nome_portaria = 2
self.col_tv02_dados_portaria = 3
self.JP = JanelaProblema()
self.CBD = ComboBoxDados()
if kwarg['dic_param_sis']:
self.ge_dic_param_sis = kwarg['dic_param_sis']
else:
msg = 'Esta faltando os parametros do sistema'
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
exit(1)
self.ge_selecionado = False
self.PC = PesqCondominio(dic_param_sis=self.ge_dic_param_sis)
self.builder = Gtk.Builder()
try:
self.Caminho = '/'.join([abspath(dirname(__file__)), 'glade', self.ge_dic_param_sis['AMBIENTE_TELA']])
self.builder.add_objects_from_file(self.Caminho, ["w02_portaria"])
except Exception as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
exit(1)
self.builder.connect_signals(self)
self.w02 = self.builder.get_object("w02_portaria")
self.w02.set_title("Cadastro de Portaria")
# ----------------------
self.cb02_a02_id_condominio = self.builder.get_object("cb02_a02_id_condominio")
self.lst_cb02 = Gtk.ListStore(str, str)
self.cb02_a02_id_condominio.set_model(self.lst_cb02)
self.desenha_cb02(cb=self.cb02_a02_id_condominio, lista=self.lst_cb02)
registros = self.PC.pesquisar_condominios()
# registros = self.carregar_condominio()
self.preencher_combo_condominio(lista=self.lst_cb02, res=registros)
# --------------------------
# self.set_dado_combo(combobox=self.cb02_a02_id_condominio,
# text=1,
# coluna=self.col_cb02_a01_id_condominio)
# --------------------------
self.l02_a02_nome_portaria = self.builder.get_object("l02_a02_nome_portaria")
self.l02_a02_nome_portaria.set_markup("<b>{a}</b>".format(a=self.l02_a02_nome_portaria.get_text()))
self.e02_a02_nome_portaria = self.builder.get_object("e02_a02_nome_portaria")
self.l02_a02_endereco = self.builder.get_object("l02_a02_endereco")
self.l02_a02_endereco.set_markup("{a}".format(a=self.l02_a02_endereco.get_text()))
self.e02_a02_endereco = self.builder.get_object("e02_a02_endereco")
self.l02_a02_numero = self.builder.get_object("l02_a02_numero")
self.l02_a02_numero.set_markup("{a}".format(a=self.l02_a02_numero.get_text()))
self.e02_a02_numero = self.builder.get_object("e02_a02_numero")
self.tv02_a02 = self.builder.get_object("tv02_a02")
self.lst_tv02 = Gtk.ListStore(str, str, str, str)
self.desenha_tv02(tv=self.tv02_a02)
self.tv02_a02.set_model(self.lst_tv02)
self.w02.set_visible(True)
self.w02.show_all()
class CadPortaria:
def __init__(self, **kwarg):
# self.ge_dic_dados = dict()
self.ge_dic_param_sis = dict()
self.ge_selecionado = False
self.ge_id_condominio = 0
self.ge_id_portaria = 0
self.col_cb02_a01_id_condominio = 0
self.col_cb02_a01_nome = 1
self.col_tv02_a02_id_condominio = 0
self.col_tv02_a02_id_portaria = 1
self.col_tv02_a02_nome_portaria = 2
self.col_tv02_dados_portaria = 3
self.JP = JanelaProblema()
self.CBD = ComboBoxDados()
if kwarg['dic_param_sis']:
self.ge_dic_param_sis = kwarg['dic_param_sis']
else:
msg = 'Esta faltando os parametros do sistema'
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
exit(1)
self.ge_selecionado = False
self.PC = PesqCondominio(dic_param_sis=self.ge_dic_param_sis)
self.builder = Gtk.Builder()
try:
self.Caminho = '/'.join([abspath(dirname(__file__)), 'glade', self.ge_dic_param_sis['AMBIENTE_TELA']])
self.builder.add_objects_from_file(self.Caminho, ["w02_portaria"])
except Exception as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
exit(1)
self.builder.connect_signals(self)
self.w02 = self.builder.get_object("w02_portaria")
self.w02.set_title("Cadastro de Portaria")
# ----------------------
self.cb02_a02_id_condominio = self.builder.get_object("cb02_a02_id_condominio")
self.lst_cb02 = Gtk.ListStore(str, str)
self.cb02_a02_id_condominio.set_model(self.lst_cb02)
self.desenha_cb02(cb=self.cb02_a02_id_condominio, lista=self.lst_cb02)
registros = self.PC.pesquisar_condominios()
# registros = self.carregar_condominio()
self.preencher_combo_condominio(lista=self.lst_cb02, res=registros)
# --------------------------
# self.set_dado_combo(combobox=self.cb02_a02_id_condominio,
# text=1,
# coluna=self.col_cb02_a01_id_condominio)
# --------------------------
self.l02_a02_nome_portaria = self.builder.get_object("l02_a02_nome_portaria")
self.l02_a02_nome_portaria.set_markup("<b>{a}</b>".format(a=self.l02_a02_nome_portaria.get_text()))
self.e02_a02_nome_portaria = self.builder.get_object("e02_a02_nome_portaria")
self.l02_a02_endereco = self.builder.get_object("l02_a02_endereco")
self.l02_a02_endereco.set_markup("{a}".format(a=self.l02_a02_endereco.get_text()))
self.e02_a02_endereco = self.builder.get_object("e02_a02_endereco")
self.l02_a02_numero = self.builder.get_object("l02_a02_numero")
self.l02_a02_numero.set_markup("{a}".format(a=self.l02_a02_numero.get_text()))
self.e02_a02_numero = self.builder.get_object("e02_a02_numero")
self.tv02_a02 = self.builder.get_object("tv02_a02")
self.lst_tv02 = Gtk.ListStore(str, str, str, str)
self.desenha_tv02(tv=self.tv02_a02)
self.tv02_a02.set_model(self.lst_tv02)
self.w02.set_visible(True)
self.w02.show_all()
def on_b02_fechar_clicked(self, widget):
"""
:param:
:return:
"""
# tela = widget.get_parent_window()
# tela.destroy()
# self.w02.destroy()
self.w02.destroy()
def on_b02_salvar_clicked(self, widget):
"""
executa as rotina para salvar e validas os campos de tela
:param:
:return:
"""
# dados_salvos = False
dic_dados = self.validar_campos()
if not dic_dados:
return False
if self.ge_selecionado:
dados_salvos = self.alterar(dic_dados=dic_dados)
else:
dados_salvos = self.incluir(dic_dados=dic_dados)
if dados_salvos:
id_condominio = self.ge_id_condominio
self.limpar_tela()
self.ge_id_condominio = id_condominio
res = self.pesquisar_portarias(id_condominio=self.ge_id_condominio)
self.mostrar_dados_tv02(lista=self.lst_tv02, res=res)
else:
msg = "Problemas ao salvar informações"
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
def on_b02_excluir_clicked(self, widget):
"""
Apaga portaria selecionada
:return:
"""
apagado = False
dic_dados = self.validar_campos()
if not dic_dados:
return False
if self.ge_selecionado:
apagado = self.apagar_portaria(id_portaria=dic_dados['a02_id_portaria'])
else:
msg = "Selecione uma portaria para apagar"
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
if apagado:
id_condominio = self.ge_id_condominio
self.limpar_tela()
res = self.pesquisar_portarias(id_condominio=id_condominio)
self.mostrar_dados_tv02(lista=self.lst_tv02, res=res)
else:
msg = "Problemas ao Apagar Portaria"
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
exit(1)
def on_cb02_a02_id_condominio_changed(self, widget):
"""
Prepara dados para ser mostrado no combobox bem como item selecionado do combo
:param widget:
:return:
"""
try:
id_condominio = self.CBD.get_dado_combo(comboboxm=widget,
col_traz=self.col_cb02_a01_id_condominio)
res = self.pesquisar_portarias(id_condominio=id_condominio)
self.lst_tv02.clear()
if res:
self.mostrar_dados_tv02(lista=self.lst_tv02, res=res)
self.ge_id_condominio = id_condominio
except AttributeError:
pass
def validar_campos(self):
"""
Validação dos campos para salvar no banco de e dados
:return: Se retorna dic_dados = False então tem problemas nos dados
Se retorna dic_dados com valors em um dicionario em pode salvar no banco de dados
"""
dic_dados = dict()
valido = True
numerovalido = re.compile(r'[0-9]')
if self.ge_id_condominio == 0:
valido = False
else:
dic_dados['a02_id_condominio'] = self.ge_id_condominio
dic_dados['a02_id_portaria'] = self.ge_id_portaria
if len(str(self.e02_a02_nome_portaria.get_text().strip())) == 0:
dic_dados = {}
self.e02_a02_nome_portaria.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, "dialog-error")
self.e02_a02_nome_portaria.grab_focus()
valido = False
else:
dic_dados['a02_nome_portaria'] = str(self.e02_a02_nome_portaria.get_text().strip())
self.e02_a02_nome_portaria.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, None)
if len(str(self.e02_a02_endereco.get_text().strip())) > 0:
dic_dados['a02_endereco'] = str(self.e02_a02_endereco.get_text().strip())
else:
dic_dados['a02_endereco'] = None
if len(str(self.e02_a02_numero.get_text().strip())) > 0:
wcampo = numerovalido.sub('', self.e02_a02_numero.get_text().strip())
if len(wcampo) > 0:
dic_dados = {}
self.e02_a02_numero.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, "dialog-error")
self.e02_a02_numero.grab_focus()
valido = False
else:
dic_dados['a02_numero'] = self.e02_a02_numero.get_text()
self.e02_a02_numero.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, None)
if valido is False:
dic_dados = False
return dic_dados
def limpar_tela(self):
"""
Limpeza de campos de tela e variaveis de trabalho
"""
# self.ge_dic_dados = dict()
self.ge_selecionado = False
self.ge_id_condominio = 0
self.ge_id_portaria = 0
self.e02_a02_nome_portaria.set_text('')
self.e02_a02_endereco.set_text('')
self.e02_a02_numero.set_text('')
self.e02_a02_nome_portaria.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, None)
self.e02_a02_endereco.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, None)
self.e02_a02_numero.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, None)
def alterar(self, dic_dados):
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
except psycopg2.ProgrammingError as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
return False
cur = conn.cursor()
try:
sql = """
UPDATE a02_portarias SET
a02_nome_portaria = %s,
a02_endereco = %s,
a02_numero = %s
WHERE a02_id_condominio = %s
AND a02_id_portaria = %s;
""", (
dic_dados['a02_nome_portaria'] if "a02_nome_portaria" in dic_dados else None,
dic_dados['a02_endereco'] if "a02_endereco" in dic_dados else None,
dic_dados['a02_numero'] if "a02_numero" in dic_dados else 0,
dic_dados['a02_id_condominio'] if "a02_id_condominio" in dic_dados else 0,
dic_dados['a02_id_portaria'] if "a02_id_portaria" in dic_dados else 0,
)
cur.execute(sql)
except psycopg2.DatabaseError as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
return False
conn.commit()
cur.close()
del conn, cur
return True
def incluir(self, dic_dados):
"""
inclução dos dados no banco de dados
retorna True caso a inclução no banco de dados seja bem sucedida
returna False caso a inclução no banco dee dados seja mal sucedida
:param dic_dados: dicionario de dados validos
:return boolean:
"""
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
except psycopg2.ProgrammingError as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
return False
cur = conn.cursor()
sql = """
INSERT INTO a02_portarias
(
a02_id_condominio,
a02_nome_portaria,
a02_endereco,
a02_numero
) VALUES(
%s,
%s,
%s,
%s
);
""", (
dic_dados['a02_id_condominio'] if "a02_id_condominio" in dic_dados else 0,
dic_dados['a02_nome_portaria'] if "a02_nome_portaria" in dic_dados else None,
dic_dados['a02_endereco'] if "a02_endereco" in dic_dados else None,
dic_dados['a02_numero'] if "a02_numero" in dic_dados else 0,
)
try:
cur.execute(sql)
except psycopg2.DatabaseError as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
return False
conn.commit()
cur.close()
del conn, cur
return True
def apagar_portaria(self, id_portaria):
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
except psycopg2.ProgrammingError as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
return False
cur = conn.cursor()
try:
sql = """
DELETE from a02_portarias WHERE a02_id_portaria = %s;
""", (id_portaria,
)
cur.execute(sql)
except psycopg2.DatabaseError as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
return False
conn.commit()
cur.close()
del conn, cur
return True
def mostrar_dados_tv02(self, lista, res):
lista.clear()
for i in res:
lista.append([
str(i['a02_id_condominio']),
str(i['a02_id_portaria']),
str(i['a02_nome_portaria']),
str(i['dados_portaria']),
])
def desenha_cb02(self, cb, lista):
"""
DESENHA AS COLUNAS DO COMBO QUE IRÁ CONTER OS TIPOS DISPONIVEL
:param cb:
:param lista:
:return:
"""
cb.set_model(lista)
cb.set_active(self.col_cb02_a01_id_condominio)
cell_a01_id_condominio = Gtk.CellRendererText()
cb.pack_start(cell_a01_id_condominio, True)
cb.add_attribute(cell_a01_id_condominio, "text", self.col_cb02_a01_id_condominio)
cell_a01_id_condominio.set_visible(False)
cell_a01_nome = Gtk.CellRendererText()
cb.pack_start(cell_a01_nome, True)
cb.add_attribute(cell_a01_nome, "text", self.col_cb02_a01_nome)
cell_a01_nome.set_visible(True)
def desenha_tv02(self, tv):
tv.set_rules_hint(True)
tv.set_grid_lines(3)
# TV_PEN.set_has_tooltip(True)
tv.set_property("headers-visible", True)
cell_tv02_a02_id_condominio = Gtk.CellRendererText()
col_tv02_a02_id_condominio = Gtk.TreeViewColumn("ID.Condominio",
cell_tv02_a02_id_condominio,
text=self.col_tv02_a02_id_condominio)
col_tv02_a02_id_condominio.set_visible(False)
tv.append_column(col_tv02_a02_id_condominio)
cell_tv02_a02_id_portaria = Gtk.CellRendererText()
col_tv02_a02_id_portaria = Gtk.TreeViewColumn("ID.Portaria",
cell_tv02_a02_id_portaria,
text=self.col_tv02_a02_id_portaria)
col_tv02_a02_id_portaria.set_visible(False)
tv.append_column(col_tv02_a02_id_portaria)
cel_tv02_a02_nome_portaria = Gtk.CellRendererText()
col_tv02_a02_nome_portaria = Gtk.TreeViewColumn("Nome",
cel_tv02_a02_nome_portaria,
text=self.col_tv02_a02_nome_portaria)
col_tv02_a02_nome_portaria.set_visible(True)
tv.append_column(col_tv02_a02_nome_portaria)
col_tv02_a02_nome_portaria.connect("clicked", self.clicado_col_tv02, tv, self.col_tv02_a02_nome_portaria)
col_tv02_a02_nome_portaria.set_reorderable(True)
cel_tv02_dados_portaria = Gtk.CellRendererText()
col_tv02_dados_portaria = Gtk.TreeViewColumn("Endereço",
cel_tv02_dados_portaria,
text=self.col_tv02_dados_portaria)
col_tv02_dados_portaria.set_visible(True)
tv.append_column(col_tv02_dados_portaria)
col_tv02_dados_portaria.connect("clicked", self.clicado_col_tv02, tv, self.col_tv02_dados_portaria)
col_tv02_dados_portaria.set_reorderable(True)
tv.set_enable_search(True)
tv.set_headers_clickable(True)
def clicado_col_tv02(self, widget, tv, coluna):
"""
habilita pesquisa de tv
"""
tv.set_enable_search(True)
widget.set_sort_column_id(coluna)
tv.set_search_column(coluna)
def pesquisar_portarias(self, id_condominio=0):
lst_dic_dados = []
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
cur.execute(""" select a02_id_condominio,
a02_id_portaria,
a02_nome_portaria,
concat(a02_endereco, ', ', a02_numero) as dados_portaria
from a01_condominio, a02_portarias
WHERE a01_id_condominio = a02_portarias.a02_id_condominio
and a01_id_condominio = %s
order by upper(a02_nome_portaria);
""", (id_condominio,))
registros = cur.fetchall()
except psycopg2.ProgrammingError as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
return False
for registro in registros:
lst_dic_dados.append(dict(registro))
if not registros:
return False
cur.close()
del conn, cur, registros
return lst_dic_dados
def on_tv02_a02_key_press_event(self, widget, event):
keyval = Gdk.keyval_name(event.keyval)
if keyval == 'Return' or keyval == 'KP_Enter':
selection = widget.get_selection()
modelx, iterx = selection.get_selected()
self.limpar_tela()
try:
id_condominio = str(modelx.get_value(iterx, self.col_tv02_a02_id_condominio))
id_portaria = str(modelx.get_value(iterx, self.col_tv02_a02_id_portaria))
self.ge_id_condominio = id_condominio
self.ge_id_portaria = id_portaria
except ValueError:
return False
finally:
self.ge_selecionado = True
dic_portaria = self.consulta_portaria(id_condominio=id_condominio, id_portaria=id_portaria)
if len(dic_portaria) != 0:
self.mostrar_dados_tela(dic_portaria=dic_portaria)
# self.ge_dic_dados = dic_portaria
self.ge_selecionado = True
else:
self.limpar_tela()
def preencher_combo_condominio(self, lista, res):
lista.clear()
for i in res:
lista.append([
str(i['a01_id_condominio']),
str(i['a01_nome']) if i['a01_nome'] else None,
])
def consulta_portaria(self, id_condominio, id_portaria):
dic_dados = {}
try:
conn = psycopg2.connect(self.ge_dic_param_sis['DSN'])
conn.set_client_encoding(self.ge_dic_param_sis['CLIENTEENCODING'])
cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
cur.execute(""" SELECT *
FROM a02_portarias
WHERE a02_id_condominio = %s
AND a02_id_portaria = %s;
;
""", (id_condominio, id_portaria)
)
registros = cur.fetchall()
except psycopg2.ProgrammingError as msg:
logging.error(msg)
self.JP.msgerro(janela=None,
texto_primario="Cadastro de Portaria",
texto_secundario=msg)
return False
for registro in registros:
dic_dados = dict(registro)
if not registros:
return False
cur.close()
del conn, cur, registros
return dic_dados
def mostrar_dados_tela(self, dic_portaria):
for key, value in dic_portaria.items():
if key == 'a02_nome_portaria':
if value is not None:
self.e02_a02_nome_portaria.set_text(str(value))
else:
self.e02_a02_nome_portaria.set_text('')
if key == 'a02_endereco':
if value is not None:
self.e02_a02_endereco.set_text(str(value))
else:
self.e02_a02_endereco.set_text('')
if key == 'a02_numero':
if value > 0:
self.e02_a02_numero.set_text(str(value))
else:
self.e02_a02_numero.set_text('')