source.archives

  1from dictionary.sql import search_user_archives_quantity, search_user_archives_name
  2from dictionary.vars import to_remove_list, to_remove_archive_list
  3from functions.query_executor import QueryExecutor
  4from functions.login import Login
  5from time import sleep
  6import streamlit as st
  7
  8
  9class Archives:
 10    """
 11    Classe que representa os arquivos, com as quatro funções básicas de um CRUD.
 12    """
 13
 14    def check_if_archive_name_already_exists(self, archive_name: str):
 15        """
 16        Verifica se o nome do arquivo já foi utilizado anteriormente.
 17
 18        Returns
 19        -------
 20        is_archive_name_available (bool): Se o nome do arquivo está disponível ou não.
 21        """
 22        is_archive_name_available: bool
 23
 24        logged_user_name, logged_user_document = Login().get_user_data(return_option="user_login_password")
 25
 26        cards_with_parameter_name_query = """SELECT COUNT(id_arquivo) FROM arquivo_texto WHERE nome_arquivo = %s AND usuario_associado = %s AND documento_usuario_associado = %s;"""
 27        query_values = (archive_name, logged_user_name, logged_user_document)
 28
 29        archives_with_parameter_name_quantity = QueryExecutor().simple_consult_query(query=cards_with_parameter_name_query, params=query_values)
 30        archives_with_parameter_name_quantity = QueryExecutor().treat_simple_result(value_to_treat=archives_with_parameter_name_quantity, values_to_remove=to_remove_list)
 31        archives_with_parameter_name_quantity = int(archives_with_parameter_name_quantity)
 32
 33        if archives_with_parameter_name_quantity == 0:
 34            is_archive_name_available = True
 35        else:
 36            is_archive_name_available = False
 37
 38        return is_archive_name_available
 39
 40    def get_user_archives_quantity(self):
 41        """
 42        Consulta a quantidade de arquivos registrados pelo usuário.
 43
 44        Returns
 45        -------
 46        user_archives_quantity (int): A quantidade de arquivos registrados pelo usuário.
 47        """
 48        logged_user_name, logged_user_document = Login().get_user_data(return_option="user_doc_name")
 49
 50        user_archives_quantity = QueryExecutor().simple_consult_query(search_user_archives_quantity, params=(logged_user_name, logged_user_document))
 51        user_archives_quantity = QueryExecutor().treat_simple_result(user_archives_quantity, to_remove_list)
 52        user_archives_quantity = int(user_archives_quantity)
 53
 54        return user_archives_quantity
 55
 56    def get_archives_names(self):
 57        """
 58        Consulta o nome dos arquivos.
 59
 60        Returns
 61        -------
 62        archives_names (list): A lista com o nome dos arquivos.
 63        """
 64        logged_user_name, logged_user_document = Login().get_user_data(return_option="user_doc_name")
 65
 66        archives_names = []
 67        user_archives_name = QueryExecutor().complex_consult_query(search_user_archives_name, params=(logged_user_name, logged_user_document))
 68        user_archives_name = QueryExecutor().treat_numerous_simple_result(user_archives_name, to_remove_list)
 69
 70        for i in range(0, len(user_archives_name)):
 71            archives_names.append(user_archives_name[i])
 72
 73        return archives_names
 74
 75    def create_new_archive(self):
 76        """
 77        Função para criação de um novo arquivo.
 78        """
 79        logged_user_name, logged_user_document = Login().get_user_data(return_option="user_doc_name")
 80        logged_user, logged_user_password = Login().get_user_data(return_option="user_login_password")
 81
 82        col1, col2 = st.columns(2)
 83
 84        with col1:
 85            with st.expander(label="Entrada de Dados", expanded=True):
 86                archive_name = st.text_input(label="Nome do arquivo", max_chars=100,help="É necessário definir um nome para identificação e consulta posterior.")
 87                uploaded_file = st.file_uploader(label="Escolha um arquivo de texto", type=["txt"], help="São permitidos arquivos de texto, na extensão '.txt'. O tamanho do arquivo não pode exceder 200 MB.")
 88
 89                content = None
 90
 91                if uploaded_file:
 92                    content = uploaded_file.read().decode("utf-8")
 93                    with col2:
 94                        with st.spinner(text="Carregando arquivo..."):
 95                            sleep(2.5)
 96                        if content != "":
 97                            with st.expander(label="Conteudo do arquivo carregado", expanded=True):
 98                                st.info(content)
 99                        elif content == "":
