def __init__(self):
self.receiver = Receiver()
self.snapshot_usuario = SnapshotMemento()
self.snapshot_produto = SnapshotMemento()
self.snapshot_aluguel = SnapshotMemento()
self.usuarios = {}
self.produtos = {}
self.alugueis = {}
self.prox_usuario = 0
self.prox_produto = 0
self.prox_aluguel = 0
class AuthOAUTH(Strategy):
def __init__(self):
self.receiver = Receiver()
self.lista_usuarios = []
def entrar(self, login, senha):
""" Mock de Autenticação por OAUTH """
try:
hash_da_senha = f'{login}{senha}'
if hash_da_senha == 'adminadmin':
oauth_cookie = True
self.receiver.notificar_todos("autenticado com sucesso usando oauth")
self.receiver.notificar_todos("deslogado com sucesso")
return oauth_cookie
else:
raise Exception('TOKEN OAUTH INVALIDO')
except Exception as e:
self.receiver.notificar_todos(e)
def sair(self):
try:
oauth_cookie = False
return oauth_cookie
except Exception as e:
self.receiver.notificar_todos(e)
class CommandInvoker():
def __init__(self):
self.__fila_comandos = []
self.receiver = Receiver()
def enfileirar(self, comando):
'''Adiciona um Comando na fila '''
self.__fila_comandos.append(comando)
def executar_fila(self):
''' Executa tudo que está na fila e zera a fila '''
for comando in self.__fila_comandos:
self.receiver.notificar_todos(f"Executando {comando}")
comando.execute()
self.__fila_comandos = []
def executar_imediatamente(self, comando):
self.receiver.notificar_todos(f"Executando {comando}")
comando.execute()
class CommandInterface(object):
def __init__(self, core):
self.core = core
self.invoker = CommandInvoker()
self.receiver = Receiver()
def add(self, texto):
try:
if texto[0] == "CRIARUSUARIO":
self.invoker.enfileirar(
CriarUsuarioCommand(self.core, texto[1], texto[2],
texto[3], texto[4]))
elif texto[0] == "EXCLUIRUSUARIO":
self.invoker.enfileirar(
ExcluirUsuarioCommand(self.core, texto[1]))
elif texto[0] == "CRIARPRODUTO":
self.invoker.enfileirar(
CriarProdutoCommand(self.core, texto[1], texto[2],
texto[3], texto[4]))
elif texto[0] == "EXCLUIRPRODUTO":
self.invoker.enfileirar(
ExcluirProdutoCommand(self.core, texto[1]))
elif texto[0] == "CRIARALUGUEL":
self.invoker.enfileirar(
CriarAluguelCommand(self.core, texto[1], texto[2],
texto[3]))
elif texto[0] == "EXCLUIRALUGUEL":
self.invoker.enfileirar(
ExcluirAluguelCommand(self.core, texto[1]))
elif texto[0] == "ENTRAR":
self.invoker.enfileirar(
EntrarCommand(self.core, texto[1], texto[2]))
elif texto[0] == "SAIR":
self.invoker.enfileirar(SairCommand(self.core))
elif texto[0] == "DESFAZER":
self.invoker.enfileirar(DesfazerCommand(self.core))
except:
self.receiver.notificar_todos(f"Erro Executando {texto}")
def rodar(self):
self.invoker.executar_fila()
class AuthPassword(Strategy):
def __init__(self):
self.receiver = Receiver()
def entrar(self, login, senha):
""" Mock de Autenticação por senha """
try:
if login == 'admin' and senha == 'admin':
magic_cookie = True
self.receiver.notificar_todos("autenticado com sucesso usando senha")
return magic_cookie
else:
raise Exception('Usuario / Senha Invalido')
except Exception as e:
self.receiver.notificar_todos(e)
def sair(self):
try:
magic_cookie = False
self.receiver.notificar_todos("deslogado com sucesso")
return magic_cookie
except Exception as e:
self.receiver.notificar_todos(e)
def __init__(self):
self.__fila_comandos = []
self.receiver = Receiver()
class LocalController(ControlAbstract, Singleton):
def __init__(self):
self.receiver = Receiver()
self.snapshot_usuario = SnapshotMemento()
self.snapshot_produto = SnapshotMemento()
self.snapshot_aluguel = SnapshotMemento()
self.usuarios = {}
self.produtos = {}
self.alugueis = {}
self.prox_usuario = 0
self.prox_produto = 0
self.prox_aluguel = 0
def inicializar_sistema(self):
## no caso do controlador local, única necessidade é carregar o arquivo
self.carregar_arquivo('sari/storage/usuario.bin',
'sari/storage/produto.bin',
'sari/storage/aluguel.bin')
def notificar_admin(self):
self.receiver.notificar_todos(
"SISTEMA SARI INICIADO - MODO ARMAZENAMENTO LOCAL")
def finalizar_sistema(self):
self.salvar_arquivo('sari/storage/usuario.bin',
'sari/storage/produto.bin',
'sari/storage/aluguel.bin')
def notificar_admin_final(self):
self.receiver.notificar_todos(
"SISTEMA SARI FINALIZADO - MODO ARMAZENAMENTO LOCAL")
def carregar_arquivo(self, a_usuarios, a_produtos, a_alugueis):
with open(a_usuarios, 'rb') as a_usuarios:
self.usuarios = pickle.load(a_usuarios)
with open(a_produtos, 'rb') as a_produtos:
self.produtos = pickle.load(a_produtos)
with open(a_alugueis, 'rb') as a_alugueis:
self.alugueis = pickle.load(a_alugueis)
self.prox_usuario = len(self.usuarios)
self.prox_produto = len(self.produtos)
self.prox_aluguel = len(self.alugueis)
def salvar_arquivo(self, a_usuarios, a_produtos, a_alugueis):
with open(a_usuarios, 'wb') as a_usuarios:
pickle.dump(self.usuarios, a_usuarios)
with open(a_produtos, 'wb') as a_produtos:
pickle.dump(self.produtos, a_produtos)
with open(a_alugueis, 'wb') as a_alugueis:
pickle.dump(self.alugueis, a_alugueis)
def criar_usuario(self, nome, email, senha, bio):
id_usuario = self.prox_usuario
self.prox_usuario += 1
usr = Usuario(id_usuario, email, nome, senha, bio)
self.usuarios[id_usuario] = usr
self.receiver.notificar_todos(
f"ID: {id_usuario} Usuario {nome} Criado")
def excluir_usuario(self, email):
try:
for key, value in self.usuarios.items():
if value.email == email:
self.usuarios.pop(key)
except:
self.receiver.notificar_todos(f'Usuario {email} não encontrado')
def criar_produto(self, id_dono, nome, preco, descricao):
id_produto = self.prox_produto
self.prox_produto += 1
prod = Produto(id_produto, id_dono, nome, preco, descricao)
self.produtos[id_produto] = prod
self.receiver.notificar_todos(f'PRODUTO {id_produto}: {nome} CRIADO')
def excluir_produto(self, id_produto):
try:
if id_produto in self.produtos.keys():
self.usuarios.pop(id_produto)
except:
self.receiver.notificar_todos(
f'Produto {id_produto} não encontrado')
def criar_aluguel(self, id_produto, id_alugador, data_aluguel):
id_trans = self.prox_aluguel
self.prox_aluguel += 1
alg = Aluguel(id_trans, id_produto, id_alugador, data_aluguel)
self.alugueis[id_trans] = alg
self.receiver.notificar_todos(
f'ALUGUEL {id_trans} {id_alugador} CRIADO')
def excluir_aluguel(self, id_trans):
try:
if id_trans in self.alugueis.keys():
self.alugueis.pop(id_trans)
except:
self.receiver.notificar_todos(f'Aluguel {id_trans} não encontrado')
def criar_memento(self):
self.snapshot_usuario.criar_snapshot(self.usuarios)
self.snapshot_produto.criar_snapshot(self.produtos)
self.snapshot_aluguel.criar_snapshot(self.alugueis)
self.receiver.notificar_todos(f'(Memento) Snapshot Criado')
def restaurar_estado(self):
self.snapshot_usuario.restaurar_ultimo_snapshot()
self.snapshot_produto.restaurar_ultimo_snapshot()
self.snapshot_aluguel.restaurar_ultimo_snapshot()
self.receiver.notificar_todos(f'(Memento) Desfeita Ultima Alteração')
def __init__(self): self.receiver = Receiver() self.lista_usuarios = []
def __init__(self):
self.receiver = Receiver()
self._db, self._cursor = None, None
class MariaDBController(ControlAbstract, Singleton):
def __init__(self):
self.receiver = Receiver()
self._db, self._cursor = None, None
def _reload(self):
"""Recarrega a conexão com a db e renova o db e o cursor """
self.db = mariadb.connect(**DATABASE_CONFIG)
self.cursor = self._db.cursor()
self.cursor.execute("USE sari;")
def inicializar_sistema(self):
self._reload()
def notificar_admin(self):
self.receiver.notificar_todos(
"SISTEMA SARI INICIADO - MODO BANCO DE DADOS")
def finalizar_sistema(self):
self.db.close()
def notificar_admin_final(self):
self.receiver.notificar_todos(
"SISTEMA SARI FINALIZADO - MODO BANCO DE DADOS")
@db_write
def criar_usuario(self, nome, email, senha, bio):
try:
self._cursor.execute(DB_PROCURAR_USUARIO_POR_EMAIL, (email, ))
user = self._cursor.fetchall()
user = list(*zip(*zip(*user)))
if user: raise Exception('Usuario Já Existe')
check_value(nome, min=2, max=64)
check_value(email, regex=r'[A-Za-z0-9@.]+$')
check_value(senha, regex=r'[A-Za-z0-9@.\+\-\*_\-\,]+$')
check_value(bio, max=256, regex=False)
self._cursor.execute(DB_CRIAR_USUARIO, (
nome,
email,
senha,
bio,
))
self.receiver.notificar_todos(
f"DB: Usuário Adicionado: {nome} {email} {senha} {bio}")
except Exception as e:
self.receiver.notificar_todos(e)
@db_write
def excluir_usuario(self, email):
try:
self._cursor.execute(DB_PROCURAR_USUARIO_POR_EMAIL, (email, ))
user = self._cursor.fetchall()
user = list(*zip(*zip(*user)))
if user:
self._cursor.execute(DB_EXCLUIR_USUARIO_POR_EMAIL, (email, ))
self.receiver.notificar_todos(f"DB: Usuário Excluido: {email}")
else:
raise Exception("Usuario Não Existe")
except Exception as e:
self.receiver.notificar_todos(e)
@db_write
def criar_produto(self, id_dono, nome, preco, descricao):
try:
check_value(id_dono, min=1, regex=r'[0-9]+$')
check_value(nome)
check_value(preco, regex=r'[A-Za-z0-9\@\.\$]+$')
check_value(descricao, max=256, regex=False)
self._cursor.execute(DB_PROCURAR_USUARIO_POR_ID, (id_dono, ))
dono_existe = self._cursor.fetchall()
self.receiver.notificar_todos(dono_existe)
if dono_existe:
self._cursor.execute(DB_CRIAR_PRODUTO, (
id_dono,
nome,
preco,
descricao,
))
self.receiver.notificar_todos(
f"DB: PRODUTO Adicionado: {nome} {preco} {descricao} {id_dono}"
)
else:
raise Exception('Usuario Não Existe')
except Exception as e:
self.receiver.notificar_todos(e)
def excluir_produto(self):
pass
def criar_aluguel(self):
pass
def excluir_aluguel(self):
pass
def __init__(self, core):
self.core = core
self.invoker = CommandInvoker()
self.receiver = Receiver()
def __init__(self): self.receiver = Receiver()