phil-guo/maruko

This system is a modular backend framework that supports both .NET (Maruko) and Java (Act) ecosystems, providing foundational infrastructure for rapid application development. It offers generic CRUD services, multi-ORM data access (Entity Framework Core, FreeSql, SqlSugar, MongoDB), and integrated tools for authentication, caching, logging, and background job scheduling. The framework also includes specific administrative modules for user and role-based access control, dynamic page configuration, and automated code generation to scaffold standard application components.

16 changes.

The project restructured into a modular architecture, migrating the .NET core to .NET Core 3.1 and introducing support for multiple ORMs including Entity Framework Core, SqlSugar, and MongoDB. It established foundational abstractions such as generic CRUD services, unit of work patterns, and attribute-driven object mapping, while adding modules for background jobs, code generation, and ASP.NET Core MVC integration.

36 changes.

This period focused on establishing the core Zero module for system administration, implementing user, role, and menu management with JWT authentication and seed data. It also expanded the framework's infrastructure by integrating FreeSql for data access, adding dynamic configuration capabilities for page layouts, and introducing a Quartz-based task scheduling module.

10 changes.

This period focused on establishing the foundational architecture of the act-framework, including core utilities for CRUD operations, caching, and security. It involved the initial implementation and configuration of the Zero and StarMap modules, covering administrative services, RBAC, and API documentation. Concurrently, a new Quartz-based task scheduling system was introduced in the Maruko project to handle background jobs.

A new WebModule has been added to the core web library to register the IHttpContextAccessor as a singleton service, enabling components within the application to access the current HTTP context.

src/Maruko.Core.Web · high confidence

New Data Transfer Objects have been introduced to support page detail retrieval and data dictionary functionality within the configuration service. This includes \GetPageDetailDTO\ for fetching page details, \PageConfigDTO\ for managing page-specific configurations (such as data URLs, row settings, and field definitions), \PageDTO\ for basic page metadata, and \SysDataDictionaryDTO\ for handling data dictionary entries (keys, values, groups, and basic data flags). These DTOs facilitate the mapping between the application layer and the underlying domain entities for these specific configuration features.

dynamic/Maruko.Dynamic.Config/Internal/Service/DTO · high confidence

Introduced a new Autofac module (FreeSqlModule) that registers the FreeSql database context as a singleton, configures the generic FreeSql repository pattern, and automatically scans the referenced assembly to register any types ending in 'Service' as their implemented interfaces.

src/Maruko.FreeSql · high confidence

Introduced a new MongoDB persistence layer consisting of a base repository (MongoDbBaseRepository) providing CRUD operations (insert, update, delete, search) and a context class (MongoDbContext) for managing MongoDB connections using configurable settings (connection string, database name, credentials).

src/Maruko.MongoDB/MongoDBRepos · high confidence

The application now includes a new NLog module that configures the logging infrastructure. This module registers NLog as the logging provider via the standard ASP.NET Core logging interface and loads the NLog configuration from the 'nlog.config' file during application initialization.

src/Maruok.Core.NLog · high confidence

Introduced a new Unit of Work implementation for the SqlSugar ORM. This adds the ISugarUnitOfWork interface and the SugarUnitOfwork class, which provide access to the SqlSugarClient instance and implement the standard IUnitOfWork contract (including Dispose, Commit, Rollback, and CommitAndRefreshChanges methods, though some transaction methods currently throw NotImplementedException). This allows the application to manage database transactions using SqlSugar within the existing dependency injection and unit of work patterns.

src/Maruko.SqlSugarCore/UnitOfWork · high confidence

Introduced new entity classes (Page, SysMenu, SysOperate, SysRole, SysRoleMenu, SysUser) that define the database schema for core system resources, including page definitions, hierarchical menu structures with operation permissions, role management, and user profiles.

zero/Maruko.Zero/Internal/Domain · high confidence

Introduced the IPageDomainService interface and its PageDomainService implementation to support fetching detailed page information. The GetPageDetail method retrieves a page by its key, associates it with its configuration, and returns the data via GetPageDetailDTO, enabling consumers to access specific page details and their associated configurations.

dynamic/Maruko.Dynamic.Config/Internal/Domain/DomainService · high confidence

