@cplace/test-mcp-server 1.0.0 → 1.1.0

package/dist/widget-specifications/_research_from_ga_products/cf-platform-makeover-attributes/research.md

@@ -0,0 +1,219 @@
+# Research: cf.platform.makeover.attributes Widget
+
+## Widget Overview
+
+**Widget ID:** `cf.platform.makeover.attributes`
+
+**Widget Name:** Attributes (new)
+
+**Brief Description:** A redesigned version of the attributes widget that displays all attributes of a page and allows editing with enhanced styling and improved UI/UX.
+
+## Purpose
+
+The `cf.platform.makeover.attributes` widget is part of a broader "makeover" initiative to modernize the cplace platform's user interface. It serves as a redesigned replacement for the original `cf.platform.attributes` widget, providing the same core functionality but with enhanced visual styling and improved user experience.
+
+### Core Functionality
+- Displays all attributes of a custom entity page
+- Allows users to view and edit attribute values
+- Provides an interface for managing page properties
+- Renders within the page layout as an embeddable widget
+
+## Use Cases
+
+### Primary Use Case: Viewing and Editing Page Attributes
+Users interact with this widget when they need to:
+- View all attributes of a specific page/entity
+- Edit attribute values directly from the page
+- Review the complete set of properties for a custom entity
+- Make quick updates to page data without navigating to separate forms
+
+### When to Choose This Widget
+
+**Choose the makeover attributes widget when:**
+- You want a modern, improved UI for displaying attributes
+- The new design language is enabled in your cplace instance
+- You're building new pages or layouts and want to use the latest UI components
+- You need the same functionality as the original attributes widget but with better styling
+
+**Choose the original attributes widget when:**
+- The makeover version is not enabled via feature flag
+- You need consistency with existing pages using the old design
+- The makeover widget is not yet available in your cplace version
+
+### Typical Usage Scenarios
+1. **Entity Detail Pages**: Embedded on pages to show all properties of an entity (project, task, document, etc.)
+2. **Edit Workflows**: Allowing users to modify entity attributes in-place
+3. **Data Review**: Providing a comprehensive view of all entity data in one location
+4. **Form Alternatives**: As an alternative to separate edit forms, enabling inline editing
+
+## Configuration Concepts
+
+### Feature Flag Control
+The widget is controlled by a feature flag that determines its availability:
+- **Configuration Property**: `cplace.uix.newAttributesWidgetEnabled`
+- **Default Value**: `false` (disabled by default)
+- **Configuration Location**: Spring Boot properties configuration
+- **Access**: Via `UixFeatureConfiguration.isNewAttributesWidgetEnabled()`
+
+This feature flag approach allows:
+- Gradual rollout of the new design
+- A/B testing between old and new versions
+- Easy toggling for troubleshooting or rollback
+- Platform-wide control of UIX (User Interface eXperience) features
+
+### Embedding Rules
+The widget has specific rules about where it can be embedded:
+
+1. **Entity Type Restriction**: Can only be embedded in `CustomEntity` types
+   - Cannot be used with system entities or type definitions
+   - Validates entity kind during embedding
+
+2. **Single Instance**: The widget checks to prevent being embedded multiple times on the same page
+   - Prevents duplicate attribute displays
+   - Enforces one attributes widget per page view
+
+3. **Feature Flag Validation**: Before embedding, validates that the new attributes widget is enabled
+   - Throws `NotEmbeddableException` if feature is disabled
+   - Ensures consistent UI experience across the platform
+
+### Visual Appearance
+- **Icon**: Uses Font Awesome icon `fa-list-alt` (list with checkmarks)
+- **Rendering**: Uses Web Component bridge architecture (`cf-wc-bridge`)
+- **Component**: Links to `AttributesWidgetComponent` in the `WidgetsModule`
+- **Template**: Uses the content widget template substitution pattern
+
+## Context and Relationships
+
+### Related Widgets
+The makeover attributes widget is part of a family of attribute-related widgets:
+
+1. **Original Attributes Widget** (`cf.platform.attributes`)
+   - Icon: `fa-pen-square`
+   - The predecessor being replaced by this makeover version
+   - Same core functionality, older styling
+
+2. **Attributes Group Widget** (`cf.platform.attributesGroup`)
+   - Displays attributes organized into groups
+   - More structured presentation of attributes
+
+3. **Connected Attributes Group Widget** (`cf.platform.connectedAttributesGroup`)
+   - Similar to attributes group but with connection capabilities
+   - For displaying related entity attributes
+
+4. **Single Attribute Widget** (`cf.platform.singleAttribute`)
+   - Displays a single attribute instead of all attributes
+   - More focused, targeted attribute display
+
+5. **Attribute History Widget** (`cf.platform.attributeHistory`)
+   - Shows the change history of attributes
+   - Audit trail functionality
+
+### Part of Larger Feature Set
+The widget is part of the **UIX (User Interface eXperience) Modernization** initiative:
+- Multiple widgets are being redesigned under the "makeover" package
+- Other makeover widgets may exist or be planned (e.g., new table widget)
+- Coordinated design language across multiple components
+- Feature flag system allows phased rollout of new designs
+
+### Architecture Integration
+
+**Backend Components:**
+- Extends `WidgetDefinition` from the core widget framework
+- Integrated through `PlatformWidgetDefinitions` extension container
+- Registered with the `PlatformPlugin.platformApp`
+- Uses `ContentWidgetTemplateSubstitution` for template rendering
+
+**Frontend Components:**
+- Web Component architecture via `cf-wc-bridge`
+- Bridges to modern JavaScript/TypeScript components
+- Part of the `WidgetsModule` component system
+- Template file: `attributesWidgetDefinition.htm` in makeover directory
+
+**Configuration Layer:**
+- `UixFeatureConfiguration` interface defines feature flags
+- `DefaultUixFeatureConfiguration` implements Spring Boot properties
+- `PlatformComponentRegistry` provides access to configuration
+- Spring-managed configuration with `@ConfigurationProperties`
+
+### Prerequisites and Dependencies
+
+**Required to Use:**
+1. Feature flag must be enabled: `cplace.uix.newAttributesWidgetEnabled = true`
+2. Page must be a `CustomEntity` type
+3. Platform must support Web Component bridge architecture
+4. Frontend widgets module must be available
+
+**System Dependencies:**
+- cf.cplace.platform (core platform)
+- Widget framework (`cf.cplace.platform.core.application.widget.*`)
+- Data model system (`cf.cplace.platform.core.datamodel.*`)
+- Frontend templating system
+- Spring Boot configuration management
+
+## Technical Implementation Notes
+
+### Key Java Classes
+- **Definition**: `cf.cplace.platform.frontend.widgets.makeover.AttributesWidgetDefinition`
+- **Location**: `main/cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/widgets/makeover/`
+- **Package**: `cf.cplace.platform.frontend.widgets.makeover`
+
+### Key Methods
+1. `getWidgetKind()`: Returns `"cf.platform.makeover.attributes"`
+2. `checkEmbeddableIn()`: Validates embedding rules and feature flag
+3. `checkShowInSelection()`: Controls widget selection visibility
+4. `checkAttributesWidgetEnabled()`: Feature flag validation
+5. `getContentSubstitution()`: Returns content template substitution
+
+### Internationalization
+Messages are defined in `messages_en.properties` and `messages_de.properties`:
+- **English Name**: "Attributes (new)"
+- **English Description**: "Displays all attributes of the page and allows editing."
+- **German translations**: Available in messages_de.properties
+
+### Design Patterns Used
+1. **Extension Container Pattern**: Registered through `PlatformWidgetDefinitions`
+2. **Template Method Pattern**: Uses abstract `WidgetDefinition` base class
+3. **Feature Toggle Pattern**: Feature flag-based activation
+4. **Validation Chain Pattern**: Multiple validation checks in embedding
+5. **Web Component Bridge Pattern**: Modern frontend integration
+
+## Comparison with Original Widget
+
+| Aspect | Original Widget | Makeover Widget |
+|--------|----------------|-----------------|
+| Widget Kind | `cf.platform.attributes` | `cf.platform.makeover.attributes` |
+| Icon | `fa-pen-square` | `fa-list-alt` |
+| Display Name | "Attributes" | "Attributes (new)" |
+| Feature Flag | Not required | Required (`cplace.uix.newAttributesWidgetEnabled`) |
+| UI/UX | Original styling | Enhanced, modern styling |
+| Functionality | View and edit attributes | Same core functionality |
+| Embedding Rules | Basic validation | Enhanced validation + feature flag |
+| Package | `frontend.widgets` | `frontend.widgets.makeover` |
+
+## Key Insights
+
+1. **Gradual Migration Strategy**: The feature flag approach suggests a careful, controlled migration from old to new design, allowing users to switch when ready.
+
+2. **Design Consistency**: Part of a broader platform modernization effort, not a standalone widget redesign.
+
+3. **Backward Compatibility**: The original widget remains available, ensuring existing pages continue to work.
+
+4. **Enterprise Readiness**: Feature flag control is essential for enterprise deployments where UI changes need careful rollout and testing.
+
+5. **Modern Frontend Architecture**: Use of Web Components suggests a move toward more modular, maintainable frontend code.
+
+## Questions for Further Clarification
+
+1. What specific UI/UX improvements does the makeover version provide?
+2. Are there performance differences between the old and new versions?
+3. What is the timeline for deprecating the original widget?
+4. Are there any limitations or known issues with the makeover version?
+5. How does the Web Component implementation differ from the original AngularJS implementation?
+
+## References
+
+- **Java Definition**: `/cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/widgets/makeover/AttributesWidgetDefinition.java`
+- **Template File**: `/cf.cplace.platform/src/main/resources/cf/cplace/platform/frontend/widgets/makeover/attributesWidgetDefinition.htm`
+- **Configuration**: `/cf.cplace.platform/src/main/java/cf/cplace/platform/configuration/UixFeatureConfiguration.java`
+- **Messages**: `/cf.cplace.platform/src/main/resources/cf/cplace/platform/messages_en.properties`
+- **Widget Registry**: `/cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/widgets/PlatformWidgetDefinitions.java`

