@getollie/cli 0.0.1

package/library/management_systems-frontend_backend_platforms/survey-generator-with-qr-codes.json

@@ -0,0 +1,68 @@
+{
+  "index": 1368,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable. Help me create a program that can generate surveys, where the surveys produced by our program can be accessed via QR code.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the survey generation system complete and functional?",
+      "description": "Review whether the code provides a complete survey creation workflow including form definition, question types (multiple choice, text input, ratings), validation rules, and survey publishing. Score 0 if the core survey creation is not implemented, 5 if only basic question types are supported, and 10 if it includes advanced features like branching logic and conditional questions.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the QR code generation properly implemented?",
+      "description": "Evaluate if the QR code generation uses established libraries (like qrcode.js or QRious) with proper error handling. Check if the QR codes store proper URLs with unique identifiers for each survey, and if they're generated with appropriate error correction levels (M or Q recommended for reliability). Deduct 5 points if the QR codes don't link directly to the surveys, and 3 points if the resolution or size options are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the system have a survey data storage and retrieval mechanism?",
+      "description": "Check if the program implements proper data persistence for both survey definitions and responses. The system should use a database (SQL or NoSQL) or at minimum localStorage with proper data structures. Verify if there's data validation before storage and proper error handling for failed saves. Deduct 5 points if there's no response data aggregation, and 5 points if there's no secure authentication for accessing results. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a responsive survey viewing interface for QR code recipients?",
+      "description": "Evaluate if the survey interface adapts to different screen sizes (desktop, tablet, mobile) since QR codes are often scanned on mobile devices. Check for touch-friendly UI elements, appropriate font sizes (minimum 16px on mobile), and proper viewport configuration. Deduct 5 points if the survey doesn't render properly on mobile screens, and 5 points if the survey submission process isn't optimized for touch interfaces. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network failures during survey submission, malformed input data, QR code scanning failures, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time response analytics 2. Survey templates library 3. Multi-language support for international surveys 4. Offline completion capability with sync when online). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple QR code generators coexisting) 2. Function modules unrelated to survey management (e.g., a built-in image editor) 3. Fancy effects that affect performance (e.g., excessive animations in survey forms). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating survey definition/rendering/data collection layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast sliding, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "hard"
+}

package/library/management_systems-frontend_backend_platforms/task-allocation-tracking-tool.json