The system now supports retrieving specific operations (permissions) associated with a menu for a given role. This is achieved through new service methods \GetMenuOfOperate\ and \GetMenuOfOperateByRole\ in the \OperateService\, which calculate the intersection of menu and role permissions or fetch operations by menu key and role ID. Corresponding request and response DTOs have been added to handle these queries.

zero/Maruko.Zero/Internal/Service/Operate · high confidence

Introduced a new set of Data Transfer Objects (DTOs) within the internal user service layer to support user authentication and profile management. These include LoginVM for handling login credentials, ResetPasswordRequest for password reset operations, SearchSysUserRequest for paginated user searches, SysUserDTO for representing user entities with role associations, and UpdatePersonalInfoRequest for modifying user profile details such as username, password, and icon.

zero/Maruko.Zero/Internal/Service/User/DTO · high confidence

Introduced the ISysUserService interface in the zero/Maruko.Zero/Internal/Service/User location, defining core user management capabilities. This interface extends ICurdAppService to provide standard CRUD operations for SysUser entities and adds specific methods for resetting passwords, handling user login, and updating personal information.

zero/Maruko.Zero/Internal/Service/User · high confidence

This change introduces foundational infrastructure for the web layer: a new BaseCurdController provides standard CRUD endpoints (page search, create/update, single and batch remove) with optional authorization; a new BaseStartup class configures JWT authentication, global exception filtering, Swagger generation (with a toggle via AppConfig), CORS, and static file serving for uploads; a SwaggerFileUploadAttribute and its associated filter enable proper Swagger documentation for file uploads; and a RemovesDTO supports batch deletion requests.

src/Maruko.Core.Web/Internal · high confidence

The module now supports automatic mapping configuration using the \AutoMapAttribute\. By applying this attribute to a type, the system automatically registers bidirectional mappings between the source and specified target types during initialization, eliminating the need for manual mapping profile definitions. This is powered by \AutoMapperObjectMapper\ which implements the core object mapping interface, and \MapperInitialize\ which scans assemblies for types decorated with the attribute to configure the AutoMapper instance.

src/Maruko.AutoMapper/AutoMapper · high confidence

This change introduces the Maruko.AspNetMvc library, providing a foundational setup for ASP.NET Core MVC applications. It includes configuration extensions to enable JWT authentication (with custom token validation and caching), Swagger API documentation, and static file serving. The package adds global filters for standardized exception handling and model validation, returning consistent API responses. It also provides utility classes for role definitions, cache key generation, image processing via SkiaSharp, and Google Authenticator (2FA) support.

src/Maruko.AspNetMvc · high confidence

A new EntityFrameworkCoreModule class has been added to the Maruko.EntityFrameworkCore project. This module inherits from KernelModule and includes references to Autofac and Microsoft.Extensions.DependencyInjection, establishing the foundational structure for integrating Entity Framework Core within the application's module system.

src/Maruko.EntityFrameworkCore · high confidence

The StarMap module is introduced with its core application entry point and a set of configuration classes that establish the module's runtime behavior. This includes JWT-based authentication via an interceptor (excluding public endpoints like Swagger docs and auth tokens), Swagger/Knife4j API documentation generation scoped to the module's controllers, and extensions for caching, MyBatis-Plus, and global exception handling. A configuration service is also added to support Redis key prefixing via environment properties.

act/act-modules/act-modules-starmap/src/main/java/com/act/modules/starmap · high confidence

The \src/Maruko.CodeGeneration\ module has been introduced to provide a code-generation engine that scaffolds standard application-layer, domain, Entity Framework Core, and Web API components for projects built on the Maruko framework. It generates application service interfaces and implementations, domain repository interfaces, EF Core repository classes and base units of work, and ASP.NET Core controllers, while also wiring up the corresponding Autofac modules and extension methods. This allows developers to automatically produce the boilerplate CRUD structure for new entities within a Maruko solution.

src/Maruko.CodeGeneration · high confidence

This change introduces the application-layer services for the system's foundational administrative features. It adds support for managing system data dictionaries, configuring pages and their layouts, and handling the full role-based access control (RBAC) lifecycle including menu trees, operation permissions, and role assignments. Additionally, it implements user management capabilities such as login, password resets, and profile updates, providing the backend logic required for these core administrative functions.

