diff --git a/solutions/custom_solutions/Generic_Penalty_Box/Generic_Penalty_Box_Configuration.md b/solutions/custom_solutions/Generic_Penalty_Box/Generic_Penalty_Box_Configuration.md new file mode 100644 index 0000000000..b534c77ba9 --- /dev/null +++ b/solutions/custom_solutions/Generic_Penalty_Box/Generic_Penalty_Box_Configuration.md @@ -0,0 +1,358 @@ +--- +uid: Generic_Penalty_Box_Configuration +description: "Configure the Generic Penalty Box app using the config.json file: map data, shape cards, tune real-time behavior, and brand your alarm wall." +--- + +# Configuring the Generic Penalty Box + +Every data-facing part of the Generic Penalty Box, including parameter IDs, element properties, card fields, detail panels, grouping rules, branding, and real-time settings, is declared in a single *config.json* file. To have the wall show information for a different connector, all you need is a configuration change, not a code change. + +Below you can find an overview of the different settings available in *config.json*. + +> [!NOTE] +> *config.json* is reloaded whenever you refresh the app, so any edits you make take effect immediately on the next browser refresh. + +## configVersion + +Stamps the schema *config.json* was written against. + +This key is required. The schema at the time of the initial release of the app is version `1`. If a future release changes the schema, this is the key that lets the app tell you plainly that your file is written using a different version, instead of failing with unrelated "missing key" errors. + +Example: + +```json +"configVersion": 1 +``` + +## Branding + +Allows you to customize the app to show specific branding. + +### Example + +```json +"branding": { + "title": "Network Penalty Box", + "subtitle": "NOC Infrastructure Monitor", + "logoUrl": "logo.png", + "emptyStateTitle": "network devices" +} +``` + +### Reference + +| Key | Type | Description | +|-----|------|-------------| +| `title` | string | The name of the app shown in the header and set as the browser tab title. | +| `subtitle` | string | The secondary line shown next to the title in the app header. | +| `logoUrl` | string | The path to the logo image, relative to the app folder. | +| `emptyStateTitle` | string | The plural noun shown in the all-clear message. For example, if this is `"network devices"`, the message will show "All network devices are operating normally." | + +## dataSource + +Controls how the app fetches its data from DataMiner. + +### Example + +```json +"dataSource": { + "scriptName": "GetGenericPenaltyBoxData", + "protocolName": "Generic Dummy", + "pollIntervalMs": 4000, + "stalenessThresholdMs": 15000 +} +``` + +### Reference + +| Key | Type | Description | +|-----|------|-------------| +| `scriptName` | string | The name of the DataMiner automation script that returns the penalty box JSON payload. | +| `protocolName` | string | The connector name passed to the script so it knows which elements to scan. | +| `pollIntervalMs` | number | How often (in ms) to poll the script when real-time updates are disabled or unavailable (see [realtime](#realtime)). | +| `stalenessThresholdMs` | number | If polling has not been successful for this length of time (in ms), cards are dimmed to indicate stale data. | + +## parameterIds + +Maps human-readable configuration keys to DataMiner parameter IDs for the given connector. These keys are referenced throughout [cardFields](#cardfields), [detailPanels](#detailpanels), and [groupingOptions](#groupingoptions). + +Every entry must be a positive integer parameter ID. The automation script reads exactly these parameters for every element and returns them under `params` in the JSON response. + +Example: + +```json +"parameterIds": { + "deviceStatus": 1, + "serviceType": 3, + "uptimePercent": 21, + "chargePercent": 209 +} +``` + +## elementProperties + +Maps configuration output keys to a DataMiner element custom property name, using the same left-to-right direction as [parameterIds](#parameterids) (configuration key on the left, DataMiner source on the right). + +The keys (on the left) are what you reference in [cardFields](#cardfields) and [groupingOptions](#groupingoptions) when the `source` key is set to `"property"`. Each key reads exactly one property name; if an element carries the value under a different property name, it will not be picked up. + +Example: + +```json +"elementProperties": { + "region": "Region", + "siteCode": "SiteCode", + "location": "Location" +} +``` + +## groupingOptions + +An array of grouping modes shown in the *Grouping* toolbar dropdown box. Users will be able to switch between them at runtime, and the last choice will be remembered per browser. + +This key is **optional**. For a flat, ungrouped wall, omit it or leave it set to `[]`. + +### Example + +```json +"groupingOptions": [ + { + "key": "serviceType", + "source": "parameter", + "label": "Group by service tier", + "tiers": [ + { "value": "Core", "tier": "core", "label": "Core - Backbone" }, + { "value": "Distribution", "tier": "distribution", "label": "Distribution - Aggregation" }, + { "value": "Access", "tier": "access", "label": "Access - Edge" } + ] + }, + { "key": "region", "source": "property", "label": "Group by region", "dynamic": true }, + { "key": "location", "source": "property", "label": "Group by location", "dynamic": true } +] +``` + +### Reference + +Each option object supports the following keys: + +| Key | Type | Required | Description | +|-----|------|----------|-------------| +| `key` | string | Yes | The [parameterIds](#parameterids) key (when `source` is `"parameter"`) or the [elementProperties](#elementproperties) output key (when `source` is `"property"`). | +| `source` | `"parameter"` or `"property"` | Yes | Where to read the group value from. | +| `label` | string | Yes | Text shown in the grouping dropdown. | +| `tiers` | array | Only when `dynamic` is not `true` | Fixed set of group buckets, listed in rank order (the first entry listed shows first). | +| `dynamic` | boolean | No | When `true`, groups are created automatically from whatever values exist. No `tiers` are needed. Unassigned elements collect in an "Unassigned" bucket. | + +Each tier object (inside `tiers`) supports the following keys: + +| Key | Type | Description | +|-----|------|-------------| +| `value` | string or number | The raw parameter or property value that matches this tier. | +| `tier` | string | Internal identifier for the tier (used in CSS class names). | +| `label` | string | Header text shown above the group on the wall. | + +The list order of the tiers is their rank order: the first tier listed is shown first, using the same convention as [cardFields](#cardfields). Inserting a new tier just means placing it where it should rank, not renumbering the rest. Each non-dynamic grouping option must define its own `tiers`; there is no fallback shared between grouping options. + +## cardFields + +Controls which data appears on each alarm card, in what order it is shown, and how it is formatted. + +The list order is the display order **and** drop order: the first field listed is the first to disappear as cards are progressively hidden while shrinking. Fields marked `"pinned": true` never drop. + +As the wall fills with elements, the fit algorithm automatically makes cards narrower and hides lower-priority fields first, in the order they are listed. Fields marked `"pinned": true` are always visible regardless of card size. + +![Card with all configured fields shown](~/solutions/images/Generic_Penalty_Box_Card_Fields_Example.png) + +### Example + +```json +"cardFields": [ + { "key": "alarm.time", "label": "Last alarm" }, + { "key": "deviceStatus", "label": "Status", "format": "text", "icon": "device_hub", "alarmColor": true, "pinned": true }, + { "key": "serviceType", "label": "Tier", "format": "text", "icon": "hub" }, + { "key": "location", "label": "Location", "format": "text", "source": "property", "icon": "location_on" }, + { "key": "connectionState","label": "Connection", "format": "text", "icon": "cable", "alarmColor": true }, + { "key": "alarm.message", "label": "Message" }, + { "key": "uptimePercent", "label": "Uptime", "format": "percent", "icon": "av_timer", "alarmColor": true }, + { "key": "vendor", "label": "Vendor", "format": "text" } +] +``` + +### Reference + +| Key | Type | Description | +|-----|------|-------------| +| `key` | string | A [parameterIds](#parameterids) key, an [elementProperties](#elementproperties) output key, or one of the reserved keys `alarm.time` and `alarm.message`. | +| `label` | string | The display label shown before the value. | +| `format` | `"text"`, `"percent"`, `"runtime"`, or `"number"` | How to format the value. `"percent"` appends `%`; `"runtime"` formats seconds as `Xh Ym`; `"number"` accepts an optional `unit` value (any string) and a `decimals` sub-key (an integer) indicating how many decimal places to show. Omit for `alarm.time` and `alarm.message`. | +| `source` | `"parameter"` or `"property"` | Defaults to `"parameter"`. Set to `"property"` for values from `elementProperties`. | +| `icon` | string | A `DataMinerIcons` ligature name shown next to the value (decorative only). If the name is not recognized, the literal text is shown on the card instead of an icon. | +| `batteryLevel` | boolean | When `true`, the value is rendered as a battery gauge icon instead of `icon`, tinted with this field's alarm color. | +| `alarmColor` | boolean | When `true`, the value text (and, for `batteryLevel` fields, the gauge) is tinted with the color of the active alarm on that specific parameter. This is the only per-field coloring mechanism; there is no client-side threshold. | +| `pinned` | boolean | When `true`, the field is never dropped as cards shrink, regardless of its position in the list. | + +> [!NOTE] +> `DataMinerIcons` ligature names largely follow the naming convention of [Google's Material Symbols](https://fonts.google.com/icons), so that gallery can be used to browse for an appropriate icon name. Not every Material Symbols name is available in `DataMinerIcons`, and `DataMinerIcons` also has some names of its own, so always verify that the chosen name renders as an icon rather than as literal text. + +The reserved `key` values are namespaced under `alarm.` so that a real parameter can safely be named `time` or `message` without colliding: + +| Key | Description | +|-----|-------------| +| `alarm.time` | Shows the age of the most recent alarm, for example "Last alarm 3m ago". If no explicit entry is listed for it, it drops first, before any listed field. | +| `alarm.message` | Shows the highest-severity alarm's parameter name and display value. If no explicit entry is listed for it, it is never dropped. | + +## detailPanels + +Defines the tabular panels shown in the detail overlay when a card is clicked. Panels are shown in the order listed. Each panel groups related fields under a heading. + +### Example + +```json +"detailPanels": [ + { + "title": "Device Identity", + "fields": [ + { "key": "ipAddress", "label": "IP Address", "format": "text" }, + { "key": "vendor", "label": "Vendor", "format": "text" }, + { "key": "model", "label": "Model", "format": "text" } + ] + }, + { + "title": "Service", + "fields": [ + { "key": "serviceType", "label": "Service Tier", "format": "text" }, + { "key": "deviceStatus", "label": "Device Status","format": "text" } + ] + } +] +``` + +![Detail overlay showing configured panels](~/solutions/images/Generic_Penalty_Box_Detail_Panels_Example.png) + +### Reference + +Each panel supports the following keys: + +| Key | Type | Description | +|-----|------|-------------| +| `title` | string | The panel heading. | +| `fields` | array | List of fields to display in the panel, using the same field structure as [cardFields](#cardfields). | + +Each entry in `fields` supports the following keys: + +| Key | Type | Description | +|-----|------|-------------| +| `key` | string | Identifier matching a [parameterIds](#parameterids) key (default) or an [elementProperties](#elementproperties) output key when `source` is `"property"`. | +| `label` | string | Display label. | +| `format` | string | Same values as [cardFields](#cardfields) (`"text"`, `"percent"`, `"number"`, `"runtime"`). | +| `source` | string | `"parameter"` (default) reads from script parameters; `"property"` reads from element properties (keys defined in [elementProperties](#elementproperties)). | +| `alarmColor` | boolean | When `true`, the value is tinted with the color of the active alarm on that specific parameter, using the same mechanism as in [cardFields](#cardfields). | + +## realtime + +Enables WebSocket push updates layered on top of polling. When this is enabled, alarm counts and parameter values update within seconds without waiting for the next poll cycle. + +The *Live*/*Offline* indicator in the header will show the current push state. + +![*Live* indicator in the Generic Penalty Box header](~/solutions/images/Generic_Penalty_Box_Live_indicator.png) + +### Example + +```json +"realtime": { + "enabled": true, + "reconnectMs": 3000, + "pollIntervalMs": 300000 +} +``` + +### Reference + +| Key | Type | Description | +|-----|------|-------------| +| `enabled` | boolean | Set to `true` to turn on WebSocket push updates. Falls back to polling-only when `false` or absent. | +| `reconnectMs` | number | How long (in ms) to wait before reconnecting after a dropped WebSocket. Default: `3000`. | +| `pollIntervalMs` | number | Poll interval used when `enabled` is `true`. Can be much longer than the polling-only interval, as push updates will fill the gaps. | + +## severityPalette + +Maps severity names to CSS color values, used by the alarm-tinted card fields (when `alarmColor` is `true` in [cardFields](#cardfields)) and the battery gauge. This key is optional; omit it entirely to use the built-in theme colors, and only add it if you want to override one or more of them. + +The defaults reference CSS custom properties defined in the theme, so dark and light mode automatically apply the correct tones. Override with any valid CSS color value. + +Example: + +```json +"severityPalette": { + "critical": "var(--sev-critical)", + "major": "var(--sev-major)", + "minor": "var(--sev-minor)", + "warning": "var(--sev-warning)" +} +``` + +## defaults + +Sets what a first-time visitor sees, before they have made any choices in the toolbar. Their choices are remembered per browser afterward. + +### Example + +```json +"defaults": { + "minSeverity": "warning", + "grouping": "serviceType", + "hideTimeout": true +} +``` + +### Reference + +| Key | Type | Description | +|-----|------|-------------| +| `minSeverity` | `"critical"`, `"major"`, `"minor"`, or `"warning"` | Minimum severity shown on first load. | +| `grouping` | string | A `groupingOptions[].key` value to select as the initial grouping mode. Falls back to the first entry in `groupingOptions` if omitted or invalid. | +| `hideTimeout` | boolean | Initial state of the *Show elements in timeout* option (`true` hides the elements in timeout). | + +> [!NOTE] +> All three keys are optional and only apply once, i.e., the first time a browser visits. The user's own choice always takes over after that. + +## layout + +Controls card sizing and density behavior. + +### Example + +```json +"layout": { + "minCardPx": 200, + "minLegibleCardPx": 150, + "showMoreThreshold": true +} +``` + +### Reference + +| Key | Type | Description | +|-----|------|-------------| +| `minCardPx` | number | The target minimum card width in pixels. The grid fills available space and does not go below this value. | +| `minLegibleCardPx` | number | Below this width, extra fields are hidden to keep the card readable. | +| `showMoreThreshold` | boolean | When `true`, an indicator on small cards signals that fields have been hidden. | + +## monitoring + +When enabled, a *View in Monitoring* button is shown in the detail overlay, linking directly to the element in the DataMiner Monitoring app. A small link icon will also be shown on each card. To see what this looks like, refer to [Using the Generic Penalty Box](xref:Generic_Penalty_Box_Usage#external-monitoring-link). + +### Example + +```json +"monitoring": { + "enabled": true, + "urlTemplate": "" +} +``` + +### Reference + +| Key | Type | Description | +|-----|------|-------------| +| `enabled` | boolean | Shows the monitoring link in the detail overlay. | +| `urlTemplate` | string | Custom URL pattern. `{dmaId}` and `{elementId}` are substituted at runtime. Leave empty to use the DataMiner default path. | diff --git a/solutions/custom_solutions/Generic_Penalty_Box/Generic_Penalty_Box_Installation.md b/solutions/custom_solutions/Generic_Penalty_Box/Generic_Penalty_Box_Installation.md new file mode 100644 index 0000000000..f522884525 --- /dev/null +++ b/solutions/custom_solutions/Generic_Penalty_Box/Generic_Penalty_Box_Installation.md @@ -0,0 +1,27 @@ +--- +uid: Generic_Penalty_Box_Installation +description: "Install the Generic Penalty Box app and set up one or multiple real-time alarm walls on your DataMiner Agent with flexible, environment-specific config." +--- + +# Installing the Generic Penalty Box + +## Deploying the Generic Penalty Box + +1. Deploy the Generic Penalty Box solution from the Catalog. + +1. When the deployment is complete, go to the folder `C:\Skyline DataMiner\Webpages\Public\generic-penalty-box` on the DataMiner Agent. + +1. Edit *generic-penalty-box/config.json* to match your environment (protocol name, parameter IDs, etc.). + + > [!TIP] + > For details, see [Configuring the Generic Penalty Box](xref:Generic_Penalty_Box_Configuration). + +1. Browse to `http://[DMA name]/public/generic-penalty-box/` in a web browser. + +## Creating additional penalty boxes + +It is possible to display multiple penalty box walls on the same DataMiner Agent, each with its own configuration, for example, one per connector or one per site. + +To do this, copy the deployed *generic-penalty-box* folder in `C:\Skyline DataMiner\Webpages\Public` and rename the copy, for example to *generic-penalty-box-eaton-ups*. + +You can then configure each copy independently by editing its own [*config.json*](xref:Generic_Penalty_Box_Configuration), and you can access the copies using the folder name, for example, `http://[DMA name]/public/generic-penalty-box-eaton-ups/`. diff --git a/solutions/custom_solutions/Generic_Penalty_Box/Generic_Penalty_Box_Overview.md b/solutions/custom_solutions/Generic_Penalty_Box/Generic_Penalty_Box_Overview.md new file mode 100644 index 0000000000..3658267602 --- /dev/null +++ b/solutions/custom_solutions/Generic_Penalty_Box/Generic_Penalty_Box_Overview.md @@ -0,0 +1,15 @@ +--- +uid: Generic_Penalty_Box_Overview +description: "Discover the Generic Penalty Box app, which provides a real-time wall of active issues with smart grouping, filtering, and fast drill-down." +--- + +# Generic Penalty Box + +A **penalty box** is an exception-only monitoring view used in broadcast Master Control Rooms (MCRs) and IT/Network Operations Centers (NOCs). Unlike a dashboard that shows the full inventory of monitored items, a penalty box shows **only the items currently in an error, degraded, or alarm state**, and keeps them visible until the issue is acknowledged or resolved. + +Generic Penalty Box is a DataMiner application that puts a live wall display of active alarms in front of your team. It watches every element of a connector you choose and shows only the elements currently in alarm. These are presented as easy-to-scan cards ordered by severity, so the most urgent issues stand out first. The wall updates itself automatically as alarms change, and the entire look and feel, including what is shown, how it is organized, and how it is branded, can be adjusted after deployment without rebuilding the app. + +> [!IMPORTANT] +> After deploying the Generic Penalty Box solution, you must edit [*config.json*](xref:Generic_Penalty_Box_Configuration) to match your environment before the app can be used. See [Installing the Generic Penalty Box](xref:Generic_Penalty_Box_Installation). + +![Generic Penalty Box wall](~/solutions/images/Generic_Penalty_Box_No_Grouping.png) diff --git a/solutions/custom_solutions/Generic_Penalty_Box/Generic_Penalty_Box_Use.md b/solutions/custom_solutions/Generic_Penalty_Box/Generic_Penalty_Box_Use.md new file mode 100644 index 0000000000..868d69bc3b --- /dev/null +++ b/solutions/custom_solutions/Generic_Penalty_Box/Generic_Penalty_Box_Use.md @@ -0,0 +1,99 @@ +--- +uid: Generic_Penalty_Box_Usage +description: "Learn how to use the Generic Penalty Box app to track alarms in real time, filter them, group them, and view detailed insights." +--- + +# Using the Generic Penalty Box + +## Overview of the app components + +![Overview of the Generic Penalty Box UI, with numbers indicating specific sections](~/solutions/images/Generic_Penalty_Box_UI_Components.png) + +The app consists of the following main components: + +1. [Real-time updates indicator](#real-time-updates-indicator) and [theme selector](#theme-selector). +1. Toolbar with, from left to right, an indicator of the total number of items in alarm, a [severity filter](#severity-filter), [timeout visibility](#timeout-visibility-setting) checkbox, and [grouping selection box](#grouping-selection-box). +1. Cards showing the items currently in an error, degraded, or alarm state. Clicking a card shows a [detail view](#detail-view). Depending on the configuration, cards can have an [external monitoring link](#external-monitoring-link). + +### Real-time updates indicator + +The *Live*/*Offline* indicator in the header indicates whether the app currently shows real-time information. + +Real-time updates are available when [realtime.enabled](xref:Generic_Penalty_Box_Configuration#realtime) is set to `true` in the *config.json* configuration. In this case, the app opens one WebSocket session per monitored element using the *Generic Parameter Webhook* GQI data source. Parameter value changes arrive within seconds and update card fields immediately, without waiting for the next polling cycle. A separate alarm page subscription updates severity and alarm counts. On a WebSocket disconnect, the app reconnects automatically after the configured `reconnectMs` interval. + +### Theme selector + +The theme button in the upper-right corner cycles through the options *Dark*, *Light*, and *System*. When you select an option, your choice is remembered per browser. + +![Generic Penalty Box app in light mode](~/solutions/images/Generic_Penalty_Box_Light_Mode.png) + +### Severity filter + +The *Min severity* dropdown box allows you to select the minimum severity level for which cards are shown. Any cards below the selected severity level will be hidden. + +For example, selecting *Major* removes all warning-only cards, so that the wall only shows the most important problems. + +This filter is runtime-only and resets to the configured default ([defaults.minSeverity](xref:Generic_Penalty_Box_Configuration#defaults) in *config.json*) when the app is loaded again. + +![Generic Penalty Box app with the severity dropdown list expanded, showing the different severities you can select](~/solutions/images/Generic_Penalty_Box_Severity_Dropdown.png) + +### Timeout visibility setting + +The *Show elements in timeout* checkbox in the toolbar reveals elements that are in a communications timeout state. + +Elements in timeout are hidden by default because their alarm data is stale. Showing them allows you to monitor how many elements are currently unreachable. + +### Grouping selection box + +In the upper-right corner of the app UI, you can find the *Grouping* dropdown box. You can use this to switch between the different modes defined for the app (using the [groupingOptions](xref:Generic_Penalty_Box_Configuration#groupingoptions) in the configuration file): + +- **Tier-based**: elements are placed into named buckets by matching their value against the configured tiers. Groups appear in the same order the tiers are listed (the first one listed shows first). Elements that match no tier collect in an "Uncategorized" bucket. +- **Dynamic**: groups form automatically from the distinct values that exist in live data. This is useful for properties like *region* or *location*, where the set of values is not fixed in advance. New values appear as new group headers automatically. +- **No grouping**: a flat grid sorted by severity and alarm recency. + +The active grouping is remembered per browser. + +![Generic Penalty Box app with "No grouping" selected, showing a flat list](~/solutions/images/Generic_Penalty_Box_No_Grouping.png) + +![Generic Penalty Box app with cards grouped by service tier](~/solutions/images/Generic_Penalty_Box_Grouped_By_Tier.png) + +![Generic Penalty Box app with cards grouped by region](~/solutions/images/Generic_Penalty_Box_Grouped_By_Region.png) + +### Detail view + +Click any card to open the detail overlay. It consists of the following components: + +- **Header**: Shows a severity indicator, the element name, and a criticality tier label. +- **Config-driven panels**: These panels can show different information depending on the [detailPanels](xref:Generic_Penalty_Box_Configuration#detailpanels) configuration in *config.json*. +- **Active alarms**: A full list of all relevant alarms, showing severity, parameter name, display value, and timestamp. +- **Properties**: The custom properties of the DataMiner element, as configured in [elementProperties](xref:Generic_Penalty_Box_Configuration#elementproperties) in *config.json*. +- **Monitoring link**: See [External monitoring link](#external-monitoring-link). + +![Generic Penalty Box app with detail overlay opened](~/solutions/images/Generic_Penalty_Box_Detail_View.png) + +### External monitoring link + +When enabled in the *config.json* configuration (i.e., [monitoring.enabled](xref:Generic_Penalty_Box_Configuration#monitoring) is set to `true`), an external monitoring link icon is shown on each card, and a *View in Monitoring* button is available at the bottom of the detail overlay. + +Both links open the element in the DataMiner Monitoring app in a new browser tab, using the URL pattern defined in *config.json* (using `monitoring.urlTemplate`). + +Below you can see what a card looks like when this setting is disabled or enabled: + +| Link disabled | Link enabled | +|--|--| +| ![Card with monitoring link disabled](~/solutions/images/Generic_Penalty_Box_Monitoring_Link_Card_Off.png) | ![Card with monitoring link enabled](~/solutions/images/Generic_Penalty_Box_Monitoring_Link_Card_On.png) | + +If the setting is enabled, a blue button is shown at the bottom of the detail overlay: + +![Detail overlay with monitoring link enabled](~/solutions/images/Generic_Penalty_Box_Monitoring_Link_Detail_On.png) + +## Mobile and responsive layout + +The wall adapts to the available viewport without a separate mobile build: + +- Cards fill the viewport in as many columns as fit at the configured [layout.minCardPx](xref:Generic_Penalty_Box_Configuration#layout) width. +- If a field is listed earlier in the [cardFields](xref:Generic_Penalty_Box_Configuration#cardfields) configuration in *config.json*, it is hidden first as cards narrow below `layout.minLegibleCardPx`. +- Fields that have been pinned (with `"pinned": true` in *config.json*) are always visible at any card size. +- The detail overlay slides in as a full-height panel on tablet viewports. + +![iPad landscape layout of the Generic Penalty Box app](~/solutions/images/Generic_Penalty_Box_Mobile_Layout.png) diff --git a/solutions/images/Generic_Penalty_Box_Card_Fields_Example.png b/solutions/images/Generic_Penalty_Box_Card_Fields_Example.png new file mode 100644 index 0000000000..93f7dce995 Binary files /dev/null and b/solutions/images/Generic_Penalty_Box_Card_Fields_Example.png differ diff --git a/solutions/images/Generic_Penalty_Box_Detail_Panels_Example.png b/solutions/images/Generic_Penalty_Box_Detail_Panels_Example.png new file mode 100644 index 0000000000..c5b2018b40 Binary files /dev/null and b/solutions/images/Generic_Penalty_Box_Detail_Panels_Example.png differ diff --git a/solutions/images/Generic_Penalty_Box_Detail_View.png b/solutions/images/Generic_Penalty_Box_Detail_View.png new file mode 100644 index 0000000000..4170d9e180 Binary files /dev/null and b/solutions/images/Generic_Penalty_Box_Detail_View.png differ diff --git a/solutions/images/Generic_Penalty_Box_Grouped_By_Region.png b/solutions/images/Generic_Penalty_Box_Grouped_By_Region.png new file mode 100644 index 0000000000..6f014027ed Binary files /dev/null and b/solutions/images/Generic_Penalty_Box_Grouped_By_Region.png differ diff --git a/solutions/images/Generic_Penalty_Box_Grouped_By_Tier.png b/solutions/images/Generic_Penalty_Box_Grouped_By_Tier.png new file mode 100644 index 0000000000..d5e752f22e Binary files /dev/null and b/solutions/images/Generic_Penalty_Box_Grouped_By_Tier.png differ diff --git a/solutions/images/Generic_Penalty_Box_Light_Mode.png b/solutions/images/Generic_Penalty_Box_Light_Mode.png new file mode 100644 index 0000000000..fbd02a3f3d Binary files /dev/null and b/solutions/images/Generic_Penalty_Box_Light_Mode.png differ diff --git a/solutions/images/Generic_Penalty_Box_Live_indicator.png b/solutions/images/Generic_Penalty_Box_Live_indicator.png new file mode 100644 index 0000000000..ecb6762bdd Binary files /dev/null and b/solutions/images/Generic_Penalty_Box_Live_indicator.png differ diff --git a/solutions/images/Generic_Penalty_Box_Mobile_Layout.png b/solutions/images/Generic_Penalty_Box_Mobile_Layout.png new file mode 100644 index 0000000000..20968ccb6a Binary files /dev/null and b/solutions/images/Generic_Penalty_Box_Mobile_Layout.png differ diff --git a/solutions/images/Generic_Penalty_Box_Monitoring_Link_Card_Off.png b/solutions/images/Generic_Penalty_Box_Monitoring_Link_Card_Off.png new file mode 100644 index 0000000000..6470a27303 Binary files /dev/null and b/solutions/images/Generic_Penalty_Box_Monitoring_Link_Card_Off.png differ diff --git a/solutions/images/Generic_Penalty_Box_Monitoring_Link_Card_On.png b/solutions/images/Generic_Penalty_Box_Monitoring_Link_Card_On.png new file mode 100644 index 0000000000..c063f6bde6 Binary files /dev/null and b/solutions/images/Generic_Penalty_Box_Monitoring_Link_Card_On.png differ diff --git a/solutions/images/Generic_Penalty_Box_Monitoring_Link_Detail_On.png b/solutions/images/Generic_Penalty_Box_Monitoring_Link_Detail_On.png new file mode 100644 index 0000000000..9df43913d0 Binary files /dev/null and b/solutions/images/Generic_Penalty_Box_Monitoring_Link_Detail_On.png differ diff --git a/solutions/images/Generic_Penalty_Box_No_Grouping.png b/solutions/images/Generic_Penalty_Box_No_Grouping.png new file mode 100644 index 0000000000..26e7f228d2 Binary files /dev/null and b/solutions/images/Generic_Penalty_Box_No_Grouping.png differ diff --git a/solutions/images/Generic_Penalty_Box_Severity_Dropdown.png b/solutions/images/Generic_Penalty_Box_Severity_Dropdown.png new file mode 100644 index 0000000000..21b50144b1 Binary files /dev/null and b/solutions/images/Generic_Penalty_Box_Severity_Dropdown.png differ diff --git a/solutions/images/Generic_Penalty_Box_UI_Components.png b/solutions/images/Generic_Penalty_Box_UI_Components.png new file mode 100644 index 0000000000..4fce3643e4 Binary files /dev/null and b/solutions/images/Generic_Penalty_Box_UI_Components.png differ diff --git a/solutions/toc.yml b/solutions/toc.yml index d2004aaecd..3a043e2d7e 100644 --- a/solutions/toc.yml +++ b/solutions/toc.yml @@ -538,6 +538,15 @@ items: topicUid: Open_Putty_with_DITT - name: Implementing DITT in a visual overview topicUid: Implementing_DITT_in_Visio + - name: Generic Penalty Box + topicUid: Generic_Penalty_Box_Overview + items: + - name: Installing the Generic Penalty Box + topicUid: Generic_Penalty_Box_Installation + - name: Configuring the Generic Penalty Box + topicUid: Generic_Penalty_Box_Configuration + - name: Using the Generic Penalty Box + topicUid: Generic_Penalty_Box_Usage - name: DataMiner Health Check Tool topicUid: DataMiner_Health_Check_Tool items: