Forem: Pavol

New universal drivers for IoT Platform

Pavol — Wed, 22 Oct 2025 06:19:26 +0000

In some of the previous blogs, I wrote a lot about the IoT platform from Total.js. Like what it is, why it can be useful, how to install individual parts to get it working, and how to set it up and start using it. But there is still one part of the platform that has to be created or modified especially for your case. And those are drivers.

We published some of the custom drivers we used before, but now we have added universal drivers. These drivers are ready to use. We created universal drivers for the electrometer, weather, meteo data, and switch. In this blog, I will introduce them to you. You can use them as they are, create new drivers based on principles used in these drivers, or modify them for your case. Also, I will show you how to add a sensor to one of them, so you will be able to adjust them correctly for your case.

The difference I want to point out first is that we changed devEUI in the received JSON to id. If you are new here, just take it as best practice. If you used one of the drivers with an older JSON schema, be careful now, the old one was because of a custom implementation.

What are universal drivers

Each of these drivers is for a different device. We created them based on specifications so they can fit easily into any device of their own type. If you need to do some modifications, it is very easy with little knowledge about drivers, which you can get in the Total.js documentation, and some basic programming skills.

Each driver has its own properties that can be processed, and there is a possibility of setting a Token. This token is for security reasons. If you set some value there, each received message has to include the same value in the received headers in the property x-token. This will be validated, and if the received header value is different, the driver will not process any data from that request. If you do not set any value to this token, validation will be skipped, and every request will be processed.

This functionality is the same for every driver.

Electrometer

The electrometer driver is for electrometer devices. It can receive and process various data that are sent to /electrometer/ endpoint.

Data structure for this driver:

{
  voltageL1: 236.97,
  voltageL2: 234.47,
  voltageL3: 238.12,
  currentL1: 6.08,
  currentL2: 1.52,
  currentL3: 0,
  activepowerL1: 1.28,
  activepowerL2: 1.27,
  activepowerL3: 1.29,
  reactivepowerL1: -0.19,
  reactivepowerL2: -0.21,
  reactivepowerL3: -0.23,
  powerfactorL1: 0.84,
  powerfactorL2: 0.94,
  powerfactorL3: 0.82,
  id: '123456789'
}

As you can see, there are a lot of different measured values like voltage for 3 phases, current for 3 phases and more. The only property that is not a measured value but is used for pairing a real device with a device in the platform is the id property.

Air quality

Air quality is a driver for indoor air quality monitoring. It can receive and process various data that are sent to /airquality/ endpoint.

Data structure for this driver:

{
  temperature: 24.7,
  humidity: 36,
  co2: 1071,
  tvoc: 122,
  id: '00162a820a010072'
}

It can process received data for temperature, humidity, CO2, and tvoc. Same as before, the only property that is not for measured values but for pairing a real device with a device in the platform is the id property.

Meteo

Meteo is a driver for outdoor weather conditions monitoring. It can receive and process various data that are sent to /meteo/ endpoint.

Data structure for this driver:

{
  temperature: 24.7,
  humidity: 36,
  pressure: 1013,
  windspeed: 3.4,
  ilumination: 12500,
  uv: 5.6
  id: '00162a820a010072'
}

It can process received data for temperature, humidity, pressure, windspeed, ilumination, and uv. Same as before, the only property that is not for measured values but for pairing a real device with a device in the platform is the id property.

Switch

Switch is a driver created for any kind of switch device with two possible values: true or false. So it is not for receiving values of the type of number, but a boolean. It can receive and process data that is sent to /switch/ endpoint.

Data structure for this driver:

{
   value: true,
   id: '123456789'
}

It can process received data as a value property, and same as before, the only property which is not for measured values but for pairing a real device with a device in the platform is the id property.

How to use the driver?

Usage of IoT drivers is very easy, you have to only copy code from the driver you want, click on the Create button in the Drivers section, paste the code there, and click save. Then the new driver will appear in the listing, and you can also see it in the process of creating a new device.

How to modify the driver?

For this example, we will use the Switch driver. Right now, we have only one property for processing data, which is value. I want to have a switch with two values, so the first will stay the same as it is now, and the second will be value2.

When we open the source code of the driver, first we have to go to exports.outputs, and add our new output.

exports.outputs = [{ id: 'value', type: 'boolean', name: 'Value', format: '{0}', stats: 'none', offline: '2 hours' }, { id: 'value2', type: 'boolean', name: 'Value 2', format: '{0}', stats: 'none', offline: '2 hours' }];

Object with id value is our original output, and value2 is the new one. value2 will also be a name of a property, from which will driver pair a value from received data.

Then we have to find com.jsonschema where we need to add also value2 for validation purposes.

 com.jsonschema = '*id:String,value:Boolean,value2:Boolean'.toJSONSchema();

As you can see, it will be the same data type as the original output, which is Boolean.

And the last addition we have to do is add this to the instance.message function, where we process received data.

if (payload?.value2 != null)
    instance.newmessage(payload.value2).send('value2');

This code will set the received value from property value2 (payload.value2) to our output with id value2, under the condition that the received value is not null.

The last thing we should do is update our readme, so every user of our application can see that this driver was modified and now it can process more data.

{
  value: true,
  value2: false,
  id: '123456789'
}

Now I will create a device based on this driver, and we can try it.

Conclusion

So that is all for this blog about IoT platform drivers. We learned about a new universal driver, and now we know how to modify it for new sensors.

I hope you like this blog, and I will happily share with you more knowledge about Total.js in future blogs.

Video:

IoT Platform Update: New Features and Enhancements

Pavol — Wed, 08 Oct 2025 07:25:15 +0000

If you read my blog, you have certainly come across some blogs about IoT platform. It is application ready to use for making easier your IoT managment, processing data and analyzing them. Despite it, we found some features and enhancements, that can make it even more powerful, and can be useful in various case you may encounter. So we got to work and now I want to present you this updates to IoT platform.

What is an IoT platform?

The IoT Platform is an application built with Total.js to work with data from IoT devices. It includes apps like Stream for receiving data, OpenReports for creating reports, Flow for visual automation, and OpenPlatform for managing everything in one place. These apps can work together to collect, process, and show data in real time. The platform helps you create your own system for monitoring and reacting to data from sensors or other devices.

This was just for quick overview, for more information, please go through this blog post about IoT platform.

Reports

Big update was done in Reports section. Now you can create your report right in the IoT platform application without the need to use OpenReports.

When you click on the Create report button in the Reports section, you will see a form like this. As you can see, there is a place for an SQL query. This is a query right to the database, and you can read any data as you wish. Of course, you need to know SQL to get the result that you want (or use AI to help).

In the Map fields input, you can rename columns. As you can see, I used it to translate the columns names to Slovak language. So now, when I open the report, header in the grid will be Názov instead of name and Hodnota instead of value.

Also, there is a new feature, that you can make an API from the report right in the form. You just need to check the checkbox Publish a value to an API endpoint, that you can see in the image and then you can access this data via url address. This url address you can find in the menu for particular report.

Just like this, you can create an API endpoint for every report you need.

If you would prefer to use reports with OpenReports application, it is still possible. You can find this archived version in the same GitHub repository with functionality as it was before update.

Devices

Devices went also through transformation. Listing of all devices is the same, but detail is switched to the box with more compact design which may be more appealing for orientation in the sensor values.

With the new design there stayed all functionality (e.g. changing of stats, hidding of unused sensors …) and we also added new features.

