Skip to main content

5.0 to 2019.3

Upgrade of the Designer project​

Neon Frames in version 5.0.x​

warning

If you are already using the Neon system in version 5.0.x, you'll have to make them again with the context / view system. Frames aren't supported anymore and existing frames can't be automatically converted into the context / view format. In this case it is essential, that you have a nonupgraded version of your project. So you can use it as a reference point for building the new contexts.

Preparation of the ADITO 5.0 project​

If you're using GIT as version management system, you should create a migration branch based on your recent stable branch, so you don't overwrite your current customizing by accident. You can do this easily by using the GIT repository browser of the ADITO 5.0 Designer.

2019_05_10_CheckoutStableAsNewBranch

2019_05_10_CheckoutStableAsNewBranchDialog

The new ADITO 2020 Designer​

To migrate the customizing to the new release, you should open the new Designer now. The Designer has undergone some major changes. To be able to navigate the program, it's adviced to have the Designer Manual handy for reference. The manual can be downloaded from the customer login of the ADITO website.

Automatic project upgrade​

Within the Designer, you can now open your project by navigating to Menu -> Open Project.

2019_05_10_ADITO_2019_DesignerOpenProject

After that you'll see the project opened in the project tree. It's shown in grey with the hint (old version) and offers to do an upgrade. Doubleclick on Upgrade project... to do the upgrade.

2019_05_10_ADITO_2019_UpgradeProject

Update Commit​

If you're using GIT, you should write a commit after you've done the upgrade. So you can go back to a specified state, if problems during one of the following steps arise. After each change or step, you should do another commit, so it's easier to go back and to track, what has happened within the project in case you need to debug.

Checking the system configuration​

In ADITO 2019 the configuration were split into two parts:

. System dependent configurations

  • These configurations are bound to different systems and can vary from system to system. I.e. development system, test system, production system. Here you configure this like server ip adresses, Port and pretty much everthing that refers to this specific system instance.

. Project dependent configurations

  • These configurations are now the same over all systems on which this project is deployed. Examples are password security rules or the used language packages.

While checking the configurations, you should have a copy of the project opened in the ADITO 5.0 Designer to be able to look up the old values, if they are missing. In most cases the automatic upgrade places the right values in the right spots, but in rare cases some values might go missing during the upgrade.

info

With ADITO 2020 all connections are made with the Port of the Jetty Proxy (http: 8080 or https: 8443) This affects clients, the Manager and webservices.

warning

If you are using your regular serverlicense file, you used with ADITO 5, you might run into some issues, because the license is bound to a specific IP address and port combination. ADITO 2020 uses automatically generated ports and binds to all addresses the server is using. This may cause a confilct with your license.

To fix this, you have to open the configuration of your system, switch to the source editor and add the XML nodes systemServerAddress and systemServerPort.

<systemServerAddress v='your ip address'>
<systemServerPort v='your client port'>

2019-11-21_ExperConfig

Deleting old iNet Reports​

The reporting engine iNet Crystal Clear isn't supported since version ADITO 2020. To prevent errors, you have to delete all old iNet reports. These old reports are shown with a red exclamation mark in the Reports node of the project tree, so they are easy to identify.

If you still need these reports, you'll have to create new identical ones using the Jasper reporting engine.

Changes to the CTI handling​

Here two changes have to be made:

  • Rename the CTI Callstate process The process, which got set as the callstate/callback process in autostart, has to be renamed to ctiClientEvent. This process now handles telephony events within ADITO 2020. In the xRM-Basic this callstate process is called cti_log, but the name may vary in your system:

    2019_05_13_ctiProzessUmbenennen

  • Changing process autostart In the code of the process autostart, you have to remove the lines, that set the CTI callstate process. For this, remove the following lines from autostart:

    2019_05_13_autostartAnpassen

Changes to the call of the telephony popup​

To make sure the telephony popup still works as intended, you have to change the frame mode, when the popup is called. In older versions, the popup had to be called with the frame mode swing.FRAMEMODE_SEARCH, now it requires swing.FRAMEMODE_SHOW. In the following picture, you see the code, where the cahnge has to be applied:

2019_05_14_TelefonPopupAufrufShow

This change could also be necessary for other calls, that use the notify window.

Process based BLOB handling:​

If you use the process based BLOB handling, you must rename the process blobManager to blobHandler. The latter is now a process required by the application core to do the handling of BLOBs / files.