@@ -0,0 +1,68 @@
+{
+  "index": 517,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Try to ensure the generated code is executable for demonstration.\n\n======== ROLE ========\nYou are an experienced code expert. You are provided with a software development requirement description and asked to generate project code based on these requirements. Strictly follow the rules to help users generate complete project code fully annotated with simple and easy-to-understand language, without outputting anything else.\n\n======== OUTPUT RULES ========\n1. Always generate complete, runnable project code, ensuring the project is fully executable\n2. Ensure all code files you output are complete, do not omit any code\n3. Carefully review and check all code before final output, evaluating its executability. If the code cannot be executed or contains errors, regenerate it\n4. If the requirements involve external API access or user data (images, videos, audio, etc.), please provide simulated data\n\n======== PROJECT REQUIREMENTS ========\nCreate a task allocation and tracking tool where project managers can create tasks, assign them to team members, set deadlines and priorities, and team members can update task status and add notes.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the task management core functionality fully implemented?",
+      "description": "Review whether the code accurately implements task CRUD operations (Create, Read, Update, Delete) with proper data validation, task assignment logic, and status tracking mechanisms. Check if task properties include title, description, assignee, deadline, priority levels, and status transitions. Score 0 if basic task operations are missing, 5 if only simple CRUD is implemented, and 10 if complete task lifecycle management with validation is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the user role management and permission system implemented?",
+      "description": "Evaluate whether the system properly distinguishes between project managers and team members with appropriate permission controls. Check if project managers can create/assign tasks while team members can only update assigned tasks. Verify user authentication, role-based access control, and secure session management. Deduct 5 points if role separation is unclear, and 3 points if permission validation is missing on sensitive operations. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the data persistence and state management properly designed?",
+      "description": "Check whether the application uses appropriate data storage mechanisms (localStorage, database integration, or API endpoints) with proper data modeling for tasks, users, and relationships. Evaluate if state management follows consistent patterns and handles concurrent updates correctly. Deduct 5 points if data loss occurs on page refresh, and 3 points if state synchronization issues exist between different views. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the tracking and notification features comprehensively implemented?",
+      "description": "Assess whether the system includes progress tracking dashboards, deadline monitoring, status change notifications, and activity logging. Check if the interface provides clear visual indicators for overdue tasks, progress summaries, and task history. Deduct 5 points if tracking visualization is missing, and 3 points if status updates don't trigger appropriate notifications. Give 10 points if comprehensive tracking with analytics is fully implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust and handles edge cases properly?",
+      "description": "Evaluate whether the code can handle common abnormal situations (invalid input data, missing user assignments, date validation errors, concurrent modifications, etc.) and provides friendly error messages with recovery mechanisms. Code with strong robustness should effectively validate all user inputs and handle edge cases gracefully, giving 10 points. If robustness is average, give 5 points, and if no error handling exists, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there innovative features that enhance productivity?",
+      "description": "Check whether the code includes valuable productivity features that go beyond basic requirements (e.g., 1. Drag-and-drop task prioritization 2. Automated deadline reminders 3. Task dependency mapping 4. Time tracking integration 5. Export/import functionality 6. Advanced filtering and search). Add 2 points for each well-implemented innovative feature (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant or unnecessary features?",
+      "description": "Strictly identify three types of redundancy: 1. Duplicate functionality implementations (e.g., multiple task creation forms) 2. Features unrelated to task management (e.g., built-in games or social media integration) 3. Over-engineered components that impact performance (e.g., excessive animations on data operations). Deduct 3 points for each redundancy found, and directly deduct 10 points if redundant code interferes with core functionality.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code demonstrate professional engineering quality?",
+      "description": "Review architectural separation (data layer, business logic, presentation layer), code organization with proper modules/components, consistent naming conventions, and maintainability. Deduct 5 points if global state pollution or poor separation of concerns is found; deduct 5 points if code duplication exceeds 25%; deduct 5 points if no code comments or documentation exists. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface design meet professional UX/UI standards?",
+      "description": "Evaluate whether the design follows modern interface principles: 1) Consistent color scheme with proper contrast ratios (WCAG AA compliant) 2) Logical information hierarchy with appropriate typography (minimum 14px font size, 1.4+ line height) 3) Intuitive navigation and clear visual grouping of related elements. Deduct 3 points for each accessibility violation, 5 points for poor color choices that strain visibility, and 5 points for cluttered or confusing layout structure. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Are the interactions smooth and provide excellent user experience?",
+      "description": "Judge whether user interactions follow UX best practices: 1) Immediate visual feedback for all clickable elements (≤ 100ms response) 2) Smooth transitions between states (200-400ms duration) 3) Clear loading states and progress indicators 4) Intuitive keyboard navigation support. Deduct 5 points for each unresponsive interaction, 3 points for jarring visual transitions, and 5 points for confusing navigation flow or hidden critical functions. Full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "hard"
+}

package/library/management_systems-frontend_backend_platforms/tauri-svelte-crud-frontend-rust-backend.json