For every device now you can add note and custom attributes. Also, you can publish every device you choose as API endpoint. So now you do not need to create custom report for device you want to have access to via API, you just need to check it in the form.

From this endpoint, you will get information about a particular device as id, driverid, serial number, locality, custom attributes, configuration, and data for every sensor. Each sensor has data as current value, date when value was received, name, id and more.

Also, if you need just data from particular sensor, you can easily get it in here by choosing an option for API endpoint in options menu for that sensor.

As you can see, you can get their data like id, name, value, format, locality, serial number, date when value was received, custom attributes and more.

Zones

This section may seem the same as it was before, but we also added note field and custom attributes for every zone. Checkbox for publishing zone to an API endpoint is here too and you can easily get information about your zone via API.

As you can see, it is very easy to do and you can get information about your zone like id, name, locality, custom attributes, area (object with points with latitude and longtidue as boundary points of the zone) and sensors. This sensors includes informations like deviceid, sensorid, value, type, date when value was received, name and more.

Drivers

In drivers, we changed design for listing of drivers. Functionality is still the same, you can search in drivers, there are still sections but it is still little more appearing for look.

Files

You can see, that we added new section with a name Files. There you can see every uploaded file to your IoT Platform (like created images for zones or uploaded files for simulations). You can see here name of the file, type, size, date of upload and you can also download selected file.

Conclusion

That is all for this blog. I hope you learned something new in this blog and that you will find these features useful in your case. If you want to stay informed about future updates of the IoT Platform you can subscribe to my blogs and I will happily share with you my knowledge not only about IoT Platform but about all Total.js.

Video:

How to create Google Gemini AI component in Total.js Flow

Pavol — Wed, 03 Sep 2025 07:14:26 +0000

We live in the times, where everyone wants to use AI everywhere. It can be very useful for many cases and I think, that if you work with Flow application from Total.js, you ask yourself at least once a question “Can I use AI here?”. Let's be honest, I do not know what is your use case, but I know how you can get your Google Gemini AI component to your Flow and now I will show it to you.

Installation of Flow application

If you are here, I am sure, that you know how to install Flow, so I am not going to explain it here step by step. But if someone is completely new here, please go to one of my older blog posts about installing the Flow application (This blog was meant for the installation of Flow for the IoT platform, but you can go just through installation and then skip the rest of the blog).

Create a new component

Now, we need to click on the green plus button for create a new component.

Now as you can see, there is already a predefined structure for Flow components. I will cut it into a few related units, to help you understand it.

General information

First of all, we can see here some general information, I will fill them in and then we can go through them step by step.

 exports.id = 'geminiapi';
 exports.name = 'Gemini API';
 exports.icon = 'ti ti-google';
 exports.author = 'Pavol Danko';
 exports.version = '1';
 exports.group = 'Services';
 exports.config = { apikey: '', model: 'gemini-1.5-flash', output: 'all' };
 exports.inputs = [{ id: 'input', name: 'Input' }];
 exports.outputs = [{ id: 'output', name: 'Output' }, { id: 'error', name: 'Error' }];

Above you can see that I filled in the id as geminiapi, where this value has to be unique for every component (if you accidentally use id from another component, that component will be replaced).

The name is basically the name of our component and icon, author, and version can tell you by their name what they are for.

The group is for sorting components in the left panel in the Flow application.

Config is very important, data defined in this object we will use later in the settings. Some things we do not want to hard code, but we want to be able to change them in component configuration. Then every component of Google Gemini API used in our Flowstream can have a different configuration with some default values. In our case, we want to be able to set apikey (it is indispensable, for API calls), model because we want to be able to change which model to use and output because we want to be able to choose if we want to have a full response on the output or only text (if it doesn’t make sense to you now, keep reading and in the next section you will understand).

Create functionality

As next we can see in predefined form of component exports.make function and instance.message function in it. It is all we need for our component. So this code, which will be explained below is all in the instance.message function.

Follow through the entire blog and at the end you will find a link to the GitHub repository with this component.

We will divide this function into three parts, but it is everything inside of the instance.message function.

var data = $.data;

if (!data) {
  $.send('error', 'Input data are missing');
  return;
}

if (!config.apikey) {
  $.send('error', 'You have to configure apikey');
  return;
}

if (data.text)
  data = data.text;

if (typeof data !== 'string') {
  $.send('error', 'Error: Wrong input format');
  return;
}

First, what you can see here is, that we set our received data into a data variable for better handling.

Then there are some conditions, basically, it is just to check if we have all the data we need. Of course, we need input data, we need apikey and then there is a condition, that will handle the processing of our input data and just like this, we can receive a string as input data or an object with text property. If some of these conditions are evaluated as true, with $.send function we will send a defined error message to the error output of the component.

var obj = {};
obj.contents = [];

var messageParts = [];

messageParts.push({ text: data });

var content = {
  parts: messageParts
};

obj.contents.push(content);

This second part is just to modify input data into a structure, that can be handled by Google Gemini API based on their documentation. Nothing complicated.

RESTBuilder.POST('https://generativelanguage.googleapis.com/v1beta/models/{0}:generateContent?key={1}'.format(config.model, config.apikey), obj).header('Content-Type', 'application/json').timeout(60000).callback(function (err, response) {
  if (err) {
    $.send('error', err);
    return;
  }

  if (config.output === 'text' && response && response.candidates && response.candidates.length > 0 && response.candidates[0].content && response.candidates[0].content.parts && response.candidates[0].content.parts.length > 0) {
    var textOutput = response.candidates[0].content.parts[0]?.text || '';
    $.send('output', textOutput);
  } else {
    $.send('output', response);
  }
});

This part can look too complicated, but in fact, it is a basic RESTBuilder with a POST method. There we have defined a URL address (based on Google Gemini API documentation) with a format function, for formatting our URL address with model and apikey. Next is our obj object with structured data for this API.

Then there is a header with data required from the API. Timeout is here for calls, that will take longer to get a response, so the value is higher than normal.

And the last is a callback, that will handle responses from Google Gemini API in case of a correct answer or even an error.

In this callback function, we can see two conditions. The first is for catching errors received from an API call. The second one is here for parse response from API to the form we want (defined in config). If we want to send only text to the output, the response will be as first check, if it includes data we need to parse, and then the response from API will be parsed and sent to the output with the function $.send. If we want to get a fully received response from API to the output, we will go through the else branch of our condition.

Settings

<div class="padding">
  <div class="m">
    <ui-component name="input" path="?.apikey" config="camouflage:1;required:1">API key</ui-component>
    <div class="help"><a href="https://aistudio.google.com/app/apikey" target="_blank"><i class="ti ti-external"></i>Generate Gemini API key</a></div>
  </div>
  <div class="grid-2">
    <div class="m">
      <ui-component name="input" path="?.model" config="dirsource:gemini-pro|Gemini Pro,gemini-1.5-flash|Gemini 1.5 Flash,gemini-1.5-pro|Gemini 1.5 Pro">Gemini Model</ui-component>
    </div>
    <div class="m">
      <ui-component name="input" path="?.output" config="dirsource:all|Full response,text|Only output text">Output Type</ui-component>
    </div>
  </div>
</div>

As you can remember, we added some config settings to our component. Now we have to create a form for a user, where they can set this configuration. This is basically a frontend code, which you will see when you double click on the component or choose Configure option in the menu.