package/dist/widget-specifications/_research_from_ga_products/cf-platform-modificationInfo/research.md

@@ -0,0 +1,141 @@
+# Widget Research: cf.platform.modificationInfo
+
+## Overview
+
+**Widget ID:** `cf.platform.modificationInfo`
+**Display Name:** Version Info (English) / Versionsinformation (German)
+**Icon:** `fa-info`
+**Repository:** main
+**Definition Class:** `cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/widgets/ModificationInfoWidgetDefinition.java`
+
+## Purpose
+
+The Modification Info widget displays version tracking metadata for pages. It shows when a page was last modified and by whom, providing transparency about content changes and enabling users to track page activity.
+
+**Short Description:**
+Displays the last modification date and modifier for a page, helping users track when and by whom content was changed.
+
+## Core Functionality
+
+The widget renders modification tracking information by:
+- Displaying the last modification timestamp
+- Showing the user who made the last modification (with a link to their profile)
+- Automatically tracking this information through the `Modifiable` mixin that pages implement
+
+### Technical Details
+
+- **Template:** `modificationInfoWidgetDefinition.htm` calls `showModificationInfo()`
+- **Data Source:** Uses the `Modifiable` mixin interface which provides:
+  - `_modifiedAt()` - timestamp of last modification
+  - `getModifierReference()` - reference to the Person who made the modification
+- **Rendering Logic:** Template at `cf/cplace/platform/frontend/templating/objectFunctions/modifiable/showModificationInfo.htm`
+- **Display Format:**
+  - If modifier is unknown: "Last modified [date]"
+  - If modifier is known: "Last modified by [user link] [date]"
+
+## Use Cases
+
+### 1. Content Transparency
+Users need to see when information was last updated to assess its currency and relevance. This is particularly important for:
+- Documentation pages
+- Policy pages
+- Process descriptions
+- Requirements documents
+
+### 2. Collaboration Tracking
+Teams working on shared pages can identify:
+- Who made recent changes
+- When the page was last touched
+- Whether the content is up-to-date
+
+### 3. Audit Trail
+Organizations requiring traceability can use this widget to:
+- Track page ownership and responsibility
+- Verify when critical information was updated
+- Monitor activity on important pages
+
+### 4. Content Management
+Content administrators can:
+- Identify stale content that hasn't been updated recently
+- See which team members are actively maintaining pages
+- Monitor page activity patterns
+
+## Configuration
+
+The Modification Info widget has **minimal configuration** by design:
+
+### Display Settings
+- **No Frame:** The widget renders without a surrounding frame (`showFrame() = false`)
+- **No Padding:** Content is rendered without padding (`isNoPadding() = true`)
+- This allows the widget to integrate seamlessly into page layouts
+
+### Embeddability Constraints
+- **Target Entity:** Can only be embedded on `Page` entities (and type definitions that apply to pages)
+- **Uniqueness:** Only one instance can be embedded per page (`checkIsNotAlreadyEmbedded`)
+- **Embedding Type:** Must be embedded as a widget (not other embedding types)
+
+### Customization Options
+The widget itself does not expose configuration parameters. The display is standardized and automatic, pulling directly from the page's modification metadata.
+
+## Related Widgets
+
+### Attribute History Widget (`cf.platform.attributeHistory`)
+**Relationship:** Complementary tracking widget
+**Difference:**
+- Attribute History tracks changes to *specific attributes* over time
+- Modification Info shows *overall page-level* last modification
+- Attribute History is configurable (select which attributes to track)
+- Modification Info is automatic and non-configurable
+
+**Use Together When:** You need both high-level page modification tracking AND detailed attribute-level change history.
+
+### Comments Widget
+**Relationship:** Related collaboration widget
+**Difference:**
+- Comments allow explicit user feedback and discussion
+- Modification Info passively tracks system-generated metadata
+- Both help with collaboration but serve different purposes
+
+## Integration Context
+
+### Modifiable Mixin
+The widget depends on the `Modifiable` mixin, which is a core platform capability that:
+- Automatically tracks creation and modification timestamps
+- Maintains references to creator and modifier users
+- Is implemented by `Page` (through `CustomEntity` → `PersistentEntity` → `Entity`)
+- Provides attributes `_modifiedAt()` and `_createdAt()` that are indexed and searchable
+
+### Typical Page Layout Position
+While not technically enforced, this widget is typically placed:
+- At the bottom of page layouts (footer area)
+- In metadata or administrative sections
+- Alongside other system information widgets
+
+The widget's frameless, padding-free design supports unobtrusive placement in page footers or compact layout areas.
+
+## Key Insights
+
+1. **Automatic Tracking:** No configuration needed - modification data is captured automatically by the platform
+2. **Single Instance:** Enforced uniqueness prevents redundant modification info on the same page
+3. **Minimalist Design:** Frameless rendering allows flexible positioning without visual clutter
+4. **Platform Integration:** Leverages core `Modifiable` mixin rather than custom tracking logic
+5. **Complementary to History:** Works alongside Attribute History for comprehensive audit capabilities
+6. **User Context:** Provides clickable links to modifier profiles for easy user identification
+
+## Implementation Notes
+
+### Widget Definition Characteristics
+- Extends `WidgetDefinition` base class
+- Returns `ContentWidgetTemplateSubstitution` with custom frame/padding settings
+- Uses platform app (`PlatformPlugin.INSTANCE().platformApp`)
+- Icon: Font Awesome info icon (`fa-info`)
+
+### Localization
+- English: "Version Info"
+- German: "Versionsinformation"
+- Template messages: "Last modified" / "Last modified by"
+
+### Technical Constraints
+- Only works with entities implementing `Modifiable` mixin
+- Requires valid Page entity context
+- Single-widget-per-page limitation enforced at widget selection time