@@ -0,0 +1,68 @@
+{
+  "index": 1247,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to provide executable code whenever possible. Please create a frontend CRUD example for customers and users using Tauri+Vite+Svelte, with an existing Rust+Actix-web+MySQL backend already in place.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the Tauri+Vite+Svelte frontend architecture properly implemented?",
+      "description": "Review whether the code correctly configures Tauri with Vite and Svelte, including proper tauri.conf.json setup, frontend build configuration, and IPC (Inter-Process Communication) bridge implementation. Check if the Svelte components are properly structured with reactive state management. Score 0 if the Tauri integration is missing or broken, 5 if basic setup exists but lacks proper IPC implementation, and 10 if all components are seamlessly integrated with proper error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are complete CRUD operations fully implemented for both customers and users?",
+      "description": "Evaluate whether all Create, Read, Update, Delete operations are implemented for both customer and user entities. Check if the frontend properly communicates with the Rust+Actix-web backend through HTTP requests or Tauri commands. Verify data validation, form handling, and proper state updates after operations. Deduct 3 points for each missing CRUD operation, 2 points if data validation is incomplete, and 2 points if state management is inconsistent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the backend integration with Rust+Actix-web+MySQL properly handled?",
+      "description": "Check whether the frontend correctly interfaces with the existing Rust+Actix-web backend, including proper API endpoint usage, request/response handling, and MySQL data persistence. Verify error handling for network failures, database connection issues, and API response parsing. Deduct 4 points if API integration is incomplete, 3 points if error handling is missing, and 3 points if data persistence verification is absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the data flow and state management architecture well-designed?",
+      "description": "Evaluate whether the application implements proper state management using Svelte stores or similar patterns for handling customer and user data. Check if the data flow between components is logical, if loading states are handled, and if the UI updates reactively to data changes. Deduct 4 points if state management is chaotic, 3 points if loading states are not handled, and 3 points if component communication is poorly implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network failures, invalid input data, backend service unavailability, Tauri API errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the CRUD experience (e.g., 1. Real-time data synchronization with WebSocket 2. Advanced search and filtering capabilities 3. Data export/import functionality 4. Offline mode with local storage 5. Bulk operations for multiple records). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple form validation logics coexisting) 2. Function modules unrelated to CRUD operations (e.g., built-in games or unnecessary utilities) 3. Overcomplicated UI components that don't add value (e.g., excessive animations for simple operations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core CRUD functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating API layer/components/stores), proper TypeScript usage, component reusability, and build process configuration. Deduct 5 points if global state pollution is found or Svelte best practices are not followed; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if Vite configuration is not optimized or build process has issues. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the CRUD interface follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times) 4) Consistent form design and table layouts. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic form/table layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the CRUD operations provide smooth user experience: 1) Form submission feedback delay ≤ 100ms 2) Loading indicators for async operations 3) Smooth transitions between list/detail views 4) Clear visual feedback for successful/failed operations 5) Intuitive navigation between customer and user management. Deduct 5 points for each operation without proper feedback, 3 points for jarring transitions, and 5 points for confusing navigation patterns. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "medium"
+}

package/library/management_systems-frontend_backend_platforms/team-scheduling-project-management-mini-program.json

@@ -0,0 +1,68 @@
+{
+  "index": 1179,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration. I want to develop a complete team scheduling and project management mini-program that includes closed-loop functionality and the ability to upload image files for completed results.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the team member management system fully implemented?",
+      "description": "Review whether the code properly implements user registration, role assignment (admin/team member), permissions control, and team structure visualization. Score 0 if user management is missing, 5 if basic user profiles exist but lack role differentiation, and 10 if there's complete RBAC (Role-Based Access Control) with proper authorization flows.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the project management functionality comprehensively developed?",
+      "description": "Check whether the code includes essential project management features: task creation, assignment, prioritization, deadline setting, status tracking, and dependency management. Deduct 5 points if project hierarchical structure (projects→milestones→tasks) is missing, 3 points if there's no critical path visualization, and 2 points if resource allocation conflicts aren't detected. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the file upload system for completed results properly implemented?",
+      "description": "Evaluate whether the image upload functionality includes: proper file type validation, size restrictions, compression before storage, preview capability, and secure storage implementation. Check if progress indicators and error handling during uploads are present. Deduct 5 points for missing image processing (resizing/compression), 3 points for lack of preview functionality, and 5 points for security vulnerabilities in file handling. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the closed-loop project workflow properly implemented?",
+      "description": "Assess whether the code implements a complete project lifecycle: task assignment → progress tracking → result submission → approval → completion/revision requests. Check if notifications for each stage transition exist and if analytics on completion rates and bottlenecks are available. Deduct 5 points if approval workflows are missing, 3 points if there's no historical tracking of changes, and 2 points if reporting functions are absent. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network failures during uploads, concurrent edits, permission conflicts, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should include data validation, proper exception handling, and graceful degradation. Give 10 points for comprehensive error handling, 5 points if basic validation exists but edge cases aren't covered, and 0 points if exceptions crash the application.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. AI-powered task estimation 2. Automated workload balancing 3. Interactive Gantt charts with drag-drop scheduling 4. In-app team communication tools). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple notification systems coexisting) 2. Function modules unrelated to team management or project tracking 3. Fancy effects that affect performance (e.g., excessive animations or transitions). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating business logic/view/data layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast sliding, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "hard"
+}