100                            with col2:
101                                st.error(body="O Conteudo do arquivo está vazio.")
102
103            register_archive_button = st.button(":floppy_disk: Fazer upload do arquivo")
104
105            if register_archive_button and uploaded_file is not None and content != "" and archive_name != "":
106                is_archive_name_available = self.check_if_archive_name_already_exists(archive_name=archive_name)
107
108                if is_archive_name_available:
109                    with col2:
110                        with st.expander(label="Validação dos dados", expanded=True):
111                            st.success(body="Nome de arquivo disponível.")
112
113                    archive_query = "INSERT INTO arquivo_texto (nome_arquivo, conteudo, usuario_associado, documento_usuario_associado) VALUES (%s, %s, %s, %s)"
114                    archive_values = (archive_name, content, logged_user_name, logged_user_document)
115
116                    if content is not None:
117                        QueryExecutor().insert_query(archive_query, archive_values,"Upload do arquivo realizado com sucesso!", "Erro ao fazer upload do arquivo:")
118
119                        log_query = """INSERT INTO logs_atividades (usuario_log, tipo_log, conteudo_log) VALUES(%s, %s, %s)"""
120                        log_query_values = (logged_user, "Cadastro", "Fez o upload do arquivo {}.".format(archive_name))
121                        QueryExecutor().insert_query(log_query, log_query_values, "Log gravado.", "Erro ao gravar log:")
122
123                else:
124                    with col2:
125                        with st.expander(label="Validação dos dados", expanded=True):
126                            st.error(body="O nome do arquivo já está sendo utilizado.")
127
128            elif register_archive_button and (uploaded_file is None or content == "" or archive_name == ""):
129
130                with col2:
131                    with st.spinner(text=""):
132                        sleep(2.5)
133
134                    if uploaded_file is None:
135                        with st.expander(label="Validação dos dados", expanded=True):
136                            st.error(body="Não foi feito o upload de um arquivo.")
137                    if archive_name == "":
138                        with st.expander(label="Validação dos dados", expanded=True):
139                            st.error(body="Não foi informado um nome para o arquivo.")
140
141    def read_archive(self):
142        """
143        Função para a consulta de um arquivo.
144        """
145        logged_user_name, logged_user_document = Login().get_user_data(return_option="user_doc_name")
146        logged_user, logged_user_password = Login().get_user_data(return_option="user_login_password")
147
148        user_archives_quantity = self.get_user_archives_quantity()
149
150        if user_archives_quantity >= 1:
151            col1, col2 = st.columns(2)
152
153            archives_names = self.get_archives_names()
154
155            with col1:
156
157                with st.expander(label="Consulta", expanded=True):
158                    selected_archive = st.selectbox(label="Selecione o arquivo", options=archives_names)
159                    safe_password = st.text_input(label="Informe sua senha", type="password", help="Corresponde a senha utilizada para acessar a aplicação.")
160                    confirm_safe_password = st.text_input(label="Confirme sua senha", type="password", help="Deve ser idêntica a senha informada acima.")
161                    confirm_selection = st.checkbox(label="Confirmar dados", value=False)
162
163                consult_button = st.button(label=":file_folder: Consultar arquivo")
164
165                if consult_button and confirm_selection:
166                    
167                    is_password_valid, hashed_password = Login().check_login(logged_user, safe_password)
168
169                    if safe_password != "" and confirm_safe_password != "" and safe_password == confirm_safe_password and is_password_valid == True:
170                        with st.spinner(text="Aguarde..."):
171                            sleep(2.5)
172
173                            archive_content_query = """
174                            SELECT 
175                                arquivo_texto.conteudo
176                            FROM
177                                arquivo_texto
178                            INNER JOIN
179                                usuarios ON arquivo_texto.usuario_associado = usuarios.nome
180                            AND arquivo_texto.documento_usuario_associado = usuarios.documento_usuario
181                            WHERE
182                                arquivo_texto.nome_arquivo = %s
183                            AND
184                                arquivo_texto.usuario_associado = %s
185                            AND
186                                arquivo_texto.documento_usuario_associado = %s;"""
187
188                            archive_content = (QueryExecutor().simple_consult_query(archive_content_query, params=(selected_archive, logged_user_name, logged_user_document)))
189                            archive_content = (QueryExecutor().treat_simple_result(archive_content, to_remove_archive_list))
190                            archive_content = archive_content.replace("\\n", " ")
191                            archive_content = archive_content.replace("  ", " ")
192                            archive_content = archive_content.split(" ")
193
194                            for i in range(0, len(archive_content)):
195                                if archive_content[i] == "":
196                                    del archive_content[i]
197
198                            with col2:
199                                with st.expander(label="Conteudo", expanded=True):
200
201                                    display_content = ""
202                                    for i in range(0, len(archive_content)):
203                                        display_content += str(archive_content[i]) + "\n\n"
204                                    st.code(display_content)
205
206                    elif safe_password != "" and confirm_safe_password != "" and safe_password == confirm_safe_password and is_password_valid == False:
207                        with col2:
208                            with st.spinner(text="Aguarde..."):
209                                sleep(0.5)
210                            with st.expander(label="Validação dos dados", expanded=True):
211                                st.error(body="A senha informada é inválida.")
212
213                    elif safe_password != confirm_safe_password:
214                        with col2:
215                            with st.spinner(text="Aguarde..."):
216                                sleep(0.5)
217                            with st.expander(label="Validação dos dados", expanded=True):
218                                st.error(body="As senhas informadas não coincidem.")
219
220                elif consult_button and confirm_selection == False:
221                    with col2:
222                        with st.spinner(text="Aguarde..."):
223                            sleep(0.5)
224                        with st.expander(label="Validação dos dados", expanded=True):
225                            st.warning(body="Confirme a seleção dos dados.")
226
227        elif user_archives_quantity == 0:
228            col1, col2, col3 = st.columns(3)
229            with col2:
230                st.warning(body="Você ainda não possui arquivos registrados.")
231
232    def update_archive(self):
233        """
234        Função para a atualização de um arquivo.
235        """
236        logged_user_name, logged_user_document = Login().get_user_data(return_option="user_doc_name")
237        logged_user, logged_user_password = Login().get_user_data(return_option="user_login_password")
238
239        user_archives_quantity = self.get_user_archives_quantity()
240
241        if user_archives_quantity >= 1:
242            col1, col2 = st.columns(2)
243
244            archives_names = self.get_archives_names()
245
246            with col1:
247
248                with st.expander(label="Consulta", expanded=True):
249                    selected_archive = st.selectbox(label="Selecione o arquivo", options=archives_names)
250                    safe_password = st.text_input(label="Informe sua senha", type="password", help="Corresponde a senha utilizada para acessar a aplicação.")
251                    confirm_safe_password = st.text_input(label="Confirme sua senha", type="password", help="Deve ser idêntica a senha informada acima.")
252                    confirm_selection = st.checkbox(label="Confirmar dados", value=False)
253
254                    if confirm_selection:
255                        is_password_valid, hashed_password = Login().check_login(logged_user, safe_password)
256
257                        if safe_password != "" and confirm_safe_password != "" and safe_password == confirm_safe_password and is_password_valid == True:
258                            with st.spinner(text="Aguarde..."):
259                                sleep(0.5)
260
261                            archive_content_query = """
262                            SELECT
263                                arquivo_texto.nome_arquivo,
264                                arquivo_texto.conteudo
265                            FROM
266                                arquivo_texto
267                            INNER JOIN
268                                usuarios ON arquivo_texto.usuario_associado = usuarios.nome
269                            AND arquivo_texto.documento_usuario_associado = usuarios.documento_usuario
270                            WHERE
271                                arquivo_texto.nome_arquivo = %s
272                            AND
273                            arquivo_texto.usuario_associado = %s
274                            AND arquivo_texto.documento_usuario_associado = %s;
275                            """
276
277                            archive_content = (QueryExecutor().complex_compund_query(query=archive_content_query, list_quantity=2, params=(selected_archive, logged_user_name, logged_user_document)))
278                            archive_content = (QueryExecutor().treat_complex_result(archive_content, to_remove_archive_list))
279
280                            for i in range(0, len(archive_content)):
281                                if archive_content[i] == "":
282                                    del archive_content[i]
283
284                            with col1:
285                                with st.expander(label="Conteudo", expanded=True):
286
287                                    display_content = ""
288                                    for i in range(0, len(archive_content)):
289                                        display_content += str(
290                                            archive_content[i]) + "\n\n"
291
292                                    st.code(display_content)
293
294                            with col2:
295                                with st.spinner(text="Aguarde..."):
296                                    sleep(0.5)
297
298                                with st.expander(label="Novos dados", expanded=True):
299                                    new_archive_name = st.text_input(label="Novo nome do arquivo", max_chars=100, help="É necessário definir um nome para identificação e consulta posterior.")
300                                    new_uploaded_file = st.file_uploader(label="Escolha um arquivo de texto", type=["txt"], help="São permitidos arquivos de texto, na extensão '.txt'. O tamanho do arquivo não pode exceder 200 MB.")
301                                    confirm_new_data = st.checkbox(label="Confirmar novos dados")
302
303                                    content = None
304
305                                    if new_uploaded_file:
306                                        content = new_uploaded_file.read().decode("utf-8")
307                                        with col2:
308                                            with st.spinner(text="Carregando arquivo..."):
309                                                sleep(0.5)
310                                            if content != "":
311                                                with st.expander(label="Conteudo do arquivo carregado", expanded=True):
312                                                    st.info(content)
313                                            elif content == "":
314                                                with col2:
315                                                    st.error(body="O Conteudo do arquivo está vazio.")
316
317                                update_archive_button = st.button(label=":arrows_counterclockwise: Atualizar arquivo")
318
319                            if confirm_new_data and update_archive_button:
320
321                                with st.spinner(text="Aguarde..."):
322                                    sleep(2.5)
323
324                                if new_archive_name != "" and content is not None:
325
326                                    is_archive_name_available = self.check_if_archive_name_already_exists(archive_name=new_archive_name)
327
328                                    if is_archive_name_available:
329                                        with col1:
330                                            with st.expander(label="Validação dos dados", expanded=True):
331                                                st.success(body="Nome do arquivo disponível.")
332
333                                        archive_query = "INSERT INTO arquivo_texto (nome_arquivo, conteudo, usuario_associado, documento_usuario_associado) VALUES (%s, %s, %s, %s)"
334                                        archive_values = (new_archive_name, content, logged_user_name, logged_user_document)
335
336                                        if content is not None:
337                                            QueryExecutor().insert_query(archive_query, archive_values, "Upload do arquivo realizado com sucesso!", "Erro ao fazer upload do arquivo:")
338
339                                            log_query = """INSERT INTO logs_atividades (usuario_log, tipo_log, conteudo_log) VALUES(%s, %s, %s)"""
340                                            log_query_values = (logged_user, "Atualização", "Atualizou os dados do arquivo {}.".format(new_archive_name))
341                                            QueryExecutor().insert_query(log_query, log_query_values,"Log gravado.", "Erro ao gravar log:")
342
343                                    else:
344                                        with col1:
345                                            with st.expander(label="Validação dos dados", expanded=True):
346                                                st.error(body="O nome do arquivo já está sendo utilizado.")
347
348                        elif safe_password != "" and confirm_safe_password != "" and safe_password == confirm_safe_password and is_password_valid == False:
349                            with col2:
350                                with st.spinner(text="Aguarde..."):
351                                    sleep(0.5)
352                                with st.expander(label="Validação dos dados", expanded=True):
353                                    st.error(body="A senha informada é ínválida.")
354
355                        if safe_password != confirm_safe_password:
356                            with col2:
357                                with st.spinner(text="Aguarde..."):
358                                    sleep(0.5)
359                                with st.expander(label="Validação dos dados", expanded=True):
360                                    st.error(body="As senhas informadas não coincidem.")
361
362        elif user_archives_quantity == 0:
363            col1, col2, col3 = st.columns(3)
364            with col2:
365                st.warning(body="Você ainda não possui arquivos registrados.")
366
367    def delete_archive(self):
368        """
369        Função para a exclusão de um arquivo.
370        """
371        logged_user_name, logged_user_document = Login().get_user_data(return_option="user_doc_name")
372        logged_user, logged_user_password = Login().get_user_data(return_option="user_login_password")
373
374        user_archives_quantity = self.get_user_archives_quantity()
375
376        if user_archives_quantity >= 1:
377            col1, col2 = st.columns(2)
378
379            archives_names = self.get_archives_names()
380
381            with col1:
382
383                with st.expander(label="Consulta", expanded=True):
384                    selected_archive = st.selectbox(label="Selecione o arquivo", options=archives_names)
385                    safe_password = st.text_input(label="Informe sua senha", type="password", help="Corresponde a senha utilizada para acessar a aplicação.")
386                    confirm_safe_password = st.text_input(label="Confirme sua senha", type="password", help="Deve ser idêntica a senha informada acima.")
387                    confirm_selection = st.checkbox(label="Confirmar dados", value=False)
388
389                    if confirm_selection:
390                        is_password_valid, hashed_password = Login().check_login(logged_user, safe_password)
391                        if safe_password != "" and confirm_safe_password != "" and confirm_safe_password == safe_password and is_password_valid == True:
392
393                            with st.spinner(text="Aguarde..."):
394                                sleep(0.5)
395
396                            archive_content_query = """
397                            SELECT
398                                arquivo_texto.nome_arquivo,
399                                arquivo_texto.conteudo
400                            FROM
401                                arquivo_texto
402                            INNER JOIN
403                                usuarios ON arquivo_texto.usuario_associado = usuarios.nome
404                            AND arquivo_texto.documento_usuario_associado = usuarios.documento_usuario
405                            WHERE
406                                arquivo_texto.nome_arquivo = %s
407                            AND
408                                arquivo_texto.usuario_associado = %s
409                                AND arquivo_texto.documento_usuario_associado = %s;
410                            """
411
412                            archive_content = (QueryExecutor().complex_compund_query(query=archive_content_query, list_quantity=2, params=(selected_archive, logged_user_name, logged_user_document)))
413                            archive_content = (QueryExecutor().treat_complex_result(archive_content, to_remove_archive_list))
414
415                            for i in range(0, len(archive_content)):
416                                if archive_content[i] == "":
417                                    del archive_content[i]
418
419                            with col2:
420                                with st.expander(label="Conteudo", expanded=True):
421
422                                    display_content = ""
423                                    for i in range(0, len(archive_content)):
424                                        if "\\n" in archive_content[i]:
425                                            display_content = str(archive_content[i])
426                                            display_content = display_content.replace("\\n", " ")
427                                        else:
428                                            display_content += str(archive_content[i]) + "\n\n"
429
430                                    st.code(display_content)
431                                    confirm_data_deletion = st.checkbox(label="Confirmar exclusão dos dados")
432                                delete_archive_button = st.button(label=":wastebasket: Deletar arquivo")
433
434                            if confirm_data_deletion and delete_archive_button:
435                                with col2:
436                                    with st.spinner(text="Aguarde..."):
437                                        sleep(2.5)
438
439                                    delete_archive_query = '''
440                                    DELETE arquivo_texto FROM arquivo_texto
441                                    INNER JOIN
442                                        usuarios ON arquivo_texto.usuario_associado = usuarios.nome
443                                    AND arquivo_texto.documento_usuario_associado = usuarios.documento_usuario
444                                    WHERE arquivo_texto.nome_arquivo = %s
445                                    AND arquivo_texto.usuario_associado = %s
446                                    AND arquivo_texto.documento_usuario_associado = %s;'''
447                                    archive_values = (selected_archive, logged_user_name, logged_user_document)
448
449                                    QueryExecutor().insert_query(delete_archive_query, archive_values,"Arquivo deletado com sucesso!", "Erro ao deletar arquivo:")
450
451                                    log_query = """INSERT INTO logs_atividades (usuario_log, tipo_log, conteudo_log) VALUES(%s, %s, %s)"""
452                                    log_query_values = (logged_user, "Exclusão", "Excluiu o arquivo {}.".format(selected_archive))
453                                    QueryExecutor().insert_query(log_query, log_query_values,"Log gravado.", "Erro ao gravar log:")
454
455                        elif safe_password != "" and confirm_safe_password != "" and confirm_safe_password == safe_password and is_password_valid == False:
456                            with col2:
457                                with st.spinner(text="Aguarde..."):
458                                    sleep(0.5)
459                                with st.expander(label="Validação dos dados", expanded=True):
460                                    st.error(body="A senha informada é inválida.")
461                        elif safe_password != confirm_safe_password:
462                            with col2:
463                                with st.spinner(text="Aguarde..."):
464                                    sleep(0.5)
465                                with st.expander(label="Validação dos dados", expanded=True):
466                                    st.error(body="As senhas informadas não coincidem.")
467
468        elif user_archives_quantity == 0:
469            col1, col2, col3 = st.columns(3)
470            with col2:
471                with st.spinner(text="Aguarde..."):
472                    sleep(0.5)
473                st.warning(body="Você ainda não possui arquivos registrados.")
474
475    def main_menu(self):
476        """
477        Menu principal.
478        """
479
480        col1, col2, col3 = st.columns(3)
481
482        with col1:
483            st.header(body=":spiral_note_pad: Arquivos")
484
485        with col2:
486            menu_options = ["Registrar arquivo", "Consultar arquivo","Atualizar arquivo", "Deletar arquivo"]
487
488            selected_option = st.selectbox(label="Menu", options=menu_options)
489
490        st.divider()
491        if selected_option == menu_options[0]:
492            self.create_new_archive()
493        elif selected_option == menu_options[1]:
494            self.read_archive()
495        elif selected_option == menu_options[2]:
496            self.update_archive()
497        elif selected_option == menu_options[3]:
498            self.delete_archive()