source.passwords

  1from dictionary.vars import field_names, to_remove_list
  2from dictionary.sql import search_accounts_query, check_user_passwords_quantity_query
  3from functions.query_executor import QueryExecutor
  4from functions.login import Login
  5from time import sleep
  6import streamlit as st
  7
  8
  9class Passwords:
 10    """
 11    Classe que representa as senhas, com as quatro funções básicas de um CRUD.
 12    """
 13    def check_if_account_name_already_exists(self, account: str):
 14        """
 15        Verifica se o nome da conta já foi utilizado anteriormente.
 16
 17        Returns
 18        -------
 19        is_account_name_available : bool
 20            Se o nome de conta está disponível ou não.
 21        """
 22        logged_user_name, logged_user_document = Login().get_user_data(return_option="user_login_password")
 23
 24        is_account_name_available: bool
 25
 26        accounts_with_parameter_name_query = """SELECT COUNT(id_senha) FROM senhas WHERE nome_site = %s AND usuario_associado = %s AND documento_usuario_associado = %s;"""
 27        query_values = (account, logged_user_name, logged_user_document)
 28        accounts_with_parameter_name_quantity = QueryExecutor().simple_consult_query(query=accounts_with_parameter_name_query, params=query_values)
 29        accounts_with_parameter_name_quantity = QueryExecutor().treat_simple_result(value_to_treat=accounts_with_parameter_name_quantity, values_to_remove=to_remove_list)
 30        accounts_with_parameter_name_quantity = int(
 31            accounts_with_parameter_name_quantity)
 32
 33        if accounts_with_parameter_name_quantity == 0:
 34            is_account_name_available = True
 35        else:
 36            is_account_name_available = False
 37
 38        return is_account_name_available
 39
 40    def get_user_passwords_quantity(self):
 41        """
 42        Consulta a quantidade de senhas cadastradas pelo usuário.
 43
 44        Returns
 45        -------
 46        user_passwords_quantity : int
 47            A quantidade de senhas cadastradas pelo usuário.
 48        """
 49        logged_user, logged_user_password = Login().get_user_data(return_option="user_login_password")
 50
 51        user_passwords_quantity = QueryExecutor().simple_consult_query(check_user_passwords_quantity_query, params=(logged_user, logged_user_password))
 52        user_passwords_quantity = QueryExecutor().treat_simple_result(user_passwords_quantity, to_remove_list)
 53        user_passwords_quantity = int(user_passwords_quantity)
 54
 55        return user_passwords_quantity
 56
 57    def get_user_accounts_names(self):
 58        """
 59        Consulta o nome das contas cadastradas pelo usuário.
 60
 61        Returns
 62        -------
 63        user_accounts : list
 64            Lista com os nomes das contas do usuário.
 65        """
 66        logged_user, logged_user_password = Login().get_user_data(return_option="user_login_password")
 67
 68        user_accounts = []
 69
 70        accounts = QueryExecutor().complex_consult_query(query=search_accounts_query, params=(logged_user, logged_user_password))
 71        accounts = QueryExecutor().treat_numerous_simple_result(accounts, to_remove_list)
 72
 73        for i in range(0, len(accounts)):
 74            user_accounts.append(accounts[i])
 75
 76        return user_accounts
 77
 78    def create_new_password(self):
 79        """
 80        Função para criação de uma nova senha.
 81        """
 82        logged_user_name, logged_user_document = Login().get_user_data(return_option="user_doc_name")
 83        logged_user, logged_user_password = Login().get_user_data(return_option="user_login_password")
 84
 85        st.info(logged_user_document)
 86
 87        col1, col2 = st.columns(2)
 88        with col2:
 89            data_validator_expander = st.expander(label="Validação dos dados", expanded=True)
 90
 91        with col1:
 92
 93            with st.expander(label="Dados", expanded=True):
 94
 95                site = st.text_input(label='Nome Site',)
 96                url = st.text_input(label='URL/Link do Site')
 97                login = st.text_input(label='Login', help="Seu usuário no site")
 98                password = st.text_input(label="Senha", type="password", help="Sua senha do site")
 99                confirm_values = st.checkbox(label="Confirmar dados", value=False)