package/library/management_systems-frontend_backend_platforms/tencent-cloud-operations-management-mini-program.json

@@ -0,0 +1,68 @@
+{
+  "index": 751,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Be sure to ensure that the generated code is executable for demonstration. How to use Tencent Cloud components to develop a technical operations management application/WeChat mini program that includes: 1. Daily inspections: inspection personnel upload inspection images, fill in inspection notes, and submit to reviewers for approval; 2. Operations support: operations staff report daily maintenance activities and submit to reviewers for approval; 3. Report queries: reviewers can check inspection and operations situations, including frequency and content.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the daily inspection module fully implemented?",
+      "description": "Evaluate whether the code accurately implements the daily inspection workflow, including image upload, note entry, and approval mechanisms using Tencent Cloud components. Check if the code implements TCB (Tencent CloudBase) for data storage, image compression and storage in COS (Cloud Object Storage), and secure user authentication. Score 0 if the core functionality is missing, 5 if basic functionality is implemented but lacking cloud integration, and 10 if fully implemented with proper Tencent Cloud services.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the operations support module correctly implemented?",
+      "description": "Review the implementation of the operations support system, including daily maintenance activity reporting and the approval workflow. Verify that it uses Tencent Cloud Serverless functions for backend logic and proper database schema design for maintenance records. The implementation should include status tracking and notifications. Deduct 5 points if the approval workflow is incomplete, 3 points if notification mechanisms are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the report query system properly designed?",
+      "description": "Assess whether the reporting system enables reviewers to effectively query and analyze both inspection and operations data. Check if it implements Tencent Cloud's data visualization components, supports filtering by date ranges, personnel, and status. Verify if it includes statistical analysis functions and exportable reports. Deduct 5 points if filtering capabilities are limited, 3 points if visualization is inadequate, and 5 points if export functionality is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the WeChat Mini Program integration properly implemented?",
+      "description": "Evaluate the WeChat Mini Program implementation, focusing on integration with Tencent Cloud services and WeChat's native capabilities. Check for proper use of WeChat login, cloud functions connection, offline data caching, and push notification integration. The code should follow WeChat Mini Program development best practices. Deduct 5 points for improper authentication flow, 3 points for missing offline capabilities, and 5 points for security vulnerabilities in cloud API calls. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as network interruption, image upload failures, form validation errors, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. AI-powered image analysis for inspection verification 2. Automated report generation with insights 3. Location-based task assignment). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple approval workflows coexisting) 2. Function modules unrelated to operations management (e.g., a built-in game feature) 3. Fancy effects that affect performance (e.g., unnecessary animations on critical paths). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating business logic/view/network layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast sliding, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "hard"
+}

package/library/management_systems-frontend_backend_platforms/test-case-management-platform.json

