def ver_solicitacoes(cls):
while True:
DB.cursor.execute(f'''
SELECT
*
FROM
rUser_User
INNER JOIN
tUser
ON
rUser_User.id_user_from = tUser.id_user
WHERE
id_user_to = {cls.owner_user['id_user']}
AND
status = 0
''')
solicitacoes = DB.cursor.fetchall()
if solicitacoes:
opcoes = [['Cancelar']] + [[f'{solicitacao["name"]}']
for solicitacao in solicitacoes]
opcao = menu_opcoes('INTERAGIR COM SOLICITAÇÃO', opcoes)
if not opcao:
return
else:
aceita = menu_opcoes(
'ACEITAR SOLICITAÇÃO?',
[['Cancelar'], ['Aceitar'], ['Rejeitar']])
if aceita == 1:
DB.cursor.execute(f'''
UPDATE
rUser_User
SET
status = 1
WHERE
id_user_from = {solicitacoes[opcao - 1]['id_user']}
AND
id_user_to = {cls.owner_user['id_user']}
''')
DB.connection.commit()
print('Solicitação aceita!')
elif aceita == 2:
DB.cursor.execute(f'''
DELETE FROM
rUser_User
WHERE
id_user_from = {solicitacoes[opcao - 1]['id_user']}
AND
id_user_to = {cls.owner_user['id_user']}
AND
status = 0
''')
DB.connection.commit()
print('Solicitação recusada.')
else:
print('Não há nenhuma solicitação para esse usuário.')
return
def ver_solicitacoes(cls):
while True:
DB.cursor.execute(f'''
SELECT
*
FROM
rUser_Group
INNER JOIN
tUser
ON
rUser_Group.id_user = tUser.id_user
WHERE
id_group = {cls.grupo['id_group']}
AND
status = 0
''')
solicitacoes = DB.cursor.fetchall()
opcoes = [['Cancelar']] + [[f'{solicitacao["name"]}'] for solicitacao in solicitacoes]
opcao = menu_opcoes('INTERAGIR COM SOLICITAÇÃO', opcoes)
if not opcao:
return
else:
opcao_solicitacao = menu_opcoes(
'INTERAGIR COM SOLICITACAO',
[['Cancelar'], ['Aceitar'], ['Recusar']]
)
# Aceitar solicitação
if opcao_solicitacao == 1:
DB.cursor.execute(f'''
UPDATE
rUser_Group
SET
status = 1
WHERE
id_user = {solicitacoes[opcao - 1]['id_user']}
AND
id_group = {cls.grupo['id_group']}
''')
DB.connection.commit()
print('Solicitação aceita!')
# Recusar solicitação
elif opcao_solicitacao == 2:
DB.cursor.execute(f'''
DELETE FROM
rUser_Group
WHERE
id_user = {solicitacoes[opcao - 1]['id_user']}
AND
id_group = {cls.grupo['id_group']}
AND
status = 0
''')
DB.connection.commit()
print('Solicitação recusada.')
def ver_membros(cls):
while True:
DB.cursor.execute(f'''
SELECT
*
FROM
rUser_Group
INNER JOIN
tUser
ON
rUser_Group.id_user = tUser.id_user
WHERE
id_group = {cls.grupo['id_group']}
AND
(status != 0)
''')
membros = DB.cursor.fetchall()
opcoes = [['Cancelar']] + [[f'{membro["name"]}'] for membro in membros]
opcao = menu_opcoes('INTERAGIR COM MEMBRO', opcoes)
if not opcao:
return
if opcao != 0:
opcoes_membro = [['Cancelar', None], ['Visitar Perfil', cls.visitar_perfil]]
# 1 = normal, 2 = admin, 3 = banido
membro = membros[opcao - 1]
if cls.eh_adm():
opcoes_membro.append(['Remover', cls.remover_membro])
if membro['status'] == 3:
opcoes_membro.append(['Desbanir', cls.alternar_banimento])
else:
opcoes_membro.append(['Banir', cls.alternar_banimento])
if membro['status'] == 1:
opcoes_membro.append(['Tornar Administrador', cls.alternar_adm])
elif membro['status'] == 2:
opcoes_membro.append(['Tornar Usuário Normal', cls.alternar_adm])
opcao_membro = menu_opcoes('INTERAGIR COM MEMBRO', opcoes_membro)
if not opcao_membro:
return
else:
opcoes_membro[opcao_membro][1](membro)
def ver_menu(cls):
print(f"Nome: {cls.grupo['name']}")
print(f"Descrição: {cls.grupo['description']}")
while True:
opcoes_grupo = [
['Cancelar', None],
['Ver foto', cls.ver_foto],
]
if not cls.eh_solicitante() and not cls.eh_membro() and not cls.eh_bloqueado():
opcoes_grupo.append(['Solicitar Entrada', cls.solicitar_entrada])
elif cls.eh_solicitante():
opcoes_grupo.append(['Cancelar Solicitação', cls.cancelar_solicitacao])
# membro ou adm
elif cls.eh_visivel():
opcoes_grupo.append(['Ver Mural', cls.ver_mural])
opcoes_grupo.append(['Ver Membros', cls.ver_membros])
elif cls.eh_membro():
opcoes_grupo.append(['Sair do Grupo', cls.sair_grupo])
if cls.eh_adm():
opcoes_grupo.append(['Ver Solicitações', cls.ver_solicitacoes])
opcao_grupo = menu_opcoes('INTERAGIR COM GRUPO', opcoes_grupo)
if not opcao_grupo:
return
opcoes_grupo[opcao_grupo][1]()
def menu_post(cls, post_interagido):
opcoes = [
['Voltar ao menu principal'],
['Ver imagem do post'],
['Ver comentários'],
]
if post_interagido['id_user'] == State.usuario_atual['id_user']:
opcoes.append(['Remover postagem'])
while True:
opcao = menu_opcoes('MENU POST', opcoes)
if not opcao:
return
elif opcao == 1:
# Ver imagem do post
ver_imagem(post_interagido)
elif opcao == 2:
# Ver comentários
cls.ver_comentarios(post_interagido)
elif opcao == 3:
# Remover postagem
DB.cursor.execute(f'''
DELETE FROM
tPost
WHERE
id_post = {post_interagido['id_post']}
''')
DB.connection.commit()
print('Postagem removida.')
return
def ver_mural(cls):
while True:
DB.cursor.execute(f'''
SELECT
*
FROM
tPost
INNER JOIN
tUser
ON
tPost.id_user = tUser.id_user
WHERE
tPost.id_wall = {cls.owner_user['id_wall']}
''')
posts = DB.cursor.fetchall()
opcoes = [['Voltar ao menu principal'], ['Criar postagem']]
for post in posts:
if not cls.is_blocked_either(State.usuario_atual['id_user'],
post['id_user']):
opcoes.append([f'-> {post["name"]}: {post["text"]}'])
opcao = menu_opcoes('POSTS', opcoes)
if not opcao:
return
elif opcao == 1:
Mural(cls.owner_user['id_wall']).fazer_postagem()
elif opcao > 1:
# interação com Post
cls.menu_post(posts[opcao - 2])
def ver_comentarios(cls, post_interagido):
while True:
DB.cursor.execute(f'''
SELECT
*
FROM
tComment
INNER JOIN
tUser
ON
tComment.id_user = tUser.id_user
WHERE
tComment.id_post = {post_interagido['id_post']}
''')
comentarios = DB.cursor.fetchall()
opcoes = [['Cancelar'], ['Comentar']]
for comentario in comentarios:
if not cls.is_blocked_either(State.usuario_atual['id_user'],
comentario['id_user']):
opcoes.append(
[f'-> {comentario["name"]}: {comentario["text"]}'])
opcao = menu_opcoes('COMENTARIOS', opcoes)
if not opcao:
return
if opcao == 1:
Mural(cls.owner_user['id_wall']).fazer_comentario(
post_interagido['id_post'])
elif opcao > 1:
cls.menu_comentario(comentarios[opcao - 2])
def ver_lista_grupos(cls):
DB.cursor.execute(f'''
SELECT
*
FROM
tGroup
WHERE
id_group NOT IN(
SELECT
id_group
FROM
rUser_Group
WHERE
id_user = {State.usuario_atual['id_user']}
AND
status = 3
)
''')
grupos = DB.cursor.fetchall()
opcoes = [['Cancelar']] + [[f'{grupo["name"]}'] for grupo in grupos]
opcao = menu_opcoes('INTERAGIR COM GRUPO', opcoes)
if opcao != 0:
Grupo(grupos[opcao - 1]['id_group']).ver_menu()
def menu_comentario(cls, comentario):
while True:
opcoes = [['Cancelar'], ['Ver respostas']]
# Só quem fez o comentário ou um administrador pode remove-lô
if comentario['id_user'] == State.usuario_atual['id_user']:
opcoes.append(['Remover comentário'])
opcao = menu_opcoes('MENU COMENTARIO', opcoes)
if not opcao:
return
elif opcao == 1:
# Ver respostas
cls.ver_respostas(comentario)
elif opcao == 3:
# Remover comentário
DB.cursor.execute(f'''
DELETE FROM
tComment
WHERE
id_comment = {comentario['id_comment']}
''')
print('Comentário removido.')
DB.connection.commit()
def ver_respostas(cls, comentario):
while True:
DB.cursor.execute(f'''
SELECT
*
FROM
tReply
INNER JOIN
tUser
ON
tReply.id_user = tUser.id_user
WHERE
tReply.id_comment = {comentario['id_comment']}
''')
respostas = DB.cursor.fetchall()
opcoes = [['Cancelar'], ['Responder']]
for resposta in respostas:
if not cls.is_blocked_either(State.usuario_atual['id_user'],
resposta['id_user']):
opcoes.append(
[f'-> {resposta["name"]}: {resposta["text"]}'])
opcao = menu_opcoes('RESPOSTAS', opcoes)
if not opcao:
return
elif opcao == 1:
Mural(cls.owner_user['id_wall']).fazer_resposta(
comentario['id_comment'])
elif opcao > 1:
cls.menu_resposta(respostas[opcao - 2])
def criar_grupo(cls):
opcoes = [['Voltar', None],
[
'Definir Visibilidade do Grupo',
cls.definir_visibilidade_grupo
], ['Definir Nome do Grupo', cls.definir_nome_grupo],
['Definir Descrição do Grupo', cls.definir_descricao_grupo],
['Definir Imagem do Grupo', cls.definir_imagem_grupo]]
while not cls.novo_grupo['nome'] or \
not cls.novo_grupo['descricao'] or \
not cls.novo_grupo['imagem']:
print('\nNome atual:', cls.novo_grupo['nome'])
print('Descrição atual:', cls.novo_grupo['descricao'])
print('Imagem atual:', cls.novo_grupo['imagem'])
visi = cls.novo_grupo['visibilidade']
print('Visibilidade atual:', ('Pública' if visi else 'Privada'))
opcao = menu_opcoes('CRIAÇÃO DE GRUPO - Etapas', opcoes)
if opcoes[opcao][1] is None:
cls.novo_grupo['nome'] = ''
cls.novo_grupo['descricao'] = ''
cls.novo_grupo['imagem'] = ''
cls.novo_grupo['visibilidade'] = 1
return
opcoes[opcao][1]()
DB.new_group(cls.novo_grupo['nome'], cls.novo_grupo['descricao'],
cls.novo_grupo['imagem'], State.usuario_atual)
print('Grupo cadastrado!')
def login(cls):
DB.cursor.execute('SELECT name, city FROM tUser')
users = DB.cursor.fetchall()
opcoes = [['Cancelar']] + [[f'{user["name"]}, {user["city"]}'] for user in users]
opcao = menu_opcoes('USUÁRIOS DISPONÍVEIS PARA LOGIN', opcoes)
if not opcao:
return
else:
DB.cursor.execute(f'SELECT * FROM tUser WHERE id_user={opcao}')
if State.usuario_atual is None:
State.usuario_atual = DB.cursor.fetchone()
else:
new_login = DB.cursor.fetchone()
opcao = input(f'Você já está logado como {State.usuario_atual["name"]}. Deseja logar como {new_login["name"]}? [S/n]: ')
if opcao.lower() != 'n':
State.usuario_atual = new_login
print(f'\nVOCÊ ESTÁ LOGADO COMO: {State.usuario_atual["name"]}')
return
def registrar(cls):
cls.novo_usuario['nome'] = ''
cls.novo_usuario['cidade'] = ''
cls.novo_usuario['imagem'] = ''
opcoes = [['Cancelar', None], ['Escolher nome', cls.definir_nome],
['Escolher cidade', cls.definir_cidade],
['Escolher imagem', cls.definir_imagem]]
while not cls.novo_usuario['nome'] or \
not cls.novo_usuario['cidade'] or \
not cls.novo_usuario['imagem']:
print('\nNome atual:', cls.novo_usuario['nome'])
print('Cidade atual:', cls.novo_usuario['cidade'])
print('Imagem atual:', cls.novo_usuario['imagem'])
opcao = menu_opcoes('CADASTRO - Etapas', opcoes)
if opcoes[opcao][1] is None:
return
opcoes[opcao][1]()
DB.new_user(cls.novo_usuario['nome'], cls.novo_usuario['cidade'],
cls.novo_usuario['imagem'])
print('Usuário cadastrado!')
def ver_amigos(cls):
while True:
amigos = cls.get_amigos(cls.owner_user['id_user'])
if amigos:
opcoes = [['Cancelar']]
for amigo in amigos:
# Checagem se são amigos mútuos só acontece em perfil de outras pessoas
if State.usuario_atual['id_user'] != cls.owner_user[
'id_user']:
DB.cursor.execute(f'''
SELECT
status
FROM
rUser_User
WHERE
status = 1
AND
(
(
id_user_from = {State.usuario_atual['id_user']}
AND
id_user_to = {amigo['id_user']}
)
OR
(
id_user_to = {State.usuario_atual['id_user']}
AND
id_user_from = {amigo['id_user']}
)
)
''')
mutuo = True if DB.cursor.fetchone() else False
else:
mutuo = False
if mutuo:
opcoes.append([
f'''{amigo['name']}, de {amigo['city']} (AMIGO MÚTUO)'''
])
else:
opcoes.append(
[f'''{amigo['name']}, de {amigo['city']}'''])
opcao = menu_opcoes('AMIGOS', opcoes)
if not opcao:
return
else:
cls.menu_usuario(amigos[opcao - 1])
else:
print('Esse usuário não tem amigos.')
return
def ver_menu(cls):
while True:
print('\n---- PERFIL ----')
print(f"Nome: {cls.owner_user['name']}")
print(f"Cidade: {cls.owner_user['city']}")
opcoes = [
['Voltar ao menu principal', None],
['Ver foto', cls.ver_foto],
]
# Menu reduzido por conta do bloqueio: FOTO ou VOLTAR
if cls.is_blocked_either(State.usuario_atual['id_user'],
cls.owner_user['id_user']):
print('Usuário bloqueado.')
opcao = menu_opcoes('OPÇÕES DO PERFIL', opcoes)
if not opcao:
return
opcoes[opcao][1]()
# ignore rest of loop
continue
if cls.eh_visivel(
) or cls.owner_user['id_user'] == State.usuario_atual['id_user']:
opcoes.append(['Ver Amigos', cls.ver_amigos])
opcoes.append(['Ver Grupos', cls.ver_grupos])
opcoes.append(['Ver Mural', cls.ver_mural])
if cls.owner_user['id_user'] == State.usuario_atual['id_user']:
# Dono do perfil está visualizando o próprio perfil
opcoes.append(['Ver Solicitações', cls.ver_solicitacoes])
opcoes.append(
['Configurações de Conta', cls.configuracoes_conta])
opcao = menu_opcoes('OPÇÕES DO PERFIL', opcoes)
if not opcao:
return
opcoes[opcao][1]()
def definir_visibilidade_grupo(cls):
opcoes = [['Cancelar'], ['Grupo Privado'], ['Grupo Público']]
while True:
opcao = menu_opcoes('VISIBILIDADE DO GRUPO', opcoes)
if not opcao:
return
elif type(opcao) == int:
cls.novo_grupo['visibility'] = opcao - 1
return
def configuracoes_conta(cls):
opcoes = [['Voltar', None],
['Definir Visibilidade', cls.definir_visibilidade],
['Atualizar Nome', cls.atualizar_nome],
['Atualizar Cidade', cls.atualizar_cidade],
['Atualizar Imagem', cls.atualizar_imagem]]
while True:
opcao = menu_opcoes('CONFIGURAÇÕES DE CONTA', opcoes)
if not opcao:
return
opcoes[opcao][1]()
def configuracoes_grupo(cls):
opcoes = [
['Voltar', None],
['Definir Visibilidade', cls.definir_visibilidade],
['Atualizar Nome', cls.atualizar_nome],
['Atualizar Descrição', cls.atualizar_descrição],
['Atualizar Imagem', cls.atualizar_imagem]
]
while True:
opcao = menu_opcoes('CONFIGURAÇÕES DE GRUPO', opcoes)
if not opcao:
return
opcoes[opcao][1]()
def executar(cls):
while True:
opcoes = [['Sair', None], ['Registrar', Credenciamento.registrar],
['Login', LoginManager.login]]
opcao = menu_opcoes('MENU INICIAL', opcoes)
if opcoes[opcao][1] is None:
return
opcoes[opcao][1]()
if State.usuario_atual:
MenuPrincipal.executar()
def executar(cls):
login_manager = LoginManager()
while True:
opcoes = [
['Logout', login_manager.logout],
['Ver Perfil', cls.ver_perfil],
['Ver Lista de Usuários', cls.ver_lista_usuarios],
['Ver Lista de Grupos', cls.ver_lista_grupos],
['Criar Grupo', cls.criar_grupo],
]
opcao = menu_opcoes('MENU INICIAL', opcoes)
opcoes[opcao][1]()
if opcoes[opcao][1] == login_manager.logout:
if State.usuario_atual is None:
return
def menu_usuario(cls, usuario):
while True:
# Ver qual o relacionamento do usuário interagido com o usuário logado
relacionamento = cls.get_relacionamento(usuario)
opcoes = [['Cancelar', None], ['Visitar Perfil', None]]
if not cls.is_blocked(user=usuario['id_user']):
if not relacionamento:
# Não existe relacionamento entre os usuários
opcoes.append(['Solicitar Amizade', cls.solicitar_amizade])
else:
# Já existe algum relacionamento entre os usuários
if relacionamento['status'] == 0:
opcoes.append([
'Desfazer Solicitação de Amizade',
cls.desfazer_solicitacao
])
elif relacionamento['status'] == 1:
opcoes.append(
['Desfazer Amizade', cls.desfazer_amizade])
else: # relacionamento['status'] == 2:
opcoes.append(['Desbloquear', cls.desbloquear_usuario])
# Opção de bloquear não aparece se o usuário já está bloqueado
if (relacionamento and relacionamento['status'] != 2)\
or (not relacionamento):
opcoes.append(['Bloquear', cls.bloquear])
opcao = menu_opcoes(f'''INTERAGIR COM USUÁRIO''', opcoes)
if not opcao:
return
if opcao != 0:
if opcao == 1:
Perfil(usuario).ver_menu()
elif opcao > 1:
opcoes[opcao][1](usuario)
DB.connection.commit()
def menu_resposta(cls, resposta):
while True:
# Interagir com resposta
opcoes = [['Cancelar']]
# Só quem postou a resposta ou um administrador pode remover
if resposta['id_user'] == State.usuario_atual['id_user']:
opcoes.append(['Remover resposta'])
opcao = menu_opcoes('MENU RESPOSTA', opcoes)
if not opcao:
return
elif opcao == 1:
DB.cursor.execute(f'''
DELETE FROM
tReply
WHERE
id_reply = {resposta['id_reply']}
''')
print('Resposta removida.')
DB.connection.commit()
def ver_lista_usuarios(cls):
DB.cursor.execute(f'''
SELECT
*
FROM
tUser
WHERE
id_user != {State.usuario_atual['id_user']}
AND
id_user NOT IN(
-- Quem bloqueou o usuário atual
SELECT
id_user_from
FROM
rUser_User
WHERE
id_user_to = {State.usuario_atual['id_user']}
AND
id_user_from != {State.usuario_atual['id_user']}
AND
status = 2
)
''')
usuarios = DB.cursor.fetchall()
opcoes_usuarios = [['Cancelar']
] + [[f'{usuario["name"]}, {usuario["city"]}']
for usuario in usuarios]
while True:
opcao = menu_opcoes('USUÁRIOS DISPONÍVEIS PARA INTERAGIR',
opcoes_usuarios)
if not opcao:
return
else:
Perfil.menu_usuario(usuarios[opcao - 1])
return
def definir_visibilidade(cls):
opcoes = [['Cancelar'], ['Perfil Privado'],
['Perfil Visível para Amigos'],
['Perfil Visível para Amigos e Amigos de amigos'],
['Perfil Público']]
while True:
opcao = menu_opcoes('VISIBILIDADE', opcoes)
if not opcao:
return
DB.cursor.execute(f'''
UPDATE
tUser
SET
visibility={opcao-1}
WHERE
id_user={cls.owner_user["id_user"]}
''')
DB.connection.commit()
print(f'Visibilidade atualizada: {opcoes[opcao]}')
def definir_visibilidade(cls):
opcoes = [
['Cancelar'],
['Perfil Privado'],
['Perfil Público']
]
while True:
opcao = menu_opcoes('VISIBILIDADE', opcoes)
if not opcao:
return
DB.cursor.execute(f'''
UPDATE
tGroup
SET
visibility={opcao-1}
WHERE
id_group={cls.grupo["id_group"]}
''')
DB.connection.commit()
print(f'Visibilidade atualizada: {opcoes[opcao]}')
def ver_grupos(cls):
while True:
DB.cursor.execute(f'''
SELECT
*
FROM
rUser_Group
INNER JOIN
tGroup
ON
rUser_Group.id_group = tGroup.id_group
WHERE
id_user = {cls.owner_user['id_user']}
AND
tGroup.id_group NOT IN(
SELECT
id_group
FROM
rUser_Group
WHERE
id_user = {State.usuario_atual['id_user']}
AND
status = 3
)
''')
grupos = DB.cursor.fetchall()
if grupos:
opcoes = [['Voltar ao menu principal']
] # + [[f'{grupo["name"]}'] for grupo in grupos]
for grupo in grupos:
# Checagem de grupo mútuo só em perfil de outras pessoas
if State.usuario_atual['id_user'] != cls.owner_user[
'id_user']:
DB.cursor.execute(f'''
SELECT
status
FROM
rUser_Group
WHERE
(status = 1 OR status = 2)
AND
id_group = {grupo['id_group']}
AND
id_user = {State.usuario_atual['id_user']}
''')
mutuo = True if DB.cursor.fetchone() else False
else:
mutuo = False
if mutuo:
opcoes.append([f'{grupo["name"]} (GRUPO MÚTUO)'])
else:
opcoes.append([f'{grupo["name"]}'])
opcao = menu_opcoes('INTERAGIR COM GRUPO', opcoes)
if not opcao:
return
else:
Grupo(grupos[opcao - 1]).ver_menu()
else:
print('Esse usuário não está em nenhum grupo.')
return
