Timill Platform Documentation

Backend Scripts

Mon, 01 Jan 0001 00:00:00 +0000

Create server-side automation scripts triggered by events, schedules, or manual execution. Supports two languages: JavaScript (Goja) and Gonja (Jinja2-style templates).

Getting Started#

Creating a Script#

Navigate to Group Settings → Backend Scripts
Click New Script
Choose a language: JavaScript or Gonja
Write your script code
Set the trigger type and schedule
Save and test

Script Structure#

JavaScript Example#

// Get the current item
var item = item;

// Update the status
item.SetStatus("approved");
item.Save();

// Add a comment
item.AddComment("Automatically approved by backend script");

// Send a notification
log("Item " + item.Title() + " has been approved");

Gonja (Jinja2) Example#

{# Update item status #}
{% set item = item %}
{{ item.SetStatus("completed") }}
{{ item.Save() }}

{# Log the change #}
{{ log("Item " ~ item.Title() ~ " completed") }}

Trigger Types#

Type	Description	Configuration
Manual	Execute on demand from UI	None
Schedule	Run on cron schedule	Cron expression (e.g., `0 9 * * *`)
Event	Fire on specific events	Event type + optional conditions
Save Hook	Run after every item save	Optional field conditions

Available Events#

Event	Trigger
`CREATE`	Item is created
`UPDATE`	Item is updated
`DELETE`	Item is deleted
`STATUS_CHANGE`	Item status changes
`FIELD_UPDATE`	Specific field is updated
`ASSIGN`	Item is assigned/unassigned
`COMMENT_CREATE`	Comment is added

Language Features#

JavaScript (Goja ES5.1)#

Best for: Complex logic, external API calls, data transformations

Browsing Items

Mon, 01 Jan 0001 00:00:00 +0000

The item browser is the primary interface for viewing and managing work items of a given type within a group. Items are shown in a configurable, spreadsheet-like table that loads more rows as you scroll.

Filtering#

Use the filter bar to narrow the list by field values. The filter accepts a query syntax that supports AND / OR logic, for example:

Chart - Status Pie Chart

Mon, 01 Jan 0001 00:00:00 +0000

Display item distribution by status as a pie chart.

Example Code#

function generateChart(api, params, context) {
 const items = api.queryItems("type = 'task'");
 const byStatus = api.groupBy(items, 'status');
 
 return echarts.createPieChart(byStatus, {
 title: 'Task Status Distribution',
 colors: ['#4ade80', '#fbbf24', '#f87171', '#60a5fa']
 });
}

Full Example#

See source: source-files/01_status_pie_chart.js

Customization#

Change query:

const items = api.queryItems("type = 'ticket'");

Add colors:

return echarts.createPieChart(byStatus, {
 title: 'Status Distribution',
 colors: ['#4ade80', '#fbbf24', '#f87171', '#60a5fa', '#c084fc']
});

General Settings

Mon, 01 Jan 0001 00:00:00 +0000

The general settings page lets group administrators configure the basic identity of a group.

Available settings#

Group name – The display name shown in navigation and listings. It can be edited inline.
Group icon – Upload an image to visually identify the group across the interface.

Deleting the group#

Deleting a group is a destructive action that requires confirmation and removes the group and its data. It is restricted to administrators with the appropriate permission.

Getting Started

Mon, 01 Jan 0001 00:00:00 +0000

Timill is an enterprise project management platform. This guide walks you through the basics to get up and running quickly.

First steps#

Sign in — use your credentials or an external authentication provider (Google, GitHub, OIDC) if configured by your administrator.
Explore your dashboard — after signing in you land on your personal dashboard, which shows widgets summarizing activity across your groups.
Join or create a group — groups are the main organizational unit. Each group has its own items, pages, members, and settings.
Browse items — navigate to a group and open the item browser to view, filter, and manage work items.
Customize your experience — rearrange dashboard widgets, save filters, and configure notifications to match your workflow.

Key concepts#

Instance — the top-level deployment of Timill, managed by instance administrators.
Group — a project workspace containing items, pages, members, and configuration.
Item — a work unit (task, bug, story, etc.) with typed fields, comments, attachments, and history.
Role — a named set of permissions assigned to group members to control access.

Getting help#

Anywhere in the app, click the help icon in the topbar to open the contextual help panel for the page you’re on. The panel shows the relevant section of these docs without leaving the app.

REST API

Mon, 01 Jan 0001 00:00:00 +0000

REST API reference for Timill Platform including all endpoints and request/response formats.

Base URL#

https://your-domain.com/api/v1

Authentication#

All endpoints require JWT authentication except public endpoints:

Authorization: Bearer <token>

Endpoints#

Instance-admin endpoints (/api/v1/admin/...) — listing every group on the instance and managing manual Plus subscriptions — live on a separate, scope-gated surface, documented for instance admins inside your own instance at /docs/api-reference/admin-rest-api/.

Viewing Pages

Mon, 01 Jan 0001 00:00:00 +0000

Pages are custom group screens built from widgets. They are used for landing pages, overviews, dashboards, and reference material that the whole group can share.

Pages are accessible from the group sidebar and appear as a flat, ordered list (group administrators control the order). Each page has a title and optional icon.

Reading a page#

A page renders the widgets an administrator has placed on it — for example item lists, charts, calendars, kanban boards, or free-text panels. Written content lives inside Free Text widgets, which support headings, lists, links, tables, and images.

Widget - Simple Item List

Mon, 01 Jan 0001 00:00:00 +0000

Basic item list with filtering by item type.

Example Code#

<div class="bg-white rounded-lg shadow">
 {{$items := queryItems (printf "type='%s'" .itemType)}}
 <h3 class="text-lg font-semibold p-4 border-b">{{.title}} ({{len $items}})</h3>
 
 <div class="divide-y">
 {{range $items}}
 <div class="p-3 hover:bg-gray-50">
 <div class="flex items-center justify-between">
 <span class="font-medium">{{.Title.Get}}</span>
 <span class="text-sm {{statusColor .Status.Get}}">{{.Status.Get}}</span>
 </div>
 </div>
 {{else}}
 <p class="p-4 text-gray-500">No items found</p>
 {{end}}
 </div>
</div>

Parameters#

Parameter	Type	Default	Description
`itemType`	string	`"task"`	Item type to filter by
`title`	string	`"Items"`	Widget title

Customization#

Change the item type:

Chart - User Workload Bar Chart

Mon, 01 Jan 0001 00:00:00 +0000

Display workload distribution across users.

Example Code#

function generateChart(api, params, context) {
 const items = api.queryItems("type = 'task'");
 const byUser = api.groupBy(items, 'assignee');
 
 const labels = Object.keys(byUser);
 const values = labels.map(u => byUser[u].length);
 
 return echarts.createBarChart({
 labels: labels,
 values: values
 }, {
 title: 'User Workload',
 xLabel: 'User',
 yLabel: 'Tasks'
 });
}

Full Example#

See source: source-files/02_user_workload_bar.js

Customization#

Filter by status:

const items = api.queryItems("type = 'task' status = 'open'");

Configuring a Group

Mon, 01 Jan 0001 00:00:00 +0000

Configure and manage groups, item types, and team settings in Timill Platform.

Creating Groups#

Navigate to Global Admin → Groups
Click Create Group
Enter group details:
- Name
- Description
- Icon
- Color
Set initial members
Create

Group Settings#

Basic Settings#

Name: Display name for the group
Description: Group description
Icon: Group icon
Color: Group accent color

Membership#

Members: Users with access to the group
Roles: Custom roles with specific permissions
Limits: Max users per group (instance setting)

Item Types#

Creating Item Types#

Go to Group Settings → Item Types
Click Create Item Type
Configure:
- Name (e.g., Tasks, Tickets, Orders)
- Icon
- Custom fields
- Statuses
- UI layout

Item Type Configuration#

Setting	Description
Name & Icon	Visual identity
Custom Fields	Additional data fields beyond defaults
Statuses	Workflow states (Open → In Progress → Done)
UI Layout	How item detail page is organized
Disabled Fields	Default fields to hide
Field Defaults	Pre-populated values for new items
Mandatory Rules	Conditional required field rules
Default Value Rules	Conditional auto-fill rules

Custom Fields#

Supported field types:

Dashboard

Mon, 01 Jan 0001 00:00:00 +0000

The personal dashboard is the first screen you see after signing in. It is your own private space for an at-a-glance view of work across the groups you belong to.

Widgets#

The dashboard is composed of widgets arranged on a grid. Widget types available on the dashboard include:

Item List — a live list of items matching a query.
Calendar — items plotted by their date fields.
Gantt — a timeline of items with dates and dependencies.
Pie Chart and Burndown Chart — item distribution and progress over time.
Free Text — any HTML/text content you want to pin.
Scripted Chart and Scripted Widget — custom widgets you build with code (Plus plan).

Each widget can pull data from a single group or, on the dashboard, from all the groups you belong to at once.

Editing Pages

Mon, 01 Jan 0001 00:00:00 +0000

Pages are edited with the same drag-and-drop widget editor used for dashboards. Editing a page means arranging widgets on a grid rather than typing into a document.

The layout editor#

In edit mode you can:

Add widgets — pick a widget type and configure its data source and display options.
Move and resize widgets by dragging them around the grid.
Remove widgets you no longer need.

For written content (text, headings, lists, links, tables, images), add a Free Text widget and edit its HTML content.

Scripted Widgets

Mon, 01 Jan 0001 00:00:00 +0000

Create custom HTML widgets using Go’s html/template syntax with built-in query helpers and automatic RBAC enforcement. Widgets are rendered server-side and integrated into pages and dashboards.

Getting Started#

Navigate to any page or dashboard
Click Add Widget → Scripted Widget
Enter a name and description
Write your Go template code
Save and preview

Every scripted widget consists of:

Viewing an Item

Mon, 01 Jan 0001 00:00:00 +0000

Opening an item displays its full detail view, where you can inspect and edit all of its data. The layout of the detail view is defined by the item type, so different types can arrange their fields into custom sections and columns.

Fields#

Each item has a set of typed fields defined by the group’s item type configuration — text, numbers, dates, dropdown lists, user and item references, attachments, and more. Edit a field by clicking on its value; changes are saved as you go.

Widget - Status Dashboard

Mon, 01 Jan 0001 00:00:00 +0000

Count items by status and display in a grid.

Example Code#

<div class="grid grid-cols-4 gap-4">
 {{$items := queryItems "type = 'task'"}}
 {{$open := filter $items "status = 'open'"}}
 {{$progress := filter $items "status = 'in-progress'"}}
 {{$review := filter $items "status = 'review'"}}
 {{$done := filter $items "status = 'done'"}}
 
 <div class="bg-blue-100 p-4 rounded text-center">
 <div class="text-2xl font-bold">{{len $open}}</div>
 <div class="text-sm">Open</div>
 </div>
 
 <div class="bg-yellow-100 p-4 rounded text-center">
 <div class="text-2xl font-bold">{{len $progress}}</div>
 <div class="text-sm">In Progress</div>
 </div>
 
 <div class="bg-purple-100 p-4 rounded text-center">
 <div class="text-2xl font-bold">{{len $review}}</div>
 <div class="text-sm">Review</div>
 </div>
 
 <div class="bg-green-100 p-4 rounded text-center">
 <div class="text-2xl font-bold">{{len $done}}</div>
 <div class="text-sm">Done</div>
 </div>
</div>

Customization#

Add more status columns:

Chart - Priority Scatter Plot

Mon, 01 Jan 0001 00:00:00 +0000

Display priority vs due date as a scatter plot.

Example Code#

function generateChart(api, params, context) {
 const items = api.queryItems("type = 'task'");
 
 const data = items
 .filter(i => i.DueDate() !== null)
 .map(i => ({
 value: [
 new Date(i.DueDate()).getTime(),
 getPriorityScore(i.GetField('priority'))
 ],
 item: i
 }));
 
 return echarts.createScatterChart(data, {
 title: 'Priority vs Due Date',
 xLabel: 'Due Date',
 yLabel: 'Priority'
 });
}

function getPriorityScore(priority) {
 switch(priority) {
 case 'critical': return 4;
 case 'high': return 3;
 case 'medium': return 2;
 case 'low': return 1;
 default: return 0;
 }
}

Full Example#

See source: source-files/03_priority_scatter.js

Customization#

Change priority values:

function getPriorityScore(priority) {
 switch(priority) {
 case 'critical': return 100;
 case 'high': return 75;
 case 'medium': return 50;
 case 'low': return 25;
 default: return 0;
 }
}

Group Home

Mon, 01 Jan 0001 00:00:00 +0000

The group home page is the landing page when you navigate into a group. It is a configurable widget page — built with the same widgets and layout editor as dashboards and other group pages — so its contents are whatever a group administrator has chosen to put there.

What you will find#

By default, a new group’s home page shows the Welcome widget, which summarises the group’s setup (item types, pages, members) and offers quick links to get started.

MCP Server

Mon, 01 Jan 0001 00:00:00 +0000

Timill ships a Model Context Protocol server bundled inside the platform itself, so AI agents (Claude, and any MCP-capable host) can read and write your Timill data the same way the REST API does — e.g. “Create a goal and a few tasks for John, blocked by the Q2 launch.”

It is served over Streamable HTTP at the path /mcp on your instance, and exposes a small set of generic tools (no hardcoded item types — they adapt to your group’s schema). Every call is authenticated per-user and enforced by the same RBAC that governs the rest of the app: an agent can only ever see and do what the authenticating user can.

Members

Mon, 01 Jan 0001 00:00:00 +0000

The members page lets group administrators control who has access to the group and what role they hold.

Adding members#

Add users by searching for their name or email. When adding a member, assign them a role that determines their permissions within the group. The number of members a group can hold may be capped by the group’s plan or an instance-wide limit.

Scripted Charts

Mon, 01 Jan 0001 00:00:00 +0000

Create dynamic data visualizations using JavaScript with Apache ECharts. Charts run in both the browser and backend (Goja VM) with full RBAC enforcement.

Getting Started#

Creating a Chart#

Navigate to any page or dashboard
Click Add Widget → Scripted Chart
Enter a name and description
Write your JavaScript code
Save and preview

Chart Structure#

Every chart script follows this pattern:

Widget - Recent Activity

Mon, 01 Jan 0001 00:00:00 +0000

Display the 5 most recently updated items.

Example Code#

<div class="bg-white rounded-lg shadow">
 {{$items := queryItems "type = 'task'"}}
 {{$recent := sort $items "updatedAt" "desc" | first 5}}
 
 <h3 class="text-lg font-semibold p-4 border-b">Recent Activity</h3>
 
 <div class="divide-y">
 {{range $recent}}
 <div class="p-3">
 <div class="flex items-center space-x-2">
 <span class="font-medium">{{.Title.Get}}</span>
 <span class="text-xs text-gray-500">{{.UpdatedAt.Get | formatDate}}</span>
 </div>
 <div class="text-sm text-gray-600">{{.Description.GetHTML | truncate 100}}</div>
 </div>
 {{else}}
 <p class="p-4 text-gray-500">No recent activity</p>
 {{end}}
 </div>
</div>

Customization#

Change the number of items:

Roles

Mon, 01 Jan 0001 00:00:00 +0000

Roles define what members are allowed to do within a group. Timill uses role-based access control (RBAC) with support for fine-grained, field-level permissions.

Creating and editing roles#

Create custom roles from the roles administration page. Each role has a name and a set of permissions that control access to items, pages, and group administration.

Permissions#

Permissions are organized by area (items, pages, admin). For each area you can grant abilities such as create, read, update, and delete. Permissions are additive – a role only has the capabilities explicitly granted to it.

Scripting API Reference

Mon, 01 Jan 0001 00:00:00 +0000

Complete JavaScript (Goja ES5.1) scripting API for backend scripts, widget scripts, and chart scripts.

Global Variables#

Variable	Type	Description
`userId`	`string`	Current user ID
`groupId`	`string`	Group ID (if group-scoped)
`instanceId`	`string`	Instance ID
`scriptId`	`string`	Current script ID
`scriptType`	`string`	`"backend"`, `"widget"`, or `"chart"`
`itemId`	`string`	Item ID (if item-scoped)
`isGroupScoped`	`boolean`	True if script runs in a group context
`isInstanceScoped`	`boolean`	True if script runs at instance level
`isItemScoped`	`boolean`	True if script runs on a specific item

`user` Object#

Available in all script types. Backend scripts get read-write access.

Page Administration

Mon, 01 Jan 0001 00:00:00 +0000

The pages section lets group administrators manage the group’s pages — the custom, widget-based screens shown in the group sidebar.

Managing pages#

Pages appear as a single ordered list. From here you can create, rename, reorder, and delete pages. Drag a page to change where it sits in the navigation sidebar.

The home page#

Every group has a special home page that serves as its landing screen. It is edited the same way as any other page; it simply stays first in the list.

Building Pages & Dashboards

Mon, 01 Jan 0001 00:00:00 +0000

Create visual reporting pages and dashboards with widgets in Timill Platform.

Creating Pages#

Navigate to Group Settings → Pages
Click Create Page
Configure:
- Name
- Layout (grid columns)
- Permissions
Add widgets
Save

Page Layouts#

Available Layouts#

Layout	Description
Single Column	Full-width layout
Two Column	50/50 split
Three Column	33/33/33 split
Custom Grid	Custom widget sizing

Widgets can be sized using the grid system:

Item Types and Fields

Mon, 01 Jan 0001 00:00:00 +0000

Item types define the schema for work items in a group. Each item type has a name and a set of fields that determine what data an item holds, plus a layout that controls how those fields are arranged on the item detail view.

Managing item types#

Create multiple item types to represent different kinds of work (e.g., Task, Bug, Feature Request). Each type has its own fields and layout.

Lists

Mon, 01 Jan 0001 00:00:00 +0000

Lists are reusable sets of options used by dropdown fields on items. Managing lists centrally keeps option sets consistent across your group.

Creating a list#

Create a new list by giving it a name and adding option entries. Each entry has a label and an optional color, used for visual distinction in the UI (e.g., kanban columns, status badges).

Editing list entries#

Add, rename, reorder, or remove entries on an existing list. Reordering changes the order entries appear in dropdowns and on kanban boards.

Forms

Mon, 01 Jan 0001 00:00:00 +0000

Forms let you create structured input interfaces for collecting data — including from external users who are not group members. (Forms must be enabled on the instance; public forms are a separate instance toggle.)

Creating a form#

Use the form builder to define the fields, labels, and layout. Form fields map to an item type’s fields so that submissions create items in the group.

Each form has its own URL. A form can require authentication, or be made public so anyone with the link can submit it — useful for intake requests, bug reports, or feedback from people outside the group.

Working with Forms

Mon, 01 Jan 0001 00:00:00 +0000

Create and manage public and internal forms that create items in Timill Platform.

Creating Forms#

Navigate to Group Settings → Forms
Click Create Form
Configure:
- Title
- Description
- Item type to create
- Field mappings
Set visibility (public/internal)
Save

Form Configuration#

Basic Settings#

Setting	Description
Title	Form display title
Description	Form instructions
Item Type	Which item type to create
Visibility	Public or internal only
Thank You Message	Message after submission

Field Mapping#

Map form fields to item fields:

Scripts

Mon, 01 Jan 0001 00:00:00 +0000

Scripts let you automate workflows and extend group behavior with code that runs on the server. Two engines are available: JavaScript and Gonja (a Jinja2-style template language).

Creating a script#

From the scripts section, create a script, choose the engine, and write your logic in the built-in code editor.

Triggers#

A script runs based on its trigger:

Manual — run on demand.
Schedule — run on a recurring cron schedule.
Event — run when something happens in the group (e.g., an item is created, updated, or deleted).
Save hook — run as part of saving an item, for example to validate or adjust field values before they are stored.

Scripted widgets and charts#

Scripts can also power custom scripted widgets and scripted charts on pages and dashboards, producing the data (or chart configuration) that the widget renders.

Script Administration

Mon, 01 Jan 0001 00:00:00 +0000

Manage backend scripts, event triggers, and scheduled tasks in Timill Platform.

Script Management#

Creating Scripts#

Navigate to Group Settings → Backend Scripts
Click New Script
Choose language: JavaScript or Gonja
Write script code
Configure trigger type and schedule
Save

Script Types#

Type	Trigger	Use Case
Manual	Execute on demand	One-time operations
Schedule	Cron expression	Daily reports, cleanup tasks
Event	Item events	Auto-assign, notifications
Save Hook	After item save	Validation, field updates

Viewing Execution History#

Go to Group Settings → Backend Scripts
Click on a script to view its execution history
Check logs for output and errors

Event Triggers#

Available Events#

Event	Trigger
`CREATE`	Item is created
`UPDATE`	Item is updated
`DELETE`	Item is deleted
`STATUS_CHANGE`	Item status changes
`FIELD_UPDATE`	Specific field is updated
`ASSIGN`	Item is assigned/unassigned
`COMMENT_CREATE`	Comment is added

Configuring Field Conditions#

For FIELD_UPDATE events, specify which fields trigger the script:

Secrets

Mon, 01 Jan 0001 00:00:00 +0000

Secrets are a secure way to store sensitive values (API keys, tokens, passwords) that scripts can reference without exposing the raw value. (Secrets must be enabled on the instance.)

Adding a secret#

Create a secret by specifying a key name and its value. The value is encrypted at rest and is never displayed in the UI again after you save it.

Using secrets in scripts#

Reference a secret by its key name in your scripts. The runtime injects the decrypted value only at execution time, keeping credentials out of your source code.

Sharing with external collaborators

Mon, 01 Jan 0001 00:00:00 +0000

External sharing gives people outside your group — clients, contractors, stakeholders — scoped, read-only or lightly-editable access to a single dashboard page, a single item, or a filtered view, without giving them a member account or a seat.

Each share is a link (a capability URL). Anyone who can open the link and pass its gate sees exactly what the link is scoped to — never the rest of the group.

Trash Bin

Mon, 01 Jan 0001 00:00:00 +0000

The trash bin holds recently deleted items, comments, and attachments, letting administrators restore them if something was removed by mistake.

Viewing deleted content#

Open the trash bin from the group admin sidebar. Deleted content is organized into separate tabs for items, comments, and attachments, each listed with its original name, deletion date, and who deleted it.

Restoring#

Select an entry and restore it to bring it back to its original location. Restored items keep their field values, comments, and attachments as they were before deletion.

Subscription and Billing

Mon, 01 Jan 0001 00:00:00 +0000

When billing is enabled on the instance, group administrators can view and manage the group’s subscription from this section. (If billing is disabled, this section is hidden.)

Viewing your plan#

The subscription page shows whether the group is on the free tier or has an active paid subscription, along with the number of seats, the next invoice date and amount, and the payment method on file. Members on a free group see an upgrade prompt instead.

Chart Source Files

Mon, 01 Jan 0001 00:00:00 +0000

This directory contains example JavaScript code for creating custom charts using the Scripted Charts feature.

How to Use These Examples#

These are example scripts that demonstrate how to write JavaScript code for scripted charts. To use them:

Navigate to a group’s page in Timill
Add a new widget and select “Scripted Chart”
In the widget configuration:
- Set a title for your chart
- Select the group to query data from
- Copy and paste the example JavaScript code into the Monaco Editor
- Optionally set a chart type hint and auto-refresh interval
Save the widget

The JavaScript code will execute on the backend when the widget is rendered, querying your data and generating an ECharts configuration.

Widget Source Files

Mon, 01 Jan 0001 00:00:00 +0000

This directory contains example Go templates for creating custom Scripted Widgets.

Overview#

Scripted Widgets allow you to create custom HTML widgets using Go’s html/template syntax. Templates have access to a powerful API for querying items, transforming data, and rendering HTML with automatic escaping for security.

Examples#

1. Simple Item List (`01_simple_item_list.html`)#

Displays a list of open items with their status badges.

Timill Platform Documentation

Backend Scripts

Getting Started#

Creating a Script#

Script Structure#

JavaScript Example#

Gonja (Jinja2) Example#

Trigger Types#

Available Events#

Language Features#

JavaScript (Goja ES5.1)#

Browsing Items

Filtering#

Chart - Status Pie Chart

Example Code#

Full Example#

Customization#

General Settings

Available settings#

Deleting the group#

Getting Started

First steps#

Key concepts#

Getting help#

REST API

Base URL#

Authentication#

Endpoints#

Viewing Pages

Navigation#

Reading a page#

Widget - Simple Item List

Example Code#

Parameters#

Customization#

Chart - User Workload Bar Chart

Example Code#

Full Example#

Customization#

Configuring a Group

Creating Groups#

Group Settings#

Basic Settings#

Membership#

Item Types#

Creating Item Types#

Item Type Configuration#

Custom Fields#

Dashboard

Widgets#

Editing Pages

The layout editor#

Scripted Widgets

Getting Started#

Creating a Widget#

Widget Structure#

Viewing an Item

Fields#

Widget - Status Dashboard

Example Code#

Customization#

Chart - Priority Scatter Plot

Example Code#

Full Example#

Customization#

Group Home

What you will find#

MCP Server

Members

Adding members#

Scripted Charts

Getting Started#

Creating a Chart#

Chart Structure#

Widget - Recent Activity

Example Code#

Customization#

Roles

Creating and editing roles#

Permissions#

`user` Object#

1. Simple Item List (`01_simple_item_list.html`)#