act/act-modules/act-modules-zero/src/main/java/com/act/modules/zero/internal · high confidence

The Zero module now includes its primary application entry point, ZeroApplication, which initializes the Spring Boot context. This component is configured to scan for MyBatis mappers within the com.act.modules.zero.internal.mapper package, enabling the module's data access layer to function correctly upon startup.

act/act-modules/act-modules-zero/src/main/java/com/act/modules/zero, act/act-modules/act-modules-zero/target/classes/com/act/modules/zero · high confidence

This change introduces the core backend service for managing system roles and their associated permissions. It adds the \RoleService\ implementation which enables retrieving all roles and assigning specific menu permissions to a role via the \SetRolePermission\ method. The service handles the logic for parsing permission strings, updating the role-menu relationship table, and prevents the deletion of the super administrator account (ID 1). Supporting Data Transfer Objects (DTOs) for roles, menus, and permission requests are also added to facilitate these operations.

zero/Maruko.Zero/Internal/Service/Role · high confidence

The application now includes initial seed data for the permission and role management module. This adds default system menus (such as button, role, menu, and user management), standard operation permissions (add, edit, query, delete, permission), a default 'Administrator' role, and an initial admin user account. These seeds establish the foundational structure for the system's access control and navigation upon first run.

zero/Maruko.Zero/Internal/Seed · high confidence

The new ZeroModule initializes the zero/Maruko.Zero area by configuring database migrations and seeding initial data. It registers entities such as SysUser, SysMenu, SysRole, and related mapping tables for structure synchronization, and inserts default seed data for menus, operations, roles, role-menu mappings, and system users, controlled by the AppConfig settings.

zero/Maruko.Zero · high confidence

The new TaskScheduling module integrates the Quartz library to provide background task management capabilities. It registers the Quartz scheduler factory within the dependency injection container and supports database schema synchronization for scheduling structures via FreeSql. Additionally, it includes a specific implementation for oil price strategy tasks, registered as a keyed service for dependency resolution.

taskScheduling/Maruko.TaskScheduling · high confidence

This change introduces the foundational configuration classes for the Zero module, establishing how the application handles security, documentation, caching, and data access. Specifically, it adds an InterceptorConfig that enforces JWT authentication on all API endpoints while explicitly excluding the login token endpoint and Swagger documentation paths. It also configures Knife4j to generate API documentation for the Zero controllers, sets up ZeroCacheConfig and ZeroMybatisPlusConfig to inherit core caching and MyBatis-Plus behaviors, and registers ZeroExceptionHandler to manage global error responses.

act/act-modules/act-modules-zero/src/main/java/com/act/modules/zero/config · high confidence

The application now includes Hangfire to manage background tasks. This adds a dashboard accessible at /hangfire with permissive authorization, registers an in-memory storage provider by default, and exposes a service interface (IHangfireJob) that allows scheduling recurring jobs via cron expressions, enqueuing background jobs, and delaying execution.

src/Maruko.Hangfire · high confidence

Added the \EfCoreBaseUnitOfWork\ class and \IEfUnitOfWork\ interface to provide a concrete Unit of Work pattern for Entity Framework Core. This implementation manages the \DbContext\ lifecycle, including commit, rollback, and change tracking operations, and exposes methods for executing raw SQL commands and managing entity states within the EF Core context.

src/Maruko.EntityFrameworkCore/UnitOfWork · high confidence

Users can now configure the FreeSql ORM provider via application settings. A new AppConfig class reads the 'FreeSql' configuration section, and the FreeSqlOption class exposes the database type (defaulting to MySQL), allowing users to specify the database provider through configuration.

src/Maruko.FreeSql/Config · high confidence

Added a new internal application service layer for FreeSql that provides generic Create, Read, Update, and Delete capabilities. The \CurdAppService\ implements \PageSearch\ for paginated queries with dynamic condition filtering and \CreateOrEdit\ for inserting or updating entities, while the \FreeSqlContext\ initializes the FreeSql ORM instance with global soft-delete filters. This change introduces the core infrastructure for data access operations using the FreeSql provider.

