The REST-API is developed according to the Open-API standards and is the preferred method of integration for many web developers. Most of the functions of signoSign/Universal can be controlled very easily via the REST-API in order to provide users with documents and signature functions. A document can be handed over to signoSign/Universal at any time and from anywhere and opened so that the user can edit and sign the document.
The REST API is very easy to integrate and is supplied with the popular Swagger-UI in addition to the technical documentation. A session of the document viewer can be managed via each token. This makes it possible to provide different documents and configurations with each call/token. The special thing here is that documents can also be completely processed in the temporary memory, without having to be stored in a database. The document is loaded directly into the viewer (the session). While it is loaded in the viewer, a lot of information and details about the document can be called up and settings can be made for the document and the viewer. A URL is generated to call up the document. After completion, the modified document can be downloaded again and deleted. In such an integration scenario, the system can be operated completely without a database.
The main API functions include in particular:
- Generate tokens, which are needed for communication and administration of sessions.
- Provision of PDF documents directly in a session or via a database.
- Generation of "sharing cases" for sending to external (unknown) users for a remote signature.
- Configuration of the viewer and the behavior of some functions.
- Generation of dynamic and static signature fields.
- Storage and assignment of certificates for signature and encryption.
- Retrieval of documents, information and configurations.
An example API sequence could look like this:
- POST/instancetoken => Generate a token to use further API methods.
- POST/viewer/document => Upload a (temporary) document to the viewer session.
- (Optional) PATCH/viewer/configuration => Configure the viewer.
- (Optional) POST/document/dynamicsignaturefields => Create dynamic signature fields based on keywords in the document.
- POST/viewer/accessurl => Generate an access URL to open the document in the viewer.
- [User edits the document]
- GET/viewer/document => Download the document from the viewer session.
- DELETE/viewer/document => Delete the document from the viewer session.
- DELETE/instancetoken => Revoke the token.
An integrator can use the plug-in to transfer user-related documents and configurations to the backend or receive them from the backend. The interface is particularly suitable if the customer application and signoSign/Universal directly or indirectly e.g. can be connected to each other via a common database. Documents and configurations can then be exchanged directly between the systems.
The implementation of the interface in Java is necessary for this type of integration. The own implementation then replaces the implementation contained, which accesses the supplied database and some of the static configuration parameters. This makes it completely or partially obsolete. The standard implementation can therefore be partially overwritten by your own code or completely replaced. This means that signoSign/Universal can also be adapted to very special requirements. With the disadvantage that development, testing and configuration effort arise during installation and updates.
The following functionalities can be adapted through your own implementation
- Custom or dynamic application configuration
- Use of your own document source or storage
- User-specific or dynamic document configuration
- Adjustments to the locking function of loaded documents
- Adjustments of the document sharing function to your own requirements
- Use your own source for certificates
- Definition of a signature time independent of the server time (e.g. via a time server)
- Evaluation and validation of URL parameters that were given when the viewer was called
The frontend offers various JavaScript functions that can be used to programmatically control the viewer when it is embedded in another web application via an iFrame. So, for example, the signing is started or the saving is triggered. In addition, the surrounding application can be informed about certain events and react to them. The special thing about an integration via an iFrame is that the surrounding application can be blocked and that it remains in control until the work in signoSign/Universal is finished.
JavaScript functions
Essentially, all the button functions of the viewer can also be called up from the surrounding application using JavaScript functions. These include in particular:
- Start the signature process
- Start the process of adding more signature fields
- Start the save process
- Logout (log off the session from the signoSign/Universal Server)
- Scroll to the previous, next or a specific page
- Call up the thumbnail menu
JavaScript events
If signoSign/Universal is embedded as an iFrame in another application, the surrounding application can be informed about certain events. Depending on the event, the behavior of signoSign/ Universal can be influenced by calling the "preventDefault" method of the object passed to the event within the defined event handler.
The main events include:
- Message event: Occurs when signoSign/Universal displays a message in a dialog.
- Signature-Performed: Occurs when a signature is made and sent to the server.
- Document-Saved: Occurs when the saving process has been performed.
- Update Form Fields: Occurs when changed form fields are synchronized with the backend.
- Pad-Opened / Pad-Closed: Occurs when the connection to the signature pad has been started or ended.
- Pad-State-Changed: Occurs as soon as the status of the opened pad changes.
