Apps
Apps
What an app is, how it is structured (datasets, workspaces, components), and where its settings and configuration are edited.
An app (App) is the user interface of a plan. It is a named, access-controlled set of views through which users read and edit the plan's data. An app belongs to exactly one plan and never holds data of its own: every number it shows is stored in a value type in that plan, and every edit is written back to that value type.
An app is built from three layers:
- Datasets say which data the app works with: a set of value types, the dimensions to show them by, and the rules that shape the data (initial values, locked values, filters, computed rows).
- Workspaces say how the data is presented: filters, data-type selection, layout and the components on each page.
- Components are the individual building blocks, such as a table, a chart, a metric box or a text block. Every data component reads from one dataset.
Actions (Handlingar) are an additional part of a workspace. They are small forms that run a Kex write script, for example to create a new project or remove rows.
Structure#
- Plandimensions, value types, calculations
- Datasetvalue types × dimensions, rules
- Workspacefilters, data types, layout
- Componenttable, chart, metric, text
- Workspaceper workspace
- Action componentvariables + Kex write script
An app has one or more datasets and one or more workspaces. A component points to a dataset by its ID, so several components, in the same workspace or in different ones, can share a dataset. Two tables on the same dataset can, for example, each show a different value type by using component filters (see Workspaces and components).
| Layer | Holds | Page |
|---|---|---|
| App | name, description, access, lock state | this page |
| Dataset | value types, dimensions and properties, initial values, locked values, dataset filter, expressions, row-level access | Datasets |
| Workspace | filter row, data types and references, value type names and order, layout, action components | Workspaces and components |
| Component | table, text, metric, chart, or a placed action | Workspaces and components |
| Action component | variables and a Kex script | Actions |
Apps hold no logic of their own
Business logic lives in the plan: in calculations, which run automatically when their source data changes, and in dataset expressions, which are evaluated when the data is loaded. Removing an app removes the view, not the data it showed. See Calculations.
Where apps are managed#
In plan administration, apps are listed under Interaction (Interaktion) together with access lists (Behörighetslistor). The breadcrumb for an app reads Plans /
Each row in the app list has a menu (⋯):
| Menu entry | Swedish label | Effect |
|---|---|---|
| Open app as end user | Öppna app som slutanvändare | opens the app in the end-user interface |
| Edit permissions | Ändra behörigheter | opens the app's access settings |
| Copy name / Copy ID | Kopiera namn till urklipp · Kopiera id till urklipp | copies the app name or GUID to the clipboard |
| Copy app | Kopiera app | creates a copy of the app |
| Delete app | Ta bort app | deletes the app |
Inside the app editor, the menu (⋯) next to the app name has:
| Menu entry | Swedish label | Effect |
|---|---|---|
| Rename | Byt namn | changes the app name |
| Copy | Kopiera | asks for a name (default |
| Delete | Ta bort | deletes the app |
| Hide / Show | Dölj · Visa | hides the app from end users, or shows it again; saved with Save (Spara) |
| Edit XML | Redigera XML | opens the raw configuration, see App configuration |
| Delete comments | Radera kommentarer | removes the cell comments made in the app |
A copy gets the configuration, name and description of the original. Cell comments are not copied; they belong to the app they were written in.
App settings#
App settings are edited under Settings (Inställningar) in the app editor.
Name and description#
The name is shown in app lists and breadcrumbs. The description (Beskrivning) is formatted text edited in a rich-text editor. End users open it with the information icon at the top right inside the app, so it is the natural place for instructions on how to use the app.
Name and description are stored on the app record, not in the app configuration. Copying the configuration from one app to another does not copy them. See App configuration.
App access#
App access (Appåtkomst) controls who can open the app:
- An access list for the app as a whole. Without a list, everyone with access to the plan can open the app.
- Row-level access per dataset: read access or read and write access, inherited from the app, full, or limited by a specific list. See Datasets.
- Lock app (Lås appen) blocks data entry in the app for all users. It does not block changes to the app's configuration.
Access lists are defined in the plan and apply across apps. For details see Security.
Visibility in app lists#
Hide sets Access/@Enabled to false in the configuration. A hidden app:
- is marked with a crossed-out eye in the admin app list and in the editor header;
- disappears from the end-user app lists;
- cannot be opened by URL either: the app shows Åtkomst nekad (access denied), also for administrators.
The app still exists and keeps its configuration and comments. Show (Visa) makes it available again.
The app editor#
Konstrukt has a complete graphical editor for app configuration. Everything described in the app pages can be set in the editor; the raw XML (or JSON through MCP) is an alternative, not a requirement.
The editor has three top-level areas:
| Area | Swedish label | Content |
|---|---|---|
| Settings | Inställningar | app access, lock, description |
| Workspace | Arbetsyta | one tab per workspace |
| Dataset | Dataset | one section per dataset: value type cards and the dimensions matrix |
Each workspace has six tabs:
| Tab | Swedish label | Content |
|---|---|---|
| Components | Komponenter | the components and their settings |
| Filters | Filter | the workspace filter row |
| Data type / references | Datatyp / referenser | plan data and references offered in the workspace |
| Value types | Värdetyper | display names and order of value types |
| Actions | Handlingar | action components |
| Layout | Layout | multi-page or grid layout |
A component has the fields component name (Komponentnamn), visibility, dataset, type (Typ) and show headers (Visa rubriker), and four sub-tabs: Settings (Inställningar), Custom aggregations and spreads (Egna aggregeringar och spridningar), Presentation rules (Presentationsregler) and Columns (Kolumner).
Test an app as a role
The top bar has Act as (Agera som), which switches the session to a role so that an administrator can see an app as that role sees it. Use it to check access lists and read-only settings before handing an app over.
Configuration format and schema version#
Behind the editor, an app configuration is stored as XML with a root element <App SchemaVersion="…">. The current schema version is 1.50. Older configurations are migrated step by step when they are read, followed by migrations that depend on the plan version (v1 or v2). A configuration therefore always reaches the current shape before it is used.
The same configuration is exposed as typed JSON through the MCP server, described by a JSON Schema whose types agents read with the MCP tool get_app_config_schema. Agents can read the configuration of any app and write configurations for apps in v2 plans. See App configuration (XML/JSON).
Saving is not round-trip
When a configuration is saved, it is rebuilt from the configuration model. XML that the model does not read, such as comments, unknown attributes and formatting, is not kept. See App configuration.
Copy before large changes
Changes to app configurations are recorded like all other changes, but no version history is shown in the interface. Copy the app, or save its XML, before large changes.
Sub-pages#
- Datasets: value types, dimensions, spreading, initial values, locked values, expressions and row-level access.
- Workspaces and components: filters, data types, layouts, tables, presentation rules, metrics and charts.
- Actions: action components, the generator, variables and scripts.
- Using apps: what end users see, cell inspection, read-only cells, comments and editing.
- App configuration (XML/JSON): the underlying configuration and how agents work with it.