src/Maruko.FreeSql/Internal/AppService · high confidence

The application now includes a new SqlSugarCore module that provides an abstract base class for configuring and instantiating SqlSugar database clients. This component allows users to define connection strings and optionally enable SQL logging via Log4net, simplifying the setup of database interactions within the Maruko framework.

src/Maruko.SqlSugarCore · high confidence

Added the IMarukoSugarRepository interface and MarukoSugarRepository class to provide a data access layer backed by the SqlSugar ORM. This implementation supports standard CRUD operations (insert, update, delete, and single entity retrieval) and exposes a SugarQuery method for advanced querying, integrating with the existing ISugarUnitOfWork for transaction management.

src/Maruko.SqlSugarCore/Reponsitory · high confidence

Added a new internal task scheduling module that enables managing and executing scheduled jobs via a REST API. The system includes a \TaskSchedulingController\ exposing endpoints to start (\executeAsync\) and stop (\closeAsync\) tasks, backed by a strategy pattern (\StrategyBase\) that integrates with Quartz for job scheduling. A specific implementation, \OilPriceJob\, is provided to scrape oil prices from a public website, parse the HTML, and persist the data into the \AllCountryOilPrice\ database table. The module also defines the necessary domain models (\TaskScheduling\, \AllCountryOilPrice\), DTOs, and service layers to support this functionality.

taskScheduling/Maruko.TaskScheduling/Internal · high confidence

The application now exposes a \ZeroOption\ configuration section that allows users to control whether database migrations and seed data initialization are enabled. These settings, defaulting to disabled, are loaded via the new \AppConfig\ class and can be adjusted in the application's configuration file to manage initial data setup and schema updates.

zero/Maruko.Zero/Config · high confidence

The act-framework-core module now provides foundational building blocks for application development, including a generic CurdAppService and BaseController that enable standard Create, Read, Update, and Delete operations with dynamic filtering and pagination. It adds a global exception handler to standardize error responses, a JWT interceptor for authentication, and a Redis configuration with utility classes for caching. Additionally, it includes a Caffeine cache configuration, a MyBatis-Plus pagination interceptor, and utility classes for context management and data mapping.

act/act-framework/act-framework-core · high confidence

A new abstract base class, FreeSqlEntity, has been added to the internal infrastructure. This class establishes a standard entity structure for FreeSql-based repositories by defining a long integer primary key with auto-increment (identity) behavior, a creation timestamp, and a boolean flag for soft deletion. Entities inheriting from this base class will automatically gain these common auditing and lifecycle management capabilities.

src/Maruko.FreeSql/Internal · high confidence

The library now provides an abstract \BaseDbContext\ class that extends \DbContext\ to serve as the foundation for database context implementations. This class introduces a \ConnStr\ property for connection string management and a generic \CreateSet\ method designed to handle entity sets for \FullAuditedEntity\ types, utilizing a concurrent dictionary to cache set instances. This change establishes the core abstraction for Entity Framework Core usage within the framework.

src/Maruko.EntityFrameworkCore/Context · high confidence

The task scheduling module now includes \AppConfig\ and \ScheduleOption\ classes to manage configuration settings. \AppConfig\ loads the \Schedule\ section from the application configuration, while \ScheduleOption\ defines the \EnableDatabaseMigrate\ boolean property, allowing users to control whether database migrations are enabled during scheduled tasks.

taskScheduling/Maruko.TaskScheduling/Config · high confidence

This change introduces the foundational structure for the Maruko framework, adding a generic CRUD application service layer with built-in object mapping, a standard repository interface supporting batch operations, and a specification pattern for complex query composition. It also defines core domain entities with auditing and soft-delete capabilities, standard DTOs for paging and filtering, and validation attributes for data integrity.

src/Maruko · high confidence

The Maruko.Dynamic.Config module has been introduced to manage dynamic application settings and handle database schema synchronization. It includes an AppConfig class that loads DynamicConfigOption settings (such as EnableDatabaseMigrate) from the configuration system, and a DynamicModule that automatically migrates database structures for Page, PageConfig, and SysDataDictionary entities when the migration flag is enabled.

