Update app

utilities_database/user_database_utils.py

@@ -1,4 +1,5 @@
 import re
+import json
 import secrets
 import pandas as pd
 import streamlit as st
@@ -13,17 +14,20 @@ def check_usr_pass(user_log_in_database, user_name: str, password: str) -> bool:
     """
     Authenticates the user_name and password.
     """
-    registered_user = user_log_in_database.fetch({'user_name': user_name}).items
-    try:
-        passwd_verification_bool = ph.verify(registered_user[0]['password'], password)
-        if passwd_verification_bool:
-            return True
+    registered_user = user_log_in_database.select('*').eq('user_name', user_name).execute()
+    if not registered_user.data:
+        return False
+    else:
+        try:
+            passwd_verification_bool = ph.verify(registered_user.data[0]['password'], password)
+            if passwd_verification_bool:
+                return True
+            return False
+        except VerifyMismatchError:
+            pass
+        except IndexError:
+            pass
         return False
-    except VerifyMismatchError:
-        pass
-    except IndexError:
-        pass
-    return False
 
 
 def check_valid_name(name_sign_up: str) -> bool:
@@ -40,7 +44,7 @@ def check_valid_name(name_sign_up: str) -> bool:
 
 def check_valid_email(email_sign_up: str) -> bool:
     """
-    Checks if the user entered a valid e-mail while creating the account.
+    Checks if the user entered a valid email while creating the account.
     """
     regex = re.compile(r'([A-Za-z0-9]+[.-_])*[A-Za-z0-9]+@[A-Za-z0-9-]+(\.[A-Z|a-z]{2,})+')
     return True
@@ -52,9 +56,9 @@ def check_valid_email(email_sign_up: str) -> bool:
 
 def check_unique_email(user_log_in_database, email_sign_up: str) -> bool:
     """
-    Checks if the e-mail already exists (since e-mail needs to be unique).
+    Checks if the email already exists (since email needs to be unique).
     """
-    authorized_users_data = user_log_in_database.fetch({'e-mail': email_sign_up}).items
+    authorized_users_data = user_log_in_database.select('*').eq('email', email_sign_up).execute().data
     if len(authorized_users_data) == 0:
         return True
     return False
@@ -80,11 +84,9 @@ def check_unique_usr(user_log_in_database, user_name_sign_up: str):
     Checks if the user_name already exists (since user_name needs to be unique),
     also checks for non-empty user_name.
     """
-    authorized_users_data = user_log_in_database.fetch({'user_name': user_name_sign_up}).items
+    authorized_users_data = user_log_in_database.select('*').eq('user_name', user_name_sign_up).execute().data
     if len(authorized_users_data) != 0:
         return False
-    if user_name_sign_up in authorized_users_data:
-        return False
     non_empty_check = non_empty_str_check(user_name_sign_up)
     if not non_empty_check:
         return None
@@ -98,19 +100,19 @@ def register_new_usr(user_log_in_database, name_sign_up: str, email_sign_up: str
     """
     new_usr_data = {'user_name': user_name_sign_up,
                     'name': name_sign_up,
-                    'e-mail': email_sign_up,
+                    'email': email_sign_up,
                     'password': ph.hash(password_sign_up),
                     'professional_level': professional_level,
-                    'time_stamp': timestamp}
+                    'created_at': timestamp}
 
-    return user_log_in_database.put(new_usr_data)
+    return user_log_in_database.insert(new_usr_data).execute()
 
 
 def check_user_name_exists(user_log_in_database, user_name: str) -> bool:
     """
     Checks if the user_name exists in the _secret_auth.json file.
     """
-    authorized_users_data = user_log_in_database.fetch({'user_name': user_name}).items
+    authorized_users_data = user_log_in_database.select('*').eq('user_name', user_name).execute().data
     if len(authorized_users_data) == 1:
         return True
     return False
@@ -118,9 +120,9 @@ def check_user_name_exists(user_log_in_database, user_name: str) -> bool:
 
 def check_email_exists(user_log_in_database, email_forgot_passwd: str):
     """
-    Checks if the e-mail entered is present in the _secret_auth.json file.
+    Checks if the email entered is present in the _secret_auth.json file.
     """
-    authorized_users_data = user_log_in_database.fetch({'e-mail': email_forgot_passwd}).items
+    authorized_users_data = user_log_in_database.select('*').eq('email', email_forgot_passwd).execute().data
     if len(authorized_users_data) == 1:
         return True, authorized_users_data[0]['user_name']
     return False, None
@@ -128,7 +130,7 @@ def check_email_exists(user_log_in_database, email_forgot_passwd: str):
 
 def generate_random_passwd() -> str:
     """
-    Generates a random password to be sent in e-mail.
+    Generates a random password to be sent in email.
     """
     password_length = 10
     return secrets.token_urlsafe(password_length)
