shuzheng/zheng

This is a multi-module Java web application framework providing a comprehensive suite of enterprise features, including user authentication, content management, payment processing, and real-time messaging. It offers a complete admin interface for managing users, roles, permissions, and system configurations, supported by a distributed RPC architecture using Dubbo and MyBatis. The system also includes utilities for file storage, caching, and code generation, all managed through a standardized, multi-environment configuration.

36 changes.

The project established a Maven multi-module structure, organizing the codebase into distinct functional areas such as CMS, UPMS, and Pay. This period focused on generating the initial data models, RPC service interfaces, and configuration files for each module, while also implementing standard error handling and utility classes across the system.

98 changes.

This period focused on expanding the platform's microservices architecture by introducing RPC interfaces, service implementations, and code generation utilities across CMS, payment, and user center modules. Simultaneously, the project significantly enhanced the admin dashboard with comprehensive user, role, and system management features, alongside a shift to Thymeleaf templates and improved logging and error handling.

The zheng-demo-rpc-service module now includes a complete Dubbo service provider implementation, including the \DemoService\ interface, its \DemoServiceImpl\ implementation, and a Spring XML configuration to expose it. A mock implementation (\DemoServiceMock\) is also provided for testing or fallback scenarios. Additionally, the service is now packaged with a full set of deployment and operational scripts (start, stop, restart, debug, and dump) for both Linux and Windows environments, facilitating easier server deployment and management.

zheng-demo/zheng-demo-rpc-service · high confidence

New MyBatis mapper interfaces (UcenterOauth, UcenterUserDetails, UcenterUserLog, UcenterUser, UcenterUserOauth) are introduced in the DAO layer, each providing standard CRUD operations (count, delete, insert, select, update) for their respective entities. Additionally, English and Chinese resource bundles are added to display standardized error messages for HTTP status codes 403, 404, 500, and a generic error state, enabling localized user feedback for these conditions.

zheng-ucenter/zheng-ucenter-dao/src/main/java/com/zheng/ucenter/dao/mapper, zheng-ucenter/zheng-ucenter-web/src/main/resources/i18n · high confidence

A new aspect, RpcLogAspect, has been added to log RPC provider and consumer details. The aspect records the start and end times of RPC calls and logs the consumer side status, remote IP, and service URL for each RPC invocation.

zheng-common/src/main/java/com/zheng/common/aspect · medium confidence

The zheng-upms RPC service layer now includes concrete implementations for managing users, roles, permissions, and organizations. This includes the new UpmsApiService for querying user permissions and roles, as well as service classes for managing user-role, user-organization, and user-permission associations. The implementation enforces that usernames must be unique and cannot be modified after creation. Additionally, the system now supports writing operation logs via UpmsLogService.

zheng-upms/zheng-upms-rpc-service/src/main/java/com/zheng/upms/rpc/service · high confidence

The zheng-cms-web module adds new Thymeleaf templates for the blog feature, including category and tag listing pages, an article detail page with a comment form, and a blog index page. These templates use Thymeleaf syntax to render dynamic content such as article titles, categories, tags, and comments, enabling the frontend to display blog-related data.

zheng-ui/zheng-cms-web · high confidence

The zheng-upms-common module now includes new constant classes (UpmsConstant, UpmsResult, and UpmsResultConstant) that define standardized return codes and messages for the UPMS system. This introduces specific result codes for login and validation scenarios, including success, failure, invalid length, empty username/password, and account/credential errors. These constants provide a centralized way to handle and interpret API responses across the system.

zheng-upms/zheng-upms-common · high confidence

A new ManageController is introduced to handle the backend dashboard at /manage/index, returning the /manage/index.jsp view. The controller includes Swagger annotations (@Api, @ApiOperation) to document the API. A corresponding ManageInterceptor is added to manage request processing for the admin area.

zheng-cms/zheng-cms-admin/src/main/java/com/zheng/cms/admin/controller · medium confidence

The CMS backend now includes new JSP views for managing content: \create.jsp\, \update.jsp\, and \index.jsp\ for articles, and \create.jsp\, \update.jsp\, and \index.jsp\ for comments. These templates provide the user interface for creating, editing, and listing articles and comments, supporting fields such as title, content, author, status, and associated system/topic identifiers.

zheng-cms/zheng-cms-admin/src/main/webapp/WEB-INF/jsp/manage/article · high confidence

A new abstract base class named AppController has been added to both the CMS search and Pay admin modules. This class serves as a common parent for controllers in each respective module, providing a shared foundation for controller implementations.

zheng-cms/zheng-cms-search/src/main/java, zheng-pay/zheng-pay-admin/src/main/java · high confidence

The admin console now includes new JSP views for managing categories and tags. Users can create, edit, and delete categories and tags through dedicated list pages and dialog forms, supporting fields for name, alias, description, icon, and type (normal or hot).

zheng-cms/zheng-cms-admin/src/main/webapp/WEB-INF/jsp/manage/tag · high confidence

The application now includes standard error pages for 403 (Forbidden), 404 (Not Found), 500 (Internal Server Error), and general exceptions, ensuring users see a consistent error display instead of raw stack traces or default container pages. The \web.xml\ configuration registers the Spring MVC dispatcher, character encoding filter, and error page mappings, establishing the core web infrastructure for the ucenter module.

zheng-ucenter/zheng-ucenter-web/src/main/webapp · high confidence

Added a demo page for Aliyun OSS upload that generates random filenames for uploaded files, and a main index page linking to it.

zheng-ui/zheng-oss-web · high confidence

The zheng-ucenter-rpc-service now includes an assembly configuration and shell/Windows batch scripts (start, stop, restart, dump, server) that package the application for deployment. The startup scripts handle launching the Java process, managing the Dubbo container, and performing diagnostic dumps (jstack, jmap, etc.). Configuration for Dubbo thread pool sizes (200 min/max) is provided in dubbo.properties.

zheng-ucenter/zheng-ucenter-rpc-service/src/main/assembly · high confidence

The zheng-common module now includes three new validation classes—LengthValidator, NotNullValidator, and SizeValidator—implemented via the Baidu fluent-validator framework. These validators enforce string length, non-null checks, and numeric range constraints, respectively, providing a standardized way to validate input data within the application.

zheng-common/src/main/java/com/zheng/common/validator · high confidence

New i18n resource files (messages\_en\_US.properties and messages\_zh\_CN.properties) were added to zheng-pay-admin, zheng-pay-web, and zheng-upms-server. These files define user-facing text for error states: 403 (Access forbidden), 404 (Page not found), 500 (Internal server error), and a generic error message. This change ensures that error pages display appropriate localized messages in both English and Chinese across these modules.

zheng-pay/zheng-pay-admin/src/main/resources/i18n, zheng-pay/zheng-pay-web/src/main/resources/i18n, zheng-upms/zheng-upms-server/src/main/resources/i18n · high confidence

The admin panel now includes a new Menu Management page (index.jsp) that lists all menus and provides buttons to create, edit, and delete them. The interface also adds 'Move Up' and 'Move Down' actions, allowing administrators to reorder menu items. The corresponding create and update forms (create.jsp, update.jsp) are introduced to handle the new menu data (parent, name, URL, target).

zheng-cms/zheng-cms-admin/src/main/webapp/WEB-INF/jsp/manage/menu · high confidence

Introduces a new Organization Management feature, providing a list view with server-side pagination and search, alongside create, edit, and delete actions. The update includes a new create.jsp form for adding organizations, an update.jsp form for editing them, and an index.jsp page that displays the organization table with toolbar buttons for CRUD operations.

(repo-wide) · high confidence