Setting the correct variants for processes​

A new property was introduced, which can be found on the processes now. The property is called variant. The variant isn't only a category, but has side effects within the system. Two variants are set automatically:

. internal This variant applies to any process that is used by the application core. Those processes have a specific name. For example: autostart, serverautostart, etc. . webservice This variant is set automatically, if a process gets published as a webservice or legacy webservice. Webservices additionally require the library variant to function correctly.

Then there are two more variants, that can be set manually:

. library This variant marks a process as a library. These processes can be imported into other processes by the import() command. If you import a process, that doesn't have the library variant, you'll get an error if you try to run the process. . executable This variant marks a process as an executable process. These processes are used to automate certain things like data imports, interfaces, etc. Without this variant, the manager won't display them as an executable and you can't trigger them or plan an interval for them to run.

After the project upgrade, most processes will have library as well as executable set. You'll have to correct that manually.

New process timer system​

Since ADITO 2019 the timer system has changed. First of all, you will have to create two new database tables in the system database. The tables are called ASYS_TIMERS and ASYS_TIMERS_SERVERRUNS. Within these tables the system now manages the timers.

info

To create these tables, use the create system tables function of the designers database editor. As this function always has the most recent create definition for the system tables.

warning

Your processes will stop until they are newly registered within the new timer system!

The second change is, that these timers are no longer managed within the ADITO client, but in the new webmanager. The webmanager can be found at https://your.server.url:8443/manager after the Neon Client is activated. The property to activate the Neon system can be found in the system configuration in the subfolder Client and is called neonVaadinClientEnabled. In the webmanager, you'll find two menu items called Processes and Process log. Within Processes you find all JDito processes, that are marked with the variant executable. You can choose the process, you want to run. Then you'll have to configure the interval with the button edit process information, after that you can start the interval using the button Start interval. If you just want to run a process once, you'll have to use the button Start process once.

Within the process log, you find informations regarding their last runs and the end status. If an error occurred, you'll find the error message there too.

You may have to change your severautostart process aswell. There is the initialization located. This isn't necessary anymore. So you can delete the lines containing process.executeProcessTimer() and initTimers(), because this is now handled by the ADITO application core.

Testing the system​

warning

Please test your whole system! Due to an update and optimization of the JavaScript engine, side effects may occur.

In ADITO 2020 the execution of JDito scripts and the order of execution was optimized, to get better performance. This can have several side effects on your system.

The changed order of execution can lead to image variable not being set, but being accessed. This happens for example if these variable get set in value processes of component. If you need these variables in one of the frame processes, you should set the varaibles in the beforeStart frame process, because this is the one, that is executed first when loading a frame.

It may happen now, that error dialogs pop up, that weren't there before. These errors were already existent, but were suppressed. Now these are no longer suppressed and show up, but these error are usually very easy to fix.

If you use the JDito method swing.getTableDataByID to read values from a newly added table row, you have to read the value directly from the editor component now. E.g. vars.getString("$comp.editor");.

Further improvments to JDito were made by updating the underlying Rhino JavaScript engine. This may cause some errors, because arrays with lexical indexes behave different. If you use something like:

var arr = [];
arr["indexString"] = "";

The length property of the array may no longer be correct, because those lexical indexes in an array are no longer counted towards the length and are no longer iterable by a regular for loop. If you have those constructs and you want to iterate over lexical indexes, you have to use the for...in loop.

E.g.:

for(let i in arr)
{
    doSomething(arr[i]);
}

Another issue is, that in some cases a NumberFormatException can occur, if the Rhino engine passes numerical values to the ADITO Java application. It may happen, that the implicit typecast from string to number won't convert it correctly. In this case, you'll have to do the typecast yourself. For example:

var a = vars.get("$field.colIndex");
var b = [];
b[a] = "foo"; // Something like this may cause the Exception
b[Number(a)] = "bar"; // Number() is the typecast, that fixes the issue

In ADITO 2020 a new search provider is used. In earlier versions Apache Lucene was implemented directly, now ADITO uses Solr, which is a search provider that builds upon Lucene. This allows for faster building of indexes, but it weighs the search hits differently. This may lead to a different order of search hits.

The existing index definitions can still be used, but it is required to do a full indexer run after the upgrade, so these indexes get rebuilt using Solr.