dynamic/Maruko.Dynamic.Config · high confidence

The dynamic configuration service now exposes new internal API endpoints to manage page configurations, retrieve detailed page information, and access system data dictionaries. Users can now perform CRUD operations on page configurations via the \/api/v1/pageConfigs/\ endpoint, fetch specific page details by key using the \getPageDetail\ action on \/api/v1/pages/\, and query data dictionary entries by group name via the \getDictionaryByGroup\ action on \/api/v1/sysDataDictionaries/\. These changes consolidate page and dictionary management within the configuration service, providing a unified interface for accessing these foundational data structures.

dynamic/Maruko.Dynamic.Config/Internal/Controllers · high confidence

The cbb application module is introduced, providing backend APIs and database structures for managing promotional banners, car brand and model catalogs, and oil price information. This includes domain models and CRUD controllers for banners and car data, alongside specialized services that scrape and store global oil prices and track scheduled price adjustment times.

cbb · high confidence

The \src/Maruko.Core.Quartz\ module now provides a complete task scheduling system backed by the Quartz.NET library with persistent storage in MySQL. Administrators can manage scheduled jobs via the new \QuartzController\ endpoints (exposed at \/api/v1/quartzs\), which support creating, updating, pausing, resuming, deleting, and querying jobs, as well as retrieving execution logs. The system supports HTTP-triggered background jobs (\DefaultBackgroundJob\) that execute configured URLs with specified methods and headers, tracking execution status and maintaining a history of the last 20 logs per job. Configuration is handled through \ScheduleModel\ and related internal models, with dependency injection registered in \MarukoQuartzModule\.

src/Maruko.Core.Quartz · high confidence

The configuration service now includes domain models to support page layout settings and data dictionary management. A new \Page\ entity stores page identifiers and names, while \PageConfig\ defines detailed page settings such as data URLs, row/column display options, and serialized field/button/function configurations. Additionally, \SysDataDictionary\ has been added to manage dictionary key-value pairs grouped by category, with a flag to distinguish basic data from other dictionary entries.

dynamic/Maruko.Dynamic.Config/Internal/Domain · high confidence

This change introduces several new internal API controllers to the zero module, expanding the system's administrative and utility capabilities. SysUserController now exposes endpoints for user login, personal info updates, and password resets. SysRoleController adds functionality to retrieve all roles and manage role permissions. SysMenuController provides methods to fetch menus by role, retrieve parent menus, and manage menu-role associations. SysOperateController exposes endpoints to retrieve operation menus by role. Additionally, SysUtilsController adds a new image upload feature that validates file types (jpg, png, gif) and saves them to a structured directory path.

zero/Maruko.Zero/Internal/Controllers · high confidence

The system now exposes new endpoints for managing menus and assigning them to roles. Users can retrieve menus filtered by role, view all parent menus, and manage menu assignments for specific roles. This includes new DTOs for menu structures, role-menu mappings, and search requests, along with service methods to handle these operations.

zero/Maruko.Zero/Internal/Service/Menu · high confidence

The application now includes dedicated module classes for integrating AutoMapper and MongoDB. The new AutoMapperModule configures the AutoMapper library via Autofac and registers a specific object mapper implementation, while the MongoDbModule sets up the MongoDB integration with a defined module load order.

src/Maruko.AutoMapper · high confidence

The dynamic configuration service now includes new implementations for managing page configurations and data dictionaries. PageConfigService handles the creation and editing of page settings by linking them to existing pages, while PageService enforces validation to ensure page keys and names are unique and non-empty. Additionally, SysDataDictionaryService has been added to manage dictionary data, introducing security restrictions that prevent non-super-administrators from modifying or deleting basic data, and providing a dedicated endpoint to retrieve dictionary items by group.

dynamic/Maruko.Dynamic.Config/Internal/Service/Imp · high confidence

The project solution has been significantly reorganized from a single monolithic structure into a modular architecture, introducing distinct projects for core functionality (Maruko.Core), data access providers (FreeSql), web hosting, logging (NLog), code generation, dynamic configuration, task scheduling, and a zero-config module. The solution file has also been upgraded from Visual Studio 2017 to Visual Studio 2022 (Version 17.0), and the repository now includes an MIT License and a README describing the framework.

