Update app

pages/2_👨‍🏫_Начало_работы.py

@@ -232,7 +232,7 @@ if st.session_state.get('-LOGGED_IN_BOOL-'):
                     save_type='download',
                     save_name=USER__SAVE_IN_CLOUD_FILE_NAME,
                     cefr_level=CEFR_TEXT_LEVEL,
-                    time_stamp=str(datetime.datetime.now())[:-7],
+                    timestamp=str(datetime.datetime.now())[:-7],
                     creator_name=st.session_state.get('-USER_NAME-'),
                     generated_result=__TASK_DATA__,
                     distractor_model=DISTRACTOR_MODEL)

pages/4_📝_Онлайн-тест (эксперимент).py

@@ -54,7 +54,7 @@ if st.session_state.get('-ONLINE_TEST_READY-') and st.session_state.get('-LOGGED
                               save_type='online_test',
                               save_name=st.session_state['-UPLOAD_CLOUD_FILE_NAME-'],
                               cefr_level=st.session_state['-LOADED_CEFR_LEVEL-'],
-                              time_stamp=str(datetime.datetime.now())[:-7],
+                              timestamp=str(datetime.datetime.now())[:-7],
                               creator_name=st.session_state.get('-USER_NAME-'),
                               test_taker_name=st.session_state.get('-USER_NAME-'),
                               test_taker_answers=RETURN_TEST_DATA,

utilities_database/user_database_utils.py

@@ -1,6 +1,6 @@
 import re
+import json
 import secrets
-import requests
 import pandas as pd
 import streamlit as st
 from trycourier import Courier
@@ -14,27 +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 load_lottie_url(url: str) -> str or None:
-    """
-    Fetches the lottie animation using the URL.
-    """
-    r = requests.get(url)
-    if r.status_code != 200:
-        return None
-    return r.json()
 
 
 def check_valid_name(name_sign_up: str) -> bool:
@@ -51,20 +44,21 @@ 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,})+')
-
-    if re.fullmatch(regex, email_sign_up):
-        return True
-    return False
+    return True
+    
+    # if re.fullmatch(regex, email_sign_up):
+    #     return True
+    # return False
 
 
 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
@@ -90,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
@@ -102,24 +94,25 @@ def check_unique_usr(user_log_in_database, user_name_sign_up: str):
 
 
 def register_new_usr(user_log_in_database, name_sign_up: str, email_sign_up: str, user_name_sign_up: str,
-                     password_sign_up: str, professional_level: str) -> None:
+                     password_sign_up: str, professional_level: str, timestamp: str) -> None:
     """
     Saves the information of the new user in the _secret_auth.json file.
     """
     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}
+                    'professional_level': professional_level,
+                    '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
@@ -127,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
@@ -137,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)
@@ -146,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)
 
@@ -171,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:
@@ -181,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:
@@ -192,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):
-    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
+                          comments=None, distractor_model=None, allow=False):
+    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':
@@ -219,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
@@ -229,55 +226,45 @@ 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':
-            return st.success('Задания успешно сохранены! Можете переходить на следующие вкладки')
+            if allow:
+                return st.success('Задания успешно сохранены! Можете переходить на следующие вкладки')
         elif save_type == 'online_test':
             return st.success('Ответы успешно сохранены!')
 
 
 def load_user_tasks_data(user_task_database, save_type, creator_name=None, test_taker_name=None):
     if save_type == 'download':
-        ITEMS = []
-        user_data = user_task_database.fetch({'creator_name': creator_name, 'save_type': save_type})
-        _last = user_data.last
-        while _last is not None:
-            ITEMS.extend(user_data.items)
-            user_data = user_task_database.fetch({'creator_name': creator_name, 'save_type': save_type}, last=_last)
-            _last = user_data.last
-        names = [item['save_name'] for item in ITEMS]
-        cefr_level = [item['cefr_level'] for item in ITEMS]
-        time_stamps = [item['time_stamp'] for item in ITEMS]
-        return_data = pd.DataFrame([names, cefr_level, time_stamps]).transpose()
+        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]
+        created_ats = [item['created_at'] for item in user_data]
+        return_data = pd.DataFrame([names, cefr_level, created_ats]).transpose()
         return_data.columns = ['Название', 'Уровень', 'Время создания']
     else:
-        ITEMS = []
-        user_data = user_task_database.fetch({'test_taker_name': test_taker_name, 'save_type': save_type})
-        _last = user_data.last
-        while _last is not None:
-            ITEMS.extend(user_data.items)
-            user_data = user_task_database.fetch({'test_taker_name': test_taker_name, 'save_type': save_type}, last=_last)
-            _last = user_data.last
-        names = [item['save_name'] for item in ITEMS]
-        cefr_level = [item['cefr_level'] for item in ITEMS]
-        time_stamps = [item['time_stamp'] for item in ITEMS]
-        creator_name = [item['creator_name'] for item in ITEMS]
-        test_taker_result = [item['test_taker_result'] for item in ITEMS]
-        return_data = pd.DataFrame([names, cefr_level, test_taker_result, time_stamps, creator_name]).transpose()
+        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]
+        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, 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,17 +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 = 'Зарегистрироваться'
@@ -91,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)
 
@@ -119,18 +119,18 @@ 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,
+                                              placeholder='Введите имя пользователя (латинские буквы и символы)')
+            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("Пароль *",
                                              placeholder='Введите пароль',
                                              type='password')
-            professional_level = st.radio('Вы являетесь преподавателем русского языка? *',
+            professional_level = st.radio('Вы являетесь преподавателем испанского языка? *',
                                           options=['Да', 'Нет'],
                                           index=1,
                                           horizontal=True)
@@ -156,12 +156,13 @@ 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,
                                                   password_sign_up=password_sign_up,
-                                                  professional_level=professional_level)
+                                                  professional_level=professional_level,
+                                                  timestamp=str(datetime.now())[:-7])
                         st.success("Регистрация прошла успешно!")
 
     def forgot_password(self) -> None:
@@ -171,13 +172,13 @@ 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=user_login_table,
+                email_forgot_passwd=email_forgot_passwd)
 
             forgot_passwd_submit_button = st.form_submit_button(label='Получить пароль')
 
             if forgot_passwd_submit_button:
-                email_exists_check, user_name_forgot_passwd = db_utils.check_email_exists(
-                    user_log_in_database=db,
-                    email_forgot_passwd=email_forgot_passwd)
                 if not email_exists_check:
                     st.error("Пользователя с таким e-mail не существует!")
 
@@ -185,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("Временный пароль выслан Вам на почту!")
@@ -206,16 +207,16 @@ class LogIn:
             new_passwd = st.text_input("Новый пароль", placeholder='Введите новый пароль',
                                        type='password')
 
-            new_passwd_1 = st.text_input("Повторите новый пароль", placeholder='Введите повторите пароль',
+            new_passwd_1 = st.text_input("Повторите новый пароль", placeholder='Повторите пароль',
                                          type='password')
 
             reset_passwd_submit_button = st.form_submit_button(label='Изменить пароль')
 
             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:
@@ -228,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("Пароль успешно изменен!")