Fix some more review comments.

Author: yogeshmahajan-1903

docs/en_US/images/preferences_misc_user_interface.png

@@ -309,12 +309,21 @@ Use the fields on the *User Interface* panel to set the user interface related p
   this setting is False, meaning that Query Tool/PSQL tabs will open in the currently
   active workspace (either the default or the workspace selected at the time of opening).
 
+* When the *Save the application state?* option is enabled  the current state of various
+  tools—such as Query Tool, ERD, Schema Diff, and PSQL—will be saved in the encrypted
+  format.If the application is closed unexpectedly, the tab is accidentally closed,
+  or the page is refreshed, the saved state will be automatically restored for
+  each respective tool.**Note:**
+
 * Use the *Themes* drop-down listbox to select the theme for pgAdmin. You'll also get a preview just below the
   drop down. You can also submit your own themes,
   check `here <https://github.com/pgadmin-org/pgadmin4/blob/master/README.md>`_ how.
   Currently we support Light, Dark, High Contrast and System theme. Selecting System option will follow
   your computer's settings.
 
+**Note:** Saving the application state will not preserve data for tool tabs opened in
+separate browser tabs when running in server mode..
+
 The Paths Node
 **************
 

docs/en_US/preferences.rst

@@ -285,8 +285,6 @@ def authenticate(self):
                 source.get_source_name())
 
             status, msg = source.authenticate(self.form)
-            print(status)
-            print(msg)
 
             if status:
                 self.set_current_source(source.get_source_name())
@@ -297,17 +295,6 @@ def authenticate(self):
                 current_app.logger.debug(
                     "Authentication initiated via source: %s is failed." %
                     source.get_source_name())
-                current_user = User.query.filter_by(username=username,
-                                                    auth_source=src).first()
-                # get list with auth source src
-                # iterate over it and find if user present with that
-                if len(users) > 0 and current_user:
-                    print('User may be coming first time so continue with all possible')
-                    break
-                elif len(users) > 0:
-                    print('User already present with other aut source break it')
-                    break
-
         return status, msg
 
     def login(self):

web/pgadmin/authenticate/__init__.py

