You may have noticed that the Price Checker was struggling to refresh prices for a large list of products.
That's because it was running all price checks at the same time, overloading the target websites.
Now, thanks to a new internal redesign, it just checks prices one by one, with an animation showing you the advancement.
We've been working very hard to produce this new plugin: You can now check the online price of an item you are editing.
That's very useful for example when you are maintaining a list of your favorite products, you can now list their prices in online shops. 7 shops are already supported, and more will be added over time. See how the Coffee Bean App has been enhanced to show you current product prices.
You can as well use this plugin to monitor the price of items you wish to buy: In one view you can see its price in different shops, and refresh them by a click of a button. Be sure to not miss any sales !
Check our new application for that: "Price Checker"
After a demand from one of our customer, we developed a plugin enabling you to easily generates charts based on your data. It is based on 
Chart.js as provided by PrimeNG components.
As for other plugins, you just need to configure the graphs needed in the Builder.
We developed a chartjs plugin to support date format without dependencies to any javascript date libraries by the way.
Now the release of Dont-code is completely automatized thanks to Github Actions.
All the core and plugins components are built, tested against each other, and deployed in one script.
After months of hard work, and even more rework than expected, we have finally made one of the main promise of Dont-code possible.
The IT guys in the enterprise can:
Thanks to the newly developed Rest plugin, you can now easily and instantly display data coming from another application
As you know, you can instantly witness the result of your application designed with Builder through the Previewer.
To do this, the Builder sends Change events to the Previewer, who then adapt its display and behavior.
Then the Previewer analyses the Change and sends it to the affected plugins that can modify their behaviors.
Until now, each plugin must have been able to react to any kind of changes, with this new version, the plugins need only to take care of changes that interest them, Dont-code framework will ensure it receives updates if another change impacts it.
Following the pure eat-your-own-dog-food principle, we are using some of our demo apps internally.
While using the Coffee Bean Evaluator, the BBQ Sauce Taster or the Complement Alimentaire Price Checker, we've found some small issues in the editor plugin
We made as well several usability enhancements
A lot of enhancements have been deployed to ease the development of plugins for the Dont-code platform:
This is fully transparent for the user but now when you open the Previewer, it downloads the Plugin from a remote location.
Before that, it was be compiled and deployed with all the plugins build-in. So what are the advantages of this dynamic approach ?
This has been possible thanks to the great work of the "Angular Architects" team.. Not only they provided the library to help support Module Federation of Webpack 5, they also created an example and walkthrough to make it easy to use !
The old Dont-code homepage didn't fill its purpose: Based on clicky.com agent, around 5 users a day were reaching the page but a large majority of them didn't stay. Only a very few were going to the developers page. I checked with some 'normal' users, and they didn't like the look and feel of the pages.
I was using Github pages framework with the So simple theme:
This was handy as for any new content I only had to write the text in markdown format, but the result was not that good.
So I've decided to rewrite the page.
Now I'm using the Titan template, it's pure HTML and javascript, and the result looks much better. Now let's see if that sparkle more interest from users !
After the move to Angular 12, we have upgraded all the projects to follow the 'strict' rules from Typescript. This means making subtle changes in almost all source code.
With this 'strict' mode, the typescript compiler is now checking all assignments to ensure null and undefined values are managed properly.
For example,let value:string = aMap.get('something');
triggers an error 'Cannot assign string|undefined type to string variable'.
Because when you declare `let value:string` in strict mode you are explicitly telling the compiler that value cannot be null or undefined. As `aMap.get('something')` can return undefined, the compiler catches this. The compiler will do the same checks for function return values, parameters, class members, and so on!
You can solve this in 2 ways:
// value's inferred type is string or undefined:
const value = aMap.get('something');
if (value) {
// compiler knows var cannot be undefined or null here
value.doOtherThing();
} else {
// Special treatment if no values are found
}
The result of all this hopefully gives developers more hints at potential nasty bugs in their code, at the expanse of speed of development and code clarity. Let's see if in the Dont-code case this is worth the effort.
This week-end has been spent upgrading Angular to version 12, and that was an easy one.
Of course this involves some mandatory steps:So it took me only a week-end to do this major upgrade, thanks Angular, Nrwl, Primetek, Jest and Cypress, I know this went smooth thanks to your hard work!
Now the basic types Currency have been added. You can now start designing finance apps.
Thanks to the great PrimeNG UI components, the Previewer now allows you to edit amount in your Currency.
List of currencies has been added as well.This took much more effort than for dates and images because I wanted to define a standard way of handling Money [with amount and currency](https://github.com/dont-code/core/blob/main/node/libs/core/src/lib/model/money-amount.ts), and I had to tweak the Dont-code framework itself to support multiple elements management by one field component.
Less than 2 days needed to add support for date, time, image and url.
Thanks to the plugin architecture it took me just a few hours to add new field types to the Dont-code platform... I just needed to copy / paste the code for the basic fields (Text, Long, Numeric) and update the Angular templates to use PrimeNg Calendar Component.
In fact, most of the time was spent adding support for grouping field types due to the increasing number of them.
Next step is to add Currencies and Monetary Amount field types. Let's see how much effort will be needed for that !
Available today, you can share information with other users by selecting "Share with Dont-code users" in the Builder.
You know you can directly edit data in the Previewer while designing your application. Until now, this data was saved in your local computer (in the [Browser's IndexedDB](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API)). However, if you select "Share information with Dont-code users", then the data will be stored through the Dont-code Data API running in our Test server and stored in a MongoDB Database.
This means another user selecting the same project will be able to see and edit the same data. Another step in the journey of a usable no-code platform. Let's see if in the Dont-code case this is worth the effort.
Session Management has been implemented.
When you update your application model in the Builder, it shares all with the Previewer through a server. This allows you to have the Previewer neatly separated from the Builder, and even starts multiple Previewers, all updated at the same time. Now when you use the [Builder Demo](https://run.dont-code.net/ide-ui/latest/), you can see at the top right a small popup showing the server it is connected to, and as well the Session used. Any modifications you're doing to your application design, is sent to the server and stored with this Session.
Then, when you Open the Previewer 
, it will display the latest updates of your application related to this Session.
In order to do that, I've used a MongoDB database running on server side and storing all sessions updates. The side effect is now I can see if and when people are using the demo.
Full Application loading is now delivered to the Previewer as well!
As a quick follow up to the last update, Previewer application now supports loading an application from scratch. With the previously mentioned support from the Builder, one can just load, save or create a new application and see the result immediately.
In the Builder Demo, you can load small applications already made: A Task Manager, a very simple Note Editor, a Recipe collection and so on...
Now one can save and load an application in the Builder.
If you have a look at the Application Builder Demo, you'll see a new menu appeared: Projects.
Clicking on it, you'll see the project screen where you can save the current project or load another one.
One can believe this would be an easy thing to develop, however even the development team were surprised to see how difficult it was. Not only we had to:
However, we didn't expect the following issues:
So all this brought complexity to the development of this feature. And fear is growing as it needs to be applied to the [Previewer](https://run.dont-code.net/preview-ui/latest) as well.
We are entering a new step in the evolution of Dont-Code. Now that we got the basic applications working, we can show and explain the concept behind the Dont-Code platform: Going one level higher than the existing low-code or no-code frameworks. Dont-Code lets you combine already developed features together just with answering questions.
We've put in place some Analytics (Clicky) and SEO (Seobility) tools, and they show a lack of recognition of Dont-code with no-code or low-code keywords.
To bring more people and more developers to the site, we'll do the following:
How to manage countries with the Dont-code platform?
We're happy to announce that a new plugin has been developed: The [Fields Plugin](https://github.com/dont-code/plugins/tree/main/libs/fields) provides a way to view / edit a Country. It is now enabled by default in the Builder and the Previewer.
In the Builder, you can create a field of type Country:
Then, in the Previewer, you can select the country directly from a list and the values are displayed nicely with the flag in the list of elements:
You can see that with the power of the dont-code platform, a plugin developed once can be reused to any application.
By the way, the source code of Fields Plugin in Github is a great way to see how to develop a plugin for the Dont-code no-code platform.
Just a quick update to announce that the Basic Plugin can now edit values of the entity.
The screenshots below show that for any created entities, you can list them (with dummy data), and as well edit them.
.
Thanks to all the work done previously, it's now quite fast to create these new features !
Since its inception, the dont-code framework is progressing slowly but steadily. As we want plugins to be tightly integrated into the framework itself, we have decided that all screens shown will be part of a plugin.
This is the purpose of the [Basic Plugin](https://github.com/dont-code/plugins/tree/main/libs/basic), it manages the display of entities by listing them and editing them. For now, it just shows table columns that dynamically adjust to the fields you declare in the editor.
Next steps, displaying a list of values, displaying edit form, running queries against the database...
By the way, the menu now supports moving, deleting and renaming entities.
We achieved quite a big step last week as the dont-code framework now supports loading plugins dynamically. It supports two types of plugins:
Of course, you can combine both in a single plugin, allowing you to add or modify any item in the editor and handle its display in the previewer !
To further enhance the plugin framework and make sure it is performant enough, even the core ui components of the previewer will be developed as plugins. You can find the basic ones in the following repository.
Two applications work together to enable the development of applications without coding. Let's describe them...
To support plugins in the editor, I need to be able to display different editor elements depending on a selection.
For example, the [Screen Plugin](https://github.com/dont-code/plugins/tree/main/lib/screen) adds a screen type item, that when selected to 'list' for example, will ask the user only about the entity name to display in the list.
So the default elements of a screen, like 'components' should be removed as they are not necessary. The handling of editor elements is done in [TextService](https://github.com/dont-code/ide-ui/tree/main/apps/ide-ui/src/app/shared/text/services/text.service.ts) class, with maps of lists and so on. Complexity is high !
Now I changed this and [EditorElement](https://github.com/dont-code/ide-ui/blob/main/apps/ide-ui/src/app/routes/editor/editor-element.ts) stores their children directly, this simplifies a lot the code, I just spent 2 days rewritting it. Two days with no new functionalities added, but now the code is simpler and ready for dynamic editing. I even removed intermediary classes that were not needed anymore... Cool!
I'm not really an expert in licenses, so I'm not sure my current choices will be the right ones.
There are several parts to the dont-core framework, and as they serve different purposes, they have different licenses.
However I don't want them to be used without something in return, so they are under AGPL license. That means you can derive your work from it, and even run them in your public cloud, but any changes to it must be open-sourced as well.
One of the most important part is the plugin system.
To be successful and different from other low-code or no-code platforms, Dont-code should be as extensible as possible. This way, persons or companies from all over the world will be able to use and add any kind of functionalities.
Of course, this is quite complex as you must allow changes in the core of the framework from external.
This is why I need to:It is starting to work now. For example, a plugin can add a list of options named 'type' to the editor by registering with
{
"schema-updates": [{
"id": "screen-list",
"description": "A screen displaying a list of items",
"changes": [{
"location": {
"parent": "#/definitions/screen",
"id": "type",
"after": "name"
},
"add": {
"enum": [
"list"
]
},
"props": {
"entity": {
"$ref": "#/definitions/entity",
"format": "#/creation/entities"
}
},
"replace": true
}]
}]
}
Of course, it is placed only at the end for now, it should as well replace the other options of screens, but it's a start.