GbReportViewer — the one report screen behind every report in GB5

Overview

A "report" in GB5 is a configured MREPORTVIEW row hanging off a menu item. Opening that menu item loads <gb-reportviewer>, which in turn loads the report's metadata, its default view, and its filter criteria, then renders whichever view type the admin configured for that view — a plain grid, a cross-tab pivot, a formatted HTML statement, or a portlet dashboard.

Component architecture

Two more components plug in for specific view types: app-gbstandardhtml renders the Html view's sanitized HTML string, and gb-dynamicwidget (borrowed from the main dashboard feature) renders each portlet in a Page view.

The 5 view types, at a glance

Full technical detail on each is in the reference table below and the developer dispatch section.

Applying Filters & Criteria

Every report opens with its filter panel (gb-filter) either visible alongside the grid or reachable via a "Filter" control, depending on the screen. The panel lists the report's configured criteria fields — text, picklist, date, and dependent-picklist fields — plus a date-range control driven by period presets.

Period filters explained

The date-range dropdown offers a fixed set of presets, each resolving to a concrete from/to date under the hood:

Saving & loading a filter configuration

If you find yourself re-entering the same criteria every time, save it as a named Configuration:

• Open the filter panel's Configuration tab.
• Pick an existing saved configuration from the searchable dropdown, or type a new name to create one.
• Click Save — enabled once a name is entered. Re-saving under the same name overwrites it.
• Picking a saved configuration from the dropdown immediately repopulates every filter field from it.
• Delete removes the currently-selected saved configuration.

Switching view types

If a report has more than one configured view (e.g. both a Grid and a Pivot view of the same data), a dropdown in the action bar lets you switch between them. Switching views re-triggers the underlying data load — a Pivot view in particular recomputes its columns every time criteria change, since the set of pivot columns depends on what distinct values are actually in the result.

Exporting a report

The action bar's Settings menu offers PDF, CSV, Excel, and "Grid Export" options, depending on what the report is configured to allow. An admin can restrict which formats appear for a given report (see ReportConfig) and cap how many rows a single export can contain — if your export would exceed that cap, you'll see a dialog telling you it was capped, rather than a silent partial file.

Scheduling a report