@@ -0,0 +1,68 @@
+{
+  "index": 313,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration. Build a modern test case management platform with these core functions: user system, case management system, and case statistics system. Implement features for adding, modifying, and importing test cases via Excel. Execute test cases and generate execution statistics. Frontend tech stack: Vue.js + Bootstrap, etc. Backend tech stack: Django + Django REST framework, etc. Database: SQLite3, etc. Based on these requirements, what questions and suggestions do you have?",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the test case management system architecture properly implemented?",
+      "description": "Review whether the code implements a clear separation of concerns with proper frontend-backend architecture. The frontend should use Vue.js component structure with proper state management, and the backend should follow Django's MVT pattern with REST API endpoints. Score 0 if the architecture is missing or fundamentally flawed, 5 if basic structure exists with some issues, and 10 if the architecture is comprehensive with proper separation of concerns.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the user system fully functional?",
+      "description": "Evaluate the implementation of user registration, authentication, authorization, and role management. Check for JWT/session-based authentication, role-based access control, proper password hashing, and account management features. Deduct 3 points if password security is inadequate, 3 points if role-based permissions are missing, and 4 points if authentication tokens aren't properly managed. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the case management system comprehensive?",
+      "description": "Assess the implementation of CRUD operations for test cases, including proper data models with relationships, validation logic, and versioning. Check for features like test case categorization, search/filtering, and bulk operations. Deduct 3 points if the data model lacks necessary fields, 3 points if validation is inadequate, and 4 points if searching/filtering capabilities are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the Excel import/export features properly implemented?",
+      "description": "Review the implementation of Excel import/export functionality for test cases. Check for proper file format validation, template handling, error reporting during import, and data integrity checks. Evaluate the UX flow for imports/exports. Deduct 3 points for missing validation, 3 points for inadequate error handling, 2 points for poor UX, and 2 points for missing template functionality. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid inputs, network issues, database failures, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should include proper exception handling, input validation, and defensive programming. Give 10 points for comprehensive error handling, 5 points for average robustness, and 0 points if exceptions aren't handled.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time collaboration on test cases 2. Test case dependency visualization 3. Automated test execution scheduling 4. AI-assisted test case generation). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to export data) 2. Function modules unrelated to test case management (e.g., a built-in chat system) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating business logic/view/API layers), unit test coverage, and build process automation. Examine frontend component reusability and backend API documentation. Deduct 3 points if global state management is poorly implemented; deduct 3 points if the code duplication rate is too high (over 30%); deduct 2 points if the build process is not automated; deduct 2 points if API documentation is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the UI follows modern design principles: 1) Harmonious color matching with Bootstrap theme customization 2) Proper layout spacing and responsive design 3) Professional typography and consistent design language. Deduct 3 points for inconsistent design elements, 3 points for non-responsive layouts, and 4 points for poor information hierarchy and navigation structure. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the statistical dashboard comprehensive and insightful?",
+      "description": "Judge the quality of the statistical system implementation: 1) Variety of metrics and KPIs (test coverage, pass/fail rates, execution times) 2) Visual data representations (charts, graphs) 3) Filtering and time-range selection 4) Export capabilities. Deduct 3 points for missing key metrics, 3 points for poor visualization choices, 2 points for limited filtering options, and 2 points for missing export functionality. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "medium"
+}

package/library/management_systems-frontend_backend_platforms/test-execution-dynamic-forms-homepage-module-ttf-icons.json