We added there inputs for apikey, which is required, and camouflage with help information, where you have a URL address to the Google Gemini web for getting your API key. Then we have here a model with some predefined models from which you can choose (dropdown menu). The last part is output, also as a dropdown menu with options for Full response or Only output text (Functionality for this we coded before in this blog).

Readme

Readme is just a text, where you can put some information about your component, to help other people (or yourself :) ) to understand what is the purpose of that component.

This component communicates with the Google Gemini API with text inputs and outputs.

Input:

// Object input format for Google Gemini API:
{
    text: String
}

// Or

text: String
For output, you can choose if you need the full response object from Gemini or only the extracted output text.

Google Gemini AI component in use

Now we can create a simple example for this component. I will use only the Trigger component with the Print component alongside our component.

In the Trigger component I will send text: “Hello, how are you?” and we will see what we will get on the output.

In the example, I used the Flow component with configuration settings, where the model is set to Gemini 1.5 Flash and output is set to Only output text.

You can find this code on my GitHub.

Conclusion

In this blog, we created a simple Total.js Flow component for communicating with Google Gemini AI.

This is all from this blog. I hope, that you learned here something new and that it will help you in your future coding.

Video part 1

Video part 2

How to install OpenReports — IoT platform

Pavol — Wed, 13 Aug 2025 12:48:40 +0000

This is a continuation of a series for the installation of the IoT platform. In the previous blog, we talked about how to install Stream application and in this blog, we will continue with the installation of the OpenReports application. In the next blogs, we will install Flow and OpenPlatform, to show you, how you can use all these apps together, to get a great application to handle and analyze your data from diverse IoT devices.

If you haven’t heard about the IoT platform or you want to get more information, please read this blog about the IoT platform first or watch this video describing the IoT platform. Please, keep in mind, that this platform is part of Total.js enterprise.

Why do you need OpenReports?

It is not necessary to use OpenReports with the IoT platform, but it can help you increase your ability to analyze and manage your data. OpenReports is an independent application and you can use it also for other purposes, so if the IoT platform is not for your case, you can still use OpenReports for all different kinds of data based on your case.

What is OpenReports?

OpenReports is a powerful reporting tool developed by Total.js. It is designed to simplify the creation and management of reports. It is a flexible application that can integrate with various data sources customizable based on your data architecture. It can generate reports in formats such as Excel or CSV with a user-friendly interface.

Installation of OpenReports

We will continue with the assumption, that you followed the previous blogs about IoT platform and stream, but this tutorial does not depend on it. So you can install OpenReports based on this blog and use it for also other cases.

Download source code and install dependencies

First, we have to download the application from a GitHub repository and save it to a directory. We can do it via the terminal with the code:

git clone https://github.com/totaljs/openreports.git

We installed all dependencies in the previous tutorial, but if you are new here, just follow your terminal console or review previous blog posts.

Update port

We run the IoT platform and stream on ports 8000 and 8001, so we have to go to the index.js file and change the port to another, in this case, we will set it to port 8002.

This is how our index.js can look:

require('total5');

const options = {};

options.port = 8002;
options.release = process.argv.includes('--release');

// Service mode:
options.servicemode = process.argv.includes('--service') || process.argv.includes('--servicemode');

Total.run(options);

Now we can run the application by terminal command:

node index.js

Now our application is running on **port 8002 **and we can access it via a web browser.

Connect OpenReports to the database

The next step is connecting to our database. When we enter OpenReports it is empty, so we will navigate to Settings and fill in a connecting string to our database (same as for IoT platform and stream applications).

Creating a view

Then we can continue to create a view of our data. For this, we need to know our database architecture. In this example, I will use only basic data, for example purposes, but you can create views and then reports based on your case.

We have to go to the section View and click on the button Create. Then we can add there a JSON to specify our view. This JSON should look like this:

{
  "id": "hourly",
  "name": "Hodinové",
  "sql": "SELECT a.sensor, b.max, a.device, b.ts AS date FROM view_sensor a INNER JOIN tbl_data_hourly b ON a.sensorid = b.sensorid AND a.deviceid = b.deviceid ORDER BY ts DESC",
  "fields": [
    {
      "output": "",
      "column": "sensor",
      "name": "Senzor",
      "type": "string",
      "group": false
    },
    {
      "output": "",
      "column": "device",
      "name": "Zariadenie",
      "type": "string",
      "group": false
    },
    {
      "output": "",
      "column": "max",
      "name": "Max",
      "type": "number",
      "group": false
    },
    {
      "output": "",
      "column": "date",
      "name": "Dátum",
      "type": "date",
      "group": false
    }
  ]
}

id is an identifier for our view, name is name, SQL is SQL query to our database and fields are fields that we want to include with column for data, name, and data type.

Creating a report

With this, we can continue to create our first report. We have to navigate to the section Reports and click on the button Create. A form will appear, where we can modify our reports to our needs, but in this example, we will create just a simple report. We have to fill in a name for our report and choose a view, so in our case, we will use the name Test and as a view, we will use the previously created view Hodinové (which means Hourly).

As you can see on the gif report is usable right after creation. Just like this, you have access to all your data from your database and you can go through them via the OpenReports application, or you can download them as CSV or Excel.

Conclusion

That is all to this blog. Now you are able to install the IoT platform, stream, and OpenReports and now you are able to create a view and report. There is a lot more that you can achieve with this application, but this was just a simple explanation of how to install it and start using it.

I hope you learned something new with this blog and I will happily share with you more knowledge about Total.js.

Video:

IoT platform — Total.js

Pavol — Wed, 13 Aug 2025 08:19:44 +0000

This is the last blog from the series about installing the IoT platform, so if you are new here, you can go through the latest blogs to get these applications set as you will see here.

After installing the IoT platform, stream, OpenReports, Flow, and OpenPlatform we can achieve the full potential of what the IoT platform offers. In this blog, we will go through some simple examples to get an overview of what the platform offers.

The main point of this application is to receive, save, and present real time data or historic data to the user. So the first thing we need is a method to get this data into the IoT platform. For this purpose we installed stream, but we need to process data in the IoT platform and we can do that with drivers.

Drivers

Drivers are a core part of this application. They can receive and process data from different kinds of devices. Different devices will need different drivers. So for example, if you want to receive data from a meteo station and electrometer, you will need an individual driver for each. Bud for more meteo stations of one kind you will need just one driver.

Because there are a lot of options for sensors, you can create custom drivers right in the IoT platform. There you can define which inputs and outputs it has to include, the endpoint, where you will receive data and you can code some operations with the data. It is also possible to create a driver, that will be connected to a camera for example and it can send requests for data at some intervals.

Driver can also have configuration and settings if you need to set separate configurations for drivers. And in the driver, you can add storage, for saving custom data from the drivers. For example, if you connect your driver to a camera, which can send you data about passing cars, you can save to the current architecture only value, but in the driver, you can create a custom database, that can contain different kinds of data, like vehicle license plate, color, type and etc.

Detailed information about how to create a driver can be find in the Total.js documentation.

Devices and sensors

When we have our driver ready, we can go to the Device section to create our device. After clicking on the Create button, we have to choose a driver and then we can fill in information about the device. The serial number is very important for every created device because based on it received data will be assigned to the device.

You can also fill in here data like reference, color, icon, locality, latitude, and longitude.