The role management interface now includes full CRUD capabilities for roles. Users can create new roles and edit existing ones via dedicated forms that capture the role's name, title, and description. Additionally, a new permission assignment dialog allows administrators to select and save role permissions using a tree-structured interface. These changes implement the core role management functionality within the application.

zheng-upms/zheng-upms-server/src/main/webapp/WEB-INF/jsp/manage/role · high confidence

The system management module now includes JSP views for listing, creating, and updating system configurations. Users can perform create, update, and delete operations via pop-up dialogs, with actions gated by Shiro permissions (upms:system:create, update, delete). The forms support fields for title, name, icon, theme color, background image upload (via WebUploader to OSS), description, and status, with server-side pagination and search enabled on the list view.

zheng-upms/zheng-upms-server/src/main/webapp/WEB-INF/jsp/manage/system · high confidence

The user management module now includes a full-featured interface for creating, editing, and deleting users, along with dedicated dialogs for assigning user organizations, roles, and permissions. The interface supports dynamic pagination and integrates with the OSS service for avatar uploads. Users can manage user attributes, assign multiple organizations and roles, and configure specific permissions through a tree-based interface that supports adding and removing permissions.

zheng-upms/zheng-upms-server/src/main/webapp/WEB-INF/jsp/manage/user · high confidence

The system now provides full CRUD and management capabilities for users, organizations, roles, permissions, systems, sessions, and logs. Administrators can create, update, and delete these entities, as well as manage user roles, user organizations, and user permissions. The user controller includes password hashing with a random salt and enforces unique usernames. Session management allows listing active sessions and forcing logout. Log management provides listing and deletion of system logs. All controllers use standard JSON responses and require specific permissions (e.g., upms:user:read, upms:role:permission).

zheng-upms/zheng-upms-server/src/main/java/com/zheng/upms/server/controller/manage · high confidence

The zheng-message module introduces a real-time notification system, pairing a Netty-based backend with a Socket.IO frontend. This change adds a README outlining the technology stack and provides several HTML demo pages (ack-index, binary-event, event, index) that implement chat and file-upload interactions using the Socket.IO JavaScript client. The client-side code connects to the server at localhost:9092, handling connection, message, and disconnect events, as well as acknowledgment callbacks and binary data handling.

zheng-message/zheng-message-server · high confidence

The zheng-oss-admin module now includes its own set of configuration files and error pages. This includes environment-specific profiles (dev, test, prod) for Redis and authentication settings, internationalization messages for error codes, and JSP templates for 403, 404, 500, and general error states. The application context and Spring MVC servlet configurations are also established to support these resources.

zheng-oss/zheng-oss-admin · high confidence

The project now includes the Bootstrap v3.3.4 CSS framework, providing standard styling for components like buttons, forms, and grid layouts. This adds a new visual baseline for the application's user interface.

zheng-cms/zheng-cms-web/src/main/webapp/resources · high confidence

A new CmsWebInterceptor has been introduced to handle common web processing tasks. It retrieves application name and UI path from configuration properties and fetches the list of CMS menus, making them available as request attributes for the view layer.

zheng-cms/zheng-cms-web/src/main/java/com/zheng/cms/web/interceptor · high confidence

The zheng-api-rpc-service module now includes assembly configuration and shell/batch scripts to support deploying and managing the Dubbo container. This includes start, stop, restart, and dump (diagnostic) scripts for Linux, along with a Windows batch file for starting the service, enabling easier deployment on low-configuration Linux servers.

zheng-api/zheng-api-rpc-service/src/main/assembly · high confidence

Introduced a Maven assembly configuration and a set of shell/Windows batch scripts to package and manage the Dubbo RPC service. The assembly creates a distributable archive containing the application binaries, configuration files (including a new dubbo.properties with thread pool settings), and runtime dependencies. Management scripts (start, stop, restart, debug, and dump) are added to the bin directory, enabling users to easily start, stop, and monitor the Dubbo container, supporting both Linux and Windows environments.

zheng-cms/zheng-cms-rpc-service/src/main/assembly, zheng-upms/zheng-upms-rpc-service/src/main/assembly · high confidence

New shell and batch scripts (start.sh, stop.sh, restart.sh, dump.sh, server.sh) and a Windows batch file (start.bat) were added to the assembly package, enabling users to start, stop, restart, and perform diagnostic dumps (jstack, jmap, etc.) for the Dubbo application. The configuration file (dubbo.properties) was also added, setting the Dubbo thread pool size to 200 to reduce thread pool shrinkage overhead.

zheng-pay/zheng-pay-rpc-service/src/main/assembly · high confidence

The admin template (zheng-admin) now includes the My97 DatePicker v4.8 Beta4, providing a date and time selection interface for users. This addition includes the core JavaScript files (WdatePicker.js, calendar.js), language packs for English and Chinese (Simplified/Traditional), and CSS styles for the default and 'whyGreen' themes, enabling date picking functionality within the backend management system.

(repo-wide) · high confidence

New MyBatis mapper XML files were added to the RPC service layer, providing SQL mapping for the pay module's core entities. This includes mappers for PayInOrder, PayInOrderDetail, PayOutOrder, PayOutOrderDetail, PayMch, PayPay, PayType, and PayVendor, enabling database operations for these tables.

zheng-pay/zheng-pay-rpc-service/src/main/java · high confidence

New MyBatis mapper interfaces have been added for the UPMS data models, including UpmsLog, UpmsOrganization, UpmsPermission, UpmsRole, UpmsRolePermission, UpmsSystem, UpmsUser, UpmsUserOrganization, UpmsUserPermission, and UpmsUserRole. Each interface provides standard CRUD operations (count, delete, insert, select, update) via the MyBatis framework, enabling database interactions for these entities.

zheng-upms/zheng-upms-dao/src/main/java/com/zheng/upms/dao/mapper · high confidence

New MyBatis mapper interfaces have been added for the pay module, including PayInOrder, PayInOrderDetail, PayMch, PayOutOrder, PayOutOrderDetail, PayPay, PayType, PayVendor, and PayVest. Each interface provides standard CRUD operations (count, delete, insert, select, update) to support database interactions for these entities.

zheng-pay/zheng-pay-dao/src/main/java/com/zheng/pay/dao/mapper · high confidence

The zheng-cms-rpc-api module now includes new service interfaces and corresponding mock implementations for managing CMS entities, including articles, categories, tags, comments, menus, pages, settings, system configurations, and topics. These interfaces define the remote procedure call contracts for the CMS system, while the mock classes provide fallback implementations for service degradation, ensuring the system can gracefully handle failures in the CMS module.

zheng-cms/zheng-cms-rpc-api · high confidence

The zheng-cms-rpc-service module now includes new service implementations for managing CMS entities, including articles, categories, tags, comments, menus, pages, settings, system configurations, and topics. Additionally, custom MyBatis mapper interfaces and XML configurations have been added to support article retrieval by category or tag, enabling the backend to fetch and count articles based on these associations.

zheng-cms/zheng-cms-rpc-service/src/main/java/com/zheng/cms/rpc/service · high confidence

Added new Java classes for RocketMQ integration: a Producer that sends test messages to 'PushTopic' and a Consumer that listens to them, both configured with a local NameServer address (127.0.0.1:9876).

zheng-cms/zheng-cms-web/src/main/java/com/zheng/cms/web/rocketmq · high confidence

A new utility for generating distributed, time-sortable unique identifiers was added to the common package. The implementation follows the Twitter Snowflake algorithm, combining a timestamp, datacenter ID, worker ID, and a sequence number into a 64-bit long. To support high-concurrency scenarios, the generator relies on a custom \SystemClock\ class that caches the current time in an \AtomicLong\ updated by a background thread, avoiding the performance overhead of repeated \System.currentTimeMillis()\ calls.

zheng-common/src/main/java/com/zheng/common/util/key · high confidence

