Methods and systems for processing power assessment reports using spreadsheet software

Abstract

This invention relates to the field of automated management technology for power assessment systems, specifically providing a method and system for processing power assessment reports using spreadsheet software. Through a plugin installed in the spreadsheet software, the system obtains assessment reports containing system file identifiers and establishes a session binding. In response to user editing, it calls the local calculation engine to execute formula calculations and displays the results. In response to a save command, if the report is identified as a system file and the session is valid, the default save behavior is intercepted, and the complete report data is fed back to the server, allowing the server to extract and store the cached calculation results of the formula cells; otherwise, the default save is allowed. This invention offloads the calculation task to the client, reducing the server load. Through save interception, session binding, and cache value priority strategies, it achieves secure closed-loop data flow and precise version control, while also being compatible with user-defined formulas, improving the flexibility and data consistency of power assessment operations.

Description

Technical Field

[0001] This invention belongs to the field of automated management technology for power assessment systems, specifically relating to a method and system for processing power assessment reports using spreadsheet software. Background Technology

[0002] In the evaluation of power engineering projects, numerous complex calculation formulas and multi-dimensional indicator calculations are often involved. Currently, the common approach is as follows: the server generates an evaluation report based on a preset template, users download it, fill in the data locally using spreadsheet software, and then upload the file back to the server, which centrally executes the calculations for all evaluation formulas.

[0003] However, this approach, which relies entirely on server-side calculations, has significant drawbacks: when there are numerous assessment items and complex formulas, the server bears a huge computational load, easily becoming a performance bottleneck and affecting system response speed. Furthermore, due to differences in calculation rules and precision logic between local spreadsheet software and the server-side calculation engine, the results recalculated on the server side are inconsistent with the results seen locally by the user, severely impacting user experience. In addition, the assessment calculation logic is usually hard-coded in the server-side code. Once the assessment rules or calculation methods are adjusted, developers must modify the code and redeploy the version, making flexible configuration and adaptation impossible, resulting in low efficiency in rule changes and high maintenance costs. Summary of the Invention

[0004] In view of the above-mentioned shortcomings of the prior art, the present invention provides a method and system for processing power assessment reports using spreadsheet software to solve the above-mentioned technical problems.

[0005] In a first aspect, the present invention provides a method for processing power assessment reports using spreadsheet software, wherein the spreadsheet software has a plugin installed, including: Obtain the power assessment report issued by the server and load the power assessment report, which contains a system file identifier; In response to the user's editing operation on the power assessment report, the local calculation engine of the spreadsheet software is invoked to perform the assessment formula calculation and display the calculation results; In response to a user-triggered report save command, determine whether the current report is a power assessment report with the system file identifier; If the judgment result is yes, then the default local saving behavior of the spreadsheet software is intercepted, and the current complete data of the power assessment report and the version identifier of the assessment item are returned to the server, so that the server can extract the cached calculation results of the formula cells from the returned report and store them. If the judgment result is negative, then the default local saving behavior is allowed.

[0006] In one alternative implementation, the method of constructing the plugin includes: The front-end interface and logic of the plugin are constructed using a Web technology stack, which includes HTML and JavaScript. The plugin is deployed as a standalone web application on a web server, and its entry Uniform Resource Locator and required permissions are registered with the spreadsheet software via a configuration file. After the plugin is started, it calls the native capabilities of the spreadsheet software through the application programming interface provided by the spreadsheet software and realizes data communication with the server.

[0007] In one optional implementation, data communication with the server is achieved, including: When the plugin starts, it obtains a short-term token from the server that is bound to the project identifier of the current assessment project. During the export phase, an export request carrying the project identifier is sent to the server, and the Uniform Resource Locator (URL) of the power assessment report returned by the server is received. During the reflow phase, in response to the intercepted save command, the application programming interface of the spreadsheet software is invoked to convert the current workbook into a binary stream, and an HTTP request carrying the binary stream, the project identifier, and the short-lived token is constructed and sent to the import interface of the server.

[0008] In one optional implementation, in response to a user's editing operation on the electricity assessment report, the local calculation engine of the spreadsheet software is invoked to perform assessment formula calculations and display the calculation results, including: After loading the power assessment report, the system requests formula configuration information that matches the current assessment item from the server. The formula configuration information defines the mapping relationship between the formula logic and the target cell position in the form of structured data. The formula configuration information is parsed, and the application programming interface provided by the spreadsheet software is called to dynamically write the formula logic into the corresponding target cell in the power assessment report; In response to the local calculation triggered by the written formula logic in the spreadsheet software, the calculation result is obtained and displayed.

[0009] In one optional implementation, the method for the server to generate the formula configuration information includes: Based on the type or indicator of the assessment item, the corresponding formula rule is matched from the pre-configured formula rule library, which stores the mapping relationship between formula logic and target cell position; Based on the matched formula rules, generate formula configuration information that includes the formula logic and the target cell position; In response to the client's formula configuration request, the formula configuration information is sent to the plugin.

[0010] In an optional implementation, formula configuration information containing the formula logic and the target cell position is generated, including: Identify the dynamic placeholders in the formula rules, whereby the dynamic placeholders correspond to the dynamic data of the current assessment item; Replace the dynamic placeholder with the actual value or actual reference address of the current assessment item to generate formula configuration information adapted to the current assessment item.

[0011] In an optional implementation, after loading the power assessment report, the method further includes: The system checks whether there are any preset hidden worksheets or custom attributes in the power assessment report as system file identifiers. If it exists, then establish a mapping relationship between the current session identifier, report identifier and project identifier of the assessment project in the local storage of the plugin.

[0012] In an optional implementation, in response to a user-triggered report save command, determining whether the current report is a power assessment report with the system file identifier includes: Retrieve the report identifier and current session identifier of the currently active report; Based on the report identifier and / or the session identifier, query whether the plugin's local storage contains a project identifier that has a mapping relationship with the report identifier and / or the session identifier; If the corresponding project identifier is found, it is determined that the current report has the system file identifier and is validly bound to the current assessment project session; If no corresponding project identifier is found, it is determined that the current report does not have a system file identifier.

[0013] In an optional implementation, applied to the server side, the method includes: In response to the client's export request, an electricity assessment report containing a system file identifier is generated and returned to the client, so that the client can edit and calculate it locally through a plugin installed in the spreadsheet software; The system receives the report data and version identifier of the assessment item returned by the client after intercepting the report save command. The returned report data includes the formula cache result calculated by the local calculation engine of the spreadsheet software after the user edits it locally on the client. The returned report data is parsed, the cached result is read from the formula cell, and the cached result is stored in the database along with the version identifier.