Where enabled (see ReportConfig's "Schedulable" setting), the action bar shows a Scheduler option. This opens the Job Worker dialog, pre-filled with the report's current filter criteria, where you choose:

Submitted jobs appear in My Jobs, with live status (Pending → Running → Completed/Failed/Cancelled) updated in real time, plus Cancel, Clone, Delete, and Download-Result actions.

Configuring Report Views

Report views are configured in the Report View Setting admin screen (gbreportviewsetting). Its wizard's first step is literally labeled "View Type" — a card grid to pick Grid / Template / Pivot / Html / Page for the view you're creating.

Setting up a Pivot view

Checking "Enable Data Pivot" on a view reveals extra per-field columns in the Properties step:

ReportConfig — per-report governance

Beyond the view itself, a separate ReportConfig record governs cross-cutting behavior for a report: which export formats are offered, how many rows an export may contain, how long its metadata stays cached, and whether it can be scheduled. See the full field reference for every setting.

Page/Portlet dashboards (View=4)

A Page-type view points at an MPAGE record via its PageId. That page's portlet layout (type, position, size, criteria, drill-down routing) is managed the same way the main dashboard's portlets are — through MPORTLET/MUSERVSPORTLET/MROLEVSPORTLET configuration. Portlet types available: Chart, Map, Datatable, Single/Multiple Card, Report, HTML, Markdown, Video, Announcement, Overall DB Card, Category Card. Portlets can publish/subscribe to each other on the same page (selecting a row in one portlet filters others) via configured pub/sub channel names.

Managing who can schedule a report

Set IsSchedulable = 1 on a report's ReportConfig to show the Scheduler option to its users. This defaults to 0 (hidden) for any report without a ReportConfig row — deliberately restrictive, since scheduling is a capability that should be turned on per-report, not exposed everywhere by default.

Known gaps for admins

• ReportConfig admin screen has no route/menu entry — needs one added before it's usable.
• The drag-and-drop Pivot Rows/Columns/Values wizard step exists but its trigger button is commented out.
• There is no recurring ("every Monday") scheduling option for reports today — only one-shot job submission. See Scheduler architecture for the reason.

Data Flow & Request Lifecycle

Opening a report (ngOnChanges → defaultreportsettings()) fires four requests concurrently via forkJoin, only resolving isLoading once all four settle (each wrapped in its own catchError, so one failing doesn't starve the others):

const rows$ = Rowservice(...).pipe(map(res => applyRowServiceResult(res)), catchError(...));
const criteriaConfig$ = CriteriaConfigservice(...).pipe(...);
const viewFields$ = viewseletionsetting(selectedview);  // Grid metadata, or Pivot/Page setup
const reportConfig$ = ReportConfigservice(menuReportId).pipe(...);

forkJoin([rows$, criteriaConfig$, viewFields$, reportConfig$])
  .subscribe(() => { this.isLoading = false; this.cdr.detectChanges(); });

View type dispatch — viewseletionsetting()

All view-type branching lives in one method in reportviewer.component.ts. Grid and Pivot branch on the numeric View value; everything else branches on the SecondTemplateLocation string:

if (selectedview.View == 0) {
  viewFields$ = this.executeGridViewSetup(selectedview);      // fetches ReportViewFieldsservice
} else if (selectedview.View == 2) {
  this.viewtype = 'PIVOT';                                // no separate metadata fetch —
  this.columnData = [];                              // columns are self-describing per response
} else if (selectedview.View == 4) {
  this.viewtype = 'PAGE';
  viewFields$ = this.loadPageView(selectedview);           // loads portlets via PortletLoaderService
} else {
  // Template / Html / fallback-Grid, dispatched via SecondTemplateLocation
}

Grid's column definitions are fetched once up front (executeGridViewSetup → ReportViewFieldsservice) because they're fixed, admin-configured fields. Pivot's are not fetched up front — they're rebuilt from every row-service response, because the pivot column set genuinely changes with the data (different date ranges → different Jan/Feb/Mar columns).

Response contracts per view type

All four call sites that handle a Rowservice response (defaultreportsettings, drilldownsettings, ApplyFilter, ReloadoRefresh, paginationfn) are consolidated into one shared applyRowServiceResult(), which branches on viewtype:

private applyRowServiceResult(res: any, isInfiniteScroll = false): void {
  const pivotPayload = this.viewtype === 'PIVOT' ? this.extractPivotPayload(res) : null;
  if (pivotPayload) {
    this.rowData = [...pivotPayload.rows, { ...pivotPayload.grandTotal, __grandTotal: true }];
    this.columnData = this.buildPivotColumnDefs(pivotPayload.rowHeaders, pivotPayload.pivotColumns);
  } else {
    this.rowData = this.extractReportDetail(res);   // flat ReportDetail array (Grid/Template/Html)
  }
  ...
}

Pivot's confirmed backend contract (same endpoint as everything else, POST /cos/Common.svc/Report — the backend routes internally off ReportViewId):

{
  "rowHeaders":   ["Department", "Region"],
  "pivotColumns": ["Jan_Amount", "Feb_Amount", "Mar_Amount"],
  "rows": [{ "Department": "Sales", "Region": "North", "Jan_Amount": 12345.00 }],
  "grandTotal": { "__grandTotal": true, "Jan_Amount": 22221.00 }
}

Dynamic pivot column keys follow {colDimensionValue}_{summaryFieldTitle}. Page/Portlet's contract is a portlet layout array — see PortletLoaderService.loadPortlets() for the exact mapping into DashboardItems.

ReportConfig wiring

Fetched as the forkJoin's 4th member via ReportConfigservice(menuReportId) (Analytics.ReportConfig.ByReport, through the shared FormActiondbservice — no cross-project import needed since that service lives in features/gblayout/). Resolves to null on 404/error, which every consumer treats as "use defaults", not a failure:

Caching architecture

• Report row data itself is never cached. reportData()'s dexieboolean parameter defaults to false and no caller anywhere passes it true — deliberate, matches the platform-wide rule against caching financial/ledger data.
• Metadata is cached (CriteriaConfig picklist, ReportViewFields, ReportConfig itself) via gbhttppost/gbhttpget's Isstore flag, default TTL 600000ms (10 min).
• TTL is now per-call configurable — gbhttpget/gbhttppost both take an optional trailing ttlMs param (defaults to 600000, so every existing caller is unaffected). DexieService.postgetApiResponse() enforces the same TTL on the read side.
• Invalidation uses gbhttpservice.gbremovedexieurl(routeKey) — called after any admin save that changes cached metadata (e.g. ReportConfig.save()/delete() invalidate Analytics.ReportConfig.ByReport).

Scheduler architecture — two separate systems

Extending the stack

Adding a new view type

1. Add a numeric branch in viewseletionsetting(), set this.viewtype to a new string.
2. If it needs its own data shape, extend applyRowServiceResult()/add an extract*Payload() helper — don't bend extractReportDetail().
3. Add a template branch keyed on the new viewtype string in reportviewer.component.html.

Adding a new export format

Add the format string to AllowedExportFormats's comma-separated convention, add an *ngIf gate on allowedExportFormats.includes('X') in gbreportaction.component.html, implement the actual export call.

Adding a new portlet type

Register it in WidgetComponentMap and handle its PortletTypeName in gbdynamicwidget.component.ts's renderWidget() switch.

Key files reference

Reference

View type table (MREPORTVIEW.REPORTVIEWTYPE)

ReportConfig field reference

API route reference (dot-code keys)

FAQ & known issues