A new UpmsInterceptor has been added to the server-side request processing chain. This interceptor retrieves the current user's information via the UpmsApiService and attaches it to the request attributes, making the user data available to views. It also exposes the Aliyun OSS policy configuration to the request scope. Additionally, the interceptor filters out AJAX requests to avoid redundant processing.

zheng-upms/zheng-upms-server/src/main/java/com/zheng/upms/server/interceptor · high confidence

The zheng-admin application now includes the WebUploader 0.1.5 plugin, adding a new file upload component. This introduces a new UI for file selection and drag-and-drop uploads, along with the necessary CSS styles and JavaScript logic to handle file selection, validation, and upload processes within the admin interface.

zheng-admin/src/plugins/webuploader-0.1.5 · high confidence

The zheng-ui/zheng-oss-web/plugins/webuploader-0.1.5 plugin has been added, introducing a new file upload capability. This includes the webuploader.css stylesheet for styling upload components and the webuploader.min.js script, which implements drag-and-drop, paste, and file picker features for HTML5-based file uploads.

zheng-ui/zheng-oss-web/plugins/webuploader-0.1.5 · high confidence

A new scheduled task named 'TestTaskImpl' has been added to the CMS web module. This component runs every 10 minutes to execute a test method that prints 'Task' to the console, providing a mechanism for periodic background execution.

zheng-cms/zheng-cms-web/src/main/java/com/zheng/cms/web/task · high confidence

Introduced new CSS files for the admin module: admin.css defines the layout and styling for the main dashboard header, sidebar, and tabbed content area; common.css provides shared utility styles and form controls; and login.css styles the login window and form fields. These styles support the new admin interface, including responsive adjustments for mobile devices and the addition of close buttons for tabs.

zheng-admin/src/css · high confidence

A new Generator class has been added to the DAO module, providing a main method to automatically generate MyBatis mapper, service, and implementation code based on configurable database and package settings.

zheng-cms/zheng-cms-dao/src/main/java/com/zheng/cms/dao · high confidence

The code generator now produces additional artifacts: Spring MVC controllers (Controller.vm), RPC service interfaces (Service.vm), service implementations (ServiceImpl.vm), and mock service classes (ServiceMock.vm). Additionally, a MyBatis Generator configuration template (generatorConfig.vm) is provided, which configures the generation of model classes, mapper XMLs, and client interfaces with specific plugins for serialization, caching, and comment suppression.

zheng-common/src/main/resources/template · high confidence

A new Generator class has been added to the zheng-upms-dao module, providing a configurable entry point for automatically generating MyBatis-related code such as models, mappers, and services. The utility reads database connection details and module settings from a generator configuration file, allowing developers to regenerate DAO and service layers based on the existing database schema.

zheng-upms/zheng-upms-dao/src/main/java/com/zheng/upms/dao · high confidence

A new Generator class has been added to the zheng-ucenter-dao module. This utility automates the generation of MyBatis artifacts (such as models and mappers) by reading database connection details from a properties file and applying a configurable table prefix and package structure.

zheng-ucenter/zheng-ucenter-dao/src/main/java/com/zheng/ucenter/dao · high confidence

A new Generator utility class has been added to the DAO module. This tool automates the generation of MyBatis mapping files and model classes based on database schema, allowing developers to quickly scaffold data access components by configuring connection details and package names.

zheng-pay/zheng-pay-dao/src/main/java/com/zheng/pay/dao · high confidence

The application now includes new configuration files to support Thymeleaf templating, Redis caching, and Dubbo RPC service consumption. Specifically, \springMVC-servlet.xml\ configures the Thymeleaf template engine and view resolver, while \applicationContext-dubbo-consumer.xml\ defines references to remote services like \UcenterOauthService\ and \UcenterUserService\ via Zookeeper. Additionally, \redis.properties\ provides connection details for Redis, and \config.properties\ defines paths for static resources.

zheng-ucenter/zheng-ucenter-web/src/main/resources · high confidence

The admin template (zheng-admin) now includes three new frontend plugins to enhance the user interface. First, 'awesome-bootstrap-checkbox' provides CSS styling for checkboxes and radio buttons with support for Bootstrap colors and states. Second, 'checkbix' adds animated, customizable checkboxes with JavaScript support for dynamic initialization. Third, 'jquery-confirm' introduces a jQuery plugin for displaying styled, animated alert and confirmation dialogs. These additions allow for more interactive and visually consistent form controls and user prompts within the admin interface.

(repo-wide) · high confidence

The webapp now includes dedicated JSP templates for handling HTTP errors and exceptions. A new index page serves as the default welcome page. Custom error pages are defined for 403 (Forbidden), 404 (Not Found), and 500 (Internal Server Error) status codes, as well as a general error page for unhandled exceptions. These templates display user-friendly messages and error details, improving the user experience when encountering errors.

zheng-oss/zheng-oss-web/src/main/webapp · high confidence

New generator.properties files have been added to the zheng-cms and zheng-upms DAO modules. These files configure the code generator with a MySQL connection to the 'dbserver' host on port 3306, using the 'zheng' database. This allows the respective modules to generate database access code based on this specific database connection.

zheng-cms/zheng-cms-dao/src/main/resources, zheng-upms/zheng-upms-dao/src/main/resources · high confidence

The zheng-pay-sdk module now includes a default App class and its corresponding unit test, providing a basic entry point and test coverage for the SDK.

zheng-pay/zheng-pay-sdk · high confidence

New web-layer components were added to the zheng-demo application. An IndexController was introduced to handle requests for JSP and Thymeleaf views, utilizing a DemoService to populate model attributes. Additionally, a DemoInterceptor was added to manage request pre-processing, specifically filtering out AJAX requests based on headers.

zheng-demo/zheng-demo-web/src/main/java · medium confidence

A new AliyunOssService was introduced to generate signed policies for direct client-side uploads to Aliyun OSS. This enables the frontend to upload files directly to the cloud storage service, including a callback mechanism that notifies the application about upload details such as file size, MIME type, and image dimensions.

zheng-oss/zheng-oss-web/src/main/java/com/zheng/oss/web/service · high confidence

The zheng-cms-job module now includes dedicated JSP templates for handling HTTP errors and status codes. Specifically, new files have been added for 403 (Forbidden), 404 (Not Found), 500 (Internal Server Error), a generic error page, and an index page. These templates provide user-facing feedback for common error conditions, with the 403 and error pages displaying exception details and messages to assist with debugging or user guidance.

zheng-cms/zheng-cms-job/src/main/webapp/WEB-INF/jsp · high confidence

The zheng-admin module now includes a dedicated login page (login.html) and a main dashboard (index.html) that supports full-page scrolling via the fullPage.js library. The index.html template features a header with system switching, a sidebar with navigation menus, and a main content area. The crud.html template provides a generic interface for creating, reading, updating, and deleting records using Bootstrap tables. Additionally, the fullPage.js plugin (version 2.9.2) and its dependencies have been added to support the full-page scrolling functionality.

zheng-admin/src · high confidence

A new JSP page for log management has been added at zheng-upms/zheng-upms-server/src/main/webapp/WEB-INF/jsp/manage/log/index.jsp. This page provides a user interface to view system logs, displaying details such as the operator, operation time, duration, request path, and IP address. It supports server-side pagination, searching, and allows administrators to select and delete specific log entries.

zheng-upms/zheng-upms-server/src/main/webapp/WEB-INF/jsp/manage/log · high confidence

Introduced new JavaScript files for the admin module: login.js handles the login form submission and input effects; admin.js implements sidebar navigation, system switching, and tabbed iframe management with right-click context menu actions (close, refresh, etc.); common.js provides shared utilities like dynamic height calculation and input styling. These files collectively enable the core user interactions for the admin template.

