-
-
-
- User interface versions
- Building blocks for user interface design
- Adding styles with a css
- Surrounding page
- Changing snippets
- Creating a custom login page (pre 3.4)
- Creating a custom login page
- Using velocity templates within the blueprint
- Create your own web pages
- HTML delivery requirements
- How to customize system mails
-
-
- Introduction to security
- Secure development
- Security certification
- Field properties concerning security
- Developing user groups securely
- Security considerations for user interface
- Secure file organization
- Securely using the request
- Cross Site Scripting (XSS)
- Other options concerning secure development
- Security analysis
- Secure deployment
- Secure application management
- Scrambling of testdata
- Anonymization of personal data
- Using robots.txt
- Permission settings
- Security measures
- Data encryption
-
- Search Engine Optimization
- OTP
- User Interface migration guide
- User account management
- Instructies voor implementatie van visueel editen van nieuwsbrieven
- Login as another user
- Support
- More information about moving to User Interface Version 4.0
- Standaard page layout
- Sections moved to layout
- Aanpassingen in release 2024-7
- Media library
- Aanpassingen in release 2024-10
- Analytics and Matomo
- Registration forms
- How to change names of classes and fields?
- Responsible Disclosure Policy
- How to upload a blob in Velocity?
- Aanpassingen in release 2024-2
- Instances
- Google Analytics
- Street and City helper (postcodecheck)
- Responsible disclosure-beleid
- Postcode check service (straat en huisnummer) kosten
- Expressions
- Regular Expression Reference
-
Using branches
The CrossmarX development platform offers branching as a form of version control. A branch of an application can be made, creating a copy of the blueprint. Changes can be made in seperate branches that will not affect the other branches. The branches can then be merged again, bringing changes together in one place and resolving any conflicts. This facilitates a flexible and secure way of working on an application.
Reasons for using branches
Multiple branches might be useful in some situations:
- Working on a major change for an application
Suppose an application requires a major change that will take some time. During this time, the application may also need some minor changes. Reloading the application to introduce the small changes is not possible, because a reload would also activate the unfinished work related to the major change. Creating a separate branch for the major change solves this problem. It allows work to continue seperately on the major change, while smaller changes can still be made in the original branch at its own pace. Both processes do not affect each other. This way of working is also a good standard protocol to control the release process. - Concurrent developers on the same application
If more developers work on the same application and want to apply their own changes without affecting the work of others. Each developer can create their own branch to work on and later decide to merge their changes in to the final 'shared' branch. This process requires some coordination between developers and agreements on what each developer works on in their branch. - Beta testing on production data
If it is required to beta test blueprint changes on production data, a branch can be created on the production environment. Only the default branch on the production environment will actually be live, so this new branch can be used to synchronize the changes from the develop environment and test them out on production data.
What is in a branch?
A branch contains a subset of the application definition:
- the blueprint
- the application files
- the macros
- the methods
All other elements of a definition, such as menus, forms, queries, dashboards, custom urls do not belong to a branch. These elements are shared by all branches on a certain environment.
How to create a branch
When the application is started for the first time on a particular environment, it will always have one single branch. Branches can be managed under 'Deployment' -> 'Manage application branches'. The following options are available there:
- Available branches
A list of branches available on this environment. Note that a branch called 'A' on environment 'X', and a branch called 'A' on environment 'Y' are not related technically in any way. It's just a name. What's currently in the branches environment is local to that environment. - Run branch ...
Pick a branch to run in the session if there is more than one branch available in this environment. - Rename branch ...
Give one of the branches another name - Set current branch as default
This will make the branch currently running in the session the default branch for all new sessions on this environment. - Create new branch ...
Create a new branch here, usually by copying an existing branch. However it is also possible to create an 'empty' branch and populate it by synchronizing with branches running on other environments. - Delete branch ...
Delete one of the branches - Merge branches
Merge changes done in different branches running on the same environment into each other.
Merging and synchronizing branches
Merging and synchronizing are two ways of bringing changes made in seperate branches together.
Merging
Two branches that are located on the same environment can be merged. At this moment the merge functionaliteit is restricted, so take notice of the following:
- One direction
Merging between two branches can only be done in one direction. When the merging process is started a branch to merge must be selected and a branch to merge into must be selected, changes will only be merged into this branch - Only within 6 months
Only changes made within 6 months can be merged. Older changes will be ignored by the merge process.
Synchronizing
With the synchronize option, a branch on a remote server can be selected to get content from. This way it is possible to synchronize data from a selected branch on the remote environment, for instance the development environment, into the current branch on the local environment, for instance the beta or production environment. During synchronization it is also possible to only select parts of the application to synchronize.
It is also possible to use the synchronisation to merge files, macros or methods between branches on the same environment.