@cplace/test-mcp-server 0.1.15 → 1.1.0

package/dist/widget-specifications/cf.cplace.dragAndDropImageView.widget/_overview.md

@@ -0,0 +1,85 @@
+## Overview
+
+Displays an image from a file reference attribute and allows easy drag-and-drop upload. The widget provides a complete image management solution for cplace Pages, offering intuitive drag-and-drop functionality for image upload, selection from existing images, and removal. It integrates deeply with cplace's Document management and permission system, storing the image as a Page attribute reference rather than just a child Document.
+
+## Primary Use Cases
+
+1. **Hero Images**: Add prominent images to Pages such as project banners or product photos
+2. **Visual Context**: Provide visual representation for abstract content like process diagrams or flowcharts
+3. **Document Visualization**: Display document previews or scanned images
+4. **Profile Pictures**: Show images associated with person or organization Pages
+5. **Asset Management**: Quick access to upload and select from Page-attached images
+
+## User Interaction Patterns
+
+### When No Image Is Set
+
+The widget displays an upload button with file picker and a table of available images (existing Document children of the Page). Users can upload new images via drag-and-drop or file picker, or select from existing images by clicking the "Insert this Image" button.
+
+### When Image Is Set
+
+The image displays with configured scaling. A remove button (red X) appears in the top-right corner. Clicking the image opens it in a lightbox view. Clicking remove clears the attribute reference and returns to the "no image" state.
+
+### Permission Handling
+
+The widget respects cplace permissions:
+- If user lacks read permissions on the referenced Document, shows "insufficient rights" message
+- If user lacks edit permissions on the attribute, upload/remove buttons are hidden
+- If user lacks create document permissions on the Page, upload is disabled
+
+## Design Considerations
+
+### Why Store as Attribute Reference?
+
+Storing the image as an attribute reference (rather than just a child Document) enables:
+- **Querying**: Search for Pages by their image attribute
+- **Validation**: Enforce that exactly one image is set
+- **Workflows**: Trigger automations when the image changes
+- **Data Model**: Image becomes part of the Page's structured data
+
+### Scaling Options
+
+Three scaling modes support different layout needs:
+- **Horizontal**: Wide images that should fill width (banners, headers)
+- **Vertical**: Tall images that should fill height (portraits, posters)
+- **Fit**: Ensure entire image is visible without cropping
+
+### Available Images Feature
+
+The widget lists all image Documents on the Page to enable reuse of uploaded images, provide visual selection without browsing the file system, show metadata (name, size, modification date), and reduce duplicate uploads.
+
+## Configuration Requirements
+
+### Attribute Constraints
+
+The reference attribute must meet specific requirements:
+- Must be a reference attribute to Document type
+- Must have "At most one value" multiplicity (maximalOne)
+- Must be editable by the user
+- Cannot be used with multi-value attributes
+
+### Entity Type Constraint
+
+This widget is only embeddable in **Page** entities and cannot be used on other entity types.
+
+## Common Pitfalls
+
+- **Using multi-value attributes**: The widget requires "At most one value" multiplicity and will not work with multi-value reference attributes
+- **Wrong attribute type**: The attribute must be a reference to Document type, not a string or other type
+- **Insufficient permissions**: Users need both edit permissions on the attribute and create document permissions on the Page to upload images
+- **Multiple images needed**: This widget manages exactly one image reference - for multiple images, use image gallery widgets or multiple instances of this widget
+
+## Related Widgets
+
+### Widget Family
+
+This is the base widget in a family of three related widgets:
+
+- **cf.cplace.dragAndDropImageView.imageWithTextWidget** (Image with text): Extends the base widget by adding overlay text with configurable positioning and rich formatting (HTML)
+- **cf.cplace.dragAndDropImageView.imageWithTextAndListWidget** (Image with text and list): Further extends the image with text widget by adding a search/list component below the image, useful for showing related entities with a visual header
+
+### Alternative Widgets
+
+- **Image gallery widgets**: For displaying multiple images
+- **Simple image display widgets**: For read-only image display without upload capability
+- **Document list widgets**: For working with images not stored as Page attributes

package/dist/widget-specifications/cf.cplace.dragAndDropImageView.widget/_summary.md