After submitting a new device, we can already see some meta information about the device with information about the chosen driver. Below that, we have listed all sensors associated with the device with their state, current value, and the date and time when the data was received.

Sensors

Sensors are created automatically after creating a device, based on a chosen driver. As we know from the previous part of this blog, every driver has their sensors defined in it.

If we want to see all sensors listed in one place, we can do it in the Sensor section. Here, we can see information about every sensor like locality, value, serial number, alerts, time, when the last value was received, and state. By clicking on a sensor, we will see a report with historic values received on that sensor with possibilities to filter in these values or export them to a CSV file.

Data ingestion in the IoT platform

When we have prepared our device like this, it is ready to receive data. With this driver, data have to be sent to the endpoint /airq/, and the data structure has to look like this:

{
  devEUI: '123',
  temperature: 24.7,
  humidity: 36,
  co2: 1071,
  tvoc: 122,
  battery: 3.61
}

Where devEUI has to be the same as the serial number defined in the device. If in the received request is any value missing it will go through without error and other values will be processed.

I will show you an example request in the application RapidAPI, of how the platform process received data. We will use data from above. The URL has to be http://0.0.0.0:8001/airq because our stream is running on this URL and the endpoint is dedicated to this driver. Do not forget about headers, when we have to have an x-token with value Total, because we set this value for a security token in this driver in the previous blog about IoT stream application.

As you can see, after sending a request, sensors change their state to online and values are displayed in the data grid.

Dataviews

If you have a case, where you need to combine data from more sensors, it is easily possible to do so in the Dataviews section of the IoT platform. It is possible to choose sensors, operations, format, and decimals. In the example case, we want to make a Sum operation of two temperatures. For this, we need to click on the Create button, fill in a name, and operation, and select the temperature sensors, that we want to Sum. You can put their different kinds of units, but in our case, we will fill into a formatted input a °C, because we want to render the unit with the resulting value.

Zones and Map

Values obtained with dataviews and sensors can be inserted into zones and then rendered on the map. First, we need to create a zone. The zone is the location on the map, where sensors are located. For creating a zone we need to know where we want to draw a zone. Then we can add sensors, which should be part of it.

Also, we can create a category for a zone. Each zone can be part of one category like parking, city building, school, etc.

Map

Every zone can be rendered on a map. In our example, we have only a zone Test with sensor Temperature in it. When we go into a Map section, we can see our zone, after zooming in a box will appear above the zone with the name of a zone and sensor name with the last received value. By clicking on that box a bigger form will appear with listed sensors, their values, and graphs. Each graph has a filter, where we can set what types of values we want to see.

Also, if you have zones with categories, you can filter which categories you want to see on the map. With this is very easy to keep an eye on zones in your interest.

Reports

We talked about reports already in the blog where we went through the installation of OpenReports, but here it is a slightly different approach. From reports created in OpenReports, we can get functional APIs with a few clicks. First of all, we have to pair our OpenReports with IoT platform application. We will do that by going to the OpenReports setting, allowing an API for reading reports and copying a link. Then we will put this link in the IoT platform Settings section in the part OpenReports.

With this setup, we can go to the Reports section and create our first API access. Here, we have to click on the Create button and choose one of the existing reports in the OpenReports. In our case, we have here only one with the name Test, which created in the previous blog about the installation of the OpenReports application. When we click on it, we will get a form, where we can fill in some information about this report, we can make it inactive or add token verification.

After submitting a form, our report will appear on our page with information about how many times it was called and we can copy a link for this API here. After copying this URL address to the browser, we will get the report in the CSV form.

Alerts

Alerts are an important part of monitoring the states of devices. Every device can have some problems and with this, we can see them all in one place. These alerts can be invoked in more ways. It could be invoked in the driver, for example, if a camera, should be sending us data after the request is not responding or we can process data in the flow, evaluate them and based on some conditions we can create an alert.

In this case, I will show you how to create an alert from the Flow application. In the previous blog about the Flow installation, we connected the received data with the Flow by TMS component. Now we will expand our Flow with components Data sorter, Alert message, IoT Stream / alert, and Print.

In the Data sorter, I filled in a condition, that we want to send to the next component only data, where a sensorid is airq_temperature because it is an id for the temperature sensor and the value has to be more than 40 degrees. Alert message component will extend our object with a message Temperature is higher than {value}, where value will be replaced by real value. This is sent to the next component, which is the IoT Stream / alert, which will send this alert to the IoT platform.

Simulations

This section is created only for testing purposes and shouldn't be a part of the production version. Its purpose is to simulate a physical device if we want to test the functionality of our platform without hardware.

Here, we have to create an endpoint, where we want to send simulation data. Then we have to prepare a CSV file and upload it to the form, select one of the endpoints, and the frequency of sending data to the endpoint. We can also launch a request and choose if we want to circulate data from the simulation file or if it should go only once through this file.

Panels

Panels are implemented by creating a small page for information displays. For example, we can imagine a case, that we have meteo values from some school building, we can have a display in the entry room, where everyone can see measured values like temperature, humidity, and more. This page is updated dynamically by received data, so it is very easy to implement by just opening a URL address on that display.

Now we can move to implementing panels in the IoT platform. First of all, we have to create a panel in the IoT platform. In the form, we will fill in a name, width, and height. After submitting this form, the panel will appear on the page and we can Copy the Flow URL address.

With this address, we have to go to the Flow application and create a component by clicking on the Create button and choosing an option Link endpoint. In the form, I will fill in a name, category, and copied URL address.

Now we have prepared our components and now we need to create a simple flow architecture.

In the architecture, we can see new components which are Tangular, Transformer, and Test panel. Tangular is important because we need to put content for a panel page into HTML. In this case, I want to render only one value, which is the temperature on a small page, so our HTML content can look like this (we will get there only values from the temperature sensor from a particular device, based on the condition in the Data sorter component):

<div style="display: flex; justify-content: center; align-items: center; text-align: center; min-height:100px; font-size: 30px">{{ value.value }}°C</div>

Now we have to change the data structure to the form suitable for the Test panel component and we can do that in the Transformer component with code like this:

data = { html: data }

Now, when our platform receives data, from a particular device, temperature data will go through this architecture and the value will be rendered to our small page.

Conclusion

That is all to our IoT platform series of blogs for now, I hope you learned something new from these blogs and I will happily share with you more knowledge about Total.js.

Video part 1:

Video part 2:

How to install OpenPlatform — IoT platform

Pavol — Wed, 06 Aug 2025 07:01:37 +0000

This is a continuation of a series for the installation of the IoT platform. In the previous blog, we talked about how to install IoT platform application, stream application, OpenReports application, and Flow application and in this blog, we will continue with the installation of OpenPlatform application. This is the last part we need to install to make the whole IoT platform and then you can use all these apps together to get a great application to handle and analyze your data from diverse IoT devices.

If you haven’t heard about IoT platform or you want to get more information, please read this blog about the IoT platform first or watch this video describing the IoT platform. Please, keep in mind, that this platform is part of Total.js enterprise.

Why do you need OpenPlatform?

As with OpenReports and Flow, it is not necessary to use OpenPlatform in the IoT platform, but it enhances possibilities for various cases. We will integrate here IoT platform application, OpenReports application, and Flow application for easier access to all of them. This will make feeling, that all of these apps are one system and we will be able to create access for our users, manage their permissions, or add new modules to our app.

What is OpenPlatform?