[0014] Secondly, the present invention provides a power assessment report processing system for spreadsheet software, comprising: The report loading module is used to obtain the power assessment report issued by the server and load the power assessment report, which contains a system file identifier; The result calculation module is used to respond to the user's editing operation on the power assessment report, call the local calculation engine of the spreadsheet software to execute the assessment formula calculation and display the calculation result; The identifier determination module is used to determine whether the current report is a power assessment report with the system file identifier in response to a report saving command triggered by the user. The save interception module is used to intercept the default local save behavior of the spreadsheet software if the judgment result is yes, and to return the current complete data of the power assessment report and the version identifier of the assessment item to the server so that the server can extract the cached calculation results of the formula cells from the returned report and store them. The local save module is used to allow the default local save behavior if the judgment result is negative.

[0015] The present invention provides a method and system for processing power assessment reports in spreadsheet software. This method offloads the calculation of power assessment formulas from the server to the client-side spreadsheet software, offering the following advantages: Through a plugin installed in the spreadsheet software, the invention responds to user editing of the assessment report by directly calling the client's local computing engine to complete the formula calculation and display the results in real time. This fully utilizes the client's computing power, fundamentally avoiding the performance bottleneck caused by the server centrally processing a large number of complex formulas. It significantly reduces the server's computational load and improves the overall system response speed and concurrent processing capabilities. Furthermore, since the calculation process is completed on the client side, the server only needs to act as a rule carrier and result receiver, without needing to concern itself with the implementation details of the specific formula logic. Even if the assessment formula is frequently adjusted or user-defined, there is no need to modify the server-side code or redeploy the calculation logic, further enhancing the system's flexibility and maintainability. Attached Figure Description

[0016] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, for those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0017] Figure 1 This is a schematic flowchart of a method according to an embodiment of the present invention.

[0018] Figure 2 This is a schematic diagram of the system architecture of one embodiment of the present invention.

[0019] Figure 3 This is a timing flowchart of the method for generating formula configuration information according to an embodiment of the present invention.

[0020] Figure 4 This is another illustrative flowchart of a method according to an embodiment of the present invention.

[0021] Figure 5 This is a schematic block diagram of a system according to an embodiment of the present invention. Detailed Implementation

[0022] To enable those skilled in the art to better understand the technical solutions of this invention, the technical solutions of the embodiments of this invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this invention, and not all embodiments. Based on the embodiments of this invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of this invention.

[0023] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention pertains. The terminology used herein in the description of the invention is for the purpose of describing particular embodiments only and is not intended to be limiting of the invention.

[0024] The power assessment report processing method for spreadsheet software provided in this embodiment of the invention is executed by a computer device, and correspondingly, the power assessment report processing system for spreadsheet software runs on the computer device.

[0025] Figure 1 This is a schematic flowchart illustrating a method according to an embodiment of the present invention. Wherein, Figure 1 The executing entity can be a power assessment report processing system using spreadsheet software. Depending on different needs, the order of the steps in this flowchart can be changed, and some can be omitted.

[0026] like Figure 1 As shown, the method includes: S1. Obtain the power assessment report issued by the server and load the power assessment report, wherein the power assessment report contains a system file identifier; S2. In response to the user's editing operation on the power assessment report, the local calculation engine of the spreadsheet software is invoked to execute the assessment formula calculation and display the calculation result; S3. In response to a user-triggered report save command, determine whether the current report is a power assessment report with the system file identifier; S4. If the judgment result is yes, then the default local saving behavior of the spreadsheet software is intercepted, and the current complete data of the power assessment report and the version identifier of the assessment item are returned to the server, so that the server can extract the cached calculation results of the formula cells from the returned report and store them. S5. If the judgment result is negative, then allow the default local saving behavior.

[0027] This invention proposes a closed-loop processing scheme of "client-side computation - cached backflow - backend verification," transforming the backend from a "computation executor" to a "rule carrier and result receiver," thereby achieving integrated data computation, version control, and secure backflow without sacrificing users' WPS Spreadsheet usage habits. The system architecture is as follows: Figure 2 As shown, it includes: The system consists of a business system frontend (list pages / button pages), WPS add-ins (plugins running in the WPS / Excel client), a backend service (SpringBoot interface service), and database and file storage. The frontend and backend are isolated via Nginx for reverse proxy and routing, facilitating unified access to different business systems.

[0028] The backend service of this invention can be uniformly provided externally as an "independent business capability," offering interfaces such as export / import / token functionality. Service registration, health checks, and configuration management are performed through a service registration and configuration center (such as Nacos), enabling it to be accessed and reused by multiple upper-layer business systems on demand. This deployment method does not require the invention to be broken down into multiple microservice components; even in a monolithic application form, unified access and canary releases across multiple systems can be achieved through Nacos + gateway (Nginx / microservice gateway).

[0029] The data access layer is implemented using JPA / ORM, allowing business code to be migrated and deployed between different relational databases (such as PostgreSQL and MySQL) by simply replacing the data source configuration and dialect, thus avoiding being bound to a single database.

[0030] The front end of the business system can be deployed as an independent static site, separated from the backend interface through Nginx; or it can be split and deployed according to the needs of micro-frontend / multi-system access, with path routing and security isolation uniformly handled by Nginx.

[0031] In a preferred embodiment of the present invention, the plugin is built and deployed using a Web technology stack to achieve cross-platform, easy-to-maintain, lightweight access.

[0032] Specifically, the method for building the plugin includes the following steps: Step 1: Develop the plugin front-end using the Web technology stack Developers use a standard Web technology stack to build the plugin's front-end interface and interaction logic. This Web technology stack includes, but is not limited to, HTML, CSS, and JavaScript (or TypeScript). HTML defines the plugin's sidebar, pop-ups, or function panel page structure; CSS controls the interface style; and JavaScript implements the business logic, such as listening for user actions, calling spreadsheet software application programming interfaces (APIs), and communicating with the server. Compared to traditional VBA or COM plugin development methods, the Web technology stack offers excellent cross-platform compatibility, portability, and a lower development threshold.

[0033] Step 2: Deploy the plugin as a standalone web application The developed plugin front-end code is packaged into a standalone web application and deployed to a web server (such as Nginx, Apache, or Tomcat). This web application has its own Uniform Resource Locator (URL), such as https: / / your-domain / plugin / index.html. Because the plugin exists as a web application, its updates and maintenance are performed only on the server side. Clients do not need to manually install or upgrade the plugin version, achieving a seamless "click-and-use" experience.

