Skip to main content

Core Components

Unlike business modules, which deliver specific functional domains (CRM, Order Management, etc.), Core Components provide the underlying toolset that powers automation, custom pages/forms, notifications, data retrieval, and more. These components are shared by all modules and make tSM highly adaptable—both for out-of-the-box use and for further customization.

Below are the main core components and technologies tSM offers:

Process Designer​

Purpose and Scope​

The Process Designer is a BPMN-based tool for creating workflows within tSM. Any process—from a simple approval step to a multi-department orchestration—can be modeled here.

Key Features​

  1. BPMN 2.0 Support

    • Provides an industry-standard notation, making workflows intuitive to design and easy to understand for anyone familiar with BPMN.

  2. Drag-and-Drop Interface

    • Allows you to visually place and connect events, tasks, and decision gateways.
    • Supports manual tasks (human-driven) and automatic/service tasks (API calls, script tasks).

  3. Versioning and Deployment

    • Processes can be updated without interrupting existing instances.
    • Deployed processes become immediately available across relevant modules (e.g., a new Ticket workflow in Trouble Ticketing).

  4. Conditional Logic and Escalation

    • Define complex logic (gateway conditions, escalations on timeouts or SLA breaches).
    • Integrates with notifications and scheduling to automate triggers or reminders.

Form Builder​

Purpose and Scope​

The Form Builder is a no/low-code environment for designing everything from simple data-entry forms to complex entity-detail pages. In tSM, nearly all user-facing screens—from creating a new CRM record to viewing an order’s detail page—can be built or extended with the Form Builder.

Key Features​

  1. Rich Library of Widgets

    • Generic Widgets: Text fields, dropdowns, date pickers, signatures, checkboxes, tables, file uploads, etc.
    • Entity-Based Widgets: Prebuilt components for tSM entities, e.g., “Customer Selector,” “Product Card,” “User Picker,” or “Order Items.”
    • Over 100 possible widgets to cover a broad range of UI needs.

  2. Visual Page (Re)Construction

    • It’s not just for pop-up forms; entire entity detail pages (like the main CRM customer screen, or a Ticket detail layout) can be created or modified in the Form Builder.
    • You can define multi-section layouts, embed listings or dashboards, and set dynamic visibility rules based on user roles or data.

  3. Dynamic Behavior & Validation

    • Add conditional fields (e.g., show “Cancellation Reason” only if “Status” = “Canceled”).
    • Validate user inputs (length, data type, cross-field dependencies) to ensure data integrity.

  4. Binding to Entities and Custom Characteristics

    • Each field can map to a tSM entity property or a custom characteristic, meaning data is stored in the underlying database/Elasticsearch without coding a new backend logic.
    • Perfect synergy with Configuration Profiles, allowing you to quickly create forms that reflect new or updated entity attributes.

Benefit: The Form Builder significantly reduces development overhead. Business analysts or super-users can adapt or create pages directly in the application—for both existing modules and entirely new custom ones.

Notification Management​

Purpose and Scope​

Notification Management configures how and when tSM sends alerts or messages across multiple channels—email, SMS, in-app, or external collaboration tools (Slack, Teams).

Key Features​

  1. Multi-Channel Delivery

    • Standard channels include email and SMS; optional connectors exist for chat or push notifications.
    • Template-based messages auto-insert data (e.g., ticket ID, order reference).

  2. Rule-Based Triggers

    • Tied to BPMN processes (e.g., “Send escalation email if no progress after 4 hours”).
    • Definable triggers for entity status changes, SLA warnings, or new lead assignments.

  3. Logging and Audits

    • Delivery logs record successes/failures, aiding troubleshooting or compliance checks.
    • Optionally track open/click metrics if integrated with external mail providers.

Output Management​

Purpose and Scope​

The Output Management component ensures that tSM can format and distribute outputs—such as PDFs, Word docs, or HTML—based on data from any module.

Key Features​

  1. Template-Driven Documents

    • Uses Handlebars or similar templating to merge dynamic data (like invoice lines, contract details) into structured layouts.
    • Generate standard documents (e.g., offers, invoices) on demand or automatically.

  2. Multi-Format Support

    • Commonly produce PDFs, DOCX, HTML, or XML.
    • Integrate with external repositories or email systems to send or store these documents.

  3. Easy Integration

    • Called from BPMN processes or UI actions (e.g., “Generate Contract PDF” button).
    • Ensures consistent design across official documents with a unifying style sheet or header/footer.