OpenPlatform is a portal for running, integrating, and managing multiple 3rd party web applications. It includes user authentication and permissions management for connected applications.

Installation of OpenPlatform

We will continue with the assumption, that you followed the previous blogs about IoT platform, stream, OpenReports, and Flow, but this tutorial does not depend on it. So you can install OpenPlatfoem based on this blog and use it also for other cases.

Download source code and install dependencies

First, we have to download an application from a GitHub repository and save it to a directory. We can do it via the terminal with the code:

git clone https://github.com/totaljs/openplatform.git

We installed all dependencies in the previous tutorial, but if you are new here, just follow your terminal console or review previous blog posts.

Update port

We run the IoT platform, stream, and Open Reports on ports 8000, 8001, and 8002, so we have to go to the index.js file and change port to another, in this case, we will set it to port 8004.

This is how our index.js can look:

require('total5');

const options = {};

options.port = 8004;
options.release = process.argv.includes('--release');

// Service mode:
options.servicemode = process.argv.includes('--service') || process.argv.includes('--servicemode');

Total.run(options);

Update the config with a connection string to the database

OpenPlatform needs to create a database, so we have to go to the config file and update their connection string. We will add the same connection string as for our application because OpenPlatform will create a new schema in this database with its own architecture. But if you want to split these two databases and have your own database for every app, you can do it too. The updated config file can look like this:

Now we can run the application by terminal command:

node index.js

Now our application is running on port 8004 and we can access it via a web browser.

When we want to log in to the application for the first time, we have to use default credentials, which are:

{
  "login": "info@totaljs.com",
  "password": "admin"
}

You can find them in the readme file in the GitHub repository of the OpenPlatform.

It is highly recommended to change your credentials after the first login.

Adding an applications

As the first application, we can add an IoT platform. This approach will be the same as for other applications, so we will be more detailed here and the next applications will be only a quicker process.

Adding an IoT platform application to OpenPlatform

When we have already prepared our IoT platform app, we have to go to the Settings section. There is already a part dedicated to OpenPlatform with prepared inputs for request and response tokens and also an Importing link to OpenPlatform. First, we have to copy this link and put it into the OpenPlatform Apps section, where we can find the Import form.

After importing an application a form will appear, where you can see some very important information, like name, request and response token, and permissions.

I will change the name to IoT, and then we have to copy the request and response token to the previously mentioned inputs in the IoT platform Settings section and save our Import in the OpenPlatform application.

Now is IoT platform application imported into OpenPlatform, but we have to give access to users to this application in OpenPlatform. For this, we have to go to the Groups section, there is right now just one group (you can create more and add new users to particular groups) and that is Admin. We will click on this group, check the IoT platform application as an allowed app (as you can see there, you can allow access not only to the full application, but also just for particular plugins as you choose), and save a form. Then after refreshing the OpenPlatform app, the IoT platform will appear there and we can access it through OpenPlatform.

Adding of an OpenReports and Flow applications to OpenPlatform

We can use the same process for importing the OpenReports application and Flow application. Both of them have an OpenPlatform part in the Settings section with an Importing link and inputs for request and response tokens.

Then we have to add permissions to these applications to group Admins in the OpenPlatform and then we can access them through the OpenPlatform application.

The only application, that we do not import here is stream application because this is just for receiving data for sensors.

Conclusion

That is all for this blog. Now you are able to install IoT platform, stream, OpenReports, Flow, and OpenPlatform with importing applications. There is a lot more that you can achieve with this application, but this was just a simple explanation of how to install it and start using it.

I hope you learned something new with this blog and I will happily share with you more knowledge about Total.js.

Video

How to install Flow — IoT platform

Pavol — Wed, 30 Jul 2025 06:45:38 +0000

This is a continuation of a series for the installation of the IoT platform. In the previous blog, we talked about how to install IoT platform application, stream application, and OpenReports application and in this blog, we will continue with the installation of the Flow application. In the next blog, we will install OpenPlatform, to show you, how you can use all these apps together to get a great application to handle and analyze your data from diverse IoT devices.

Why do you need Flow?

As with OpenReports, it is not necessary to use Flow in the IoT platform, but it enhances possibilities for various cases. Flow is an independent application and you can use it also for other purposes, so if the IoT platform is not for your case, you can still use Flow for different kinds of cases.

What is Flow?

Flow is a low code visual programming interface created by Total.js and it is an alternative to Node-red. It is designed to simplify the creation and management of data workflows and automation processes. Flow integrates effortlessly with the Total.js ecosystem, as well as with external APIs and third-party services. Its versatility and seamless integration capabilities make it a valuable tool for automating tasks, streamlining operations, and enhancing productivity.

Installation of OpenReports

We will continue with the assumption, that you followed the previous blogs about IoT platform, stream, and OpenReports, but this tutorial does not depend on it. So you can install Flow based on this blog and use it also for other cases.

Download source code and install dependencies

First, we have to download an application from a GitHub repository and save it to a directory. We can do it via the terminal with the code:

git clone https://github.com/totaljs/flow.git

We installed all dependencies in the previous tutorial, but if you are new here, just follow your terminal console or review previous blog posts.

Update port

We run the IoT platform, stream, and Open Reports on ports 8000, 8001, and 8002, so we have to go to the index.js file and change port to another, in this case, we will set it to port 8003.

This is how our index.js can look:

require('total5');

const options = {};

options.port = 8003;
options.release = process.argv.includes('--release');

// Service mode:
options.servicemode = process.argv.includes('--service') || process.argv.includes('--servicemode');

Total.run(options);

Now we can run the application by terminal command:

node index.js

Now our application is running on port 8003 and we can access it via a web browser.

Creating a flow stream

When we access our Flow application we can log in with a predefined name and password (you should change that right after login). We will create a flowstream with the name Test and a form with components to download will appear.

Creating a TMS connection

Now we want to create a TMS connection between our IoT platform and Flow. This will give us an opportunity to process real-time data from our IoT platform. For example, we can create alerts based on values from sensors, send emails, create requests, and a lot more. In this example, we will only catch incoming data and print them.

To do this, we need to add a TMS component to drivers in the IoT platform and set a Token value. We will set value to 123456 for example purposes.

Then we need to go to Flow and add there TMS connection by clicking on the green plus button and choosing an option TMS sources. There we will create a new source and fill in a value for TMS source and Token. The token value is as we said before 123456 and the TMS source value is http://0.0.0.0:8001/$tms/. This url is port to our stream application with endpoint $tms for TMS purposes.

As you can see above, after creating a TMS source, new components are automatically added to our Flow. New components are streams for realtime data and alerts.

Now we can create a small stream of data from the realtime component, delay component, and print component. realtime component is already downloaded, bud delay and print components we have to download. After that, we can just drag and drop these components into the workspace and connect them as we can see in the picture below.

As we can see above when we can catch incoming data for every sensor without any further configuration. This gives us the possibility to process them in real time and use them for different purposes, like sending them to other applications or triggering some action based on a value or more.

Conclusion

That is all for this blog. Now you are able to install IoT platform, stream, OpenReports, and Flow with some basic architecture. There is a lot more that you can achieve with this application, but this was just a simple explanation of how to install it and start using it.

I hope you learned something new with this blog and I will happily share with you more knowledge about Total.js.

Video:

How to install stream to IoT platform — Total.js

Pavol — Wed, 16 Jul 2025 07:04:45 +0000