[0034] Step 3: Register the plugin with the spreadsheet software via configuration file To enable spreadsheet software (such as WPS Office or Microsoft Excel) to recognize and load the plugin, a configuration file is required. For WPS Office, this configuration file is jsplugins.xml; for Microsoft Excel, it is the Web Add-in manifest file (manifest.xml). This configuration file must declare at least the following information: the plugin's unique identifier (ID); the plugin's name and description; the plugin's entry URL (i.e., the address of the web application deployed in step two); and the permissions required by the plugin, such as reading and writing the current workbook, listening for save events, and accessing the network.

[0035] Place the configuration file in the directory specified by the spreadsheet software, or push it to the user terminal through an enterprise-level policy. The spreadsheet software will automatically read the configuration file when it starts up and load the plugin according to the entry URL.

[0036] Step 4: Runtime interaction after plugin startup The plugin activates when a user opens the spreadsheet software and loads the performance report. The plugin runs within the spreadsheet software's built-in browser engine (such as the Chromium engine) and interacts with the host environment through the spreadsheet software's exposed JavaScript APIs. Specifically, it includes: Calling native capabilities: The plugin reads or writes cell content, obtains the currently active workbook, and listens for lifecycle events such as WorkbookBeforeSave through APIs (such as WPS's Application object or Excel's Office.context), thereby realizing functions such as save interception and data reading.

[0037] Communicating with the server: The plugin interacts with the backend services of the business system via standard HTTP / HTTPS protocols (such as Ajax or Fetch API). For example, it requests a short-term token from the server when the plugin starts, and uploads the workbook's binary stream, along with project identifiers, tokens, and other data, to the server's import interface when the user saves a report.

[0038] Through the above construction method, this invention realizes a plug-in system that is decoupled from spreadsheet software and can be deployed and maintained independently. This plug-in can not only make full use of the powerful local computing engine of spreadsheet software, but also communicate efficiently with backend services through standard Web technologies, providing a reliable technical foundation for subsequent core functions such as save interception, data reflow, and token verification.

[0039] Preferably, in order to adapt to the access requirements of different business systems, the entry URL of the plugin can be dynamically specified through configuration parameters, so that the same plugin code can be reused by multiple independently deployed business systems, further enhancing the universality and scalability of the present invention.

[0040] In one embodiment of the present invention, based on step S1, the following will provide a possible embodiment and describe its specific implementation in a non-limiting manner.

[0041] S101, User triggers export request The user selects an assessment item to be filled in on the front-end page of the business system (such as the assessment item management list), and clicks the "Export Report" or a similar button. The front-end page first sends a request to the server to apply for a short-term token bound to the item identifier (projectId). After verifying the user's permission, the server generates the short-term token, sets a validity period (for example, 30 minutes), and stores the binding relationship between the token and the projectId in a cache or database at the same time.

[0042] S102. The server generates an assessment report containing a system file identifier The front end carries the short-term token to call the export interface of the server (for example, / export?projectId=xxx&token=yyy). After receiving the request, the server first verifies the validity of the token and its consistency with the projectId. After the verification is passed, the server performs the following operations: 1. Filling basic data: Obtain the corresponding basic data of the assessment item (such as item name, investment amount, planned progress, etc.) according to the projectId, and write the data into the corresponding cells according to a preset report template (in Excel format).

[0043] 2. Injecting the system file identifier: To enable the client plug-in to identify the report as a "system file", the server adds an invisible identifier to the generated Excel file. In this embodiment, the identifier is a hidden worksheet. The server creates a worksheet named "__SYS_META__" (or other agreed names), and sets its attribute to xlSheetVeryHidden, so that users cannot view or unhide it through the conventional interface. The hidden worksheet can store metadata, such as item ID, version number, report identifier, etc. In addition, a custom document property can also be used as the system file identifier, which has the same effect as the hidden worksheet.

[0044] 3. Generating the file and returning the URL: The server saves the Excel file filled with data and added with the identifier to a temporary storage area (such as a local disk or object storage), and exposes the file as an accessible URL in the form of an HTTP static resource (for example, https: / / domain.com / excel / 202601 / P2026001_AssessmentReport.xlsx). The server then returns the URL to the front end.

[0045] S103. The client acquires and loads the report After the front end receives the URL returned by the server, it wakes up the local spreadsheet software client through a specific protocol (such as a custom URL Scheme), and passes the URL to the client as a parameter. The client starts the spreadsheet software and invokes its "open file from URL" function (for example, the OpenFromUrl interface of WPS or the Workbooks.Open method of Excel combined with a network path). The spreadsheet software downloads the Excel file, opens it in the window, and presents it to the user.

[0046] S104. The plug-in identifies the system file identifier and establishes an initial binding When the spreadsheet software opens the assessment report, the installed plug-in will listen to the document opening event (such as WorkbookOpen). The plug-in performs the following initialization operations: Traverse all worksheets in the current workbook, and check whether there is a hidden worksheet with a predetermined name (such as "__SYS_META__"). If it exists, it is determined that the current document is a system file.

[0047] After confirming the system file identifier, the plug-in reads information such as the project identifier (projectId) and session identifier (sessionId) from the specified cells or custom properties of the hidden worksheet, and establishes a mapping relationship in the plug-in's local storage (such as localStorage or IndexedDB), for example: { sessionId: "abc123", documentId: "P2026001_AssessmentReport.xlsx", projectId: "P2026001"}. This mapping relationship will be used to verify the validity of the session binding during subsequent save interception.

[0048] So far, the client has successfully acquired and loaded the electric power assessment report containing the system file identifier, and completed the plug-in's identification of the system file and preliminary session binding, making preparations for the user's subsequent local editing, calculation and data backflow.

[0049] As another implementation, the system file identifier may also adopt custom document properties instead of a hidden worksheet. When generating the Excel file, the server writes a property named "SystemDocFlag" with a value of true through a library such as POI. When the plug-in opens the document, it reads the property through the API of the spreadsheet software, and can also identify the system file. This implementation also falls within the protection scope of the present invention.

[0050] In one embodiment of the present invention, based on step S2, the following will provide a possible embodiment and describe its specific implementation in a non-limiting manner.

[0051] Users input raw data into designated cells in various worksheets of the spreadsheet software based on the actual completion status of the assessment projects. For example, in the "Investment Completion Status" worksheet, users sequentially fill in basic indicators such as "Actual Investment Completed This Month (Ten Thousand Yuan)," "Cumulative Investment Completed (Ten Thousand Yuan)," and "Planned Completion Rate." Each time a user completes input in a cell and presses the Enter key or clicks on another cell, the spreadsheet software automatically triggers its local calculation engine to recalculate all affected formulas in the worksheet containing that cell.