100
101            send_button = st.button(':floppy_disk: Cadastrar Senha')
102
103            if send_button and confirm_values == True:
104                with col2:
105                    with st.spinner(text="Aguarde..."):
106                        sleep(2.5)
107                if site != '' and url != '' and login != '' and password != '':
108                    is_name_available = self.check_if_account_name_already_exists(account=site)
109                    if is_name_available:
110                        with col2:
111                            with data_validator_expander:
112                                st.success(body="Nome de conta válida.")
113                        insert_password_query = "INSERT INTO senhas(nome_site, url_site, login, senha, usuario_associado, documento_usuario_associado) VALUES(%s, %s, %s, %s, %s, %s)"
114                        query_values = (site, url, login, password, logged_user_name, logged_user_document)
115                        QueryExecutor().insert_query(query=insert_password_query, values=query_values,success_message='Senha cadastrada com sucesso!', error_message='Erro ao cadastrar senha:')
116                        log_query = '''INSERT INTO logs_atividades (usuario_log, tipo_log, conteudo_log) VALUES(%s, %s, %s)'''
117                        log_query_values = (logged_user, 'Cadastro', 'Cadastrou a senha {} associada ao email {}'.format(query_values[0], query_values[3]))
118                        QueryExecutor().insert_query(query=log_query, values=log_query_values, success_message='Log gravado.', error_message='Erro ao gravar log:')
119                    else:
120                        with col2:
121                            with data_validator_expander:
122                                st.error(body="O nome da conta já está sendo utilizado.")
123                else:
124                    with col2:
125                        with st.spinner(text="Aguarde..."):
126                            sleep(0.5)
127                        with data_validator_expander:
128                            st.error('Há um ou mais campos vazios.')
129
130            elif send_button and confirm_values == False:
131                with col2:
132                    with st.spinner(text="Aguarde..."):
133                        sleep(0.5)
134                    with data_validator_expander:
135                        st.warning(body="Você deve confirmar os dados antes de prosseguir.")
136
137    def read_password(self):
138        """
139        Função para a consulta de uma senha.
140        """
141        logged_user_name, logged_user_document = Login().get_user_data(return_option="user_login_password")
142        logged_user, logged_user_password = Login().get_user_data(return_option="user_doc_name")
143
144        user_passwords_quantity = self.get_user_passwords_quantity()
145
146        if user_passwords_quantity == 0:
147            col1, col2, col3 = st.columns(3)
148
149            with col2:
150                st.warning(body="Você ainda não possui senhas cadastradas.")
151
152        elif user_passwords_quantity >= 1:
153            col1, col2 = st.columns(2)
154            user_accounts = self.get_user_accounts_names()
155
156            with col2:
157                data_validator_expander = st.expander(
158                    label="Validação dos dados", expanded=True)
159
160            with col1:
161                with st.expander(label="Consulta", expanded=True):
162                    selected_option = st.selectbox(label="Selecione a conta", options=user_accounts)
163                    safe_password = st.text_input(label="Informe sua senha", type="password", help="Corresponde a senha utilizada para acessar a aplicação.")
164                    confirm_safe_password = st.text_input(label="Confirme sua senha", type="password", help="Deve ser idêntica a senha informada acima.")
165                    confirm_selection = st.checkbox(label="Confirmar seleção")
166
167                consult_button = st.button(label=":file_folder: Consultar senha")
168
169            account_details_query = '''
170                SELECT 
171                    senhas.nome_site,
172                    senhas.url_site,
173                    senhas.login,
174                    senhas.senha
175                FROM
176                    senhas
177                WHERE
178                    senhas.nome_site = %s
179                        AND senhas.usuario_associado = %s
180                        AND senhas.documento_usuario_associado = %s;
181            '''
182            account_details_values = (selected_option, logged_user_name, logged_user_document)
183
184            result_list = QueryExecutor().complex_consult_query(query=account_details_query, params=account_details_values)
185            result_list = QueryExecutor().treat_complex_result(values_to_treat=result_list, values_to_remove=to_remove_list)
186
187            if confirm_selection and consult_button:
188                is_password_valid, hashed_password = Login().check_login(logged_user, safe_password)
189                if safe_password != "" and confirm_safe_password != "" and safe_password == confirm_safe_password and is_password_valid == True:
190                    with col2:
191                        with st.spinner(text="Aguarde..."):
192                            sleep(2.5)
193                        with st.expander(label="Dados", expanded=True):
194                            aux_string = ''
195                            for i in range(0, len(result_list)):
196                                st.write(field_names[i])
197                                aux_string = str(result_list[i])
198                                if aux_string.startswith('b'):
199                                    aux_string = aux_string[1:]
200                                st.code(body="{}".format(aux_string))
201
202                            log_query = '''INSERT into logs_atividades (usuario_log, tipo_log, conteudo_log) VALUES(%s, %s, %s)'''
203                            query_values = (logged_user, 'Consulta', 'Consultou a senha do site {}'.format(selected_option))
204                            QueryExecutor().insert_query(query=log_query, values=query_values, success_message='Log gravado.', error_message='Erro ao gravar log:')
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 data_validator_expander:
211                            st.error(body="A senha informada é inválida.")
212
213                elif safe_password != confirm_safe_password and (safe_password != "" and confirm_safe_password != ""):
214                    with col2:
215                        with st.spinner(text="Aguarde..."):
216                            sleep(0.5)
217                        with data_validator_expander:
218                            st.error(body="As senhas informadas não coincidem.")
219
220                elif safe_password == '' or confirm_safe_password == '':
221                    with col2:
222                        with st.spinner(text="Aguarde..."):
223                            sleep(0.5)
224                        with data_validator_expander:
225                            if safe_password == '':
226                                st.error(body="A senha não foi preenchida.")
227                            if confirm_safe_password == '':
228                                st.error(body="A confirmação da senha não foi preenchida.")
229
230            elif confirm_selection == False and consult_button:
231                with col3:
232                    with st.spinner(text="Aguarde..."):
233                        sleep(0.5)
234                    with data_validator_expander:
235                        st.warning(body="Confirme a seleção antes de realizar a consulta.")
236
237    def update_password(self):
238        """
239        Função para a atualização de uma senha.
240        """
241        logged_user_name, logged_user_document = Login().get_user_data(return_option="user_login_password")
242        logged_user, logged_user_password = Login().get_user_data(return_option="user_doc_name")
243
244        user_passwords_quantity = self.get_user_passwords_quantity()
245
246        if user_passwords_quantity == 0:
247            col1, col2, col3 = st.columns(3)
248            with col2:
249                st.warning(body="Você ainda não possui senhas cadastradas.")
250
251        elif user_passwords_quantity >= 1:
252            col1, col2 = st.columns(2)
253            user_accounts = self.get_user_accounts_names()
254
255            with col2:
256                data_validator_expander = st.expander(
257                    label="Validação dos dados", expanded=True)
258
259            with col1:
260                with st.expander(label="Consulta", expanded=True):
261                    selected_option = st.selectbox(
262                        label="Selecione a conta", options=user_accounts)
263                    safe_password = st.text_input(
264                        label="Informe sua senha", type="password", help="Corresponde a senha utilizada para acessar a aplicação.")
265                    confirm_safe_password = st.text_input(label="Confirme sua senha", type="password", help="Deve ser idêntica a senha informada acima.")
266                    confirm_selection = st.checkbox(label="Confirmar seleção")
267
268            account_details_query = '''
269                SELECT 
270                    senhas.nome_site,
271                    senhas.url_site,
272                    senhas.login,
273                    senhas.senha
274                FROM
275                    senhas
276                WHERE
277                    senhas.nome_site = %s
278                        AND senhas.usuario_associado = %s
279                        AND senhas.documento_usuario_associado = %s;
280            '''
281            account_details_values = (selected_option, logged_user_name, logged_user_document)
282
283            result_list = QueryExecutor().complex_consult_query(query=account_details_query, params=account_details_values)
284            result_list = QueryExecutor().treat_complex_result(values_to_treat=result_list, values_to_remove=to_remove_list)
285
286            if confirm_selection:
287                is_password_valid, hashed_password = Login().check_login(logged_user, safe_password)
288                if safe_password != "" and confirm_safe_password != "" and safe_password == confirm_safe_password and is_password_valid == True:
289                    with col2:
290                        with st.spinner(text="Aguarde..."):
291                            sleep(0.5)
292                        with st.expander(label="Novos dados", expanded=True):
293                            st.info(body="Site: {}".format(selected_option))
294                            url = st.text_input(label='URL/Link do Site')
295                            login = st.text_input(label='Login', help="Seu usuário no site")
296                            password = st.text_input(label="Senha", type="password", help="Sua senha do site")
297                            confirm_values = st.checkbox(label="Confirmar dados", value=False)
298
299                        send_button = st.button(':arrows_counterclockwise: Atualizar Senha')
300
301                        if confirm_values and send_button:
302                            with col2:
303                                with st.spinner(text="Aguarde..."):
304                                    sleep(2.5)
305                            update_site_query = '''UPDATE senhas SET url_site = %s, login = %s, senha = %s WHERE nome_site = %s AND usuario_associado = %s AND documento_usuario_associado = %s;'''
306                            update_site_values = (url, login, password, selected_option, logged_user_name, logged_user_document)
307                            QueryExecutor().insert_query(query=update_site_query, values=update_site_values, success_message="Senha atualizada com sucesso!", error_message="Erro ao atualizar senha:")
308                            log_query = '''INSERT into logs_atividades (usuario_log, tipo_log, conteudo_log) VALUES(%s, %s, %s)'''
309                            query_values = (logged_user, 'Atualização', 'Atualizou a senha do site {}.'.format(selected_option))
310                            QueryExecutor().insert_query(query=log_query, values=query_values, success_message='Log gravado.', error_message='Erro ao gravar log:')
311
312                if safe_password != "" and confirm_safe_password != "" and safe_password == confirm_safe_password and is_password_valid == False:
313                    with col2:
314                        with st.spinner(text="Aguarde..."):
315                            sleep(0.5)
316                        with data_validator_expander:
317                            st.error(body="A senha informada é inválida.")
318
319                elif safe_password != "" and confirm_safe_password != "" and safe_password != confirm_safe_password:
320                    with col2:
321                        with st.spinner(text="Aguarde..."):
322                            sleep(0.5)
323                        with data_validator_expander:
324                            st.error(body="As senhas informadas não coincidem.")
325
326    def delete_password(self):
327        """
328        Função para a exclusão de uma senha.
329        """
330        logged_user_name, logged_user_document = Login().get_user_data(return_option="user_login_password")
331        logged_user, logged_user_password = Login().get_user_data(return_option="user_doc_name")
332
333        user_passwords_quantity = self.get_user_passwords_quantity()
334
335        if user_passwords_quantity == 0:
336            col1, col2, col3 = st.columns(3)
337            with col2:
338                st.warning(body="Você ainda não possui senhas cadastradas.")
339        elif user_passwords_quantity >= 1:
340            col1, col2 = st.columns(2)
341            user_accounts = self.get_user_accounts_names()
342            data_validator_expander = st.expander(label="Validação dos dados", expanded=True)
343            with col1:
344                with st.expander(label="Consulta", expanded=True):
345                    selected_option = st.selectbox(label="Selecione a conta", options=user_accounts)
346                    safe_password = st.text_input(label="Informe sua senha", type="password", help="Corresponde a senha utilizada para acessar a aplicação.")
347                    confirm_safe_password = st.text_input(label="Confirme sua senha", type="password", help="Deve ser idêntica a senha informada acima.")
348                    confirm_selection = st.checkbox(label="Confirmar seleção")
349
350            account_details_query = '''
351                SELECT 
352                    senhas.nome_site,
353                    senhas.url_site,
354                    senhas.login,
355                    senhas.senha
356                FROM
357                    senhas
358                WHERE
359                    senhas.nome_site = %s
360                        AND senhas.usuario_associado = %s
361                        AND senhas.documento_usuario_associado = %s;
362            '''
363            account_details_values = (selected_option, logged_user_name, logged_user_document)
364            result_list = QueryExecutor().complex_consult_query(query=account_details_query, params=account_details_values)
365            result_list = QueryExecutor().treat_complex_result(values_to_treat=result_list, values_to_remove=to_remove_list)
366
367            if confirm_selection:
368                is_password_valid, hashed_password = Login().check_login(logged_user, safe_password)
369                if safe_password != "" and confirm_safe_password != "" and safe_password == confirm_safe_password and is_password_valid == True:
370
371                    with col2:
372                        with st.spinner(text="Aguarde..."):
373                            sleep(0.5)
374                        with st.expander(label="Dados", expanded=True):
375                            aux_string = ''
376                            for i in range(0, len(result_list)):
377                                st.write(field_names[i])
378                                aux_string = str(result_list[i])
379                                if aux_string.startswith('b'):
380                                    aux_string = aux_string[1:]
381                                st.code(body="{}".format(aux_string))
382                            confirm_delete_selection = st.checkbox(label="Confirmar exclusão")
383                        delete_password_button = st.button(label=":wastebasket: Deletar senha")
384
385                    if confirm_delete_selection and delete_password_button:
386                        with col2:
387                            with st.spinner(text="Aguarde..."):
388                                sleep(2.5)
389
390                            delete_password_query = '''DELETE senhas FROM senhas WHERE nome_site = %s AND usuario_associado = %s AND documento_usuario_associado = %s;'''
391                            delete_password_values = (selected_option, logged_user_name, logged_user_document)
392                            QueryExecutor().insert_query(query=delete_password_query, values=delete_password_values, success_message="Senha excluída com sucesso!", error_message="Erro ao excluir senha:")
393
394                            log_query = '''INSERT into logs_atividades (usuario_log, tipo_log, conteudo_log) VALUES(%s, %s, %s)'''
395                            query_values = (logged_user, 'Exclusão', 'Excluiu a senha do site {}'.format(selected_option))
396                            QueryExecutor().insert_query(query=log_query, values=query_values, success_message='Log gravado.', error_message='Erro ao gravar log:')
397
398                    elif confirm_delete_selection == False and delete_password_button:
399                        with col1:
400                            with st.spinner(text="Aguarde..."):
401                                sleep(0.5)
402                            with data_validator_expander:
403                                st.warning(body="Confirme a exclusão da senha.")
404
405                elif safe_password != "" and confirm_safe_password != "" and safe_password == confirm_safe_password and is_password_valid == False:
406                    with col2:
407                        with st.spinner(text="Aguarde..."):
408                            sleep(0.5)
409                        with data_validator_expander:
410                            st.error(body="A senha informada é inválida.")
411
412                elif safe_password != confirm_safe_password:
413                    with col2:
414                        with st.spinner(text="Aguarde..."):
415                            sleep(0.5)
416                        with data_validator_expander:
417                            st.error(body="As senhas informadas não coincidem.")
418
419    def main_menu(self):
420        """
421        Menu Principal.
422        """
423        col1, col2, col3 = st.columns(3)
424
425        with col1:
426            st.header(body=":lock: Senhas")
427
428        with col2:
429            menu_options = ["Cadastrar senha", "Consultar senha", "Atualizar senha", "Deletar senha"]
430            password_option = st.selectbox(label="Menu", options=menu_options)
431
432        st.divider()
433
434        if password_option == menu_options[0]:
435            self.create_new_password()
436        elif password_option == menu_options[1]:
437            self.read_password()
438        elif password_option == menu_options[2]:
439            self.update_password()
440        elif password_option == menu_options[3]:
441            self.delete_password()