This is a continuation of a series for the installation of the IoT platform. In the previous blog, we talked about how to install IoT platform application and in this blog, we will continue with the installation of stream application. In the next blogs, we will install OpenReports, Flow, and OpenPlatform, to show you, how you can use all these apps together, to get a great application to handle and analyze your data from diverse IoT devices.

If you haven’t heard about this application or you want to get more information, please read this blog about the IoT platform first or watch this video describing the IoT platform. Please, keep in mind, that this platform is part of Total.js enterprise.

Why do you need a stream application?

The stream application is used to capture incoming data. The domain on which the stream will be located will serve as the destination for the data sent from the sensors. Also by visiting the link, we can see a list of all devices along with statistics.

Installation of stream application

We will continue with the assumption that you followed the previous blog because this blog is a direct continuation of it. So if you haven't, please, go as first to this blog and then come back.

Download source code and install dependencies

In the previous blog, we downloaded the source code also for the stream application and we installed npm packages in our root directory, so now we can skip this part.

Connect database

Stream application works with same the database as the IoT platform. We prepared this database in our previous blog, so now we need just the connection string, to connect stream to this database. To do this, we have to go to the file config in the stream directory and update the database property with the connection string.

Stream installation

First, we have to move to the stream directory in our terminal.

In the stream directory, we can see file index.js. You can open this file and see there are some options for our application.

require('total5');

const options = {};

// options.ip = '127.0.0.1';
options.port = '8001';
// options.unixsocket = PATH.join(F.tmpdir, 'app_name.socket');
// options.unixsocket777 = true;
// options.config = { name: 'Total.js' };
// options.sleep = 3000;
// options.inspector = 9229;
// options.watch = ['private'];
// options.livereload = 'https://yourhostname';
// options.watcher = true; // enables watcher for the release mode only controlled by the app `F.restart()`
// options.edit = 'wss://www.yourcodeinstance.com/?id=projectname'
options.release = process.argv.includes('--release');

// Service mode:
options.servicemode = process.argv.includes('--service') || process.argv.includes('--servicemode');
// options.servicemode = 'definitions,modules,config';

// Cluster:
// options.tz = 'utc';
// options.cluster = 'auto';
// options.limit = 10; // max 10. threads (works only with "auto" scaling)

F.run(options);

As we know from the previous blog, here we can change some options for our application. You can see, that I changed the port because the default port is 8000 and on this port, we already have an IoT platform running. So I chose to change port to 8001.

Now we can run this application from our terminal with the command (do not forget to be in the stream directory):

node index.js

When we enter our url, when the stream is running, we can see some statistics about the stream. For now, only the database is connected to our stream.

Conclusion

This is all for stream installation and now I will show you, why we needed it and how you can use these applications together.

How it works

Now, when we prepare our IoT platform and stream, I can show you how it works. You will see how you can get data from some sensors into the platform.

Create driver

The first thing we need to know is what data we can get from a device. Based on this, we will create a driver for this type of device. In our case, we will use the driver from the drivers directory, which we downloaded from GitHub. This driver is used for air quality devices, and in readme, we can see what data it can receive.

As you can see in a gif, our driver can process objects with data temperature, humidity, co2, tvoc, battery, and devEUI. devEUI is for the serial number of the device and it has to be different for every device of this type.

If you want to create a driver for your own special case, you can read more about creating a driver here, or you can use existing drivers as an example.

Create device

After creating a driver, we can create a device based on this driver. We can do that on the Devices page by clicking on Create and then we can choose the driver for a new device.

After that, we can fill in some information about our device. In our example, we will fill only the Device identifier, which is used to pair received data with the existing device. I choose, that our serial number for this example will be test123.

As you can see, all sensors for our device are made automatically after creating the device, because they are defined in our driver.

Also, when we check url of our stream, we can see, that a new device was registered.

Security check

To secure received data, the driver can be secured with a token. We will use this functionality in our example. In the driver we used is implemented checking x-token from the header of received data with the token. This token we can set for our driver in our platform, by clicking on settings in the driver menu.

As a value for a token, I used value Total.

Receiving data

In our example, I will send data to our platform with the RapidAPI app. When we want to create a request to send into our IoT platform, it has to contain a few things:

Url address

The url address is url of our stream application plus the endpoint for the driver of that device. So in our example, url address is http://0.0.0.0:8001/airq with the method POST.

Headers

As I wrote before, to secure our data, we have to add a token for checking, if data are coming from our device. In our case, we will use a header with the name x-token and with the value Total.

Data

And the last part of our request is data. Data are in JSON format like this:

{
  devEUI: 'test123',
  temperature: 15,
  humidity: 45,
  co2: 1032,
  tvoc: 3.4,
  battery: 3.61
}

When we send this request, our sensors will go from offline state to online state and we can see actual values received in our IoT platform.

That is all to this blog. Now you are able to install an IoT platform and stream, you can create a driver, and a device and receive data from your IoT device. There is a lot more that you can achieve with this platform and I will show you some basics in upcoming blogs.

I hope you learned something new with this blog and I will happily share with you more knowledge about Total.js.

Video:

How to install IoT platform — Total.js

Pavol — Fri, 11 Jul 2025 07:38:59 +0000

We got some questions about how to install this platform, so I decided to write you a blog about it, with step by step guidance. I will divide this blog into more parts. In this first, we will talk about installing the IoT platform, in the next one we will install stream, then OpenReports, and Flow, and the last part will be installing OpenPlatform and connecting it all in one.

Now maybe you are asking what it even is an IoT platform. If you haven't heard about this application or you want to get more information, please read this blog about the IoT platform first or watch this video describing the IoT platform. Please, keep in mind, that this platform is part of Total.js enterprise.

Our recommendation of versions for use are:

PostgreSQL v15 +
Node.js v18+
Total v5

I start from the assumption, that you already have installed your PostgreSQL database and Node.js. There are already many tutorials to do this, so we will focus only on installing the IoT platform and connecting it with the database.

IoT platform

We will divide this part into smaller parts for easier orientation.

Download

First, we have to download our code from GitHub (I will not share a link here, because you have to be part of Total.js Enterprise to have access there) and save it into your folder.

I want to work in the folder IoT, so I opened a terminal in this folder and I used the command:

git clone <***github link***>

Install dependencies

In this case, both applications (IoT platform and stream) need to install npm packages total5 and querybuilderpg. You can do that in their separate folders with the command:

npm install

But when we need it for both applications, we will install it in the root application with the command:

npm install total5 querybuilderpg

Now, when we prepared our npm packages, our directories can be organized like this:

Create database

Before installing the IoT platform, we have to prepare our database. In the admin folder, we can find the file database.sql. This is the script, which will create all our table structures for application. So we have to run this code in the database.

After running this script, we can see that everything is done and our database is prepared.

To connect the IoT platform with this database, we have to open the file config in the admin directory and update the database with the connection string.

IoT platform installation

First, we have to move to the admin directory in our terminal.

In the admin directory, we can see the file index.js. You can open this file and see there are some options for our application.

require('total5');

const options = {};

// options.ip = '127.0.0.1';
// options.port = parseInt(process.argv[2]);
// options.unixsocket = PATH.join(F.tmpdir, 'app_name.socket');
// options.unixsocket777 = true;
// options.config = { name: 'Total.js' };
// options.sleep = 3000;
// options.inspector = 9229;
// options.watch = ['private'];
// options.livereload = 'https://yourhostname';
// options.watcher = true; // enables watcher for the release mode only controlled by the app `F.restart()`
// options.edit = 'wss://www.yourcodeinstance.com/?id=projectname'
options.release = process.argv.includes('--release');