[0052] In addition to inputting basic data, users can also directly write or modify formulas in the performance evaluation report. Common use cases include: Adjusting the assessment coefficient: Based on the latest requirements from the superior department, the user changes the weighting coefficient in the "Assessment Score" formula from 0.3 to 0.35. The user enters =B10×0.35+C10×0.65 in the target cell (e.g., "F10") and presses Enter.

[0053] Add an auxiliary calculation column: Users found that the original formula in the report did not include the "safety deduction item", so they entered =IF(E10>10,-5,0) in the newly added "G column" and added the result of this column to the total score.

[0054] Referencing data from other worksheets: Users can write cross-worksheet formulas, such as =SUM('Investment Overview'!C5:C9, 'Cost Details'!D3:D8).

[0055] In the above process, users follow the standard formula syntax of spreadsheet software to write code without having to learn any additional interfaces or scripting languages.

[0056] The native calculation engine built into spreadsheet software (such as WPS Office's ET Calculation Engine or Microsoft Excel's Calculation Engine) is responsible for parsing the user-input formulas, building a cell dependency tree, and performing calculations in topological order. For the example above: When a user enters =B10×0.35+C10×0.65, the calculation engine automatically recognizes that the cell depends on the values ​​of B10 and C10. If B10 or C10 changes, the cell will be automatically recalculated.

[0057] The calculation engine follows the standard spreadsheet operation rules: multiplication and division before addition and subtraction, parentheses first, function calls, etc.

[0058] Once the calculation is complete, the spreadsheet software immediately displays the result (e.g., "87.5") in the target cell, allowing users to visually see the change in their assessment score.

[0059] In this step, the plugin does not participate in, intercept, or modify any user's editing operations or calculation processes. The plugin is merely in an "observer" state, and its main task is to listen for lifecycle events such as document opening and saving, but does not interfere with changes to cell content.

[0060] This design allows users to be fully immersed in the native spreadsheet software experience. All formula calculations utilize the client's powerful local computing power, eliminating the need to send data back to the server for any calculations, thus fundamentally avoiding server-side computational load. Furthermore, since formula calculations and result display are entirely handled by the local engine, any custom modifications to formulas made by the user take effect immediately and receive feedback, greatly improving the flexibility of performance evaluation processes.

[0061] In a preferred embodiment, to address the issue that front-end users may be unfamiliar with complex power assessment formulas and unable to accurately input calculation formulas, this invention provides a dynamic formula injection method that integrates front-end and back-end collaboration. This method, without altering the core architecture of "calculation pushed to the client," achieves automated adaptation and transparent application of assessment formulas through server-side formula configuration distribution and dynamic formula writing via client plugins. Please refer to [reference needed]. Figure 3 Specifically, it includes the following steps: S201, Client Request Formula Configuration Information Once the client (the spreadsheet software with the plugin installed) successfully loads the power assessment report and completes system file identification, the plugin automatically sends a formula configuration request to the server. This request carries the project identifier (projectId) of the current assessment item and the optional project type (projectType) parameter. After receiving the request, the server performs the corresponding processing (see S204 to S206 for details).

[0062] S202, Client-side formula parsing configuration information The plugin receives formula configuration information returned by the server. This information, in structured data format (such as JSON), defines the mapping relationship between formula logic and target cell positions. A typical example of a JSON-formatted formula configuration is as follows: {"version": "1.0","projectId": "P20260101","rules": [{"sheetName": "Investment Overview","cell": "C10","formula": "=SUM(C5:C9)","comment": "Calculate the deviation ratio between actual investment and planned investment in this period"},{"sheetName": "Assessment Summary","cell": "F10","formula": "=IF(D10>100, D10*1.2, D10*0.9)","style": { "color": "red", "fontWeight": "bold"}}]}.

[0063] The plugin iterates through each rule in the rules array, executing the following sub-steps in sequence: Locate the target worksheet by sheetName, and locate the target cell by cell.

[0064] Extract the formula string and prepare it to be written into the Formula attribute of the cell.

[0065] Optionally, the comment can be written to the cell's comment section for users to view by hovering over it.

[0066] Optionally, the font color, background color, and other styles of the cell can be dynamically adjusted based on the style field to achieve visual alerts.

[0067] S203, The client dynamically writes the formula and triggers local calculation. The plugin calls the application programming interface (API) provided by the spreadsheet software (such as the `Range.Formula` property in the WPS JS API or `range.formulas` in the Excel Web Add-in) to write the formula string extracted from S202 into the target cell. After the write operation is complete, the spreadsheet software's built-in calculation engine automatically detects the addition or change of the cell formula and immediately triggers a recalculation for that cell and all dependent cells. After the calculation is complete, the calculation result (such as a number, string, or error value) will be displayed in the cell in real time, and the user can see the assessment indicator value calculated based on the formula rules issued by the server without any additional operation.

[0068] S204, The server matches formula rules based on the project type. The server pre-builds and stores a formula rule base. In this implementation, the rule base is implemented in the form of a database table (such as t_formula_rule), which contains at least the following fields: rule_id: Unique identifier for the rule; project_type: Applicable project type (e.g., "Power Grid Infrastructure", "Technical Upgrading and Overhaul", "Distribution Network Transformation"); indicator_code: Assessment indicator code; target_sheet: Target worksheet name; target_cell: Target cell location; formula_template: Formula template, which may contain dynamic placeholders (e.g., {{total_invest}}, {{adjust_factor}}); comment_text: Formula description text; style_info: Style configuration (JSON format).

[0069] When the server receives a formula configuration request (carrying projectId) from the client, it first queries the corresponding project type projectType based on projectId, and then filters all rule records that match projectType from the formula rule base.

[0070] S205, Server-side dynamic placeholder replacement is performed. The server retrieves dynamic data for the current assessment items. For example, in the formula for total investment deviation rate =SUM(C5:C9), the reference addresses of C5:C9 are fixed and do not need to be replaced; however, for more general formula templates, such as ={{actual investment}} / {{planned investment}}×100%, the placeholders need to be replaced with actual values ​​or cell reference addresses.

[0071] The specific replacement process is as follows: 1. Iterate through each formula rule matched in S204 and extract the string "formula_template".

[0072] 2. Identify dynamic placeholders in the template. Placeholders can use specific syntax, such as double curly braces {{placeholder}}.