zheng-admin/src/js · high confidence

Added a suite of new utility classes in the \zheng-common\ module to support application functionality. This includes \AESUtil\ for encrypting and decrypting configuration passwords, \CaptchaUtil\ for generating image-based verification codes, and \CookieUtil\ for managing HTTP cookies. The update also introduces \EhCacheUtil\ and \RedisUtil\ for caching operations, alongside \JdbcUtil\ for database interactions and \JmsUtil\ for JMS messaging. Additionally, \MybatisGeneratorUtil\ and \VelocityUtil\ are added to support automated code generation for MyBatis and service layers, while \SpringContextUtil\ provides access to the Spring application context. Other additions include \JarUtil\ for extracting resources, \RequestUtil\ for handling HTTP requests, and \StringUtil\ for string manipulation.

zheng-common/src/main/java/com/zheng/common/util · high confidence

New scripts and configuration files have been added to the project-tools directory to simplify local development. A Windows batch script (nginx.bat) and corresponding Nginx configuration files (nginx.conf, server configs for zheng-config and zheng-ui) are provided to start, stop, and restart Nginx on Windows. Additionally, batch and shell scripts (ngrok.bat, ngrok.sh) along with an ngrok configuration file are included to manage ngrok tunneling for ports 7771 and 1000/1001.

project-tools · high confidence

A new README.md file has been added to the project-bootstrap directory, serving as an introduction to the project and containing resources such as module dependency diagrams and topology diagrams.

project-bootstrap · high confidence

New scheduled task classes, LongSchedule and MapSchedule, have been added to the web module. These classes implement the IScheduleTaskDealSingle interface to handle scheduled jobs for Long and Map data types respectively, each logging execution status and defining task selection and comparison logic.

zheng-cms/zheng-cms-web/src/main/java/com/zheng/cms/web/schedule · medium confidence

A new Initialize class has been added to the server module, implementing the BaseInterface to handle system initialization logic. This provides a dedicated entry point for startup procedures, logging an informational message upon initialization.

zheng-upms/zheng-upms-server/src/main/java/com/zheng/upms/server · high confidence

A new TestController was added to expose a /test endpoint that calls the ApiService, and a DefaultMessageQueueListener was introduced to consume JMS text messages using a thread pool for asynchronous processing.

zheng-api/zheng-api-server/src/main/java · medium confidence

Introduced new RPC API interfaces for the ucenter module, including UcenterApiService, UcenterOauthService, UcenterUserDetailsService, UcenterUserLogService, UcenterUserOauthService, and UcenterUserService, each with corresponding mock implementations for fallback behavior. Additionally, added common constant classes UcenterConstant, UcenterResult, and UcenterResultConstant to support the new service layer.

zheng-ucenter/zheng-ucenter-rpc-api · high confidence

Added new model classes and their corresponding example/query classes for the user center module, including UcenterOauth, UcenterUser, UcenterUserDetails, and UcenterUserLog, along with their respective Example classes for database querying.

zheng-ucenter/zheng-ucenter-dao/src/main/java/com/zheng/ucenter/dao/model · high confidence

Introduced new web controllers to demonstrate object storage functionality. Added AliyunOssController to handle policy generation and upload callbacks for Aliyun OSS, and DemoController to provide endpoints for uploading and downloading files via Aliyun OSS. Also added QiniuDemo as a standalone example for Qiniu cloud storage integration.

zheng-oss/zheng-oss-web/src/main/java/com/zheng/oss/web/controller · high confidence

A new Shiro realm, UpmsRealm, has been introduced in the upms-client module to centralize user authentication and role/permission authorization. For users, this means login and access checks are now handled through a unified client-side authentication flow that supports both standard password-based login and a password-less client mode (triggered when zheng.upms.type is set to 'client'). The realm fetches user roles and permissions via the UpmsApiService, ensuring consistent authorization checks across the application.

zheng-upms/zheng-upms-client/src/main/java/com/zheng/upms/client/shiro/realm · medium confidence

The codebase now includes auto-generated Java model classes for the payment domain, including \PayInOrder\, \PayInOrderDetail\, \PayMch\, \PayOutOrder\, \PayOutOrderDetail\, and \PayPay\, along with their corresponding \Example\ query classes. These classes provide the data structures and query criteria builders used by the data access layer to interact with the database.

zheng-pay/zheng-pay-dao/src/main/java/com/zheng/pay/dao/model · high confidence

Added new MyBatis mapper interfaces and corresponding model classes for CMS entities including articles, categories, comments, menus, pages, settings, system configurations, tags, and topics. Each entity includes an Example class for query construction, enabling developers to perform database operations on these CMS resources.

zheng-cms/zheng-cms-dao/src/main/java/com/zheng/cms/dao/model · high confidence

The zheng-ucenter-rpc-service module has been initialized with the core data access and service layers for the user center. This includes MyBatis XML mappers and Java service implementations for UcenterUser, UcenterUserDetails, UcenterUserLog, UcenterOauth, and UcenterUserOauth. The service is configured to start via the Alibaba Dubbo container.

zheng-ucenter/zheng-ucenter-rpc-service/src/main/java · high confidence

The zheng-cms-rpc-service module now includes its own set of configuration files, enabling it to connect to external services independently. This includes a JDBC configuration for master and slave database connections, a Redis cache configuration, an Ehcache XML definition for local memory/disk caching, and a Log4j properties file that routes logs to daily-rotating files and the console. These changes allow the RPC service to operate with its own data source and caching layers, separate from other modules.

zheng-cms/zheng-cms-rpc-service/src/main/resources · high confidence

The application now supports Alipay mobile and PC website payments, with configuration files defining the Alipay client, trade request beans, and environment-specific properties for dev, test, and prod. Additionally, the webapp's default homepage is set to /index.jsp, a thread pool is configured for background tasks, and logging is structured by date with separate error logs.

zheng-pay/zheng-pay-web/src/main/resources · high confidence

The zheng-cms-admin module is introduced with its foundational configuration files. This includes Spring XML configurations for ActiveMQ, Dubbo consumers, Ehcache, thread pools, and the zhengAdmin utility. It also adds properties for Redis, logging (log4j), and environment-specific settings (dev, test, prod) covering Redis, ActiveMQ, and OSS endpoints, alongside client-side properties for zheng-admin, zheng-upms, and zheng-oss integration.

zheng-api/zheng-api-server/src/main/resources, zheng-cms/zheng-cms-admin/src/main/resources, zheng-ucenter/zheng-ucenter-rpc-service/src/main/resources · high confidence

The zheng-cms-search service is now fully configured with dedicated resource files. A Dubbo consumer configuration defines remote service references (CMS, category, comment, and tag services) with fallback handling enabled. A thread pool executor is configured with a core size of 50, max size of 1000, and a queue capacity of 20,000. Logging is set up to write to daily-rotating files in the ../logs directory. Environment-specific properties (dev, test, prod) are provided to set the application name and profile. Finally, the default homepage is set to /index.jsp.

zheng-cms/zheng-cms-search/src/main/resources · medium confidence

The application now includes its foundational configuration files, including \config.properties\ for environment and Aliyun OSS settings, \log4j.properties\ for time-based log rotation, and \springMVC-servlet.xml\ for Thymeleaf and Spring MVC setup. Additionally, internationalized error messages for 403, 404, 500, and generic errors are provided in both English and Chinese.

zheng-oss/zheng-oss-web/src/main/resources · high confidence