// Service mode:
options.servicemode = process.argv.includes('--service') || process.argv.includes('--servicemode');
// options.servicemode = 'definitions,modules,config';

// Cluster:
// options.tz = 'utc';
// options.cluster = 'auto';
// options.limit = 10; // max 10. threads (works only with "auto" scaling)

F.run(options);

For example, the default port to start an application is 8000, so if you want to change it, you can do it here. I will continue with the unchanged file because I want to start my application like this.

Now we can run this application from our terminal with the command (do not forget to be in the admin directory):

node index.js

Login to the IoT platform

We can now open url from our terminal in a browser.

As you can see, we got an Unauthorized 401 error. To log in we have to add endpoint /admin to our url, so the full url will be in our case http://0.0.0.0:8000/admin.

After entering this endpoint, we are redirected to the login form. Here we can fill sign-in form with default credentials and enter the application. After entering the application you can change credentials to your preferences by clicking on the account icon and choosing the Change credentials option from the menu.

Conclusion

This was the first part of the IoT platform installation. We got an IoT application installed and you can now use everything in it. But to get your data to this application, you have to also install the stream application. Because that is the application, that will catch requests and save new data in to database.

In the next blog, we will continue with stream installation and I will show you how you can send data to your stream and get them to your IoT platform for further processing and analysis.

I hope you learned something new with this blog and I will happily share with you more knowledge about Total.js.

Video:

Revolutionize Your IoT Management with Total.js IoT Platform: Simplify, Monitor, and Optimize

Pavol — Thu, 03 Jul 2025 17:47:06 +0000

With over 20 billion IoT devices in use today and projections of 40 billion by 2030, managing this rapidly growing ecosystem is more crucial than ever.

Overcoming Challenges in IoT Integration

If you use IoT devices for monitoring environmental conditions, managing smart city infrastructures, optimizing industrial operations, or you use IoT devices at all, it can be hard to keep track of every device. Managing and visualizing data from various IoT devices (like weather stations or electricity meters) can be challenging, especially with different manufacturers.

Devices often use different protocols and formats, complicating their integration into one system. On top of that, setting up alerts, reports, APIs, or simple dashboards frequently demands considerable time and technical expertise.

Without a centralized way to manage these devices, your IoT ecosystem can quickly become fragmented, inefficient, and hard to scale. This creates not only technical headaches but also missed opportunities to fully utilize your data and make smarter decisions.

Why a Unified IoT Solution Matters

Managing IoT devices without a centralized platform can quickly become overwhelming. Different devices often require separate applications. This fragmented approach not only consumes time but also increases the risk of errors and inefficiencies.

With a unified IoT solution, you gain the ability to streamline processes, integrate diverse devices seamlessly, and centralize all your data in one place. A single platform allows you to keep track of your data, analyze them, and even automate responses in one application.

Imagine the ability to set up real-time alerts, generate detailed reports and APIs, create simple dashboards, and access historical data effortlessly, all from one interface. Beyond saving time, a unified solution enables you to focus on insights and decision-making rather than troubleshooting and technical challenges.

In an increasingly connected world, having a system that simplifies and enhances IoT management is no longer optional — it’s essential for staying ahead.

The Total.js IoT Platform: Your All-in-One Solution

Simplify IoT management with the Total.js IoT Platform — a powerful solution to streamline workflows and boost efficiency. By integrating modules like IoT platform, Stream, Flow, OpenReports, and OpenPlatform, you gain great control over your IoT ecosystem.

With powerful features and a variety of integration options, this platform makes the Internet of Things (IoT) accessible, efficient, and tailored to your needs. With the Total.js IoT Platform, you can seamlessly connect, monitor, and manage diverse devices and sensors, no matter their type or manufacturer. The platform simplifies data processing, and visualization, allowing you to focus on insights rather than infrastructure, and on top of that it allows you to create custom reports, APIs, and dashboards.

Core Benefits of the Total.js IoT Platform:

Customizable drivers — drivers process incoming data. You can customize drivers to handle data precisely according to your requirements. For example, you can create a driver, that can connect and receive data from any source (MQTT, Modbus, etc.), camera (Dahua, Verkada, etc.), or you can create a driver with an endpoint, where you will receive data as REST API calls.

Simple Device Management —all of your IoT devices in one place with basic meta information, like a serial number, a reference, or a locality.

Real-Time data — real-time data is crucial for effective monitoring. Live updates from your devices allow you to gain immediate insights and faster decision making.

Custom Alerts — react instantly to events like temperature spikes or increased pollution levels.

Map Visualization — track your devices on an interactive map with real-time values.

Complex Reporting System — Create custom reports to analyze trends, value evolutions, or key metrics based on your use case.

Simple API Creation — Quickly build APIs from your reports to connect your IoT ecosystem with other systems.

Dynamic Dashboards — Custom simple dashboards to keep an eye on your important metrics in real-time for tailored monitoring experiences.

By choosing the Total.js IoT Platform, you gain a powerful, scalable, and user-friendly tool to transform your IoT operations. It’s not just a solution — it’s a game-changer for businesses looking to harness the full potential of IoT technology.

Visit Total.js IoT platform page to explore its full potential and see how it can transform your operations. Don’t wait — explore the possibilities today!

Video:

j-Box - Total.js

Pavol — Tue, 08 Apr 2025 09:33:40 +0000

j-Box is part of the jComponent UI library from Total.js. You can find more information about j-Box on componentator.com or GitHub.

j-Box is a great flexible UI component, that can be used to implement a wide variety of pop-up windows to your web application. You can use it for forms, tooltips, notices, galleries, or whatever you need as a pop-up window.

In the previous blog post, I wrote about j-Importer and already showed you a little bit of j-Box. In this blog, we will continue with the code from the previous blog, because we prepared there j-Importer for our j-Box. So if you are new here, please read the previous blog before, to fully understand the connections here and why we used both components together.

Because we want to use j-Box as a pop-up window for an example form, we will create it as a new HTML file. This file we put in the forms folder in our directories and it will be imported by j-Importer, when we click on the button we already prepared in the previous blog. This HTML file can have HTML parts, styles, and also JavaScript PLUGIN for itself.

How to use j-Box

As the first step you have to know how to use the jComponent library. I wrote about it in my previous blog, so for more information please read this blog post about jComponent.

Initialization

We can initialize more j-Box components if we need them, but they have to be in different files if we want to use them separately. In this example, I will show you how to initialize one j-Box, and based on that you will learn, that it is very easy and you will be able to use it further.

<ui-component name="box" path="*form" config="if:CLASS;title:TEST;width:350;submit:?/submit;reload:?/reload" plugin="CLASS" class="hidden CLASS">
  <nav>
    <button class="exec" data-exec="?/menu"><i class="ti ti-angle-down"></i>Menu</button>
  </nav>

  <div class="padding">
    CLASS
  </div>

  <nav>
    <button name="submit">SUBMIT</button>
    <button name="cancel">CANCEL</button>
  </nav>
</ui-component>

You can see in this example the word CLASS in multiple places. It is important to understand, that this word is in this case a reserved word (same as ~PATH~). Both will be replaced in the background for value, from the defined path. In this case, it is a value testform, because we used this path to invoke our j-Box and it is listening on that path.