@@ -212,6 +212,7 @@ define('pgadmin.browser', [
       let save_the_workspace = prefStore.getPreferencesForModule('misc').save_app_state;
       if(save_the_workspace){
         this.restore_pgadmin_state();
+        pgBrowser.docker.default_workspace.focus();
       }
     },
     check_corrupted_db_file: function() {
@@ -299,33 +300,33 @@ define('pgadmin.browser', [
     },
 
     restore_pgadmin_state: function () {
-      getApiInstance().get(
+      getApiInstance({'Content-Encoding': 'gzip'}).get(
         url_for('settings.get_application_state')
       ).then((res)=> {
         if(res.data.success && res.data.data.result.length > 0){
-          _.each(res.data.data.result, function(tool_state){
-            let tool_name = tool_state.tool_name;
-            let tool_data = tool_state.tool_data;
-            let sql_id = `${tool_name}-${getRandomInt(1, 9999999)}`;
-
-            if (tool_name == 'sqleditor'){
-              localStorage.setItem(sql_id, tool_data);
-              showQueryTool.relaunchSqlTool(tool_state, sql_id);
-            }else if(tool_name == 'psql'){
-              pgAdmin.Tools.Psql.openPsqlTool(null, null, tool_state);
-            }else if(tool_name == 'ERD'){
-              localStorage.setItem(sql_id, tool_data);
-              pgAdmin.Tools.ERD.showErdTool(null, null, false, sql_id, tool_state);
-            }else if(tool_name == 'schema_diff'){
-              localStorage.setItem(sql_id, tool_data);
-              pgAdmin.Tools.SchemaDiff.launchSchemaDiff(sql_id);
+          _.each(res.data.data.result, function(toolState){
+            let toolNme = toolState.tool_name;
+            let toolData = toolState.tool_data;
+            let toolDataId = `${toolNme}-${getRandomInt(1, 9999999)}`;
+            let connectionInfo = toolState.connection_info;
+
+            if (toolNme == 'sqleditor'){
+              localStorage.setItem(toolDataId, toolData);
+              showQueryTool.relaunchSqlTool(connectionInfo, toolDataId);
+            }else if(toolNme == 'psql'){
+              pgAdmin.Tools.Psql.openPsqlTool(null, null, connectionInfo);
+            }else if(toolNme == 'ERD'){
+              localStorage.setItem(toolDataId, toolData);
+              pgAdmin.Tools.ERD.showErdTool(null, null, false, connectionInfo, toolDataId);
+            }else if(toolNme == 'schema_diff'){
+              localStorage.setItem(toolDataId, toolData);
+              pgAdmin.Tools.SchemaDiff.launchSchemaDiff(toolDataId);
             }
           });
 
           // call clear application state data.
           try {
-            getApiInstance().delete(url_for('settings.delete_application_state'), {
-            });
+            getApiInstance().delete(url_for('settings.delete_application_state'), {});
           } catch (error) {
             console.error(error);
             pgAdmin.Browser.notifier.error(gettext('Failed to remove query data.') + parseApiError(error));

web/pgadmin/browser/static/js/browser.js

@@ -455,7 +455,7 @@ export default function AdHocConnection({mode}) {
       'pgadmin:tool:show',
       `${BROWSER_PANELS.PSQL_TOOL}_${transId}`,
       openUrl,
-      {title: escapedTitle, db: db_name},
+      {title: escapedTitle, db: db_name, server_name: formData.server_name, 'user': user_name},
       {title: panelTitle, icon: 'pg-font-icon icon-terminal', manualClose: false, renamable: true},
       Boolean(open_new_tab?.includes('psql_tool'))
     );

web/pgadmin/misc/workspaces/static/js/AdHocConnection.jsx

@@ -16,6 +16,8 @@
 import json
 from flask import render_template, Response, request, session, current_app
 from flask_babel import gettext
+
+from pgadmin.settings import delete_tool_data
 from pgadmin.user_login_check import pga_login_required
 from pgadmin.utils import PgAdminModule
 from pgadmin.utils.ajax import success_return, \
@@ -238,6 +240,9 @@ def save():
             data['mid'], data['category_id'], data['id'], data['value'])
         sgm.get_nodes(sgm)
 
+        if data['name'] == 'save_app_state' and not data['value']:
+            delete_tool_data()
+
         if not res:
             return internal_server_error(errormsg=msg)
 

web/pgadmin/preferences/__init__.py

@@ -8,13 +8,17 @@
 ##########################################################################
 
 """Utility functions for storing and retrieving user configuration settings."""
-
+import os
 import traceback
 import json
 
 from flask import Response, request, render_template, url_for, current_app
 from flask_babel import gettext
 from flask_login import current_user
+from selenium.webdriver.support.expected_conditions import \
+    element_selection_state_to_be
+from sqlalchemy import false
+
 from pgadmin.user_login_check import pga_login_required
 from pgadmin.utils import PgAdminModule
 from pgadmin.utils.ajax import make_json_response, bad_request,\
@@ -262,26 +266,32 @@ def get_file_format_setting():
                               info=get_file_type_setting(list(data.values())))
 
 
+
+
 @blueprint.route(
     '/save_application_state',
     methods=["POST"], endpoint='save_application_state'
 )
 @pga_login_required
 def save_application_state():
     """
-    Args:
-        sid: server id
-        did: database id
+    Expose an api to save the application state which stores the data from
+    query tool, ERD, schema-diff, psql
     """
     data = json.loads(request.data)
-    id = data['trans_id']
+    trans_id = data['trans_id']
     fernet = Fernet(current_app.config['SECRET_KEY'].encode())
     tool_data = fernet.encrypt(json.dumps(data['tool_data']).encode())
     connection_info = data['connection_info'] \
         if 'connection_info' in data else None
+    if 'open_file_name' in connection_info and connection_info['open_file_name'] and 'is_editor_dirty' in connection_info and connection_info['is_editor_dirty']:
+        last_saved_file_hash = compute_sha256_large_file(connection_info['open_file_name'])
+        print(last_saved_file_hash)
+        connection_info['last_saved_file_hash'] = last_saved_file_hash
+
     try:
         data_entry = ApplicationState(
-            uid=current_user.id, id=id,connection_info=connection_info,
+            uid=current_user.id, id=trans_id,connection_info=connection_info,
             tool_name=data['tool_name'], tool_data=tool_data)
 
         db.session.merge(data_entry)
@@ -304,6 +314,9 @@ def save_application_state():
 )
 @pga_login_required
 def get_application_state():
+    """
+    Returns application state if any stored.
+    """
     fernet = Fernet(current_app.config['SECRET_KEY'].encode())
     result = db.session \
         .query(ApplicationState) \
@@ -312,8 +325,26 @@ def get_application_state():
 
     res = []
     for row in result:
+        connection_info = row.connection_info
+        print(connection_info)
+        if 'open_file_name' in connection_info and connection_info['open_file_name']:
+            file_path = connection_info['open_file_name']
+            file_deleted = False if os.path.exists(file_path) else True
+            connection_info['file_deleted'] = file_deleted
+            if not file_deleted and connection_info['is_editor_dirty']:
+                if 'last_saved_file_hash' in connection_info and connection_info['last_saved_file_hash']:
+                    connection_info['external_file_changes'] = check_external_file_changes(file_path, connection_info['last_saved_file_hash'])
+
+
+        # if 'open_file_name' in connection_info and connection_info['open_file_name']:
+        #     initial_file_hash = connection_info['initial_file_hash']
+        #     file_deleted, file_modified_in_pgadmin, file_modified_externally = detect_file_change(connection_info['open_file_name'], tool_data, initial_file_hash )
+        #     connection_info['file_deleted'] = file_deleted
+        #     connection_info['file_modified_in_pgadmin'] = file_modified_in_pgadmin
+        #     connection_info['file_modified_externally'] = file_modified_externally
+
         res.append({'tool_name': row.tool_name,
-                    'connection_info': row.connection_info,
+                    'connection_info': connection_info,
                     'tool_data': fernet.decrypt(row.tool_data).decode(),
                     'id': row.id
                     })
@@ -335,10 +366,16 @@ def delete_application_state():
     if request.data:
         data = json.loads(request.data)
         trans_id = int(data['panelId'].split('_')[-1])
-    return delete_tool_data(trans_id)
+    status, msg = delete_tool_data(trans_id)
+    return make_json_response(
+        data={
+            'status': status,
+            'msg': msg,
+        }
+    )
 
 
-def delete_tool_data(trans_id):
+def delete_tool_data(trans_id=None):
     try:
         if trans_id:
             results = db.session \
@@ -354,17 +391,66 @@ def delete_tool_data(trans_id):
         for result in results:
             db.session.delete(result)
         db.session.commit()
-        return make_json_response(
-            data={
-                'status': True,
-                'msg': 'Success',
-            }
-        )
+        return True, 'Success'
     except Exception as e:
         db.session.rollback()
-        return make_json_response(
-            data={
-                'status': False,
-                'msg': str(e),
-            }
-        )
+        return False, str(e)
+
+
+import hashlib
+
+def compute_sha256_large_data_in_memory(data):
+    """Hash large data (in-memory) by processing in chunks."""
+    sha256_hash = hashlib.sha256()
+    # Process data in 8 KB chunks
+    string_data = json.loads(data)
+    chunk_size = 8192
+    for i in range(0, len(string_data), chunk_size):
+        chunk = string_data[i:i + chunk_size]
+        sha256_hash.update(chunk.encode("utf-8"))
+
+    return sha256_hash.hexdigest()
+
+
+def compute_sha256_large_file(file_path):
+    """Compute SHA-256 hash for large files by reading in chunks."""
+    sha256_hash = hashlib.sha256()
+
+    # Open the file in binary mode
+    with open(file_path, "rb") as file:
+        # Read and hash in 8 KB chunks (can adjust the chunk size if needed)
+        for chunk in iter(lambda: file.read(8192), b""):
+            print(chunk)
+            sha256_hash.update(chunk)
+
+    return sha256_hash.hexdigest()
+
+
+def detect_file_change(file_path, data, initial_file_hash ):
+    file_deleted = False
+    file_modified_in_pgadmin = False
+    file_modified_externally = False
+    if os.path.exists(file_path):
+        current_file_hash = compute_sha256_large_file(file_path)
+        stored_data_hash = compute_sha256_large_data_in_memory(data)
+        if stored_data_hash != current_file_hash:
+            if stored_data_hash != initial_file_hash:
+                # file changes in pgadmin
+                file_modified_in_pgadmin = True
+
+            if current_file_hash != initial_file_hash:
+                # file is changed externally
+                file_modified_externally = True
+
+    else:
+        file_deleted = True
+        file_modified_in_pgadmin = True
+    return file_deleted, file_modified_in_pgadmin, file_modified_externally
+
+
+def check_external_file_changes(file_path, last_saved_file_hash):
+    current_file_hash = compute_sha256_large_file(file_path)
+    if current_file_hash != last_saved_file_hash:
+        return True
+    return False
+

web/pgadmin/settings/__init__.py

@@ -10,27 +10,48 @@ import React, { useContext, useMemo } from 'react';
 import PropTypes from 'prop-types';
 import getApiInstance from '../../static/js/api_instance';
 import url_for from 'sources/url_for';
+import { getBrowser } from '../../static/js/utils';
+import usePreferences from '../../preferences/static/js/store';
 
 const ApplicationStateContext = React.createContext();
 
 export const useApplicationState = ()=>useContext(ApplicationStateContext);
 
-export function retrieveDataFromLocalStorgae(sqlId){
-  let sqlValue = JSON.parse(localStorage.getItem(sqlId));
-  localStorage.removeItem(sqlId);   
-  return sqlValue;
+export function getToolData(localStorageId){
+  let toolDataJson = JSON.parse(localStorage.getItem(localStorageId));
+  localStorage.removeItem(localStorageId);   
+  return toolDataJson;
 }
 
 export function ApplicationStateProvider({children}){
-  const saveToolData = (data) =>{
-    getApiInstance().post(
+  const preferencesStore = usePreferences();
+  const saveAppState = preferencesStore?.getPreferencesForModule('misc')?.save_app_state;
+  const openNewTab = preferencesStore?.getPreferencesForModule('browser')?.new_browser_tab_open;
+
+  const saveToolData = (toolName, connectionInfo, transId, toolData) =>{
+    let data = {
+      'tool_name': toolName,
+      'connection_info': connectionInfo, 
+      'trans_id': transId,
+      'tool_data': toolData
+    };
+    getApiInstance({'Content-Encoding': 'gzip'}).post(
       url_for('settings.save_application_state'),
       JSON.stringify(data),
     ).catch((error)=>{console.error(error);});
   };
 
+  const enableSaveToolData = (toolName)=>{
+    let toolMapping = {'sqleditor': 'qt', 'schema_diff': 'schema_diff', 'psql': 'psql_tool', 'ERD': 'erd_tool'};
+    if(openNewTab?.includes(toolMapping[toolName])){
+      return saveAppState && getBrowser().name == 'Electron';
+    }
+    return saveAppState;
+  };
+
   const value = useMemo(()=>({
     saveToolData,
+    enableSaveToolData
   }), []);
 
   return <ApplicationStateContext.Provider value={value}>