If your client won't connect, it may be because the property "neonUseSelfSingnedCertificate" isn't set. The connection uses SSL by standard, which requires a certificate. If no certificate is installed, the connection won't be established. With the help of the property the server can create its own certificate to use for encrypting the connections.

Changes to ADITO webservices​

In ADITO 2020 webservices are no longer directly accessable. The services are now masked by the Jetty Proxy. You will have to change the port of existing service calls to the port configured in the system configuration properties neonHttpPort if you use HTTP or neonHttpsPort if you use HTTPS and you have to access it with different subfolders in the URL. These are:

  • /services/rest/servicename?params This is the folder for accessing REST webservices.
  • /services/soap/servicename This is the folder for accessing SOAP webservices.

Examples:

The property webservice user was moved from the system configuration to the webservice processes themselves. That entails, that you have to set the users at the webservice processes now. This change allows for the use of multiple different user contexts, so each webservice could have its own user, which in turn allows for better rights and access management.

Changing Java Webstart to JLoadr​

Until ADITO 2020 Java Webstart was used to provide the client packages to different machines. ADITO 5 allowed for parallel use of Webstart and JLoadr, ADITO 2020 now uses JLoadr exclusively. If you used Java Webstart, you will have to configure Jloadr to supply the client package. The configurations for JLoadr can be found in the system config in the node JLoadr

2019_05_13_JLOADRConfig

Details on how to configure JLoadr can be found in the document AID034.

64 Bit only​

From ADITO 2020 onwards, only 64 bit operating system will be supported. Please make sure all PCs that run ADITO 2020 are on a 64 bit OS!

Changes to Neon entities​

In ADITO 2020 the entity model was further developed. This entails many changes to how they work. If you used Neon in ADITO 5, those entities may have to be remade. The changes include new/changed processes, opening of Neon frames via JDito is not longer possible and tables may behave differently.

If you used ADITO 5 Neon, please test all your entities.

Changes to plugins​

From ADITO 2019 onward, the PhoneNumberPlugin, which was used for automatic formatting of phone numbers, is not working anymore. This is due to the new Java version and changes within the external libraries. This functionality is now contained within the system.cti JDito module. You'll have to change your system to use those methods instead of the plugin now. Further documentation to each of the methods can be found with the ADITO Designers code completion feature.

import("system.cti");

//for formatting a phone number
cti.formatPhoneNumber(pPhoneNumber, pRawInputOnInvalid, pCountry);
//for checking the validity of an input phone number
cti.isValidPhoneNumber(pPhoneNumber, pTestForMatchingCountry, pCountry);

Plugins can always break, if you upgrade the version of the ADITO system or the used Java version. For plugins, which are provided by ADITO an update will typically be available. If you wrote your own plugins, you have to check its compatibility with a new version by testing it on your test environment and update your code accordingly.

Database systems

Oracle Database​

If you're using an Oracle DBMS it is necessary to add a new XML Node to the configuration of the system database in your serverconfig.xml file:

<entry key='service' value=''/>

Changing MariaDB / MySQL Collation​

If you run your ADITO system with a MariaDB or MySQL database, you have to change the database collation to utf8mb4, so your database can support unicode letters. There are different approaches:

  • If you want to create a new database:
mysql -u USER -p 
create database DB_NAME charset=utf8mb4; 
use NAME; 
SET NAMES 'utf8mb4';
  • If an existing database should be converted, it works best with dumping the database and reimporting it:
mysqldump -u USER -p -c -e --default-character-set=utf8mb4 --single-transaction --skip-set-charset --add-drop-database -B DB_NAME > dump.sql 
sed -i.bak -e 's/) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;/) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;/' dump.sql 
mysql -u USER -p 
source dump.sql;

There are some changes, you have to do in the config file of your database:

[client] 
default-character-set = utf8mb4 

[mysql] 
default-character-set = utf8mb4 

[mysqld] 
character_set_server=utf8mb4 
collation_server=utf8mb4_general_ci

Firebird​

warning

From ADITO 2020 onward the Firebird DBMS is no longer supported.

If you want to use ADITO 2020, you will have to migrate to another DBMS, which can be very difficult to do, if you're using Firebird Extensions. Please consult your database administrator before upgrading to ADITO 2020.

The supported DBMS can be found in AID017 in chapter 2.3.