(repo-wide) · high confidence

A change to existing behaviour in act/act-modules/act-modules-starmap/target/classes/com/act/modules/starmap — 3 commits, 1 file.

act/act-framework, act/act-modules/act-modules-starmap/target/classes/com/act/modules/starmap · medium confidence · unverified

The application now includes a global exception filter that catches unhandled errors and returns a standardized JSON error response with a 500 status code, ensuring consistent error reporting to clients. Additionally, Swagger documentation generation has been enhanced to automatically detect and correctly document file upload endpoints (POST/PUT requests with IFormFile parameters or specific attributes), configuring the OpenAPI schema to accept multipart/form-data requests for seamless API testing.

src/Maruko.Core.Web/Internal/Filters · high confidence

The new FreeSqlRepository implementation adds a boolean parameter to the Delete methods, allowing users to choose between physical deletion and soft deletion. When soft deletion is selected, the repository updates the entity's IsDelete flag to true instead of removing the record from the database, enabling data recovery and audit trails without permanent loss.

src/Maruko.FreeSql/Internal/Repos · high confidence

The application now uses dedicated configuration classes (AppConfig, WebOption, SwaggerOption) to manage settings via the configuration system. Users can now control Swagger visibility through the IsEnableSwagger flag, and configure Web authentication parameters such as Key, Secret, AuthExpired, and IsEnableAuth.

src/Maruko.Core.Web/Config · high confidence

The repository layer has been restructured into two distinct components: an abstract base class (MarukoRepositoryBase) that defines the common interface and shared query logic, and a concrete EF Core implementation (MarukoBaseRepository) that handles data persistence via the unit of work. This separation clarifies the contract for repository consumers while centralizing the EF Core-specific operations like insert, update, and delete in the concrete class.

src/Maruko.EntityFrameworkCore/Repository · high confidence

The SysUserService implementation now provides core user management capabilities, including login via JWT token generation, user creation/editing with MD5 password hashing, and deletion protection for the admin account. It supports paginated user queries that join with roles to filter by username, role name, or role ID, and allows resetting passwords to a default value or updating personal profile information.

zero/Maruko.Zero/Internal/Service/User/Imp · high confidence

15 commits adding/updating tests in act/act-modules/act-modules-zero/target/test-classes/com/act/modules/zero; Added integration tests for the zero module's core services; Added test infrastructure and logging configuration for Maruko.Core; Added unit tests for FreeSql CURD operations; Added unit tests for StarMap application context and Redis integration; Added unit tests for Zero module services; Added unit tests for page configuration and code generation services; Added unit tests for the object mapping functionality.

This change introduces a new Java-based 'act-framework' module (including core, zero, and starmap sub-modules) with dependencies on Spring Boot 2.7.3, MyBatis-Plus, and Knife4j. Simultaneously, the .NET Maruko framework and its extensions (AutoMapper, FreeSql, Hangfire, MongoDB, NLog, Quartz, SqlSugar, and Zero) are migrated from older targets (netstandard1.4, netcoreapp2.1/2.2) to netcoreapp3.1, updating associated NuGet packages such as AutoMapper 10.1.1, FreeSql 2.5.200, and Hangfire 1.6.23.

(dependencies) · high confidence

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

• CAI 39 → 37 (-1.3)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 48 → 47 (-1.2)
• Architecture 92 → 92 (+0.9)
• Maturity 38 → 34 (-4.1)
• Readiness 27 → 27 (+0.0)
• Security 70 → 67 (-3.0)
• Performance 60 → 60 (+0.0)