Dashboards​

Purpose and Scope​

The Dashboards functionality provides real-time, high-level views of metrics, statuses, or performance indicators across tSM. Each user or team can tailor dashboards to their role.

Key Features​

  1. Customizable Widgets

    • Graphs, tables, counters, pivot charts.
    • Link each widget to one or more data sources (like TQL queries or Elasticsearch indexes).

  2. Interactive Filtering

    • Filter data on the fly (by date range, region, or custom fields).
    • Click a chart segment to drill down into a Listing view or entity detail.

  3. Personal or Shared Dashboards

    • Users can create private dashboards or share them with teams.
    • Admins can push standardized dashboards for specific roles (e.g., “Network Ops Dashboard”).

Calendars​

Purpose and Scope​

The Calendar component provides timeline-based scheduling and event visibility. It’s commonly used for workforce, preventive maintenance, or personal task scheduling.

Key Features​

  1. Multi-View

    • Month, week, or day layout, with color-coding for priorities or event types.
    • Combine multiple calendars (personal, team, module-specific) into a single overlay.

  2. Event Linking

    • Tie each event to a tSM entity (ticket, order, project), so you can jump to the detail page with a click.
    • Automatic creation of calendar events from BPMN tasks (e.g., a scheduled maintenance window).

  3. Reminders & Conflict Detection

    • Configurable pop-ups or emails for upcoming events.
    • Warn if multiple events clash for the same resource or technician.

Listings​

Purpose and Scope​

Listings offer the standard data-grid approach to viewing records. They appear across tSM (e.g., a list of all tickets, a customer search page, or an orders backlog).

Key Features​

  1. Dynamic Filtering and Sorting

    • End-users can filter by multiple columns (customer name, ticket status, date range, etc.).
    • Profile-based columns let each role see relevant fields.

  2. Batch Operations

    • Support multi-select and bulk actions (like reassigning orders, mass ticket closure).

  3. Fast Data Retrieval

    • Can leverage Elasticsearch indexing or TQL for near-real-time searching and efficient paging.

Scheduler​

Purpose and Scope​

The Scheduler automates recurring tasks (report generations, nightly data synchronization, periodic database cleaning) without manual intervention.

Key Features​

  1. Cron Expressions

    • Schedule tasks using flexible cron syntax (e.g., run daily at 3:00 AM).
    • Supports advanced intervals or once-only triggers.

  2. Integration with Processes

    • A scheduled job might launch a BPMN process (e.g., monthly invoice run), or call an external API.
    • Track job histories, success/failure statuses.

  3. Monitoring

    • Log each run with timestamps, duration, and any errors, making it easy to troubleshoot.

User Management​

Purpose and Scope​

User Management (UM) handles authentication, authorization, and role/permission assignments across tSM. While it doesn’t directly deliver “business functionalities,” it’s crucial for secure, multi-tenant, and role-based operations.

Key Features​

  1. User Accounts and Groups

    • Create and manage user accounts (internal staff, external partners).
    • Assign groups/roles that define permissions within modules and forms (e.g., read-only in CRM vs. full create/edit in Ticketing).

  2. Access Control

    • Fine-grained privileges (e.g., who can see financial data, who can reassign orders).
    • Integration with single sign-on (SSO) or LDAP/Active Directory if needed.

  3. Audit and Security

    • Logs user login attempts, critical changes, or escalations.
    • Enforces password policies, session timeouts, or multi-factor authentication, depending on environment constraints.

Technological Components​

Though often “behind the scenes,” these technical components are what enable tSM to be integrated, automated, and extended with minimal custom code.

tSM Public APIs​

tSM provides RESTful endpoints for external integrations and self-service portals. Key aspects include:

  1. TM Forum Compatibility

    • Many of tSM’s APIs align with TM Forum Open APIs (e.g., for customer, order, product, resource management), ensuring easier B2B synergy with standards-based platforms.

  2. Entity CRUD and Process Interactions

    • External systems can create, read, update, or delete records (customers, tickets, etc.) or even trigger BPMN processes.
    • Roles and permissions from User Management apply, so only authorized clients can call certain APIs.

  3. Swagger/OpenAPI Documentation

    • Each endpoint is documented in the platform’s built-in “Public API” docs.
    • Built-in testing tools or Postman-like integrations can quickly validate API calls.