Added foundational configuration files for the zheng-pay-admin module, including a Spring-based thread-pool setup (corePoolSize 50, maxPoolSize 1000, queueCapacity 20000), a log4j logging configuration that writes to console and daily-rotating files (../logs/zheng-pay-admin.log and ../logs/zheng-pay-admin.error.log), environment-specific profile properties (dev, test, prod) that set the active environment, and a Spring MVC servlet configuration that maps the root path '/' to /index.jsp as the default home page.

zheng-pay/zheng-pay-admin/src/main/resources · high confidence

The zheng-demo web module now includes its foundational configuration files, establishing the runtime environment for the application. This adds Dubbo consumer setup for service discovery and RPC, a JavaMail sender with an asynchronous thread pool for email notifications, and a Thymeleaf view resolver configured for UTF-8 encoding. Additionally, the change introduces logging configuration via Log4j with daily-rotating files, a properties file for application metadata, and an OSS client configuration for cloud storage integration.

zheng-demo/zheng-demo-web/src/main/resources · high confidence

The zheng-api subsystem is now structured with a shared constants module (zheng-api-common) and an RPC API module (zheng-api-rpc-api). The common module adds ApiConstant, ApiResult, and ApiResultConstant to standardize API response codes and messages. The RPC module defines the ApiService interface with a hello method and provides a mock fallback implementation (ApiServiceMock) for graceful degradation. These changes establish the foundational API contract and common utilities for the zheng-api system.

zheng-api/zheng-api-common, zheng-api/zheng-api-rpc-api · medium confidence

Added new constant and result classes for the CMS module: CmsConstant, CmsResult, and CmsResultConstant. CmsResult extends BaseResult and uses CmsResultConstant to provide standardized success, failure, and error responses (e.g., file type not supported, invalid length/parameter). This unifies how the CMS system returns results to users.

zheng-cms/zheng-cms-common · medium confidence

Added new controllers for single sign-on (SSO) and the admin backend. The SSO controller handles login, logout, and code validation via Redis, supporting back-url redirection and remember-me functionality. The ManageController provides the backend home page, displaying registered systems and user permissions. These changes implement the core authentication and dashboard features for the UPMS server.

zheng-upms/zheng-upms-server/src/main/java/com/zheng/upms/server/controller · high confidence

Added UpmsAuthenticationFilter and UpmsSessionForceLogoutFilter to the zheng-upms-client module. The authentication filter now supports a 'client' mode that validates a code via HTTP to the SSO server and performs password-less login using the username from the request parameters. It also manages local Redis-based session caching and redirects unauthenticated users to the SSO login page. The new force-logout filter handles forced session invalidation by redirecting to the login page with a forceLogout flag.

zheng-upms/zheng-upms-client/src/main/java/com/zheng/upms/client/shiro/filter · high confidence

The zheng-cms-job module is introduced with new resource files that configure ActiveMQ-based message queue consumption (including a transactional JMS container and default listeners), Dubbo RPC consumer references for CMS services (articles, categories, comments, tags) with mock fallbacks, a Spring thread pool executor for task scheduling, and a default MVC view mapping to /index.jsp. Environment-specific properties (dev, test, prod) are added to support multi-environment configuration for ActiveMQ broker URLs.

zheng-cms/zheng-cms-job/src/main/resources · high confidence

The zheng-pay-rpc-api module now includes new Java interfaces and their corresponding mock implementations for various payment-related entities, including PayInOrder, PayOutOrder, PayMch, PayPay, PayType, PayVendor, and PayVest. Each service interface extends a common BaseService, while the mock classes extend BaseServiceMock, providing a foundation for the payment architecture.

zheng-pay/zheng-pay-rpc-api · high confidence

A new common package under zheng-common/base introduces a generic BaseService interface and its abstract implementation, providing standard CRUD and pagination methods. The implementation automatically switches the database connection: read operations (queries) use the slave data source, while write operations (insert, update, delete) use the master data source. This is achieved via a DynamicDataSource utility that manages thread-local data source context, falling back to the default master source if none is specified. Additionally, a BaseResult class is added to standardize API response formats, and a BaseInterface is provided for system initialization callbacks.

zheng-common/src/main/java/com/zheng/common/base · high confidence

Adds new classes for the OSS system: OssConstant for configuration values (endpoint, bucket name, max size, expire time), OssResult for result handling, and OssResultConstant for status codes. Additionally, introduces an XML configuration file (applicationContext-oss.xml) that uses Spring to manage the Aliyun OSS client bean, separating SDK logic from configuration.

zheng-oss/zheng-oss-sdk · high confidence

The application now exposes dedicated controller endpoints for user sign-up, sign-in, sign-out, and password reset. The SignController handles GET/POST requests for /signup, /signin, /signout, and /password\_reset, returning Thymeleaf template views or JSON responses. Additionally, a new UcenterWebInterceptor is introduced to manage pre- and post-request processing, including filtering AJAX requests and setting application context attributes like app name and UI path.

zheng-ucenter/zheng-ucenter-web/src/main/java · high confidence

The pay module now includes a new set of shared constants and result wrappers to standardize API responses. PayConstant defines success and failed status strings, while PayResult and PayResultConstant provide a structured way to handle API responses with specific codes and messages for success and failure states.

zheng-pay/zheng-pay-common · high confidence