@@ -0,0 +1 @@
+Displays an image from a file reference attribute and allows easy drag-and-drop upload.

package/dist/widget-specifications/cf.cplace.draggablePageList.widget/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.draggablePageList.widget",
+  "Description": "{\"en\":\"The “Drag and Drop Prioritization” widget displays pages (instances of types) in a sortable list. In the widget, you can change the order of the list entries using drag and drop. You can remove the sorting of an entry by moving an entry to the “Unsorted entries” column.\",\"de\":\"Das Widget „Drag-and-Drop-Priorisierung“ zeigt Seiten (Instanzen von Typen) in einer sortierbaren Liste an. Im Widget können Sie die Reihenfolge der Listeneinträge per Drag-and-Drop ändern. Sie können die Sortierung eines Eintrags aufheben, indem Sie einen Eintrag in die Spalte „Unsortierte Einträge“ verschieben.\"}",
+  "Localized Name": "{\"en\":\"Drag and Drop Prioritization\",\"de\":\"Drag-and-Drop-Priorisierung\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.draggablePageList",
+  "App": "cf.cplace.draggablePageList",
+  "Localized App Name": "{\"en\":\"Drag and Drop List\",\"de\":\"Drag-and-Drop-Liste\"}",
+  "Repository": "cplace-paw",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.cplace.draggablePageList.widget/_meta.json

@@ -0,0 +1,11 @@
+{
+  "tags": [
+    "list",
+    "drag-drop",
+    "sortable",
+    "searchable",
+    "navigation",
+    "inline-edit"
+  ],
+  "requiredApp": "cf.cplace.draggablePageList"
+}

package/dist/widget-specifications/cf.cplace.draggablePageList.widget/_overview.md

@@ -0,0 +1,93 @@
+## Overview
+
+The "Drag and Drop Prioritization" widget displays pages (instances of types) in a sortable list. In the widget, you can change the order of the list entries using drag and drop. You can remove the sorting of an entry by moving an entry to the "Unsorted entries" column.
+
+Instead of manually entering numeric priority values, users can simply drag items into the desired order, and the widget automatically persists the changes to a configurable numeric attribute. The widget displays items from a search query and can optionally separate sorted entries from unsorted ones in dual list layouts.
+
+## Use Cases
+
+### Task and Backlog Management
+- Managing task backlogs where items need to be ordered by priority
+- Sprint planning with drag-and-drop story prioritization
+- Work item ranking and ordering
+- Queue management for items awaiting processing
+
+### Roadmap and Planning
+- Ordering features or initiatives by priority
+- Timeline sequencing of deliverables
+- Release planning with priority-based sorting
+- Sequential process planning
+
+### Resource Management
+- Prioritizing resource requests or assignments
+- Budget allocation ordering
+- Service request queue management
+- Workflow step ordering
+
+## Operating Modes
+
+### Single List Mode
+Displays only sorted entries where all items have an order value assigned. This mode is suitable when you're working with a fully prioritized set of items and don't need to distinguish between sorted and unsorted entries. Configure by setting `showUnsortedEntries` to false.
+
+### Vertical Dual List Mode
+Displays sorted entries first with unsorted entries shown below. This layout works well for workflows where new items need to be reviewed and then dragged into the priority order. The vertical stacking makes it easy to scan both lists without horizontal scrolling. Configure by setting `showUnsortedEntries` to true and `showUnsortedEntriesHorizontallly` to false.
+
+### Horizontal Dual List Mode
+Shows sorted and unsorted entries side-by-side, useful for "backlog" versus "prioritized" visualization patterns. This mode provides a clear visual separation between items that have been prioritized and those awaiting prioritization, similar to Kanban-style boards. Configure by setting both `showUnsortedEntries` and `showUnsortedEntriesHorizontallly` to true.
+
+## Design Considerations
+
+### When to Use This Widget
+Choose this widget when:
+- You need visual management of priority or order for a set of pages
+- The order needs to be persisted in a numeric attribute
+- Users benefit from an intuitive drag-and-drop interface rather than manual numeric entry
+- You need to separate sorted items from unsorted/new items
+- You want to display responsible users and metadata alongside items
+
+### Data Model Requirements
+The widget requires:
+- A numeric attribute on the target page type for storing order/priority values
+- Optional user reference attribute for displaying responsible parties
+- Optional attributes for icons, labels, and blocked status indicators
+
+The search configuration must return pages of a single type to ensure consistent attribute handling.
+
+### Performance Considerations
+The widget includes a configurable hit count limit (default: 1000 items) to prevent performance issues with large datasets. When search results exceed this limit, the widget displays an error alert. Plan your search configuration to stay within this threshold or adjust the limit based on your performance requirements.
+
+### Permission Requirements
+Users need:
+- Edit permissions on the order attribute to reorder items through drag-and-drop
+- Read permissions to view the listed pages and their metadata
+
+## Rich Item Display
+
+Each item in the list can display multiple pieces of information:
+- **Item title** with clickable link to the page
+- **Type indicator icons** from a configurable attribute
+- **Responsible user avatars** with overflow handling (shows "+N" for additional users)
+- **Label indicators** from configurable attributes displayed as tags
+- **Additional icon attributes** for visual metadata
+- **Blocked item highlighting** based on a boolean/indicator attribute
+
+This rich display helps users make informed prioritization decisions without needing to open individual pages.
+
+## Common Pitfalls
+
+- **Search returning multiple types**: The widget requires search results to contain pages of a single type. If your search returns mixed types, you'll encounter validation errors.
+- **Missing order attribute**: Without a numeric attribute to store order values, the drag-and-drop functionality cannot persist changes.
+- **Exceeding hit count limits**: Large search results can trigger the hit count limit error. Refine your search or adjust the `hitCountLimit` setting.
+- **Incorrect attribute types**: The order attribute must be numeric and sortable. Using text or other attribute types will not work correctly.
+
+## Alternative Widgets
+
+- **cf.platform.embeddedSearchAsList**: Use this for standard search results lists when drag-and-drop ordering is not needed
+- **cf.cplace.dragAndDropImageView.imageWithTextAndListWidget**: Consider this alternative drag-and-drop widget for different visualization needs
+- **de.visualistik.visualRoadmap.widget**: For roadmap visualization that may incorporate similar prioritization concepts with timeline context
+
+## Related Patterns
+
+- **Master-Detail Pattern**: Combine with detail widgets to allow users to view and edit items without leaving the prioritization view
+- **Backlog Management**: Use horizontal dual list mode to implement backlog grooming workflows
+- **Priority Queue**: Use single list mode for simple priority queue management where all items are always sorted