package/dist/widget-specifications/_research_from_ga_products/cf-platform-myElements/research.md

@@ -0,0 +1,116 @@
+# Widget Research: cf.platform.myElements
+
+## Overview
+
+**Widget ID:** `cf.platform.myElements`
+**Display Name:** My Elements
+**Repository:** main
+**Definition Class:** `cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/widgets/MyElementsWidgetDefinition.java`
+**Icon:** `fa-user`
+
+## Description
+
+The My Elements widget displays incoming references for Person entities. It shows all other cplace pages that reference or are associated with a specific person.
+
+## Purpose
+
+This widget is a specialized variant of the Incoming References widget (`cf.platform.incomingReferences`), specifically designed for use with Person entities. While the standard Incoming References widget explicitly forbids embedding in Person pages (with the error message "Not embeddable in person; use myElements widget instead"), the My Elements widget provides this exact functionality for user profiles.
+
+## Use Cases
+
+1. **Personal Dashboard**: Display all pages and entities that reference a specific user on their profile page
+2. **User Activity Overview**: Show what projects, tasks, documents, or other entities are associated with a person
+3. **Relationship Visualization**: Help users understand their involvement and connections across the cplace system
+4. **Accountability Tracking**: Identify all items where a person is mentioned, assigned, or referenced
+
+## Key Features
+
+- Displays incoming references from other cplace pages to the Person entity
+- Automatically filters and presents references in a structured format
+- Shows relationships where the person is referenced in attributes of other entities
+- Context-aware display that understands Person-specific relationships
+
+## Configuration
+
+### Embedding Requirements
+
+- **Can be embedded in:** Person entities (and type definitions that apply to Person)
+- **Embedding type:** Widget embedding only
+- **Restrictions:** Widget cannot be embedded if already present (enforces single instance per page)
+
+### Configuration Options
+
+The widget uses the standard `WidgetConfiguration` infrastructure but does not expose custom configuration options. It works out-of-the-box with default settings.
+
+### Technical Details
+
+- **Template:** Uses `myElementsWidgetDefinition.htm` which delegates to `incomingReferences()` function
+- **Scope Object:** The Person entity being displayed
+- **Rendering:** Utilizes the same underlying mechanism as the Incoming References widget, but scoped to Person entities
+
+## Relationship to Other Widgets
+
+### Related Widgets
+
+1. **cf.platform.incomingReferences** (Incoming References)
+   - Parent/sibling widget with nearly identical functionality
+   - Cannot be used with Person entities
+   - My Elements is the Person-specific equivalent
+   - Both share the same underlying template mechanism (`incomingReferences()`)
+
+2. **cf.platform.wiki** (Wiki Widget)
+   - Another widget that supports Person entities
+   - Displays descriptive content rather than references
+   - Often used alongside My Elements on Person pages
+
+### Architectural Context
+
+The widget demonstrates the cplace pattern of creating entity-specific widget variants:
+- Standard widgets are restricted to certain entity types
+- Specialized widgets provide tailored functionality for specific entities
+- This ensures appropriate UI/UX for different contexts while sharing underlying implementation
+
+## Technical Implementation
+
+### Key Code Elements
+
+**Widget Definition:**
+```java
+public class MyElementsWidgetDefinition extends WidgetDefinition {
+    public static final String KIND = "cf.platform.myElements";
+
+    @Override
+    public void checkEmbeddableIn(PersistentEntity entity, WidgetEmbedding embedding) {
+        checkIsEmbeddedAsWidget(entity, embedding);
+        checkEntityKindAndAllowTypeDefinitionsWhichApplyToIt(entity, embedding, Person.class);
+    }
+}
+```
+
+**Template:**
+```html
+$this.incomingReferences()$
+```
+
+The template simply delegates to the `incomingReferences()` method, which handles the actual rendering of reference relationships.
+
+## Localization
+
+- **English:** My Elements
+- **German:** Meine Elemente
+
+The name emphasizes the personal/ownership aspect of the references displayed for the user.
+
+## Development Notes
+
+- Widget has no description in the localization files (description returns null)
+- Uses the standard WidgetTemplateSubstitution pattern
+- Belongs to the Platform App (PlatformPlugin.INSTANCE().platformApp)
+- No custom client-side assets or JavaScript components
+
+## Constraints and Limitations
+
+1. **Single Instance:** Cannot be embedded multiple times on the same Person page
+2. **Entity Type Restriction:** Only works with Person entities (enforced at widget definition level)
+3. **No Configuration:** Does not expose user-configurable options
+4. **Read-Only:** Displays references but does not provide editing capabilities