[0073] 3. Based on the actual data source of the current assessment item (such as indicator values ​​in the database or the address of a specific cell in the basic data table), replace each placeholder with the actual value (such as the value "3500") or the cell reference address (such as "C5").

[0074] 4. Generate the final formula string that can be directly written into Excel cells (e.g., =3500 / 5000×100% or =C5 / C6×100%).

[0075] S206, Server sends formula configuration information The server assembles all processed formula rules (including the final formula string) into structured formula configuration information (JSON format) and returns it as an HTTP response to the client plugin. To improve efficiency, the server can configure a caching strategy to directly return cached configuration information within a short time for the same project type and dynamic data, avoiding duplicate calculations.

[0076] S207, Coordination between User-Defined Formulas and Configuration Formulas In this implementation, the formula configuration information sent by the server is only used to initialize the recommended formulas in the report. Users can still directly modify the formulas in the cells or add new custom formulas. The plugin will not prevent or overwrite the user's modifications because the core principle of this invention is "client-side calculation priority." The user's modified formulas will be fed back to the server along with the report, and the server will retain the user's custom formula logic when receiving it (i.e., it still reads the cached values ​​and does not overwrite them). This design provides both assisted filling capabilities and ensures the user's flexible customization permissions.

[0077] In one embodiment of the present invention, based on step S3, the following will provide a possible embodiment and describe its specific implementation in a non-limiting manner.

[0078] In response to a user-triggered report save command, the plugin needs to determine whether the currently active report is a power assessment report with a system file identifier and whether it is effectively bound to the current assessment project session. To accurately and efficiently perform this determination, this invention adopts a preferred scheme based on local mapping relationships. This scheme consists of two stages: establishing mapping relationships during the loading stage, and querying and determining mapping relationships during the save stage.

[0079] S301, Loading Phase: Detect system file identifiers and establish mapping relationships. When a user opens an electricity performance assessment report from the business system, the spreadsheet software loads the report, and the plugin simultaneously listens for document open events (such as WorkbookOpen). The plugin performs the following initialization operations: Step 1: Detect system file identifiers The plugin iterates through all worksheets in the current workbook, checking for a hidden worksheet with a predefined name (e.g., "__SYS_META__"). This hidden worksheet is created by the server when generating the report, and its visibility is set to "extremely hidden" (xlSheetVeryHidden). Regular users cannot view or unhide it through the spreadsheet software's interface menu, thus providing excellent tamper resistance.

[0080] If the hidden worksheet is detected, the current report is determined to be a system file.

[0081] As another detection method, the plugin can also read custom document properties to check for the existence of a property named "SystemDocFlag" with a value of true. This method can also identify system file identifiers and is implemented in a more lightweight way.

[0082] Step 2: Read metadata If it is confirmed to be a system file, the plugin reads the following information from a specified cell (such as A1, B1) or custom property of the hidden worksheet: Project Identifier (projectId): A unique identifier for the current assessment project, such as "P20260101".

[0083] Session ID (sessionId): A temporary session ID generated and distributed by the server during export, or a unique ID generated locally by the plugin. This ID is used to distinguish between different sessions that open the same report.

[0084] Report Identifier (reportId or docId): A unique identifier for the current report, which can be a file name, document ID, or a UUID assigned by the server.

[0085] Step 3: Establish local mapping relationships The plugin stores the information read above, along with the context of the current session, in its local storage. Local storage can use the browser's localStorage, IndexedDB, or a dedicated storage API provided by the spreadsheet software. The stored data structure is a map, and its key-value pairs can be designed as follows: Use the report identifier as the key and the project identifier as the value; or use the session identifier as the key and the project identifier + report identifier as the value; or use a composite key (session identifier + report identifier) ​​as the key and the project identifier as the value.

[0086] In this implementation, a simple mapping with the report identifier as the key is used. Example data is as follows: {"P20260101_Assessment Report.xlsx": {"projectId": "P20260101","sessionId": "sess_abc123"}}. Additionally, the plugin can store the current session identifier in a memory variable for quick access later.

[0087] At this point, the preparation work for the loading phase is complete. This mapping relationship will be retained in local storage until the user closes the report or the session times out.

[0088] S301, Storage Phase: Obtain the identifier and query the mapping relationship to make a judgment. When a user presses a save shortcut (such as Ctrl+S) or clicks the save icon during report editing, the plugin gains control by listening for the spreadsheet software's pre-save event (such as WorkbookBeforeSave). At this point, the plugin executes the following decision logic: Step 1: Obtain the identifier of the current activity report The plugin calls the API provided by the spreadsheet software to obtain the document identifier of the currently active workbook. The methods for obtaining this identifier include: Read the Name property of the workbook to get the file name (e.g., "P20260101_Assessment Report.xlsx").

[0089] Call the workbook's GetBuiltinProperties or similar interface to obtain the unique document ID pre-written by the server.

[0090] At the same time, the plugin obtains the current session identifier (usually a variable stored in memory, or the most recently used session identifier read from local storage).

[0091] Step 2: Query the mapping relationship in local storage The plugin queries the local mapping table established during the loading phase based on the obtained report identifier (and optional session identifier). The query logic is as follows: Prioritize using the report identifier as the key: search the mapping table for an entry that exactly matches the current report identifier.

[0092] Optionally, session identifier verification can be combined: if the session identifier is stored in the mapping table, the current session identifier is further compared with the stored value to prevent the same report from being misjudged in different sessions.

[0093] Step 3: Determine the result If a corresponding project identifier is found, it is determined that the current report has a system file identifier and the session binding is valid. At this point, the plugin performs subsequent operations such as interception and saving, and data reflow (see other implementation methods for details).

[0094] If no corresponding project identifier is found, it is determined that the current report does not have a system file identifier (for example, the user directly opened a regular Excel file on the local disk, or a non-system-generated file copied from other sources). In this case, the plug-in allows the spreadsheet software's default local save behavior, saving the file to the user-specified local path without interfering with the user's normal office operations.

[0095] Specific application scenarios include: Scenario A (System File, Normal Reflow): A user exports a report named "Infrastructure Project Assessment Form.xlsx" from the business system. When the plugin opens the report, it detects a hidden worksheet and establishes a mapping relationship: {"Infrastructure Project Assessment Form.xlsx": {projectId:"P001"}}. After the user edits the file and presses Ctrl+S, the plugin retrieves the current filename "Infrastructure Project Assessment Form.xlsx", finds the corresponding projectId: "P001", determines it to be a system file, intercepts the default save, and triggers an upload reflow.