package/dist/widget-specifications/cf.cplace.draggablePageList.widget/_summary.md

@@ -0,0 +1 @@
+Displays pages in a sortable list where users can change the order using drag and drop. Supports separating sorted and unsorted entries with the order persisted in a configurable numeric attribute.

package/dist/widget-specifications/cf.cplace.dynamicCodeBlockWidget.dynamicCodeBlockWidget/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.dynamicCodeBlockWidget.dynamicCodeBlockWidget",
+  "Description": "{\"en\":\"Represents a dynamically generated code block with content defined using cplaceJS.\",\"de\":\"Stellt einen dynamisch generierten Codeblock dar, dessen Inhalt via cplaceJS definiert wird.\"}",
+  "Localized Name": "{\"en\":\"Dynamic Code Block\",\"de\":\"Dynamischer Codeblock\"}",
+  "Icon": "fa-code",
+  "Plugin": "cf.cplace.dynamicCodeBlockWidget",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace-utility-widgets",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.cplace.dynamicCodeBlockWidget.dynamicCodeBlockWidget/_meta.json

@@ -0,0 +1,9 @@
+{
+  "tags": [
+    "low-code",
+    "rich-text",
+    "read-only",
+    "detail-view"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.cplace.dynamicCodeBlockWidget.dynamicCodeBlockWidget/_overview.md

@@ -0,0 +1,75 @@
+## Overview
+
+Represents a dynamically generated code block with content defined using cplaceJS. The widget displays formatted code snippets with syntax highlighting, where the code content is generated dynamically through a cplaceJS script. This widget is useful for showing code examples, configuration snippets, or any text content that benefits from code formatting, with the content determined at runtime based on page data or other dynamic criteria.
+
+**Use when you need to:**
+- Display code examples or snippets that change based on page context
+- Show dynamically generated configuration files or scripts
+- Present formatted text output from calculations or data transformations
+- Create documentation pages with context-aware code samples
+
+**Alternatives:**
+- **Rich Text Widget** - For static code blocks or when content doesn't need to be generated dynamically
+- **Low-Code Text Widget** - For plain text output without code formatting
+
+## Operating Modes
+
+### Dynamic Content Generation
+
+The widget's primary mode is to execute a cplaceJS expression that returns the code content to display. The script has access to the embedding page's context and can:
+- Extract attribute values and format them as code
+- Generate configuration snippets based on page properties
+- Construct code examples using template patterns
+- Transform data into formatted output
+
+**Typical scenarios:**
+- Showing API request examples with actual parameter values from the page
+- Displaying generated SQL queries based on filter selections
+- Presenting configuration snippets with environment-specific values
+- Creating documentation with examples that reflect current settings
+
+## Design Considerations
+
+### When to Use This Widget
+
+Use the Dynamic Code Block when:
+- The code content needs to be generated based on page data
+- You want syntax highlighting for better readability
+- The content should update when page attributes change
+- You need to show technical content (JSON, XML, code) in a formatted way
+
+Avoid when:
+- The code content is static and doesn't change (use Rich Text instead)
+- You need user interaction with the code (editing, copying with click)
+- The output is better suited to table or structured display
+- Performance is critical and the script is computationally expensive
+
+### Content Formatting
+
+The widget provides code block formatting with monospace font and syntax highlighting, making it ideal for technical content. Consider:
+- The readability of the generated content
+- Whether line numbers or specific syntax highlighting is needed
+- The length of the generated code (very long blocks may need scrolling)
+- How the code block integrates with surrounding widgets
+
+### Script Performance
+
+Since the cplaceJS expression executes on page load and potentially on updates:
+- Keep scripts lightweight and efficient
+- Avoid complex computations that could slow page rendering
+- Cache results when possible if the same code is generated repeatedly
+- Consider whether the dynamic generation is necessary or if static content would suffice
+
+## Common Pitfalls
+
+- **Complex script logic** - Overly complicated scripts make maintenance difficult; consider simplifying or using helper functions
+- **Missing error handling** - Scripts that fail silently leave the widget empty; include fallback content
+- **Excessive content** - Very long code blocks can overwhelm the page; consider pagination or showing excerpts
+- **Lack of context** - Without explanatory text nearby, users may not understand what the code represents
+
+## Related Patterns
+
+- **Documentation Generation** - Automatically creating code examples based on actual system configuration
+- **Configuration Display** - Showing current settings in a copy-pasteable format
+- **Query Builder Output** - Displaying the generated query that will be executed based on user selections
+- **API Documentation** - Creating endpoint examples with real parameter values from related pages

package/dist/widget-specifications/cf.cplace.dynamicCodeBlockWidget.dynamicCodeBlockWidget/_summary.md

@@ -0,0 +1 @@
+Represents a dynamically generated code block with content defined using cplaceJS.

package/dist/widget-specifications/cf.cplace.ecf.attribute.conversion.widget.enumMappingTable/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.ecf.attribute.conversion.widget.enumMappingTable",
+  "Description": null,
+  "Localized Name": "{\"en\":\"Enum Mappings\",\"de\":\"Aufzählungszuordnungen\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.ecf",
+  "App": "cf.cplace.ecf.ecfCore",
+  "Localized App Name": "{\"en\":\"Enterprise Connectivity Foundation Core App\",\"de\":\"Enterprise Connectivity Foundation Core App\"}",
+  "Repository": "cplace-ecf",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.cplace.ecf.attribute.conversion.widget.enumMappingTable/_meta.json

@@ -0,0 +1,10 @@
+{
+  "tags": [
+    "table",
+    "attributes",
+    "read-only",
+    "searchable",
+    "filterable"
+  ],
+  "requiredApp": "cf.cplace.ecf.ecfCore"
+}

package/dist/widget-specifications/cf.cplace.ecf.attribute.conversion.widget.enumMappingTable/_overview.md

@@ -0,0 +1,167 @@
+## Overview
+
+The Enum Mapping Table widget provides a specialized configuration interface for defining value-level mappings between enumeration attributes in cplace and their counterparts in external systems. It is a core component of the Enterprise Connect Foundation (ECF) framework, enabling administrators to configure how specific enum values should be translated during bidirectional synchronization.
+
+This widget displays enum mapping records in a table format, showing pairs of cplace enum values and external system enum values. Each row represents a single value mapping that will be used during data synchronization to ensure consistent translation between systems.
+
+## Primary Use Cases
+
+### External System Integration
+
+When integrating cplace with external systems (e.g., Jira, ServiceNow, custom REST APIs), enumeration attributes often have different value representations. For example:
+
+**Scenario**: Syncing project status between cplace and an external project management tool
+- **cplace values**: "Not Started", "In Progress", "Completed", "On Hold"
+- **External system values**: "TODO", "IN_PROGRESS", "DONE", "BLOCKED"
+
+The Enum Mapping Table widget allows administrators to define these mappings so that:
+- When syncing FROM external to cplace (INBOUND): "IN_PROGRESS" maps to "In Progress"
+- When syncing FROM cplace to external (OUTBOUND): "Completed" maps to "DONE"
+
+### Configuration Scenarios
+
+**Enumeration Attribute Mapping**
+- Map cplace enum attribute values to external system enum values
+- Support for different value names and labels between systems
+- Configure bidirectional mappings (inbound and outbound synchronization)
+
+**Boolean Attribute Mapping**
+- Special case of enum-like conversion for boolean attributes
+- Maps True/False values between systems that may use different representations (e.g., "Yes"/"No", "1"/"0", "Active"/"Inactive")
+
+**Synchronization Configuration**
+- Embedded within enum conversion pages as part of the broader ECF attribute mapping configuration
+- Enables attribute-level conversion rules for ECF connectors
+- Part of the complete sync configuration hierarchy
+
+## Design Considerations
+
+### Strict Embedding Context
+
+The widget can ONLY be embedded in:
+1. Pages of Enum Conversion types (`cf.cplace.ecf.enumConversion` or `cf.cplace.ecf.enumBooleanConversion`)
+2. Type definitions for Enum Conversion types
+
+The widget enforces these embedding rules strictly and will throw a `NotEmbeddableException` if embedded elsewhere. This ensures the widget always has access to the parent enum conversion context it requires.
+
+### Dynamic Value Population
+
+The widget displays two primary columns with dynamically populated values:
+
+**cplace Enum Values**
+- Automatically populated based on the attribute type configured in the parent attribute mapping
+- Supports custom attributes with enumeration constraints and built-in boolean attributes
+- For boolean attributes, shows "True" and "False" options
+- Values reflect the actual enum options available in cplace
+
+**External Enum Values**
+- Populated by external system connectors
+- Specific to the connector and external attribute being mapped
+- Reflects the actual enum options available in the external system
+
+### Data Filtering
+
+The widget automatically filters displayed mappings by:
+- Space (workspace of the conversion page)
+- Type (`cf.cplace.ecf.enumValueMapping`)
+- Conversion reference (shows only mappings for the current conversion)
+
+This ensures administrators only see mappings relevant to the current enum conversion being configured.
+
+## Configuration Workflow
+
+Typical configuration workflow:
+
+1. Create or edit a Sync Configuration
+2. Add an Attribute Mapping for an enum attribute
+3. System creates or references an Enum Conversion page
+4. Navigate to the Enum Conversion page
+5. The Enum Mapping Table widget displays automatically
+6. For each value pair:
+   - Select a cplace enum value from the dropdown
+   - Select the corresponding external enum value from the dropdown
+   - Save the mapping
+7. Repeat until all values are mapped
+8. Activate synchronization
+
+## Important Constraints
+
+**Manual Mapping Required**
+- While enum conversions can be auto-created, individual value mappings must be manually configured
+- No automatic value matching or suggestion is performed
+
+**One-to-One Mappings**
+- Each value can only map to one value in the opposite system
+- Multiple mappings for the same source value will cause errors during synchronization
+
+**Complete Mappings**
+- All non-null values must have explicit mappings
+- No default or fallback values are supported
+- Missing mappings will cause errors during synchronization
+
+**Immutability During Sync**
+- Mappings should not be modified while synchronization is running
+- Changes may not take effect until the next sync cycle
+
+## Integration Context
+
+### ECF Framework Integration
+
+The widget is part of the Enterprise Connect Foundation (ECF), which provides:
+- Common synchronization logic and UI configurations
+- Bidirectional data sync between cplace and external systems
+- Attribute mapping and conversion framework
+- Validation and error handling during sync
+
+### Widget Hierarchy
+
+```
+Sync Configuration Page
+└── Attribute Mapping Table
+    └── Attribute Mapping Page (for enum attribute)
+        └── Enum Conversion Page
+            └── Enum Mapping Table Widget
+                └── Individual Enum Value Mapping Pages
+```
+
+### Synchronization Flow
+
+**Configuration Phase** (uses this widget):
+1. Administrator creates attribute mapping
+2. System creates enum conversion page
+3. Widget displays to configure value mappings
+
+**Sync Execution Phase**:
+1. ECF reads enum value mappings
+2. Values are translated during sync using configured mappings
+3. System validates mappings are complete and unambiguous
+
+## Related Components
+
+**Generic Search As Table Widget** (`cf.platform.embeddedSearchAsTable`)
+- The Enum Mapping Table widget extends this base widget definition
+- Inherits standard table features (sorting, filtering, column selection)
+- Specializes the table for enum mapping configuration
+
+**Attribute Mapping Widgets**
+- Work alongside this widget in the broader ECF configuration
+- Define which attributes to sync and their mapping rules
+- Reference enum conversions when needed for enum/boolean attributes
+
+## Common Pitfalls
+
+**Incomplete Mappings**
+- Forgetting to map all enum values leads to sync errors
+- Ensure every non-null value has a corresponding mapping
+
+**Modifying During Active Sync**
+- Changing mappings while sync is running may cause inconsistent behavior
+- Always pause synchronization before modifying value mappings
+
+**Incorrect Embedding**
+- Attempting to embed the widget outside enum conversion pages will fail
+- The widget requires the parent enum conversion context to function
+
+**Ambiguous Mappings**
+- Creating multiple mappings for the same source value causes validation errors
+- Each value must have exactly one target mapping

package/dist/widget-specifications/cf.cplace.ecf.attribute.conversion.widget.enumMappingTable/_summary.md

@@ -0,0 +1 @@
+Displays and manages value-level mappings between cplace enumeration attributes and external system enumeration attributes for data synchronization in the Enterprise Connect Foundation (ECF).

package/dist/widget-specifications/cf.cplace.ecf.configuration.widget.attributeMappingTable/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.ecf.configuration.widget.attributeMappingTable",
+  "Description": null,
+  "Localized Name": "{\"en\":\"Attribute Mappings\",\"de\":\"Attributzuordnungen\"}",
+  "Icon": "cf-attribute-selection",
+  "Plugin": "cf.cplace.ecf",
+  "App": "cf.cplace.ecf.ecfCore",
+  "Localized App Name": "{\"en\":\"Enterprise Connectivity Foundation Core App\",\"de\":\"Enterprise Connectivity Foundation Core App\"}",
+  "Repository": "cplace-ecf",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.cplace.ecf.configuration.widget.attributeMappingTable/_meta.json

@@ -0,0 +1,10 @@
+{
+  "tags": [
+    "table",
+    "read-only",
+    "references",
+    "detail-view",
+    "searchable"
+  ],
+  "requiredApp": "cf.cplace.ecf.ecfCore"
+}

package/dist/widget-specifications/cf.cplace.ecf.configuration.widget.attributeMappingTable/_overview.md

@@ -0,0 +1,64 @@
+## Overview
+
+The Attribute Mapping Table widget displays all attribute mappings associated with a synchronization configuration in the Enterprise Connect Foundation (ECF) plugin. It provides a table view of how cplace attributes are mapped to external system attributes for data synchronization purposes.
+
+This widget automatically queries and displays all `Attribute Mapping` entities that reference the current synchronization configuration page, excluding the redundant "Configuration" column since the widget is embedded within the configuration page itself.
+
+## Use Cases
+
+### Primary Use Case: Configuring Data Synchronization
+
+When administrators set up data synchronization between cplace and an external system (like Jira, SAP, or other enterprise systems), they need to define which attributes should be synchronized and how. The Attribute Mapping Table widget provides a central view of all these mappings within a configuration.
+
+**Scenario**: An administrator is configuring a Jira integration to synchronize task data. They use this widget to:
+- View all existing attribute mappings at a glance
+- Understand which cplace fields map to which Jira fields
+- See the synchronization direction for each mapping
+- Identify which mappings have custom conversions applied
+
+### Supporting Use Cases
+
+1. **Configuration Review**: Review all attribute mappings for a synchronization configuration before enabling it
+2. **Troubleshooting**: When data isn't synchronizing correctly, use the table to verify mappings are configured as expected
+3. **Documentation**: Serves as a quick reference for what data flows between systems
+4. **Auditing**: Administrators can audit the complete attribute mapping setup for compliance
+
+## Design Considerations
+
+### Context Requirements
+
+**Embedding Constraint**: This widget can ONLY be embedded in pages of type `cf.cplace.ecf.syncConfiguration` (ECF Synchronization Configuration). Attempting to embed it in other page types will fail with a `NotEmbeddableException`.
+
+### Default Layout Integration
+
+The widget is automatically included in the **Configuration tab** of synchronization configuration pages:
+- The Configuration tab contains: Attributes widget + Attribute Mappings Table widget
+- The Synchronization tab contains: Sync Metadata Table widget
+
+This provides a logical separation between configuration elements and operational synchronization data.
+
+### Data Model
+
+The widget displays entities of type `cf.cplace.ecf.attributeMapping` which include:
+- **cplace Attribute**: The cplace attribute being mapped
+- **External Attribute**: The external system attribute being mapped
+- **Sync Direction**: INBOUND (external→cplace) or OUTBOUND (cplace→external)
+- **Conversion Parameters**: Optional conversion configuration for data transformation
+
+## Related Patterns
+
+### Related Widgets
+
+- **Sync Metadata Table Widget** (`cf.cplace.ecf.configuration.widget.syncMetadataTable`): Companion widget that displays synchronization metadata entities in the Synchronization tab
+- **Layout Tabs Widget** (`cf.cplace.layoutTabsWidget`): Used to organize the Configuration and Synchronization tabs
+
+### Dependencies
+
+- Requires the ECF plugin (`cf.cplace.ecf`) to be installed
+- Requires a connector app to provide the synchronization configuration types
+- Works with ECF synchronization framework components (SyncConfiguration, AttributeMapping, Conversion interfaces)
+
+## Common Pitfalls
+
+- **Incorrect Embedding**: Attempting to use this widget outside of ECF Synchronization Configuration pages will fail. This widget is specifically designed for ECF configurations and cannot be used as a general-purpose table widget.
+- **Missing Connector**: The widget requires an active ECF connector app to be installed. Without a connector, the synchronization configuration types won't be available.

package/dist/widget-specifications/cf.cplace.ecf.configuration.widget.attributeMappingTable/_summary.md

@@ -0,0 +1 @@
+Displays a table of attribute mappings that define how data fields are synchronized between cplace and external systems within a synchronization configuration.

package/dist/widget-specifications/cf.cplace.ecf.connector.extension.widget.cleanupConfigTable/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.ecf.connector.extension.widget.cleanupConfigTable",
+  "Description": null,
+  "Localized Name": "{\"en\":\"Sync Cleanup Job Configurations\",\"de\":\"Konfigurationen der Synchronisierungsbereinigungsjobs\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.ecf",
+  "App": "cf.cplace.ecf.ecfCore",
+  "Localized App Name": "{\"en\":\"Enterprise Connectivity Foundation Core App\",\"de\":\"Enterprise Connectivity Foundation Core App\"}",
+  "Repository": "cplace-ecf",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.cplace.ecf.connector.extension.widget.cleanupConfigTable/_meta.json

@@ -0,0 +1,11 @@
+{
+  "tags": [
+    "table",
+    "searchable",
+    "references",
+    "navigation",
+    "selectable",
+    "scheduling"
+  ],
+  "requiredApp": "cf.cplace.ecf.ecfCore"
+}