• Bounded contexts not declared
• Build status unknown
• Duplicated block (10 lines × 3) (src/Maruko.CodeGeneration/Generate/CodeGenerate.Application.cs)
• Duplicated block (13 lines × 2) (taskScheduling/Maruko.TaskScheduling/Internal/Jobs/OilPriceJob.cs)
• Duplicated block (9 lines × 2) (src/Maruko.CodeGeneration/Generate/CodeGenerate.Application.cs)
• Duplicated block (9 lines × 2) (src/Maruko.CodeGeneration/Generate/CodeGenerate.Application.cs)
• No exposed public API
• Test runner surfaced no tests
• The term 'AppConfig' is used for multiple distinct concepts: a general configuration class, a property named 'configuration' inside a class also named 'AppConfig', and specific implementations for FreeSql and TaskScheduling. This creates ambiguity between the configuration container and the configuration data itself.
• The term 'Specification' is used for both a concrete implementation ('AnySpecification') and an interface ('ICompositeSpecification'). While the interface has an 'I' prefix, the concrete class does not follow a consistent 'Concrete' or 'Impl' pattern, and the namespace suggests a domain pattern where 'Specification' is the core concept. However, 'AnySpecification' is a specific type of specification, which is fine, but the lack of a consistent naming convention for concrete vs interface (one has 'I', one doesn't) is a minor inconsistency in the domain layer.
• There is a mix of 'Oil' and 'OilPrice' and 'AllCountryOilPrice' in the Cbb namespace. 'OilDTO' vs 'OilPrice' vs 'AllCountryOilPrice' suggests different concepts or inconsistent naming for similar entities. Specifically, 'OilDTO' and 'OilPrice' might be related but are named differently.
• Thin analysable surface across projects
• Unstable project Cbb.Application
• Unstable project Maruko.Dynamic.Config
• Unstable project Maruko.TaskScheduling
• dormant codebase — no living knowledge left to concentrate
• redundant comment (cbb/Cbb.Application/Internal/Services/Imp/AllCountryOilPriceService.cs)
• redundant comment (src/Maruko.Core.Quartz/Internal/Models/JobInfo.cs)

• CommentedOutCode (src/Maruko.FreeSql/Internal/AppService/CurdAppService.cs)
• CommentedOutCode (src/Maruko.FreeSql/Internal/AppService/CurdAppService.cs)
• CommentedOutCode (src/Maruko.FreeSql/Internal/AppService/CurdAppService.cs)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (cbb/Cbb.Application/Internal/Domain/AppAllCountryOilPrice.cs)
• Duplicated block (10 lines × 2) (zero/Maruko.Zero/Internal/Service/Menu/Imp/SysMenuService.cs)
• Duplicated block (10 lines × 3) (src/Maruko.CodeGeneration/Generate/CodeGenerate.Application.cs)
• Duplicated block (10–11 lines × 2) (src/Maruko.CodeGeneration/Generate/CodeGenerate.Application.cs)
• Duplicated block (20 lines × 2) (src/Maruko/Extensions/Http/WebUtilsHttpConnectionPool.cs)
• Duplicated block (24–25 lines × 2) (cbb/Cbb.Application/Internal/Services/Imp/AllCountryOilPriceService.cs)
• Duplicated block (9 lines × 2) (src/Maruko.CodeGeneration/Generate/CodeGenerate.Application.cs)
• End-of-life runtime: .NET netcoreapp3.1
• High IaC: WD-DOCKER-0013 (docker/Dockerfile)
• Inconsistent naming for base service classes: 'CurdAppServiceBase' vs 'CurdAppServiceTPrimaryKey'. The suffix 'TPrimaryKey' in the latter appears to be a remnant of a generic parameter name or a copy-paste error, breaking the naming convention of using 'Base' for base classes.
• Inconsistent naming for identifier/collection properties: 'Ids' (plural, implying a collection of IDs) vs 'Unique' (singular, abstract noun). While 'Unique' might refer to a single unique identifier, the naming convention for ID-related properties is inconsistent across the codebase (e.g., 'CarModelId', 'BrandId', 'PageId' are singular). 'Unique' is ambiguous compared to 'Id' or 'Ids'.
• Inconsistent naming for request-related properties: 'UseRoutName' (typo, verb-noun) vs 'RequestType' (noun-noun). While they refer to different concepts, the presence of a typo ('Rout') in one and a clean name in the other indicates a lack of review consistency.
• Leaked secret: high-entropy-secret (docker/AntDeploy.json)
• Medium IaC: WD-DOCKER-0003 (docker/Dockerfile)
• Medium IaC: WD-DOCKER-0010 (docker/Dockerfile)
• …and 10 more

• Unchanged — 28 HTTP endpoints

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

phil-guo/maruko 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.