[0096] Scenario B (Normal file, allowed to save): The user opens a file named "Personal Budget.xlsx" on their own computer (this file has no hidden worksheets and no mapping relationship is established). After the user edits the file and presses Ctrl+S, the plugin retrieves the filename "Personal Budget.xlsx", finds no entry in the local mapping table, determines it as a non-system file, and allows it to be saved by default. The file is saved normally to the local machine without the user's knowledge.

[0097] Scenario C (Fake File, Interception Failed): A malicious user manually created an Excel file and added a hidden worksheet named "__SYS_META__", attempting to disguise it as a system file for re-upload. However, because the file did not undergo the normal export process when opened, the plugin's local storage did not establish a mapping relationship between the file and any projectId. When the user saved it, the plugin checked the mapping table and found it empty, determining it to be a non-system file, and directly allowed local saving without triggering re-upload, thus effectively preventing data pollution from the fake file.

[0098] To further enhance security, the plugin can also record a timestamp when establishing the mapping relationship and check if the session has timed out when saving (for example, if more than 24 hours have passed from opening to saving, the session is deemed invalid, and the user is required to retrieve a new report from the business system). This measure can effectively prevent issues such as long-term token hoarding or older versions overwriting newer versions.

[0099] In addition, the storage scope of the mapping relationship is limited to the current spreadsheet software instance or the plugin context under the current domain name. Plugin instances of different business systems are isolated from each other, ensuring data security when multiple systems access each other in parallel.

[0100] In one embodiment of the present invention, based on steps S4 and S5, a possible embodiment will be given below, and its specific implementation will be described in a non-limiting manner.

[0101] When the plugin determines, based on the local mapping relationship, that the current report is a power assessment report with a system file identifier and a valid session binding (the result is "Yes"), the plugin executes the interception and reflow process. Conversely, if it determines that the current report does not have a system file identifier or that the session binding is invalid (the result is "No"), the plugin allows the default saving behavior to ensure that it does not interfere with the user's normal office operations. The specific process is as follows: S4. If the judgment result is "yes": intercept the default save behavior and perform data reflow. When a user presses a save shortcut key (such as Ctrl+S) or clicks the save icon in the spreadsheet software, the plugin gains callback control by listening to the pre-save events provided by the spreadsheet software (such as the WorkbookBeforeSave event in WPS or the Workbook.BeforeSave event in Excel). After completing the system file identifier and session binding validity check as described above, if the result is "yes", the plugin performs the following steps: Step 1: Disable default local save behavior The plugin calls the Cancel property of the event object (or a similar mechanism) to mark the default behavior of the pre-save event as canceled. Specifically, in the WPS JS API, cancel = true; in the Excel Web Add-in, event.completed can be called with the cancel flag passed in. The effect of this operation is that the spreadsheet software will not perform the original local file save operation (i.e., no "Save As" dialog box will pop up, and the original file on the local disk will not be overwritten), thus completely handing over control of the save process to the plugin. Users will not see any abnormal pop-ups or error messages during this period, and the experience is no different from a normal save.

[0102] Step 2: Obtain the binary stream of the current complete data in the report. The plugin calls the application programming interface (API) provided by the spreadsheet software to obtain the complete data of the currently active workbook. In this implementation, it is achieved in the following way: Calling the SaveAs method of the workbook object, along with the Memory Stream parameter, saves the workbook to a temporary memory buffer instead of a disk file.

[0103] Alternatively, you can call a dedicated export interface (such as WPS's GetFileBinary or Excel's Workbook.getFileAsync) to directly obtain binary data (Blob or ArrayBuffer) representing the entire workbook.

[0104] This binary stream contains all the data edited locally by the user, including: the original numerical values ​​entered by the user, user-defined or modified formula strings, and the cached formula cell calculation results (CachedFormulaResultType) that have been calculated and written to the file by the spreadsheet software's local calculation engine. It's worth noting that the plugin does not need to parse the specific cell content, nor does it need to distinguish between formulas and numerical values; it only needs to package and upload the complete binary stream.

[0105] Step 3: Construct an upload request and include metadata The plugin constructs an HTTP POST request, targeting a predefined data import interface on the server (e.g., / import). The request carries the following information: Report binary stream: The Blob or ArrayBuffer obtained in step 2 is used as the request body, which is usually encapsulated in multipart / form-data format, with the field name being file.

[0106] Project Identifier (projectId): Queryed from the local mapping table, it is sent along with the form field projectId to inform the server which assessment project the report belongs to.

[0107] Version identifier (versionId or timestamp): Optionally, carry the version number of the current report or the timestamp of the last export for the server to perform version conflict detection.

[0108] Short-lived token: The short-lived token is carried in the Authorization field of the request header or the token field of the request body for the server to verify the legitimacy of this reflow. This token is obtained from the server during the export phase and bound to the projectId.