We used the same HTML tag as for other components - ui-component. We used the same attributes as before, a name with a value box because we want to use component j-Box. Attribute path with value **form* where (star) is in the background replaced for path common, so final path is common.form. The last attribute is **config* with settings if with value CLASS which is a condition for showing the form, it's compared with the value within of the defined path. Setting title with value TEST which is a title for the form. width with a value of 350 which means, that the form will have a width of 350 pixels. submit with value ?/submit, which means, that a function submit from a particular PLUGIN will be invoked after clicking on the button submit. And setting reload with value ?/reload, which means, that function reload from particular PLUGIN will be invoked after reload.

The next attribute is a plugin with the value CLASS, which sets our plugin value to testform because as I wrote before, the word CLASS will be replaced in the background.

The last attribute is class, which is basically a class, and we set their values hidden and CLASS because we want to use this as a unique class for our form. It is good for us when we do not want to mix our styles between different forms and app.

You can see in the code, that this component has its inside divided into three parts.

The first part is navigation with one button for the menu. This button you can see in the header of our component. You can remove this part, or implement there some pop-up menu with options. For this example, I implemented there menu. This menu is made with the jComponent j-Menu. By clicking on the button Menu, the function menu from our PLUGIN is invoked and a menu will appear. (JavaScript PLUGIN is part of the test.html file, which includes our component j-Box, so this PLUGIN is created exactly for this form and they are part of the same plugin - testform).

exports.menu = function(el) {
  var opt = {};
  opt.items = [];
  opt.items.push({ id: 'eidt', name: 'Edit', icon: 'ti ti-pencil' });
  opt.items.push({ id: 'remove', name: 'Remove', icon: 'ti ti-trash red' });
  opt.align = 'right';
  opt.element = el;
  opt.callback = function(selected) {
    console.log(selected);
  };
  SETTER('menu/show', opt);
};

With this code, we will get a pop-up menu with two options - Edit and Remove.

Content

The middle part is for content in our j-Box. In the code, you can see, that I wrote there only the word CLASS, but because it is replaced in the background, you can see the testform rendered on the web.

This is the part of the component, where you can put your content. It depends completely on your case if you use it for some information text, gallery, form, or whatever you need.

You can put there for example some jComponent j-Input components and make a form from it. I will take some content from j-Input in componentator.com and I will show you how it will look.

Code used in this example (only replaced middle part):

<div class="padding">
  <ui-component name="input" path="?.framework" config="placeholder:Choose a framework;dirsource:frameworks" class="m">Framework</ui-component>
  <ui-component name="input" path="?.terms" config="type:checkbox" class="m">I agree with terms</ui-component>
  <ui-component name="input" path="?.notes" config="type:multiline;innerlabel:1;placeholder:Enter notes" class="m">Notes</ui-component>
  <ui-component name="input" path="?.frameworks" config="placeholder:Select frameworks;multiple:true;dirsource:frameworks">Frameworks</ui-component>
  <br />
  <ui-component name="input" path="?.city" config="required:1;placeholder:Where do you live?;dirsource:cities;innerlabel:true;dircustom:true">City</ui-component>
  <br />
  <ui-component name="input" path="?.date" config="placeholder:Enter date;type:date;required:true;innerlabel:true">Date</ui-component>
  <br />
  <ui-component name="input" path="?.search" config="placeholder:Search...;type:search;innerlabel:true">Search</ui-component>
  <br />
  <ui-component name="input" path="?.password" config="placeholder:Type a password...;type:password">Password</ui-component>
</div>

And because this form has defined also the plugin attribute, all values are now available on this plugin path (testform in this case).

Buttons

The last section is buttons, which are rendered in the bottom part of the form. It is optional for you, you can use both these buttons, remove them, or use only one you need. In this example, I will show you how to use it. In the configuration for the j-Box component we defined, that we want to invoke the function submit after clicking on the submit button. So we have to create this function in our PLUGIN.

exports.submit = function() {
  console.log('SUBMIT');
};

Now, after clicking on the submit button we will get text SUBMIT in our console.

You can do the same also for the Cancel button.

Maybe it will help you more if you see the complete code in the test.html file, so I will add it here.

I hope you learned something new with this blog, but do not forget, that this was only for example purposes and you can do a lot more with this component.

Video tutorial

j-Importer - Total.js

Pavol — Tue, 18 Mar 2025 09:03:02 +0000

j-Importer is part of the jComponent library from Total.js. You can find more information about j-Importer on componentator.com or GitHub.

Importer is a great component to use, when you want to import HTML templates, scripts, or styles to your page. You can do this import dynamically based on some condition on a path.

In this blog, I will show you how to use j-Importer to import pop-up form, and in the next one, I will show you how to work with that form. So these two blogs will be related and for total understanding, please read both of them.

How to use j-Importer

As the first step you have to know how to use the jComponent library. I wrote about it in my previous blog, so for more information please read this blog post.

Initialization

We can initialize as many j-Importers as we need. In this example, I will show you how to initialize one j-Importer, and based on that you will learn, that it is very easy and you will be able to use it further.

Case for this example will be importing one pop up form in our page by clicking on button Open form. This form will be empty and I will tell you more about it in the next blog.

Example:

<ui-component name="importer" path="*form" config="if:testform;url:../forms/test.html;reload:?/reload"></ui-component>

We used the same HTML tag as for other components - ui-component. You can see in the example three attributes, name, path, and config. In the first attribute, we wrote value importer, because that is the name of the component we want to use. The second attribute is the path with value *form, where * (star) is in the background replaced for path common. So the final path will look like a common.form. In the config, we have settings if with value testform, which is a condition for importing. url with value ../forms/test.html, which is the address to the document we want to import (in this case it is test.html in folder forms). The last one is reload with value ?/reload.

Settings like this mean, that when we set the value on path common.form to testform, file test.html from folder forms will be imported to our page and function reload in this file will be invoked.

So now, when we have prepared our importer, we can create a button and function to invoke it.

<button class="exec open" data-exec="?/openform">Open form</button>

Our button has a text Open form and by clicking on this button we want to invoke function ?/openform in JavaScript PLUGIN.

exports.openform = function() {
  SET('*form', 'testform');
};

As you can see in the openform function, we only need to set value in the common.form to testform to invoke our j-Importer.

Example code in test.html:

<ui-component name="box" path="*form" config="if:CLASS;title:TEST;width:350;reload:?/reload" plugin="CLASS" class="hidden CLASS">
  <div class="padding">
    CLASS
  </div>
</ui-component>

We used component j-Box in this file, but we will talk more about this component in the next blog, this is only for example usage.

Now when we click on the Open form button, j-Box will appear thanks to j-Importer.

As you can remember, we also added the setting reload to our j-Importer. So we can expand our example and add function exports.reload to the form file. This function will be invoked automatically after importing the test.html file.

PLUGIN(function(exports) {
  exports.reload = function() {
    console.log('HERE');
  };
});

After importing the form, we want to get text HERE in our console.

As you can see in the example, the text HERE will appear in the console after every invoking of our form. It means that the function reload in JavaScript PLUGIN of our form is invoked every time by j-Importer. You can use this for example for getting some data to your form or whatever you want to render in the j-Box component. It does not have to be a form, it can be some popup window, notice, tooltip, and more.

I hope you learned something new with this blog, but do not forget, that this was only for example purposes and you can do a lot more with this component.