@@ -137,7 +139,7 @@ def generate_random_passwd() -> str:
 def send_passwd_in_email(auth_token: str, user_name_forgot_passwd: str, email_forgot_passwd: str, company_name: str,
                          random_password: str) -> None:
     """
-    Triggers an e-mail to the user containing the randomly generated password.
+    Triggers an email to the user containing the randomly generated password.
     """
     client = Courier(auth_token=auth_token)
 
@@ -162,9 +164,8 @@ def change_passwd(user_log_in_database, email_forgot_passwd: str, random_passwor
     """
     Replaces the old password with the newly generated password.
     """
-    user_key = user_log_in_database.fetch({'e-mail': email_forgot_passwd}).items[0]['key']
     updates = {'password': ph.hash(random_password)}
-    return user_log_in_database.update(updates, user_key)
+    return user_log_in_database.update(updates).eq('email', email_forgot_passwd).execute()
 
 
 def check_current_passwd(user_log_in_database, email_reset_passwd: str, current_passwd: str = None) -> bool:
@@ -172,7 +173,7 @@ def check_current_passwd(user_log_in_database, email_reset_passwd: str, current_
     Authenticates the password entered against the user_name when
     resetting the password.
     """
-    authorized_user_data = user_log_in_database.fetch({'e-mail': email_reset_passwd}).items[0]
+    authorized_user_data = user_log_in_database.select('*').eq('email', email_reset_passwd).execute().data[0]
     if current_passwd is None:
         current_passwd = 'b'
     try:
@@ -183,18 +184,23 @@ def check_current_passwd(user_log_in_database, email_reset_passwd: str, current_
     return False
 
 
-def save_data_in_database(user_task_database, save_type, save_name, cefr_level, time_stamp, creator_name=None,
+def save_data_in_database(user_task_database, save_type, save_name, cefr_level, created_at, creator_name=None,
                           generated_result=None, test_taker_name=None, test_taker_answers=None, test_taker_result=None,
                           comments=None, distractor_model=None, allow=False):
-    already_saved_names = user_task_database.fetch({'creator_name': creator_name,
-                                                    'save_name': save_name,
-                                                    'cefr_level': cefr_level}).items
-    already_saved_tasks = user_task_database.fetch({'creator_name': creator_name,
-                                                    'generated_result': generated_result,
-                                                    'cefr_level': cefr_level}).items
-    already_saved_tests = user_task_database.fetch({'test_taker_name': test_taker_name,
-                                                    'save_name': save_name,
-                                                    'cefr_level': cefr_level}).items
+    already_saved = user_task_database.select('*').execute().data
+    already_saved_names = [task for task in already_saved 
+                           if (task['creator_name']==creator_name 
+                               & task['save_name']==save_name 
+                               & task['cefr_level']==cefr_level)]
+    already_saved_tasks = [task for task in already_saved 
+                           if (task['creator_name']==creator_name 
+                               & task['generated_result']==generated_result 
+                               & task['cefr_level']==cefr_level)]
+    already_saved_tests = [task for task in already_saved 
+                           if (task['test_taker_name']==test_taker_name 
+                               & task['save_name']==save_name 
+                               & task['cefr_level']==cefr_level)]
+
     if save_name == '' and save_type == 'download':
         save_name = generated_result['name']
     if len(already_saved_names) != 0 and save_type == 'download':
@@ -210,7 +216,7 @@ def save_data_in_database(user_task_database, save_type, save_name, cefr_level,
                 'save_type': save_type,
                 'save_name': save_name,
                 'cefr_level': cefr_level,
-                'time_stamp': time_stamp,
+                'created_at': created_at,
                 'creator_name': creator_name,
                 'generated_result': generated_result,
                 'distractor_model': distractor_model
@@ -220,14 +226,14 @@ def save_data_in_database(user_task_database, save_type, save_name, cefr_level,
                 'save_type': save_type,
                 'save_name': save_name,
                 'cefr_level': cefr_level,
-                'time_stamp': time_stamp,
+                'created_at': created_at,
                 'creator_name': creator_name,
                 'test_taker_name': test_taker_name,
                 'test_taker_answers': test_taker_answers,
                 'generated_result': generated_result,
                 'test_taker_result': test_taker_result,
                 'comments': comments}
-        user_task_database.put(new_save_data)
+        user_task_database.insert(new_save_data).execute()
         if save_type == 'download':
             if allow:
                 return st.success('Задания успешно сохранены! Можете переходить на следующие вкладки')
@@ -237,27 +243,28 @@ def save_data_in_database(user_task_database, save_type, save_name, cefr_level,
 
 def load_user_tasks_data(user_task_database, save_type, creator_name=None, test_taker_name=None):
     if save_type == 'download':
-        user_data = user_task_database.fetch({'creator_name': creator_name, 'save_type': save_type}).items
+        user_data = user_task_database.select('*').eq('creator_name', creator_name).eq('save_type', save_type).execute().data
         names = [item['save_name'] for item in user_data]
         cefr_level = [item['cefr_level'] for item in user_data]
-        time_stamps = [item['time_stamp'] for item in user_data]
-        return_data = pd.DataFrame([names, cefr_level, time_stamps]).transpose()
+        created_ats = [item['created_at'] for item in user_data]
+        return_data = pd.DataFrame([names, cefr_level, created_ats]).transpose()
         return_data.columns = ['Название', 'Уровень', 'Время создания']
     else:
-        user_data = user_task_database.fetch({'test_taker_name': test_taker_name, 'save_type': save_type}).items
+        user_data = user_task_database.select('*').eq('test_taker_name', test_taker_name).eq('save_type', save_type).execute().data
         names = [item['save_name'] for item in user_data]
         cefr_level = [item['cefr_level'] for item in user_data]
-        time_stamps = [item['time_stamp'] for item in user_data]
+        created_ats = [item['created_at'] for item in user_data]
         creator_name = [item['creator_name'] for item in user_data]
         test_taker_result = [item['test_taker_result'] for item in user_data]
-        return_data = pd.DataFrame([names, cefr_level, test_taker_result, time_stamps, creator_name]).transpose()
+        return_data = pd.DataFrame([names, cefr_level, test_taker_result, created_ats, creator_name]).transpose()
         return_data.columns = ['Название', 'Уровень', 'Оценка', 'Дата прохождения', 'Автор заданий']
     return return_data
 
 
 def load_users_particular_task(user_task_database, load_mode, creator_name, save_name, cefr_level,):
-    return_data = user_task_database.fetch({'creator_name': creator_name,
-                                            'save_name': save_name,
-                                            'save_type': load_mode,
-                                            'cefr_level': cefr_level}).items[0]['generated_result']
+    return_data = user_task_database.select('*').eq('creator_name', creator_name)\
+                                                .eq('save_name', save_name)\
+                                                .eq('save_type', load_mode)\
+                                                .eq('cefr_level',cefr_level).execute().data[0]['generated_result']
+    return_data = json.loads(return_data.replace("'", '"'), strict=False)
     return return_data

utilities_database/user_database_widgets.py

@@ -1,18 +1,17 @@
-from deta import Deta
 import streamlit as st
 from datetime import datetime
+from supabase import create_client, Client
 from utilities_option_menu.option_menu import option_menu
 import utilities_database.user_database_utils as db_utils
 from utilities_database.user_database_utils import check_usr_pass
 from utilities_cookies.encrypted_cookie_manager import EncryptedCookieManager
 
-DETA_KEY = st.secrets['DETA_KEY']
-DETA_TABLE = st.secrets['DETA_TABLE']
-DETA_USER_TABLE = st.secrets['DETA_USER_SAVE_TEXT_TABLE']
+DB_URL = st.secrets['SUPABASE_URL']
+DB_KEY = st.secrets['SUPABASE_KEY']
 
-deta = Deta(DETA_KEY)
-db = deta.Base(DETA_TABLE)
-user_save_text_table = deta.Base(DETA_USER_TABLE)
+Client = create_client(DB_URL, DB_KEY)
+user_login_table = Client.table('UserLogIn')
+user_save_text_table = Client.table('TaskData')
 st.set_page_config(page_title='GenLexTasksEnter', layout="wide", page_icon=':es:')
 
 login_call = 'Зарегистрироваться'
@@ -92,7 +91,7 @@ class LogIn:
                 login_submit_button = st.form_submit_button(label='Войти')
 
                 if login_submit_button:
-                    authenticate_user_check = check_usr_pass(user_log_in_database=db,
+                    authenticate_user_check = check_usr_pass(user_log_in_database=user_login_table,
                                                              user_name=user_name,
                                                              password=password)
 
@@ -120,12 +119,12 @@ class LogIn:
             email_sign_up = st.text_input("E-mail *",
                                           placeholder='Введите Ваш e-mail')
             valid_email_check = db_utils.check_valid_email(email_sign_up)
-            unique_email_check = db_utils.check_unique_email(user_log_in_database=db,
+            unique_email_check = db_utils.check_unique_email(user_log_in_database=user_login_table,
                                                              email_sign_up=email_sign_up)
 
             user_name_sign_up = st.text_input("Имя пользователя *",
                                               placeholder='Введите имя пользователя (латинские буквы и символы)')
-            unique_user_name_check = db_utils.check_unique_usr(user_log_in_database=db,
+            unique_user_name_check = db_utils.check_unique_usr(user_log_in_database=user_login_table,
                                                                user_name_sign_up=user_name_sign_up)
 
             password_sign_up = st.text_input("Пароль *",
@@ -157,7 +156,7 @@ class LogIn:
 
                 if valid_name_check:
                     if valid_email_check and unique_email_check and unique_user_name_check:
-                        db_utils.register_new_usr(user_log_in_database=db,
+                        db_utils.register_new_usr(user_log_in_database=user_login_table,
                                                   name_sign_up=name_sign_up,
                                                   email_sign_up=email_sign_up,
                                                   user_name_sign_up=user_name_sign_up,
@@ -174,7 +173,7 @@ class LogIn:
         with st.form("Forgot Password Form"):
             email_forgot_passwd = st.text_input("Email", placeholder='Введите Ваш email')
             email_exists_check, user_name_forgot_passwd = db_utils.check_email_exists(
-                user_log_in_database=db,
+                user_log_in_database=user_login_table,
                 email_forgot_passwd=email_forgot_passwd)
 
             forgot_passwd_submit_button = st.form_submit_button(label='Получить пароль')
@@ -187,7 +186,7 @@ class LogIn:
                     random_password = db_utils.generate_random_passwd()
                     db_utils.send_passwd_in_email(self.auth_token, user_name_forgot_passwd, email_forgot_passwd,
                                                   self.company_name, random_password)
-                    db_utils.change_passwd(user_log_in_database=db,
+                    db_utils.change_passwd(user_log_in_database=user_login_table,
                                            email_forgot_passwd=email_forgot_passwd,
                                            random_password=random_password)
                     st.success("Временный пароль выслан Вам на почту!")
@@ -215,9 +214,9 @@ class LogIn:
 
             if reset_passwd_submit_button:
                 email_exists_check, user_name_reset_passwd = db_utils.check_email_exists(
-                    user_log_in_database=db,
+                    user_log_in_database=user_login_table,
                     email_forgot_passwd=email_reset_passwd)
-                current_passwd_check = db_utils.check_current_passwd(user_log_in_database=db,
+                current_passwd_check = db_utils.check_current_passwd(user_log_in_database=user_login_table,
                                                                      email_reset_passwd=email_reset_passwd,
                                                                      current_passwd=current_passwd)
                 if not email_exists_check:
@@ -230,7 +229,7 @@ class LogIn:
                     st.error("Пароли не совпадают!")
 
                 if email_exists_check and current_passwd_check:
-                    db_utils.change_passwd(user_log_in_database=db,
+                    db_utils.change_passwd(user_log_in_database=user_login_table,
                                            email_forgot_passwd=email_reset_passwd,
                                            random_password=new_passwd)
                     st.success("Пароль успешно изменен!")

Вход.py

@@ -16,17 +16,19 @@ __login__obj = LogIn(auth_token=st.secrets['COURIER_AUTH_TOKEN'],
                      hide_footer_bool=False,
                      lottie_url='https://assets2.lottiefiles.com/packages/lf20_jcikwtux.json')
 LOGGED_IN = __login__obj.build_login_ui()
-st.session_state['-LOGGED_IN-'] = True
-st.session_state['-LOGGED_IN_BOOL-'] = True
-st.session_state['-USER_NAME-'] = '-PUBLIC_USER-'
+st.session_state['-LOGGED_IN-'] = False
 # Check for username in cookies
-# if '-USER_NAME-' not in st.session_state:
-#     if __login__obj.cookies.get('__streamlit_login_signup_ui_username__'):
-#         if not is_valid_uuid(__login__obj.cookies['__streamlit_login_signup_ui_username__']):
-#             st.session_state['-USER_NAME-'] = __login__obj.cookies['__streamlit_login_signup_ui_username__']
-#             st.session_state['-LOGGED_IN_BOOL-'] = True
+if '-USER_NAME-' not in st.session_state:
+    if __login__obj.cookies.get('__streamlit_login_signup_ui_username__'):
+        if not is_valid_uuid(__login__obj.cookies['__streamlit_login_signup_ui_username__']):
+            st.session_state['-USER_NAME-'] = __login__obj.cookies['__streamlit_login_signup_ui_username__']
+            st.session_state['-LOGGED_IN_BOOL-'] = True
 
 if LOGGED_IN:
     st.session_state['-LOGGED_IN_BOOL-'] = True
-    # st.session_state['-USER_NAME-'] =
     st.success('Можете переходить к следующим вкладкам!')
+
+# st.markdown('*Автор-разработчик: А.В.Белый, кафедра математической лингвистики, филологический факультет СПбГУ,'
+#             ' 4 курс, бакалавриат, "Прикладная, компьютерная и математическая лингвистика (английский язык)"*'
+#             '\n\n*Научный руководитель: канд. филол. наук, доц. О.А.Митрофанова*')
+# st.markdown('*E-mail: st087202@student.spbu.ru*')