Benefit: The Public APIs make it simple to embed tSM’s functionalities into existing portals, integrate with external CRMs or ERPs, or allow customers to manage their services or open tickets themselves.

Scripting in tSM: SpEL, TQL, and JEXL​

In addition to its no-code/low-code approaches (like Process Designer and Form Builder), tSM also supports scripting to handle logic, calculations, conditions, or data queries. Each scripting language targets a different layer within tSM:

  1. tSM SpEL (Spring Expression Language)

    • Where Used: Primarily backend logic, e.g., within BPMN process definitions, SLA calculations, or algorithmic steps in automated tasks.
    • Purpose: Provide quick, inline expressions or scripts referencing tSM variables and entity fields (like #ticket.status or #orderTotal).
    • Common Use Cases:
      • Evaluating conditions in gateways (“If #orderTotal > 100, route to manager approval”).
      • Setting default values or transformations in service tasks.
      • Writing short code snippets for calculations (like “SLA time = now() + 48 hours”).
    • Example: #if(#ticket.priority == 'High').then(#escalate = true).else(#escalate = false)

  2. TQL (tSM Query Language)

    • Where Used: Data queries that tap into Elasticsearch indexes or tSM entity listings for advanced filtering, aggregations, or real-time analytics.
    • Purpose: Similar to an SQL-like syntax but designed for Elasticsearch/OpenSearch backends.
    • Common Use Cases:
      • Building custom dashboards with aggregated data (“Show me count of tickets by category”).
      • Advanced listing filters or pivot-like queries for real-time data retrieval.
      • Generating complex reports (e.g., grouping orders by product type and region, counting usage records, etc.).
    • Example: 
      SELECT status, COUNT(id) AS total
      FROM ticket
      WHERE priority = 'Critical'
      GROUP BY status
      HAVING total > 50

  3. JEXL (Java Expression Language) in tSM

    • Where Used: Front-end logic, specifically in forms and pages (via the Form Builder and UI components).
    • Purpose: Enables dynamic behavior directly in the browser, without requiring server-side code changes.
    • Common Use Cases:
      • Conditional show/hide of fields in a form, e.g., “If user selects ‘Company’, display ‘Tax ID’ field.”
      • On-change event logic, e.g., “When the user picks a product, auto-fill the price field from the product reference.”
      • Inline calculations or validations that execute client-side to make the UI experience more dynamic and responsive.
    • Example: 
      // JEXL snippet for a front-end form condition
      "visible": "this.type == 'B2B' && parent.country == 'SK'"
      This might show a certain field only if the record’s type is B2B and the country is SK.

Why multiple languages?

  • SpEL solves server-side, process-oriented logic (within BPMN tasks, SLA, or back-end event triggers).
  • TQL addresses advanced data queries/analytics against the indexing layer (Elasticsearch).
  • JEXL gives front-end forms/pages quick, real-time logic that runs in the user’s browser, letting you conditionally display fields or manipulate UI data with minimal latency or developer overhead.

All three coexist within tSM to balance performance, maintainability, and user-friendliness, ensuring each environment (front-end UI, back-end processes, data analytics) has the right scripting tool for the job.

Elasticsearch​

Elasticsearch underpins tSM’s real-time indexing of data—especially for search-driven features (like listing filters) or analytics dashboards. Key highlights:

  • High-Performance Search: Full-text, wildcard, fuzzy, or structured queries.
  • Aggregations: Summaries, histograms, or bucket-based analyses for reporting.
  • Scalability: Accommodates large data volumes typical in telecom logs, usage records, or historical tickets.

Summary​

tSM’s Core Components provide the scaffolding that unifies all business modules and empowers users to customize or extend the system with minimal code. The Process Designer orchestrates workflows; the Form Builder builds entire pages; Notification and Output Management handle messaging and document generation; Dashboards, Calendars, Listings, and the Scheduler equip teams with the visibility and automation they need day-to-day. Meanwhile, User Management underpins secure role-based access, and Technological Components (Public APIs, scripting, Elasticsearch) further open the platform to integration and tailored functionality.

By leveraging these components together, organizations can adapt tSM to evolving requirements—whether adding new data fields to an existing module, building a brand-new “mini module” for a specialized process, or integrating tSM deeper into their enterprise ecosystem.