[0109] Step 4: Send the request and process the response The plugin sends the above data to the server via asynchronous HTTP requests. During the sending process, the plugin can display the upload progress (such as "Saving... 45%) in the spreadsheet software's sidebar or pop-up window to provide user-friendly feedback.

[0110] Upload successful: When the server returns an HTTP 200 status code and a success indicator (such as {"code":200, "message":"success"}), the plugin briefly displays "Save successful" in the sidebar and then disappears automatically. Users will experience no difference from a normal local save.

[0111] Upload Failure: If the upload fails due to network issues, expired token, server errors, or other reasons, the plugin will display a message box stating "Data not synchronized. Please check your network and click 'Retry'," along with a "Retry" button. After the user clicks 'Retry', the plugin will re-execute steps 3 and 4.

[0112] Step 5: Status update after reflow is complete After a successful upload, the server will return an updated version identifier or timestamp. The plugin can update this new version identifier in its local mapping table for use the next time a save is made. Simultaneously, the plugin can clear or update short-lived tokens (if the server issues a new token) to maintain the continuity of subsequent operations.

[0113] S5. If the judgment result is "No": Allow the default local save behavior. When the user presses the save shortcut key or clicks the save icon, the plugin gains control through the pre-save event and performs the system file identifier and session binding validity check described above. If the result is "no," meaning the current report does not have a system file identifier (e.g., the user directly opened a regular Excel file on the local disk, a file opened from an email attachment, or a file copied from another source that has no system mapping), the plugin performs the following operations: Step 1: Do not interfere with the default save process The plugin does not call the Cancel method of the event object (or explicitly sets cancel = false), allowing the spreadsheet software to continue executing its default local save logic.

[0114] Step 2: Save the spreadsheet locally. The spreadsheet software executes the save according to the user's preset method: if the file has been saved before, it will directly overwrite the original local file; if the file is newly created and not saved, a "Save As" dialog box will pop up, allowing the user to select the local save path.

[0115] Step 3: No additional operations required for the plugin. Throughout the entire saving process, the plugin does not initiate any network requests, upload any data, or display any reflow-related prompts on the interface. Users are completely unaware of the plugin's existence, and the experience is exactly the same as with the native spreadsheet software without the plugin installed.

[0116] Typical application scenarios: Scenario 1 (System File, Normal Backflow): A user exports "Project A Assessment Table.xlsx" from the power assessment system, edits multiple data points in WPS, modifies a formula (changing the weight from 0.3 to 0.35), and then presses Ctrl+S. The plugin determines that the file has a corresponding projectId in the local mapping table, so it cancels WPS's default local save and uploads the complete binary stream containing the new formula and calculation results to the server. The user sees a "Save Successful" message in the sidebar. The entire process takes less than 2 seconds, and the experience is almost indistinguishable from a local save.

[0117] Scenario 2 (Non-system file, allowed to save): The user opens "Personal Finance Table.xlsx" on their own computer, edits it, and presses Ctrl+S. The plugin cannot find a record for this file in the local mapping table, determines it as a non-system file, and allows it to be saved by default. The file is saved normally to the local disk, and the plugin does not perform any upload operation.

[0118] Scenario 3 (Fake File, Preventing Backflow): A malicious user manually creates an Excel file and adds a hidden worksheet with the same name as a system file, attempting to upload it to the server via a save operation. When this file is opened, it doesn't go through the normal export process, and there's no corresponding projectId or session identifier in the local mapping table. After the user edits and saves it, the plugin fails to query the mapping, determines it's a non-system file, and directly allows local saving without triggering a backflow upload, thus effectively preventing data corruption.

[0119] Please refer to Figure 4 The core process of the method provided by this invention includes: (1) When a user selects a project in the business system, the front end requests a short-term token (token) bound to the projectId from the back end.

[0120] (2) The front end calls the export interface, the back end fills in the basic data according to the template to generate xlsx, and returns an accessible URL.

[0121] (3) The front end wakes up the WPS client and opens the file via URL (OpenFromUrl).

[0122] (4) After the add-in is opened, it performs "system file marking" (hidden sheet) and session binding (sessionId, DocID / Name). (projectId mapping).

[0123] (5) Users can edit data / adjust formulas in WPS, and all complex formula calculations are completed by the native engine of WPS / Excel.

[0124] (6) When the user presses Ctrl+S or clicks WPS to save: the add-in only intercepts the save of "system files and session matching", triggering SaveAsUrl to upload to the backend / import.

[0125] (7) Backend receives and parses files: Reads the cached value (the final display value written when WPS saves) from the formula cell and puts it into the database, while also writing the version history and file storage.

[0126] (8) The user returns to the business system to refresh the page and reads the latest data from the database to complete the closed loop.

[0127] Key technical details include: (1) Controlled URLs and file reachability After the backend generates the xlsx file, it exposes the file as an HTTP URL ( / ExcelFile / xxx.xlsx) through static resource mapping. The frontend passes the URL to the WPS client to open it, avoiding the problem of "server disk path is unreachable on client".

[0128] (2) System file identification and session binding (only effective for system files) System files are written to a hidden worksheet as an indicator of invisibility when opened, and the sessionId and DocID / Name are recorded in the add-in store. The projectId mapping allows a postback to be triggered only if the system file identifier exists and the session matches.

[0129] (3) Native save interception (Ctrl+S / Save) and non-system allowance When the user presses Ctrl+S or clicks save: If the file is identified as a system file and the session matches, WPS will cancel the default save option and instead use SaveAsUrl to upload it to / import. Otherwise, allow WPS to save by default to ensure that users are not affected when opening other Excel files on their computers.

[0130] (4) Data parsing strategy that prioritizes cached values When parsing Excel on the backend, formula cells are not recalculated. Instead, the cached results corresponding to CachedFormulaResultType are read to maintain consistency with the WPS display and avoid inconsistencies caused by differences in the calculation engines between POI and WPS / Excel.

[0131] (5) Version binding and security control.

[0132] The backend issues a short-term token bound to the projectId. This token (header or query) is carried during both export and import. The backend verifies the context consistency between the token and the projectId to prevent cross-project / cross-version overwriting and implements traceable rollback based on version history.

[0133] (6) Database adaptation The persistence layer uses JPA, decoupling business code from database types and enabling migration and deployment between different relational databases.

[0134] (7) Microservices are compatible with different system access. The backend can be split into microservices based on export / import / token / project management, with unified routing handled by Nginx; the frontend can be deployed as a static site or a multi-entry micro-frontend. This implementation maintains interface consistency and independent scalability when multiple business systems access the system in parallel.

[0135] The server verifies the returned data: (1) Calculation engine difference verification (cached value vs. backend recalculation) Output the differences between cachedValue (WPS cache) and calculatedValue (POI recalculation) for each formula cell in the same Excel file via the consistency comparison interface: Uploaded file testing API: POST / test / consistency; The interface output includes totalFormulas, inconsistentCount, and details (sheet, cell, formula, cachedValue, calculatedValue). When inconsistentCount > 0, it objectively proves that "differences exist in the calculation engine" and that the "cached value priority strategy" ensures that the data returned to the database is consistent with the WPS display.

[0136] (2) Non-system files do not trigger postback verification. Compare the saving behavior of the two types of files: System files (opened from the business system and matching the session): Ctrl+S triggers interception and SaveAsUrl returns the imported files; Non-system files (any Excel file on the user's local computer): Ctrl+S will not trigger interception or return, and will completely use WPS's default save function to ensure that it does not affect the user's normal work.

[0137] This can be verified by comparing the front-end WebNotify logs: system file saves will show WorkbookBeforeSave / SaveAsUrl / return import requests; non-system file saves will not show the above requests and events.

[0138] In some embodiments, the power assessment report processing system for spreadsheet software may include multiple functional modules composed of computer program segments. The computer programs for each program segment in the power assessment report processing system for spreadsheet software may be stored in the memory of a computer device and executed by at least one processor to perform (see details). Figure 1 (Description) Functionality for processing power assessment reports in spreadsheet software.

[0139] In this embodiment, the power assessment report processing system for spreadsheet software can be divided into multiple functional modules based on its functions, such as... Figure 2 As shown. The module referred to in this invention is a series of computer program segments that can be executed by at least one processor and perform a fixed function, and is stored in memory. In this embodiment, the functions of each module will be described in detail in subsequent embodiments.

[0140] The report loading module is used to obtain the power assessment report issued by the server and load the power assessment report, which contains a system file identifier; The result calculation module is used to respond to the user's editing operation on the power assessment report, call the local calculation engine of the spreadsheet software to execute the assessment formula calculation and display the calculation result; The identifier determination module is used to determine whether the current report is a power assessment report with the system file identifier in response to a report saving command triggered by the user. The save interception module is used to intercept the default local save behavior of the spreadsheet software if the judgment result is yes, and to return the current complete data of the power assessment report and the version identifier of the assessment item to the server so that the server can extract the cached calculation results of the formula cells from the returned report and store them. The local save module is used to allow the default local save behavior if the judgment result is negative.

[0141] Although the present invention has been described in detail with reference to the accompanying drawings and preferred embodiments, the present invention is not limited thereto. Various equivalent modifications or substitutions can be made to the embodiments of the present invention by those skilled in the art without departing from the spirit and essence of the invention, and such modifications or substitutions should all be within the scope of the present invention. Any variations or substitutions that can be easily conceived by those skilled in the art within the technical scope disclosed in the present invention should also be covered within the protection scope of the present invention.

Claims

1. A power audit report processing method for a spreadsheet software installed with a plug-in, characterized by, include: Obtain the power assessment report issued by the server and load the power assessment report, which contains a system file identifier; In response to the user's editing operation on the power assessment report, the local calculation engine of the spreadsheet software is invoked to perform the assessment formula calculation and display the calculation results; In response to a user-triggered report save command, determine whether the current report is a power assessment report with the system file identifier; If the judgment result is yes, then the default local saving behavior of the spreadsheet software is intercepted, and the current complete data of the power assessment report and the version identifier of the assessment item are returned to the server, so that the server can extract the cached calculation results of the formula cells from the returned report and store them. If the judgment result is negative, then the default local saving behavior is allowed.

2. The method according to claim 1, characterized in that, The method for constructing the plugin includes: The front-end interface and logic of the plugin are constructed using a Web technology stack, which includes HTML and JavaScript. The plugin is deployed as a standalone web application on a web server, and its entry Uniform Resource Locator and required permissions are registered with the spreadsheet software via a configuration file. After the plugin is started, it calls the native capabilities of the spreadsheet software through the application programming interface provided by the spreadsheet software and realizes data communication with the server.

3. The method according to claim 2, characterized in that, To achieve data communication with the server, including: When the plugin starts, it obtains a short-term token from the server that is bound to the project identifier of the current assessment project. During the export phase, an export request carrying the project identifier is sent to the server, and the Uniform Resource Locator (URL) of the power assessment report returned by the server is received. During the reflow phase, in response to the intercepted save command, the application programming interface of the spreadsheet software is invoked to convert the current workbook into a binary stream, and an HTTP request carrying the binary stream, the project identifier, and the short-lived token is constructed and sent to the import interface of the server.

4. The method according to claim 1, characterized in that, In response to the user's editing operation on the electricity assessment report, the local calculation engine of the spreadsheet software is invoked to perform the assessment formula calculation and display the calculation results, including: After loading the power assessment report, the system requests formula configuration information that matches the current assessment item from the server. The formula configuration information defines the mapping relationship between the formula logic and the target cell position in the form of structured data. The formula configuration information is parsed, and the application programming interface provided by the spreadsheet software is called to dynamically write the formula logic into the corresponding target cell in the power assessment report; In response to the local calculation triggered by the written formula logic in the spreadsheet software, the calculation result is obtained and displayed.

5. The method according to claim 4, characterized in that, The methods for the server to generate the formula configuration information include: Based on the type or indicator of the assessment item, the corresponding formula rule is matched from the pre-configured formula rule library, which stores the mapping relationship between formula logic and target cell position; Based on the matched formula rules, generate formula configuration information that includes the formula logic and the target cell position; In response to the client's formula configuration request, the formula configuration information is sent to the plugin.

6. The method according to claim 5, characterized in that, Generate formula configuration information containing the formula logic and the target cell position, including: Identify the dynamic placeholders in the formula rules, whereby the dynamic placeholders correspond to the dynamic data of the current assessment item; Replace the dynamic placeholder with the actual value or actual reference address of the current assessment item to generate formula configuration information adapted to the current assessment item.

7. The method according to claim 1, characterized in that, After loading the power assessment report, the method further includes: The system checks whether there are any preset hidden worksheets or custom attributes in the power assessment report as system file identifiers. If it exists, then establish a mapping relationship between the current session identifier, report identifier and project identifier of the assessment project in the local storage of the plugin.

8. The method according to claim 7, characterized in that, In response to a user-triggered report save command, determine whether the current report is a power assessment report with the system file identifier, including: Retrieve the report identifier and current session identifier of the currently active report; Based on the report identifier and / or the session identifier, query whether the plugin's local storage contains a project identifier that has a mapping relationship with the report identifier and / or the session identifier; If the corresponding project identifier is found, it is determined that the current report has the system file identifier and is validly bound to the current assessment project session; If no corresponding project identifier is found, it is determined that the current report does not have a system file identifier.

9. A method for processing power assessment reports using spreadsheet software, characterized in that, Applied to the server side, the method includes: In response to the client's export request, an electricity assessment report containing a system file identifier is generated and returned to the client, so that the client can edit and calculate it locally through a plugin installed in the spreadsheet software; The system receives the report data and version identifier of the assessment item returned by the client after intercepting the report save command. The returned report data includes the formula cache result calculated by the local calculation engine of the spreadsheet software after the user edits it locally on the client. The returned report data is parsed, the cached result is read from the formula cell, and the cached result is stored in the database along with the version identifier.

10. A power assessment report processing system for spreadsheet software, used to execute the method according to any one of claims 1-7, characterized in that, include: The report loading module is used to obtain the power assessment report issued by the server and load the power assessment report, which contains a system file identifier; The result calculation module is used to respond to the user's editing operation on the power assessment report, call the local calculation engine of the spreadsheet software to execute the assessment formula calculation and display the calculation result; The identifier judgment module is used to respond to the report saving command triggered by the user and determine whether the current report is a power assessment report with the system file identifier; The save interception module is used to intercept the default local save behavior of the spreadsheet software if the judgment result is yes, and to return the current complete data of the power assessment report and the version identifier of the assessment item to the server so that the server can extract the cached calculation results of the formula cells from the returned report and store them. The local save module is used to allow the default local save behavior if the judgment result is negative.

Images