@@ -0,0 +1,68 @@
+{
+  "index": 1260,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for display. Tasks completed:\n1. Test execution - added multiple query options to the operating condition execution interface;\n2. Added dynamic form controls;\n3. Test records - added multiple query options to the operating condition execution interface;\n4. Added homepage module;\n5. Improved the TTF icon library",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Are the multiple query options for operating condition execution interface fully implemented?",
+      "description": "Review whether the code accurately implements the query form with proper validation, filtering logic, and state management. Check if the advanced filtering options allow for complex combinations and flexible parameter adjustments. Score 0 if query functionality is missing, 5 if only basic filtering is implemented, and 10 if it includes advanced features like fuzzy search, range filters, and parameter persistence.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the dynamic form control system properly implemented?",
+      "description": "Evaluate the implementation of dynamic form controls including validation logic, error handling, and state management. Check if the controls support conditional visibility, dependent validation, and value interpolation. Deduct 3 points if controls lack accessibility features, 3 points if validation logic is inconsistent, and 4 points if state management causes memory leaks. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the test records query options correctly integrated with the execution interface?",
+      "description": "Examine whether the test records query interface is properly connected to the execution system, with appropriate data flow between components. Verify that search results update reactively and maintain consistency with filter states. Deduct 5 points if the query results don't synchronize correctly with execution context, and 3 points if pagination or sorting logic has edge cases. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the homepage module comprehensive and well-integrated?",
+      "description": "Assess the homepage module for completeness, featuring dashboard elements, navigation system, and proper integration with other system modules. Check for responsive design implementation and information architecture. Deduct 5 points if key metrics are missing, 3 points for poor navigation design, and 2 points for inadequate responsive behavior. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as form validation errors, network interruption, empty states, concurrent operations, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Smart query suggestions based on usage patterns 2. Visualization of test result trends 3. Keyboard shortcut system for power users). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple filtering mechanisms coexisting) 2. Function modules unrelated to the test system (e.g., unnecessary analytics) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating logic/view/data layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Examine the TTF icon library implementation for consistency, proper sizing and alignment. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast sliding, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "hard"
+}

package/library/management_systems-frontend_backend_platforms/ticket-management-system.json