Added new MyBatis Generator plugins to enhance code generation: SerializablePlugin makes generated model and Example classes implement java.io.Serializable (and optionally GWT's IsSerializable) to support distributed environments; PaginationPlugin adds limit/offset fields and XML logic for MySQL pagination; CommentGenerator adds JavaDoc comments to generated model fields based on database remarks.

zheng-common/src/main/java/com/zheng/common/plugin · high confidence

The zheng-cms-admin module now includes new Spring MVC controllers for managing CMS entities: articles, categories, comments, menus, pages, settings, tags, and topics. Each controller exposes RESTful endpoints for list, create, update, and delete operations, with Swagger 2 annotations for API documentation. The controllers implement consistent validation using FluentValidator and return standardized CmsResult responses. Menu management includes up/down reordering endpoints. All controllers use JSP view resolution for their index pages.

zheng-cms/zheng-cms-admin/src/main/java/com/zheng/cms/admin/controller/manage · high confidence

The zheng-upms-rpc-api module now exposes a comprehensive set of RPC service interfaces for the Upms system, including UpmsApiService, UpmsLogService, UpmsOrganizationService, UpmsPermissionService, UpmsRolePermissionService, UpmsRoleService, UpmsSystemService, UpmsUserOrganizationService, UpmsUserPermissionService, UpmsUserRoleService, and UpmsUserService. Each interface is paired with a corresponding mock implementation (e.g., UpmsApiServiceMock) that provides service degradation, ensuring the system can gracefully handle failures or unavailability of the actual service implementations.

zheng-upms/zheng-upms-rpc-api · high confidence

Added new XML and properties configuration files to the zheng-cms-web module's resources directory. These include Spring context configurations for ActiveMQ, Dubbo consumer services, Ehcache, and thread pools, alongside property files for Redis, logging (log4j), and general application settings. This establishes the web layer's integration with message queues, remote services, caching, and logging.

zheng-cms/zheng-cms-web/src/main/resources · high confidence

Added two new utility classes in the client module: RequestParameterUtil, which filters out specific request parameters (upms\_code, upms\_username) from URLs, and SerializableUtil, which handles the serialization and deserialization of HTTP sessions using Base64 encoding. These utilities support session management and request handling within the UPMS client.

zheng-upms/zheng-upms-client/src/main/java/com/zheng/upms/client/util · high confidence

The zheng-upms-server module now includes a comprehensive set of new configuration files and Spring XML definitions to support its role as a Dubbo consumer and internal service provider. This includes applicationContext-dubbo-consumer.xml which registers Dubbo references for Upms services (system, organization, user, role, permission, log, and API) with mock fallbacks, alongside dedicated configurations for Ehcache caching (applicationContext-ehcache.xml, ehcache.xml, shiro-ehcache.xml), thread pooling (applicationContext-threadpool.xml), and zhengAdmin integration. Additionally, environment-specific properties (dev, test, prod) and client property files (zheng-upms-client, zheng-admin-client, zheng-config-client, zheng-oss-client) are introduced to manage runtime settings for Redis, SSO, and OSS, while log4j.properties and springMVC-servlet.xml configure logging and JSP view resolution.

zheng-upms/zheng-upms-server/src/main/resources · high confidence

A change to existing behaviour in zheng-admin/src/images — 3 commits, 18 files.

zheng-admin/src/images · medium confidence · unverified

Users can now complete payments via Alipay on both desktop and mobile web platforms. The new AlipayController exposes endpoints for PC and mobile web payment flows, handling the generation of payment requests and processing asynchronous notification callbacks with signature verification.

zheng-pay/zheng-pay-web/src/main/java · high confidence

The admin dashboard now supports dynamic system switching and dynamic menu rendering. Users can switch between different systems via a dropdown in the header, which updates the sidebar menu and header title based on the selected system's permissions and configuration. The sidebar menu is dynamically generated from the ${upmsPermissions} list, filtering and displaying menu items specific to the current system. Additionally, the header includes a system switcher that iterates over ${upmsSystems} to allow users to change the active system context.

zheng-upms/zheng-upms-server/src/main/webapp/WEB-INF/jsp/manage · medium confidence

The application now supports distinct configuration profiles for dev, test, and prod environments. Each profile in the \profiles\ directory defines environment-specific settings for Aliyun OSS, including endpoints, bucket names (e.g., \shuzheng\, \shuzheng\_prod\, \shuzheng\_test\), and callback URLs, allowing the web application to adapt its storage and upload behavior based on the active environment.

zheng-oss/zheng-oss-web/src/main/resources/profiles · medium confidence

The zheng-cms-rpc-service now includes dedicated configuration files for dev, test, and prod environments. Each profile defines the application name, environment identifier, and connection details for the MySQL database (pointing to 'dbserver') and Redis cache (pointing to 'rdserver'). This allows the service to adapt its database and cache endpoints based on the active environment.

zheng-cms/zheng-cms-rpc-service/src/main/resources/profiles · medium confidence

A new Session Management page has been added, allowing administrators to view user sessions with their current status: online, offline, or kicked (force\_logout). The interface includes a table displaying session details such as creation time, last access time, IP address, and user agent. Administrators can select one or more sessions and use the 'Force Logout' button to immediately terminate those sessions, which will cause the affected users to be logged out and redirected to the login page.

zheng-upms/zheng-upms-server/src/main/webapp/WEB-INF/jsp/manage/session · medium confidence

A new LogAspect class has been introduced to automatically intercept controller methods and record detailed operational logs. This aspect captures request metadata (IP, URI, method, parameters), extracts operation descriptions and permissions from annotations, measures execution time, and serializes the response result to JSON for easier log analysis. The aspect ensures that every controller execution is logged with comprehensive context, facilitating better monitoring and debugging of API interactions.

zheng-upms/zheng-upms-client/src/main/java/com/zheng/upms/client/interceptor · medium confidence

The application now provides localized error messages for HTTP 403, 404, 500, and a generic server error in both English (messages\_en\_US.properties) and Chinese (messages\_zh\_CN.properties). This ensures that users see appropriate error text in their preferred language when encountering these common error conditions.

zheng-cms/zheng-cms-web/src/main/resources/i18n · high confidence

Introduced new resource files to support multi-environment configuration and logging. This includes a config.properties file for application and environment variables, a log4j.properties file that routes logs to daily-rotating files and the console, and property files for JDBC and Redis connections that use placeholders for environment-specific values.

zheng-pay/zheng-pay-rpc-service/src/main/resources · high confidence

The application now displays custom JSP templates for HTTP error codes 403, 404, and 500, as well as a general error page for unhandled exceptions. These pages are configured in web.xml to handle specific error codes and exception types, ensuring users see a consistent error interface rather than default server pages.

zheng-api/zheng-api-server/src/main/webapp · high confidence

A new 'generator.properties' file was added to the DAO module's resources, defining the JDBC driver, URL (pointing to 'dbserver' on port 3306), and credentials for the code generator. This change updates the database connection details used by the code generation process, moving from a local host address to a specific server host.

zheng-ucenter/zheng-ucenter-dao/src/main/resources · medium confidence

The search module now includes its own set of JSP templates for handling common HTTP status codes and the default landing page. Specifically, new files have been added for 403 (Forbidden), 404 (Not Found), 500 (Internal Server Error), a generic error page, and the main index page. These templates provide consistent user-facing responses for errors and the default view within the search application.

zheng-cms/zheng-cms-search/src/main/webapp/WEB-INF/jsp · high confidence

New JSP templates have been added to both the admin and web modules to handle common HTTP error states and general exceptions. Specifically, the application now provides dedicated views for 403 (Forbidden), 404 (Not Found), and 500 (Internal Server Error) conditions, as well as a generic error page that displays exception details. This ensures that users see a consistent, styled error page rather than a raw stack trace or browser default when these errors occur.

zheng-pay/zheng-pay-admin/src/main/webapp/WEB-INF/jsp, zheng-pay/zheng-pay-web/src/main/webapp/WEB-INF/jsp · high confidence

New properties files (dev.properties, test.properties, prod.properties) have been added to the profiles directory, each defining the environment (dev, test, or prod), the application name (zheng-ucenter-web), and the zheng.ui.path pointing to the UI static resource path (http://ui.zhangshuzheng.cn:1000/). This enables the application to load different configuration settings depending on the active environment.

zheng-cms/zheng-cms-web/src/main/resources/profiles, zheng-demo/zheng-demo-web/src/main/resources/profiles, zheng-ucenter/zheng-ucenter-web/src/main/resources/profiles · high confidence

The zheng-upms-rpc-service now includes dedicated property files for the dev, test, and prod environments. Each file defines environment-specific settings for the MySQL database (pointing to 'dbserver') and Redis (pointing to 'rdserver'), along with the application name. This change enables the service to dynamically load the correct database and cache connections based on the active profile, replacing the previous single configuration approach.

zheng-api/zheng-api-rpc-service/src/main/resources/profiles, zheng-pay/zheng-pay-rpc-service/src/main/resources/profiles, zheng-upms/zheng-upms-rpc-service/src/main/resources/profiles · medium confidence

The application now includes internationalized error messages for HTTP status codes 403, 404, and 500, as well as a generic error message. These messages are defined in the new \messages\_en\_US.properties\ and \messages\_zh\_CN.properties\ files, providing English and Chinese translations for user-facing error states.

zheng-demo/zheng-demo-web/src/main/resources/i18n, zheng-wechat-mp-service · low confidence

The admin application now includes dedicated JSP templates for handling common error states, ensuring users see appropriate messages for 403 (Forbidden), 404 (Not Found), 500 (Internal Server Error), and general exceptions. Additionally, the root index page now automatically redirects to the /manage/index route, establishing the default landing page for the admin interface.

zheng-cms/zheng-cms-admin/src/main/webapp/WEB-INF/jsp · high confidence

The admin interface now displays localized error messages for common HTTP status codes (403, 404, 500) and a generic error state in both English and Chinese. This ensures that users see appropriate, language-specific feedback when encountering access denied, page not found, or internal server errors.

zheng-cms/zheng-cms-admin/src/main/resources/i18n, zheng-cms/zheng-cms-job/src/main/resources/i18n · high confidence

The admin module now includes custom error pages for 403, 404, and 500 status codes, as well as a general error page for unhandled exceptions, which will display user-friendly messages instead of default server errors. Additionally, logging is configured via log4j to output to console and daily-rotating files, and a thread pool is defined for asynchronous request handling.

zheng-wechat/zheng-wechat-mp/zheng-wechat-mp-admin · medium confidence

The admin portal's main page now redirects users to an external Single Sign-On and admin interface at http://upms.zhangshuzheng.cn:1111/. This replaces the previous local JSP-based landing page, effectively making the CMS admin area a gateway to the separate zheng-admin application.

zheng-cms/zheng-cms-admin/src/main/webapp/WEB-INF/jsp/manage · high confidence

A new ApplicationContextListener has been added to automatically invoke the initMapper method on all beans annotated with @BaseService, and call the init method on all beans implementing the new BaseInterface during Spring container initialization. This ensures that these components are properly initialized as soon as the application context is fully loaded.

zheng-common/src/main/java/com/zheng/common/listener · high confidence

Session handling for zheng-upms-client has been consolidated into the client module, introducing a Redis-based session storage and a custom session model that tracks online status and user-agent details. Users benefit from shared session state across services and the ability to remotely force-logout active sessions, with expired sessions automatically filtered from the active list.

zheng-upms/zheng-upms-client/src/main/java/com/zheng/upms/client/shiro/session · medium confidence

The database connection settings for the code generator have been updated to point to the 'dbserver' host on port 3306, replacing the previous '127.0.0.1' address. The configuration now includes specific JDBC parameters for Unicode and auto-reconnect behavior.

zheng-pay/zheng-pay-dao/src/main/resources · medium confidence

The zheng-admin admin template now uses shared JSP includes for the head and footer sections. This refactors the static resources by consolidating common CSS and JavaScript dependencies (such as Bootstrap, jQuery, and zTree) into reusable templates, which should simplify maintenance and ensure consistent styling and script loading across the admin pages.

zheng-upms/zheng-upms-server/src/main/webapp/resources · high confidence

The project has introduced shared JSP templates for the admin panel's head and footer sections. These new files, located in the resources/inc directory, centralize the inclusion of CSS and JavaScript libraries (such as Bootstrap, jQuery, and various plugins) and common tag libraries. This change allows the admin interface to reuse these components across different pages, ensuring consistent styling and script loading.

zheng-cms/zheng-cms-admin/src/main/webapp/resources · high confidence

The CMS web application's front-end controllers (Blog, Index, News, Page, Qa, Search, and Topic) have been updated to render views using Thymeleaf templates instead of the previous JSP-based view resolution. This change affects how the CMS renders its public-facing pages, including the homepage, article listings, category and tag pages, and single-page content, ensuring that all returned templates are processed by the Thymeleaf engine.

zheng-cms/zheng-cms-web/src/main/java/com/zheng/cms/web/controller · high confidence

The web application now includes a default index page and a web.xml configuration that sets up Spring MVC with character encoding, context listeners, and session management. This establishes the foundational structure for the demo application.

zheng-demo/zheng-demo-web/src/main/webapp · medium confidence

Added a new Generator utility class that uses MyBatis to auto-generate DAO/Entity code based on database metadata. The module now includes jdbc.properties and redis.properties files that externalize connection details. Database URLs and credentials are now referenced via placeholders (e.g., ${datasource.master.jdbc.driver}), and Redis hostnames are set to 'rdserver' instead of hardcoded localhost, supporting multi-environment configuration.

zheng-wechat/zheng-wechat-mp/zheng-wechat-mp-dao · medium confidence

The ZhengApiRpcServiceApplication entry point has been updated to launch the Dubbo container via com.alibaba.dubbo.container.Main, replacing the previous startup mechanism. Additionally, the ApiServiceImpl class now implements the ApiService interface with a basic hello method, reflecting the new RPC service structure.

zheng-api/zheng-api-rpc-service/src/main/java, zheng-cms/zheng-cms-rpc-service/src/main/java/com/zheng/cms/rpc · medium confidence

The ucenter frontend pages have been converted from the previous template format to Thymeleaf templates. This change updates the underlying template engine used to render the user center interface, which may affect how templates are structured and how resources are referenced within the ucenter-web module.

zheng-ui/zheng-ucenter-web · medium confidence

A new login page for the SSO (single sign-on) flow has been added at zheng-upms/zheng-upms-server/src/main/webapp/WEB-INF/jsp/sso/login.jsp. The page provides username and password fields, a 'remember me' checkbox, and integrates with Shiro authentication. It also handles forced logout scenarios by displaying an alert and redirecting to the login page, and includes JavaScript to break out of iframes on session timeout.

zheng-upms/zheng-upms-server/src/main/webapp/WEB-INF/jsp/sso · medium confidence

The default message queue listener classes in the admin, job, and web modules have been updated to follow Alibaba Java Coding Guidelines. Specifically, the \DefaultMessageQueueListener\ in each module now uses \org.slf4j.Logger\ for logging instead of the previous implementation, and the \onMessage\ method processes \TextMessage\ payloads by submitting them to a \ThreadPoolTaskExecutor\ for asynchronous handling. These changes ensure consistent, thread-safe, and compliant message consumption across all three components.

zheng-cms/zheng-cms-admin/src/main/java/com/zheng/cms/admin/jms, zheng-cms/zheng-cms-job/src/main/java, zheng-cms/zheng-cms-web/src/main/java/com/zheng/cms/web/jms · medium confidence

Added new JSP templates for handling HTTP errors and default routing. Specifically, 403 (Forbidden), 404 (Not Found), 500 (Internal Server Error), and a generic error page (error.jsp) have been introduced to provide consistent user feedback. The 403 and error pages include logic to distinguish between AJAX requests and standard page loads, while the 500 page displays detailed exception information. Additionally, a new index.jsp has been added to redirect users to the /manage/index path, unifying the default landing page.

zheng-upms/zheng-upms-server/src/main/webapp/WEB-INF/jsp · high confidence

The application now provides consistent, user-friendly error pages for common HTTP status codes (403, 404, 500) and general exceptions. These JSP templates display specific error codes, descriptive messages, and in the case of 500 errors, a fallback redirect to the homepage. This change ensures that users see a clear, branded error page rather than a default server error, improving the user experience during unexpected failures or access denials.

zheng-cms/zheng-cms-web/src/main/webapp/WEB-INF/jsp · high confidence

The zheng-api-rpc-service now includes dedicated configuration files to standardize its runtime behavior. A new config.properties file defines the application name and environment profile, while a new log4j.properties file configures structured logging. This setup routes logs to the console and splits output into time-based daily log files (zheng-api-rpc-service.log and zheng-api-rpc-service.error.log) located in the ../logs directory, ensuring consistent log formatting and separation of error logs.

zheng-api/zheng-api-rpc-service/src/main/resources · medium confidence

The RPC service application now uses the Alibaba Dubbo container's Main class for startup, replacing the previous Spring Boot-based entry point. This change aligns the service with the Dubbo Main startup approach, which may affect how the service is launched and configured in development and production environments.

zheng-upms/zheng-upms-rpc-service/src/main/java/com/zheng/upms/rpc · medium confidence

The data models for the UPMS module have been updated, including the addition of a new 'role' field. This change affects the database schema and the corresponding Java model classes (such as UpmsLog, UpmsOrganization, UpmsPermission, UpmsRole, and UpmsSystem) and their example query classes, ensuring the codebase aligns with the latest system data table structures.

zheng-upms/zheng-upms-dao/src/main/java/com/zheng/upms/dao/model · medium confidence

The project's data model has been updated with new SQL scripts and migration files. This includes the addition of a user center module with tables for user profiles, authentication methods, and operation logs, as well as updates to the CMS module with tables for articles, categories, comments, and tags. The changes also include a README file explaining how to use PowerDesigner to manage the data model and generate SQL scripts.

project-datamodel · medium confidence

The zheng-upms-rpc-service module now includes its own set of resource files, separating configuration from shared modules. This includes log4j.properties for time-splitting log output, ehcache.xml for local caching, and properties files for JDBC (master/slave) and Redis connections. The config.properties file also introduces environment variable placeholders for app.name and profile.env.

zheng-upms/zheng-upms-rpc-service/src/main/resources · medium confidence

Added a new unit test for the UpmsService, specifically testing the countByExample method via the UpmsSystemService, to verify system count retrieval.

zheng-upms/zheng-upms-rpc-service/src/test, zheng-upms/zheng-upms-server/src/test · high confidence

The project is now organized as a Maven multi-module build, with a root \pom.xml\ defining the \zheng\ parent artifact and declaring sub-modules including \zheng-admin\, \zheng-common\, \zheng-oss\, \zheng-upms\, \zheng-cms\, \zheng-pay\, \zheng-ucenter\, \zheng-wechat\, \zheng-shop\, \zheng-api\, \zheng-message\, and \zheng-demo\. Each module is configured with Java 1.7 compilation, and the \zheng-common\ module establishes a shared dependency management block that pins versions for Spring 4.3.20, Shiro 1.3.2, MyBatis 3.4.2, and other core libraries, ensuring consistent dependency resolution across the project.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 26 → 23 (-3.2)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 26 → 25 (-0.6)
• Architecture 100 → 98 (-2.2)
• Maturity 48 → 31 (-17.4)
• Readiness 12 → 10 (-2.1)
• Security 58 → 55 (-3.0)
• Accessibility 36 → 32 (-3.7)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 11) (zheng-common/src/main/java/com/zheng/common/base/BaseServiceImpl.java)
• Duplicated block (10 lines × 2) (zheng-common/src/main/java/com/zheng/common/plugin/PaginationPlugin.java)
• Duplicated block (10 lines × 2) (zheng-upms/zheng-upms-rpc-service/src/main/java/com/zheng/upms/rpc/service/impl/UpmsPermissionServiceImpl.java)
• Duplicated block (10 lines × 3) (zheng-cms/zheng-cms-web/src/main/java/com/zheng/cms/web/controller/BlogController.java)
• Duplicated block (10 lines × 3) (zheng-cms/zheng-cms-web/src/main/java/com/zheng/cms/web/controller/BlogController.java)
• Duplicated block (10 lines × 3) (zheng-cms/zheng-cms-web/src/main/java/com/zheng/cms/web/controller/BlogController.java)
• Duplicated block (10 lines × 4) (zheng-cms/zheng-cms-dao/src/main/java/com/zheng/cms/dao/model/CmsTopic.java)
• Duplicated block (11 lines × 6) (zheng-cms/zheng-cms-dao/src/main/java/com/zheng/cms/dao/model/CmsMenu.java)
• Duplicated block (11 lines × 6) (zheng-common/src/main/java/com/zheng/common/base/BaseServiceImpl.java)
• Duplicated block (12 lines × 2) (zheng-cms/zheng-cms-job/src/main/java/com/zheng/cms/job/jms/DefaultMessageQueueListener.java)
• Duplicated block (12 lines × 2) (zheng-common/src/main/java/com/zheng/common/base/BaseServiceImpl.java)
• Duplicated block (12 lines × 2) (zheng-common/src/main/java/com/zheng/common/util/AESUtil.java)
• Duplicated block (12 lines × 2) (zheng-upms/zheng-upms-rpc-service/src/main/java/com/zheng/upms/rpc/service/impl/UpmsPermissionServiceImpl.java)
• Duplicated block (12 lines × 4) (zheng-message/zheng-message-server/src/main/java/com/zheng/message/server/ChatLauncher.java)
• Duplicated block (13 lines × 2) (zheng-api/zheng-api-server/src/main/java/com/zheng/api/server/jms/DefaultMessageQueueListener.java)
• Duplicated block (14 lines × 2) (zheng-cms/zheng-cms-dao/src/main/java/com/zheng/cms/dao/model/CmsPage.java)
• Duplicated block (15 lines × 10) (zheng-cms/zheng-cms-dao/src/main/java/com/zheng/cms/dao/model/CmsArticleCategory.java)
• Duplicated block (15 lines × 2) (zheng-cms/zheng-cms-dao/src/main/java/com/zheng/cms/dao/model/CmsComment.java)
• …and 62 more

• (anonymous) (cognitive 91) (zheng-admin/src/plugins/waves-0.7.5/waves.js)
• (anonymous) (cyclomatic 74) (zheng-admin/src/plugins/waves-0.7.5/waves.js)
• (anonymous)::(anonymous)::(anonymous)::(anonymous)::main (cognitive 29) (zheng-admin/src/plugins/select2/js/select2.full.js)
• (anonymous)::(anonymous)::(anonymous)::(anonymous)::main (cognitive 29) (zheng-admin/src/plugins/select2/js/select2.js)
• (anonymous)::(anonymous)::(anonymous)::(anonymous)::main (cyclomatic 22) (zheng-admin/src/plugins/select2/js/select2.full.js)
• (anonymous)::(anonymous)::(anonymous)::(anonymous)::main (cyclomatic 22) (zheng-admin/src/plugins/select2/js/select2.js)
• (anonymous)::(anonymous)::(anonymous)::(anonymous)::normalize (cognitive 63) (zheng-admin/src/plugins/select2/js/select2.full.js)
• (anonymous)::(anonymous)::(anonymous)::(anonymous)::normalize (cognitive 63) (zheng-admin/src/plugins/select2/js/select2.js)
• (anonymous)::(anonymous)::(anonymous)::(anonymous)::normalize (cyclomatic 32) (zheng-admin/src/plugins/select2/js/select2.full.js)
• (anonymous)::(anonymous)::(anonymous)::(anonymous)::normalize (cyclomatic 32) (zheng-admin/src/plugins/select2/js/select2.js)
• (anonymous)::(anonymous)::(anonymous)::apply (cognitive 74) (zheng-admin/src/plugins/select2/js/select2.full.js)
• (anonymous)::(anonymous)::(anonymous)::apply (cognitive 74) (zheng-admin/src/plugins/select2/js/select2.js)
• (anonymous)::(anonymous)::(anonymous)::apply (cyclomatic 40) (zheng-admin/src/plugins/select2/js/select2.full.js)
• (anonymous)::(anonymous)::(anonymous)::apply (cyclomatic 40) (zheng-admin/src/plugins/select2/js/select2.js)
• (anonymous)::(anonymous)::(anonymous)::fromElement (cognitive 29) (zheng-admin/src/plugins/select2/js/select2.full.js)
• (anonymous)::(anonymous)::(anonymous)::fromElement (cognitive 29) (zheng-admin/src/plugins/select2/js/select2.js)
• (anonymous)::(anonymous)::(anonymous)::fromElement (cyclomatic 23) (zheng-admin/src/plugins/select2/js/select2.full.js)
• (anonymous)::(anonymous)::(anonymous)::fromElement (cyclomatic 23) (zheng-admin/src/plugins/select2/js/select2.js)
• (anonymous)::(anonymous)::(anonymous)::handler (cognitive 28) (zheng-admin/src/plugins/select2/js/select2.full.js)
• (anonymous)::(anonymous)::(anonymous)::handler (cyclomatic 27) (zheng-admin/src/plugins/select2/js/select2.full.js)
• …and 158 more

• Containers 0 added · 0 removed · contexts 1 added · 1 removed · edges 0 added · 0 removed

• zheng-demo-web

• zheng-wechat-mp-service

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

shuzheng/zheng was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.