@@ -0,0 +1,68 @@
+{
+  "index": 1375,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Try to ensure the generated code is executable. Below are SQL scripts generated based on the entity classes you provided. These scripts will create corresponding database tables, and define field types, primary keys, comments, and other information.\n\n### 1. `chat_record` table\n```sql\nCREATE TABLE `chat_record` (\n  `id` INT(11) NOT NULL AUTO_INCREMENT COMMENT 'Primary Key ID',\n  `from_user_id` INT(11) NOT NULL COMMENT 'Sender',\n  `to_user_id` INT(11) NOT NULL COMMENT 'Recipient',\n  `status` INT(11) NOT NULL COMMENT '0 Unread 1 Read',\n  `content` VARCHAR(255) NOT NULL COMMENT 'Message content',\n  `create_time` DATETIME NOT NULL COMMENT 'Creation time',\n  PRIMARY KEY (`id`)\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='Chat records table';\n```\n\n### 2. `sys_notice` table\n```sql\nCREATE TABLE `sys_notice` (\n  `id` INT(11) NOT NULL AUTO_INCREMENT COMMENT 'Notice ID',\n  `notice_title` VARCHAR(255) NOT NULL COMMENT 'Notice title',\n  `notice_type` INT(11) NOT NULL COMMENT 'Notice type (1 notification 2 announcement)',\n  `notice_content` TEXT NOT NULL COMMENT 'Notice content',\n  `status` INT(11) NOT NULL COMMENT 'Notice status (0 active 1 closed)',\n  `create_time` DATETIME NOT NULL COMMENT 'Creation time',\n  `update_time` DATETIME NOT NULL COMMENT 'Update time',\n  PRIMARY KEY (`id`)\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='Notifications and announcements table';\n```\n\n### 3. `sys_user` table\n```sql\nCREATE TABLE `sys_user` (\n  `id` INT(11) NOT NULL AUTO_INCREMENT COMMENT 'Primary Key ID',\n  `nickname` VARCHAR(255) NOT NULL COMMENT 'Nickname',\n  `avatar` VARCHAR(255) NOT NULL COMMENT 'Avatar',\n  `password` VARCHAR(255) NOT NULL COMMENT 'Password',\n  `mobile` VARCHAR(20) NOT NULL COMMENT 'Phone number',\n  `email` VARCHAR(255) NOT NULL COMMENT 'Email',\n  `role_id` INT(11) NOT NULL COMMENT 'Role',\n  `dept_id` INT(11) NOT NULL COMMENT 'Department ID',\n  `update_time` DATETIME NOT NULL COMMENT 'Modification time',\n  `create_time` DATETIME NOT NULL COMMENT 'Creation time',\n  `locked` INT(11) NOT NULL COMMENT '1 valid 2 invalid',\n  `deleted` INT(11) NOT NULL COMMENT 'Logical deletion 0 normal 1 deleted',\n  `confirm_password` VARCHAR(255) NOT NULL COMMENT 'Confirm password',\n  PRIMARY KEY (`id`)\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='Backend admin user table';\n```\n\n### 4. `ticket` table\n```sql\nCREATE TABLE `ticket` (\n  `id` INT(11) NOT NULL AUTO_INCREMENT COMMENT 'Primary Key ID',\n  `train_number` INT(11) NOT NULL COMMENT 'Train number',\n  `pass_station` VARCHAR(255) NOT NULL COMMENT 'Via stations',\n  `train_number_type` INT(11) NOT NULL COMMENT 'Train type 1 High-speed 2 EMU 3 Direct 4 Express 5 Other',\n  `ticket_number` INT(11) NOT NULL COMMENT 'Number of tickets',\n  `seat_type` INT(11) NOT NULL COMMENT 'Seat type 1 Soft seat 2 Hard seat 3 Sleeper',\n  `status` INT(11) NOT NULL COMMENT '1 Online 2 Offline',\n  `starting_point` VARCHAR(255) NOT NULL COMMENT 'Departure point',\n  `ending_point` VARCHAR(255) NOT NULL COMMENT 'Destination',\n  `price` INT(11) NOT NULL COMMENT 'Price',\n  `starting_time` DATETIME NOT NULL COMMENT 'Departure time',\n  `arriving_time` DATETIME NOT NULL COMMENT 'Arrival time',\n  `create_time` DATETIME NOT NULL COMMENT 'Creation time',\n  `update_time` DATETIME NOT NULL COMMENT 'Update time',\n  PRIMARY KEY (`id`)\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='Ticket table';\n```\n\n### 5. `ticket_order` table\n```sql\nCREATE TABLE `ticket_order` (\n  `id` INT(11) NOT NULL AUTO_INCREMENT COMMENT 'Primary Key ID',\n  `order_id` VARCHAR(255) NOT NULL COMMENT 'Order ID',\n  `user_id` INT(11) NOT NULL COMMENT 'User ID',\n  `ticket_id` INT(11) NOT NULL COMMENT 'Ticket ID',\n  `username` VARCHAR(255) NOT NULL COMMENT 'Username',\n  `id_card` VARCHAR(255) NOT NULL COMMENT 'ID card number',\n  `create_time` DATETIME NOT NULL COMMENT 'Creation time',\n  `update_time` DATETIME NOT NULL COMMENT 'Update time',\n  PRIMARY KEY (`id`)\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='Ticket order table';\n```\n\n### 6. `user` table\n```sql\nCREATE TABLE `user` (\n  `id` INT(11) NOT NULL AUTO_INCREMENT COMMENT 'Primary Key ID',\n  `nickname` VARCHAR(255) NOT NULL COMMENT 'Nickname',\n  `password` VARCHAR(255) NOT NULL COMMENT 'Password',\n  `avatar` VARCHAR(255) NOT NULL COMMENT 'Avatar',\n  `gender` INT(11) NOT NULL COMMENT 'Gender',\n  `mobile` VARCHAR(20) NOT NULL COMMENT 'Phone number',\n  `status` INT(11) NOT NULL COMMENT 'Status 1 Normal 2 Banned',\n  `create_time` DATETIME NOT NULL COMMENT 'Creation time',\n  `update_time` DATETIME NOT NULL COMMENT 'Update time',\n  PRIMARY KEY (`id`)\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='User table';\n```\n\n### Notes:\n1. **Field types**: Adjust field types according to actual needs, such as the length of `VARCHAR` or the range of `INT`.\n2. **Character set**: Default to `utf8mb4` to support more characters (such as emoji).\n3. **Engine**: Default to `InnoDB` engine, supporting transactions and foreign keys.\n4. **Comments**: Table name and field comments can be adjusted according to actual requirements.\n\nPlease help me generate a ticket management system based on the above table information, using Spring Boot, MyBatis, and templates for the frontend pages.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the database schema design logically sound?",
+      "description": "Review whether the database tables follow normalization principles, have appropriate data types, constraints, and relationships. Check for primary/foreign key definitions, indexes for performance optimization, and proper cascading rules for referential integrity.Deduct 5 points for each missing index on frequently queried fields; 10 points if foreign key constraints are not implemented correctly between related tables (e.g., ticket_order.ticket_id → ticket.id); 5 points for inappropriate data types (e.g., using VARCHAR for numeric values); 3 points for each missing constraint that could lead to data integrity issues. The full score is 15 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the Spring Boot project structure properly organized?",
+      "description": "Evaluate if the code follows the standard Spring Boot project structure with clear separation of concerns (Controller, Service, Repository layers). Check for proper package organization, configuration management, and dependency injection patterns.Give full 10 points if the project follows strict layered architecture patterns with proper separation of concerns. Deduct 3 points if controllers contain business logic; 3 points if service layer is bypassed; 2 points if repositories are accessed directly from controllers; 5 points if dependency injection is not used appropriately. Score 0 if the basic MVC pattern is not followed.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the MyBatis integration complete and efficient?",
+      "description": "Check if MyBatis mappers, XML files, and annotations are correctly implemented. Assess if complex queries use efficient SQL, pagination is implemented, and if proper result mapping is configured.Award 10 points for a complete implementation with XML mappers or annotations, properly configured datasource, and transaction management. Deduct 3 points for missing pagination; 3 points for N+1 query issues; 2 points for inefficient SQL queries; 5 points if dynamic SQL is not used where appropriate. Score 0 if basic CRUD operations are not functional.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the ticket management system's core functionality implemented?",
+      "description": "Review if the system includes essential features: ticket creation/modification, searching/filtering, booking process, order management, and user authentication. Check if business rules like seat availability validation and booking constraints are implemented.Full 15 points for implementing all core ticket management features including search, booking, payment workflow, and order management. Deduct 3 points for each missing major feature; 5 points if ticket availability checking is not implemented; 5 points if the booking process is incomplete; 2 points for each business rule violation. Score 0 if the basic ticket CRUD operations are not functional.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code handles exceptions properly, includes input validation, implements transaction management correctly, and provides appropriate error handling and logging.Evaluate whether the code can handle common abnormal situations (such as invalid inputs, duplicate bookings, concurrent modifications) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Real-time seat availability visualization 2. Smart recommendation system 3. Automated notification system for ticket status changes 4. Trip planning assistant).Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple booking methods coexisting) 2. Function modules unrelated to ticket management (e.g., a built-in game) 3. Fancy effects that affect performance (e.g., unnecessary animations).Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design, code reuse patterns, exception handling strategy, unit test coverage, and build process automation. Check for code comments and documentation.Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated; deduct 3 points if documentation is insufficient. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the ticket management UI follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing 3) Professional font system (body font size ≥ 14px, line height over 1.5 times) 4) Clear information hierarchy for ticket listings and details.Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. Deduct 3 points if ticket information is not clearly presented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the ticket booking flow and management operations conform to user expectations: 1) Responsive feedback for ticket search/booking operations 2) Clear visual indicators for seat availability 3) Intuitive navigation between ticket search, booking, and order management.Deduct 5 points for each operation without feedback, 3 points for slow response times during ticket searches, and 5 points for hard-to-find key booking functions. Deduct 3 points if the booking process requires unnecessary steps. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Management Systems-Frontend/Backend Platforms",
+  "difficulty": "medium"
+}