From 2f8704973fb5cbd74e2603efd21fe44186d70bb0 Mon Sep 17 00:00:00 2001 From: Strolch GitHub Actions Build Date: Mon, 12 Jul 2021 12:02:09 +0000 Subject: [PATCH] [AUTO] New version of website --- public/404.html | 2 +- public/api/index.html | 8 ++++---- public/categories/index.html | 6 +++--- public/development/index.html | 8 ++++---- public/documentation/architecture/index.html | 8 ++++---- public/documentation/components/index.html | 8 ++++---- public/documentation/do-and-donts/index.html | 6 +++--- public/documentation/index.html | 8 ++++---- public/documentation/model/index.html | 8 ++++---- public/documentation/observers/index.html | 8 ++++---- public/documentation/policies/index.html | 8 ++++---- public/documentation/priviles/index.html | 8 ++++---- public/documentation/queries/index.html | 8 ++++---- public/documentation/realms/index.html | 8 ++++---- public/documentation/reports/index.html | 8 ++++---- public/documentation/runtime-configuration/index.html | 8 ++++---- public/documentation/searches/index.html | 8 ++++---- public/documentation/services-and-commands/index.html | 8 ++++---- public/documentation/transactions/index.html | 8 ++++---- public/documentation/versioning/index.html | 8 ++++---- public/download/index.html | 8 ++++---- public/history/index.html | 8 ++++---- public/index.html | 6 +++--- public/plc/architecture/index.html | 8 ++++---- public/plc/example-set-up/index.html | 8 ++++---- public/plc/index.html | 8 ++++---- public/tags/index.html | 6 +++--- public/tutorial/configuration/index.html | 8 ++++---- public/tutorial/crud-book/index.html | 8 ++++---- public/tutorial/index.html | 8 ++++---- public/tutorial/model/index.html | 8 ++++---- 31 files changed, 117 insertions(+), 117 deletions(-) diff --git a/public/404.html b/public/404.html index c5a8fa0..b9e7073 100644 --- a/public/404.html +++ b/public/404.html @@ -1 +1 @@ -404 Page not found

Error

Woops. Looks like this page doesn't exist ¯\_(ツ)_/¯.

Go to homepage

Page not found!

\ No newline at end of file +404 Page not found

Error

Woops. Looks like this page doesn't exist ¯\_(ツ)_/¯.

Go to homepage

Page not found!

\ No newline at end of file diff --git a/public/api/index.html b/public/api/index.html index e1687b1..64b9fd6 100644 --- a/public/api/index.html +++ b/public/api/index.html @@ -1,7 +1,7 @@ -API - Strolch

API

Overview

The Strolch API revolves around the StrolchTransaction object. The main concept is to implement your use cases in Service implementations. You open a transaction using the openTx(String)-method and then perform the use case by adding your Command instances to the transaction.

Transactions are opened on a StrolchRealm. The realms are used to @@ -136,4 +136,4 @@ StrolchRealm realm = container= tx.getResourceBy("TestType", "MyTestResource"); ... } -

\ No newline at end of file +
\ No newline at end of file diff --git a/public/categories/index.html b/public/categories/index.html index a5e76c3..ba441e1 100644 --- a/public/categories/index.html +++ b/public/categories/index.html @@ -1,3 +1,3 @@ -Categories - Strolch

category :: -Categories

    \ No newline at end of file +Categories - Strolch

    category :: +Categories

      \ No newline at end of file diff --git a/public/development/index.html b/public/development/index.html index fffde20..874dc51 100644 --- a/public/development/index.html +++ b/public/development/index.html @@ -1,7 +1,7 @@ -Development - Strolch

      Development

      Prerequisites

      To start developing Strolch you need an installed:

      • Java JDK 11
      • Apache Maven 3.x

      Building Strolch

      Setting up Strolch is just a few lines:

      git clone https://github.com/4treesCH/strolch.git
 cd strolch
 mvn clean install -DskipTests

      Note: To run the tests you will need to configure the PostgreSQL Databases. See @@ -42,4 +42,4 @@ you should replace the placeholders in the brackets:

      Start the program using:

      mvn exec:java
-

      Happy coding =))

      Tools used

      The following tools are used to develop Strolch and Strolch-based projects:

      \ No newline at end of file +

      Happy coding =))

      Tools used

      The following tools are used to develop Strolch and Strolch-based projects:

      \ No newline at end of file diff --git a/public/documentation/architecture/index.html b/public/documentation/architecture/index.html index 23b2069..daf9ed6 100644 --- a/public/documentation/architecture/index.html +++ b/public/documentation/architecture/index.html @@ -1,6 +1,6 @@ -Architecture - Strolch

      Architecture

      Architecture

      Birds View

      A Strolch agent’s architecture can be seen as a simple three-tier architecture. +Architecture - Strolch

      Architecture

      Architecture

      Birds View

      A Strolch agent’s architecture can be seen as a simple three-tier architecture. The presentation layer is mostly a web frontend, where the communication with the agent is done via REST API calls.

      The agent itself implements the business logic using Services, Commands, Queries etc.

      The agent can communicate with other 3rd systems using any API, where it is @@ -16,4 +16,4 @@ thus behave differently, depending on the element being accessed.

    • Transa model and are the central API for the developer.
    • Privileges → Strolch is user agnostic and any action, i.e. Service, Query, etc. is authorized against the authenticated user.
    • Observers → modifications to the model are propagated to listeners using the observer pattern.
    • Audits → Every access (read, modify) of the model are audited
    • Versioning → modifications to objects are versioned and thus can be rolled -back at a later time.
      • \ No newline at end of file +back at a later time.
      \ No newline at end of file diff --git a/public/documentation/components/index.html b/public/documentation/components/index.html index 65cf9fa..9f6a36b 100644 --- a/public/documentation/components/index.html +++ b/public/documentation/components/index.html @@ -1,6 +1,6 @@ -Components - Strolch

      Components

      Components

      A Strolch agent can be easily extended with arbitrary components. An agent +Components - Strolch

      Components

      Components

      A Strolch agent can be easily extended with arbitrary components. An agent is basically a container for classes extending StrolchComponent with a life cycle. These classes mostly implement an interface which describes the operations that are supported by the component.

      The following represents a list of the most used components:

      • RealmHandler: li.strolch.agent.impl.DefaultRealmHandler
      • PrivilegeHandler: li.strolch.runtime.privilege.DefaultStrolchPrivilegeHandler
      • EnumHandler: li.strolch.runtime.query.enums.DefaultEnumHandler
      • PolicyHandler: li.strolch.policy.DefaultPolicyHandler
      • ServiceHandler: li.strolch.service.api.DefaultServiceHandler
      • StrolchSessionHandler: li.strolch.rest.DefaultStrolchSessionHandler
      • PersistenceHandler: multiple implementations
      • PostInitializer: project specific implementation
      • MailHandler: li.strolch.handler.mail.SmtpMailHandler

      A component has a life-cycle, which is governed by the Agent’s own life-cycle. @@ -60,4 +60,4 @@ element:

      Now when the agent is started, the component can be retrieved and used.
 E.g from inside a Service:
      MailHandler mailHandler = getComponent(MailHandler.class);
 mailHandler.sendMail("My Subject", "Hello World", "test@test.ch");
-
      
\ No newline at end of file
+
      
\ No newline at end of file
diff --git a/public/documentation/do-and-donts/index.html b/public/documentation/do-and-donts/index.html
index 2533d00..0e00892 100644
--- a/public/documentation/do-and-donts/index.html
+++ b/public/documentation/do-and-donts/index.html
@@ -1,3 +1,3 @@
-Do and Don't - Strolch
      Do and Don't
      This page discusses things you should and shouldn’t do when using Strolch
      The following is a simple list of do’s and don’ts:
      • 1 Service per use-case, should mostly delegate to Commands.
      • Commands implement use-cases or parts of it, and are thus reusable.
      • Subclass ResourceSearch, OrderSearch and ActivitySearch when implementing use-case specific search - this allows privilege checking.
      • One Transaction at a time - no TX inside of another TX.
      • Commands are added to TXs and performed on close: tx.addCommand(Command) and then tx.commitOnClose()
      • Use tx.flush() if you need to perform first some work and then as late as possible call tx.commitOnClose()
      • Only access ElementMaps if really no other way, mostly use tx.get*By(), tx.findBy() and searches - if a specific get is missing, then add the method to StrolchTransaction and send a pull request!
      • Use tx.stream*() methods to iterate over all elements, if you don’t want to use a search.
      • Don’t write logic in REST API beans. Delegate to other services, making your code reusable!
      • Transform to JSON using the StrolchElementToJsonVisitor.
      • References between objects is done by adding a ParameterBag with the id relations to the object and then StringParameters with the value being the ID, the UOM set to the type of element being referenced and the Interpretation set to the class type being referenced.
      
\ No newline at end of file
+Do and Don't - Strolch
      Do and Don't
      This page discusses things you should and shouldn’t do when using Strolch
      The following is a simple list of do’s and don’ts:
      • 1 Service per use-case, should mostly delegate to Commands.
      • Commands implement use-cases or parts of it, and are thus reusable.
      • Subclass ResourceSearch, OrderSearch and ActivitySearch when implementing use-case specific search - this allows privilege checking.
      • One Transaction at a time - no TX inside of another TX.
      • Commands are added to TXs and performed on close: tx.addCommand(Command) and then tx.commitOnClose()
      • Use tx.flush() if you need to perform first some work and then as late as possible call tx.commitOnClose()
      • Only access ElementMaps if really no other way, mostly use tx.get*By(), tx.findBy() and searches - if a specific get is missing, then add the method to StrolchTransaction and send a pull request!
      • Use tx.stream*() methods to iterate over all elements, if you don’t want to use a search.
      • Don’t write logic in REST API beans. Delegate to other services, making your code reusable!
      • Transform to JSON using the StrolchElementToJsonVisitor.
      • References between objects is done by adding a ParameterBag with the id relations to the object and then StringParameters with the value being the ID, the UOM set to the type of element being referenced and the Interpretation set to the class type being referenced.
      
\ No newline at end of file
diff --git a/public/documentation/index.html b/public/documentation/index.html
index d14333e..90265f6 100644
--- a/public/documentation/index.html
+++ b/public/documentation/index.html
@@ -1,6 +1,6 @@
-Documentation - Strolch
      Documentation
      Overview
      Strolch’s documentation has only just begun, but as more and more details of
 the implementation in Strolch are fixed, more documentation can be created and
-will be available here.
      Currently we have the following topics of discussion:
      
\ No newline at end of file
+will be available here.
      Currently we have the following topics of discussion:
      
\ No newline at end of file
diff --git a/public/documentation/model/index.html b/public/documentation/model/index.html
index d04c149..e314d28 100644
--- a/public/documentation/model/index.html
+++ b/public/documentation/model/index.html
@@ -1,6 +1,6 @@
-Model - Strolch
      Model
      Model
      Before we dive into the entire model, let’s show an example and how it would
+Model - Strolch
      Model
      Model
      Before we dive into the entire model, let’s show an example and how it would
 be modelled in Strolch and use in Strolch:
      Strolch model example
      A possible model would look as follows:
      <?xml version="1.0" encoding="UTF-8" ?>
 <StrolchModel xmlns="https://strolch.li/xsd/StrolchModel-1.6.xsd">
 
@@ -261,4 +261,4 @@ listing will perform simple operations:
      </Activity>
 
 </StrolchModel>
-
      
\ No newline at end of file
+
      
\ No newline at end of file
diff --git a/public/documentation/observers/index.html b/public/documentation/observers/index.html
index cfffcfe..27838f6 100644
--- a/public/documentation/observers/index.html
+++ b/public/documentation/observers/index.html
@@ -1,6 +1,6 @@
-Observers - Strolch
      Observers
      Observers
      All changes done in a Strolch transaction are recorded and then propagated to
+Observers - Strolch
      Observers
      Observers
      All changes done in a Strolch transaction are recorded and then propagated to
 any registered observers.
      The observer feature is opt-in and is configured for each realm. In the
 StrolchConfiguration.xml file enable observers by adding the
 enableObserverUpdates property per realm:
      <StrolchConfiguration>
@@ -43,4 +43,4 @@ observerHandler.regis
     logger.info(elements.size() + " resources were added!");
   }
 });
-
      
\ No newline at end of file
+
      
\ No newline at end of file
diff --git a/public/documentation/policies/index.html b/public/documentation/policies/index.html
index 91d5b42..eba9895 100644
--- a/public/documentation/policies/index.html
+++ b/public/documentation/policies/index.html
@@ -1,6 +1,6 @@
-Policies - Strolch
      Policies
      Policies
      Policies are an integral part when writing business logic in Strolch. In many
+Policies - Strolch
      Policies
      Policies
      Policies are an integral part when writing business logic in Strolch. In many
 cases it would suffice to write all such logic in Services and Commands, but
 as soon as behaviour can change, depending on the element being accessed, then
 this would quickly lead to many if/else blocks.
      Since writing large if/else blocks is not maintanable in the long run, Strolch
@@ -65,4 +65,4 @@ policies is defined, e.g.:
      =policyHandler.getPolicy(executionPolicyDef,tx);
     executionPolicy.execute(...);
 }
-
      
\ No newline at end of file
+
      
\ No newline at end of file
diff --git a/public/documentation/priviles/index.html b/public/documentation/priviles/index.html
index af63623..69af169 100644
--- a/public/documentation/priviles/index.html
+++ b/public/documentation/priviles/index.html
@@ -1,6 +1,6 @@
-Privileges - Strolch
      Privileges
      Privileges
      No framework is complete without user management and privilege validation. The
+Privileges - Strolch
      Privileges
      Privileges
      No framework is complete without user management and privilege validation. The
 basic form would be Users and Roles, and then validating that an authenticated
 user has a given role. In Strolch we go a step further: A User has roles
 assigned, and each role has a set of Privileges. The privileges can overlap, a
@@ -70,4 +70,4 @@ used when modifying an authenticated user, i.e. killing a session, or
 modifying its current state, e.g. locale etc.
    • Internal: UsernameFromCertificateWithSameOrganisationPrivilege → Same as
 UsernameFromCertificatePrivilege but expects the authenticated user to have a
 property organisation and validates that the user being modified is in the
-same organisation.
      • Note: As a rule, the sequence is AllAllowed → Allow → Deny → default deny
      
\ No newline at end of file
+same organisation.
      Note: As a rule, the sequence is AllAllowed → Allow → Deny → default deny
      
\ No newline at end of file
diff --git a/public/documentation/queries/index.html b/public/documentation/queries/index.html
index 09bc5a8..79ff8b3 100644
--- a/public/documentation/queries/index.html
+++ b/public/documentation/queries/index.html
@@ -1,6 +1,6 @@
-Queries - Strolch
      Queries
      Queries
      The Query API is deprecated and the search API should be used instead.
      As is custom for every framework, querying the model must be possible. Strolch
+Queries - Strolch
      Queries
      Queries
      The Query API is deprecated and the search API should be used instead.
      As is custom for every framework, querying the model must be possible. Strolch
 queries are implemented using the StrolchQuery interface and one of its concrete
 implementations: ResourceQuery, OrderQuery, ActivityQuery.
      A Strolch element always has two identifiers: Type and Id. The type is important
 as it classifies an element. So if a car and a house would be modelled in
@@ -58,4 +58,4 @@ classes provide the most used scenarios:
      • OrderById
      • OrderByNam
 
   List<Resource> cars = tx.doQuery(query);
 }
-
      
\ No newline at end of file
+
      
\ No newline at end of file
diff --git a/public/documentation/realms/index.html b/public/documentation/realms/index.html
index c85c79b..31a7497 100644
--- a/public/documentation/realms/index.html
+++ b/public/documentation/realms/index.html
@@ -1,6 +1,6 @@
-Realms - Strolch
      Realms
      Realms
      Realms implement multi-tenant capabilities. A Strolch agent can have an
+Realms - Strolch
      Realms
      Realms
      Realms implement multi-tenant capabilities. A Strolch agent can have an
 arbitrary number of realms configured and each realm has its own persistence
 configuration, allowing to separate mandates completely.
      A realm can run in one of the following modes:
      • EMPTY
 This is a transient data store mode, where no model changes are
@@ -79,4 +79,4 @@ StrolchRealm realm = container= tx.getResourceBy("TestType", "MyTestResource");
   ...
 }
-
      
\ No newline at end of file
+
      
\ No newline at end of file
diff --git a/public/documentation/reports/index.html b/public/documentation/reports/index.html
index 90a042e..dccb3f3 100644
--- a/public/documentation/reports/index.html
+++ b/public/documentation/reports/index.html
@@ -1,6 +1,6 @@
-Reports - Strolch
      Reports
      Reports
      Since Strolch has a generic model, it was rather straight forward to create a
+Reports - Strolch
      Reports
      Reports
      Since Strolch has a generic model, it was rather straight forward to create a
 simple API for writing reports. In Strolch a report is defined by using its own
 model, i.e. a Report is a Resource of type Report.
      A report consists of the following parts:
      • policy definition, thus allowing extensions
      • basic configuration like base object type, order direction, etc.
      • column definitions
      • joins
      • ordering definition
      • filters
      An example of a report is as follows:
      
 <Resource Id="stockReport" Name="Stock Report" Type="Report">
@@ -156,4 +156,4 @@ List<JsonObject>
     .filter("Product", "product01") //
     .dateRange(dateRange) //
     .doReportAsJson()
-
      Note: See the GenericReportTest for examples.
      
\ No newline at end of file
+
      Note: See the GenericReportTest for examples.
      
\ No newline at end of file
diff --git a/public/documentation/runtime-configuration/index.html b/public/documentation/runtime-configuration/index.html
index 917b068..50c6fbf 100644
--- a/public/documentation/runtime-configuration/index.html
+++ b/public/documentation/runtime-configuration/index.html
@@ -1,6 +1,6 @@
-Runtime Configuration - Strolch
      Runtime Configuration
      Runtime Configuration
      A Strolch runtime configuration comprises two parts: a configuration part, and
+Runtime Configuration - Strolch
      Runtime Configuration
      Runtime Configuration
      A Strolch runtime configuration comprises two parts: a configuration part, and
 a model part. The configuration are files located in the ..config/ folder,
 and the model are files located in the ../data folder.
      In an absolute minimal configuration, the Strolch runtime requires the
 following folder structure:
      • ../config/
        • ../StrolchConfiguration.xml → configures the Strolch agent
        • ../PrivilegeConfig.xml → configures user management
        • ../PrivilegeUsers.xml → contains the users in an XML based user management file
        • ../PrivilegeRoles.xml → contains the roles and privileges in an XML based user management
      StrolchConfiguration.xml
      The StrolchConfiguration.xml file configures the Strolch agent. The StrolchConfiguration.xml defines the following:
      • <StrolchConfiguration> root element
      • <env id="xxx"> different environments with the possibility of having a
@@ -108,4 +108,4 @@ String environment = StrolchEnvironmentthis.agent.setup(environment, new File(realPath));
 this.agent.initialize();
 this.agent.start();
-
      
\ No newline at end of file
+
      
\ No newline at end of file
diff --git a/public/documentation/searches/index.html b/public/documentation/searches/index.html
index 0365047..25b9fbd 100644
--- a/public/documentation/searches/index.html
+++ b/public/documentation/searches/index.html
@@ -1,6 +1,6 @@
-Searches - Strolch
      Searches
      Searches
      As is custom for every framework, querying, or searching, the model must be
+Searches - Strolch
      Searches
      Searches
      As is custom for every framework, querying, or searching, the model must be
 possible. Strolch searches are implemented using the StrolchSearch class and
 one of its concrete implementations: ResourceSearch, OrderSearch,
 ActivitySearch.
      A Strolch element always has two identifiers: Type and Id. The type is
@@ -50,4 +50,4 @@ use a strolch search, add it to the role of the user in PrivilegeRoles.xml
     </Allow> <!-- internal used for when the search is done in an internal service -->
     <Allow>li.strolch.bookshop.search.BookSearch</Allow>
 </Privilege>
-
      
\ No newline at end of file
+
      
\ No newline at end of file
diff --git a/public/documentation/services-and-commands/index.html b/public/documentation/services-and-commands/index.html
index 8f612b4..2734530 100644
--- a/public/documentation/services-and-commands/index.html
+++ b/public/documentation/services-and-commands/index.html
@@ -1,6 +1,6 @@
-Services and Commands - Strolch
      Services and Commands
      Services and Commands
      Services are written to implement a specific use-case. Commands are written to
+Services and Commands - Strolch
      Services and Commands
      Services and Commands
      Services are written to implement a specific use-case. Commands are written to
 implement re-usable parts of a use-case. The use-case can be abstract
 e.g., AddResourceService or very specific e.g. CreatePatientService.
      Should the use-case be re-usable in different scenarios, then commands should
 implement the logic, and the services should then execute the commands. E.g.
@@ -75,4 +75,4 @@ perform the task of adding a new Order. Note how:
      • the Service opens t
     }
   }
 }
-
      
\ No newline at end of file
+
      
\ No newline at end of file
diff --git a/public/documentation/transactions/index.html b/public/documentation/transactions/index.html
index a890980..b3c2749 100644
--- a/public/documentation/transactions/index.html
+++ b/public/documentation/transactions/index.html
@@ -1,6 +1,6 @@
-Transactions - Strolch
      Transactions
      Transactions
      Strolch Transactions play a central role in a Strolch agent. A transaction is
+Transactions - Strolch
      Transactions
      Transactions
      Strolch Transactions play a central role in a Strolch agent. A transaction is
 opened for a realm, and grants access to the model of the agent. Transactions
 are implemented as a Java try-with-resources by implementing
 the AutoCloseable
@@ -56,4 +56,4 @@ define if the TX should commit, or not:
        if (tx.needsCommit())
     tx.commitOnClose();
 }
-
      
\ No newline at end of file
+
      
\ No newline at end of file
diff --git a/public/documentation/versioning/index.html b/public/documentation/versioning/index.html
index 3602fc6..5996d25 100644
--- a/public/documentation/versioning/index.html
+++ b/public/documentation/versioning/index.html
@@ -1,6 +1,6 @@
-Versioning - Strolch
      Versioning
      Versioning
      One of Strolch’s features that sets it apart from other frameworks, is that
+Versioning - Strolch
      Versioning
      Versioning
      One of Strolch’s features that sets it apart from other frameworks, is that
 versioning is baked into Strolch’s fabric. The feature is opt-in, as it is not
 required in all projects, but it only needs enabling, for all modifications to
 objects to be versioned, so that rollbacks can be done when needed.
      The feature is enabled for each realm. In the StrolchConfiguration.xml file
@@ -36,4 +36,4 @@ any references on an element to other elements will also be restored. As long as
 the relationship is to the same element, then this is not an issue, but should
 the relationship have changed, then it this must be handled and the user
 performing a revert be allowed to decided which element to reference in the
-reverted version.
      
\ No newline at end of file
+reverted version.
      
\ No newline at end of file
diff --git a/public/download/index.html b/public/download/index.html
index 0e85800..9acb52f 100644
--- a/public/download/index.html
+++ b/public/download/index.html
@@ -1,8 +1,8 @@
-Download - Strolch
      Download
      Download
      Strolch is
 on Maven central
 , but if the latest version is not there, then build it locally. A guide can be
 found on the development page.
      Strolch is also built on Jenkins, so you can see if the
-latest version passes all tests.
      
\ No newline at end of file
+latest version passes all tests.
      
\ No newline at end of file
diff --git a/public/history/index.html b/public/history/index.html
index 40e3031..25298cb 100644
--- a/public/history/index.html
+++ b/public/history/index.html
@@ -1,5 +1,5 @@
-History - Strolch
      History
      Overview
      Strolch is an open source component based software agent written in Java and can be compared, in a light sense, with the Java EE stack: Strolch takes care of persistence, implements Services for use cases, Commands as re-usable algorithms and has a parameterized data model.
      Strolch has an intrinsic understanding for mandates, which are called realms so that a single agent can be used to implement applications with multiple users/customers for instance in SaaS environments.
      The parameterized data model consists of three top level objects, Resources, Orders and Activities. These objects can have any number of ParameterBags which in turn can have any number of Parameters on them. This allows for a very dynamic modelling of data structures including modification at run time. Multiple ready to use Parameter types are already implemented which handle the primitive types in Java including ListParameters for collections of these primitive types.
      One of the main features of the Strolch agent, is that persistence is handled transparently and the user must not be worried about databases and the likes. Currently there are two implementations for persisting the Strolch model, a PostgreSQL and an XML file persistence. Currently both persistence layers persist the data by converting to XML and storing it into the database. The XML file persistence stores each object in its own file.
      The agent itself has a small memory footprint and requires very few components to start. For the agent to be useful it needs additional functionality which is implemented in StrolchComponents. Each component is registered via its Java interface on the agent and is bound to the life cycle of the agent. When the agent is started, these components can be retrieved and used to perform any number of functionalities. This is the preferred way to extend the Strolch agent. There are a number of components already implemented, e.g. the ServiceHandler which executes Services in a controlled fashion and can validate authorized access to these services.
      No software product is complete without a system for authentication and authorization. Strolch implements this by using the Privilege framework which has been written by Robert von Burg. The standard ServiceHandler detects the existence of the PrivilegeHandler and then validates that the user has authorization to perform the service. This framework is implemented as its own Strolch component, thus can be retrieved at any time during execution to perform fine grained and special authorization validation.
      Motivation
      A question often asked is why create Strolch. What are its benefits in contrast to using Java SE with an OR-Mapper like Hibernate, or using Java EE on JBoss or Glassfish? Especially since many of the features existing in those stacks needed to be re-created in Strolch.
      The first answer to this question is that those systems are often overly complicated and bloated. Java SE with Hibernate certainly is a viable option when it comes to being light-weightier but Hibernate, even though it is supposed to, often fails to truly help remove the need to really understand an RDBMS. Often enough Hibernate will just get in the way of the most important part of development: writing the business code. Being an OR-Mapper which is supposed to implement all the nitty-gritty details of an RDBMS system, Hibernate, and JPA for that matter, still often has the developer go back to understanding these details.
      Strolch tries a different approach to persistence. Instead of writing pojos/entities, Strolch’s model has the concept that each element’s attributes are part of a composition pattern: each attribute is its own object and thus can be dynamically changed at runtime, but also makes persistence of such an element generic. Instead of having fixed attributes for a concrete class, these parameters are stored in a map and are accessed through the parameter’s ID.
      Assigning an ID to an attribute for accessing of course brings its own downsides, i.e. the parameter might simply not be there, when being accessed. This is certainly an issue that the developer must handle, when implementing a project using Strolch, but allows the developer to not need to worry about persistence, as this is generically handled.
      Since the persistence is generically handled, and Strolch stays lightweight on its requirements at runtime, the developer can quickly get down to what is important for business value: Writing the business logic and the presentation layer. Here too Strolch tries to help the developer by bringing in concepts which are easy to follow: Use cases are implemented as Services, and re-usable business logic is put into Commands.
      There will be reasons against using Strolch, as there will be against using the Java EE stack, or an OR-Mapper or even the Java ecosystem for that fact. Important is to note, that the concepts behind Strolch are nothing new, but have been implemented in at least two previous proprietary products. Since those products are not accessible to the public, it was decided that a re-implementation might be of use to the programming community at large.
      Currently, there is at least one company using Strolch in a commercial project which helps drive Strolch’s development and further motivates its existence.
      Strolch is an open source project and licensed under the Apache License 2.0.
      ##Technology
+Strolch is written in Java and is programmed against the JDK 8. Strolch runs on any JRE 8 compliant environment. Strolch is tested on the Oracle JRE 8.
      
\ No newline at end of file
diff --git a/public/index.html b/public/index.html
index c870003..e236e3f 100644
--- a/public/index.html
+++ b/public/index.html
@@ -1,5 +1,5 @@
-Strolch Overview - Strolch
      navigation
      Strolch Overview
      Strolch is framework for developing Software. It’s main features are:
      • Complete persisted data model:
        • Parameters and values by time
        • Resources, Orders with arbitrary parameter grouping
        • Activity/Action hierarchy with arbitrary depth
        • Policies for delegation
        • JSON as well as XML transformation
        • Locator API
      • Transactions with pessimistic locking and optional read-locking
      • Search API
      • Component based
      • Deeply integrated privilege handling
      • Fully in-memory
      • Persisted auditing, versioning, operations log
      • DAOs for file system or PostgreSQL, easily extended
      • Execution framework
      • Service / Command oriented
      • Reporting API configured by Resource objects
      • REST API for data access
      • WebComponents UI for
        • Inspector
        • Users
        • Roles
        • Operations Log
        • Login Screen
        • Jobs
      • runs on plain old Java SE
      Strolch Intro
      It is a different framework to Spring and other similar type of Java
+Strolch Overview - Strolch
      navigation
      Strolch Overview
      Strolch is framework for developing Software. It’s main features are:
      • Complete persisted data model:
        • Parameters and values by time
        • Resources, Orders with arbitrary parameter grouping
        • Activity/Action hierarchy with arbitrary depth
        • Policies for delegation
        • JSON as well as XML transformation
        • Locator API
      • Transactions with pessimistic locking and optional read-locking
      • Search API
      • Component based
      • Deeply integrated privilege handling
      • Fully in-memory
      • Persisted auditing, versioning, operations log
      • DAOs for file system or PostgreSQL, easily extended
      • Execution framework
      • Service / Command oriented
      • Reporting API configured by Resource objects
      • REST API for data access
      • WebComponents UI for
        • Inspector
        • Users
        • Roles
        • Operations Log
        • Login Screen
        • Jobs
      • runs on plain old Java SE
      Strolch Intro
      It is a different framework to Spring and other similar type of Java
 frameworks, as the model is defined as an abstract model, where you
 always have the same three types of objects: Resources, Orders and
 Activities. The fields are mapped as Parameter objects, of which the
@@ -25,4 +25,4 @@ reasons to improve and extend the framework. There is a Polymer
 Inspector component which makes it easy to see and manipulate the
 actual data. The new Search API makes it really easy to query your data.
      Yes, Strolch is different, but the concept has come out of the planning
 and execution segment, and has been refined over the years until it has
-become what it is today.
      API
      Check out the API page to see how to use Strolch.
      More to motivation etc.
      
\ No newline at end of file
+become what it is today.
      API
      Check out the API page to see how to use Strolch.
      More to motivation etc.
      
\ No newline at end of file
diff --git a/public/plc/architecture/index.html b/public/plc/architecture/index.html
index 0e637db..10f2e52 100644
--- a/public/plc/architecture/index.html
+++ b/public/plc/architecture/index.html
@@ -1,6 +1,6 @@
-Architecture - Strolch
      Architecture
      Architecture
      Overview
      Strolch PLC Architecture Overview
      The Strolch PLC architecture sees the Strolch Agent as the server, managing
+Architecture - Strolch
      Architecture
      Architecture
      Overview
      Strolch PLC Architecture Overview
      The Strolch PLC architecture sees the Strolch Agent as the server, managing
 logical devices, i.e. multiple sensors and actors together and thus deciding on
 further steps. With this architecture multiple PLCs can be combined together in
 one agent for flow control.
      PLC Architecture
      Strolch PLC Architecture
      On the agent side the two main classes are the PlcGwServerHandler and the
@@ -12,4 +12,4 @@ can be directly extended.
      On the PLC side, the PlcGwClientHandlerPlcHandler initializes the model and connections. The Plc class is Strolch
 agnostic and manages the connections and notifies PlcListener instances on
 changes coming from the underlying connections. The PlcService implementations
-implement business logic, and can also be notified on updates from connections.
      
\ No newline at end of file
+implement business logic, and can also be notified on updates from connections.
      
\ No newline at end of file
diff --git a/public/plc/example-set-up/index.html b/public/plc/example-set-up/index.html
index a654583..4d94afd 100644
--- a/public/plc/example-set-up/index.html
+++ b/public/plc/example-set-up/index.html
@@ -1,6 +1,6 @@
-Example Set-Up - Strolch
      Example Set-Up
      Example Set-Up
      This example setup describes the movement of containers over conveyors. The
+Example Set-Up - Strolch
      Example Set-Up
      Example Set-Up
      This example setup describes the movement of containers over conveyors. The
 conveyors have motors which can be started and stopped by a GPIO output pin
 controlled on a Raspberry Pi and each conveyor has a light barrier to detect the
 occupancy of a container and the Raspberry Pi detects this on GPIO input pins.
      Further at each conveyor location is a barcode reader to read the ID of a
@@ -421,4 +421,4 @@ a PlcConnection:
      </ParameterBag>
     </Resource>
 </StrolchModel>
-
      See strolch-plc-example-connections.xml for further examples.
      
\ No newline at end of file
+
      See strolch-plc-example-connections.xml for further examples.
      
\ No newline at end of file
diff --git a/public/plc/index.html b/public/plc/index.html
index bd07997..de6eb0e 100644
--- a/public/plc/index.html
+++ b/public/plc/index.html
@@ -1,8 +1,8 @@
-PLC - Strolch
      PLC
      Overview
      Using Strolch as a PLC has certain advantages and disadvantages. The following
 is a list of advantages:
      • Same programming model and language for server and PLC
      • PLC has the same privilege handling as in Strolch
      • Simulating down to the PLC level is easily possible for easier testing of
 server logic
      Of course using the Java language as a PLC has its limitations, we have manage
 to use it for customers and are satisfied with the result. What follows is a
-description in how to set up your own Strolch based PLC.
      Checkout the code at GitHub
      Currently, we have the following topics of discussion:
      
\ No newline at end of file
+description in how to set up your own Strolch based PLC.
      Checkout the code at GitHub
      Currently, we have the following topics of discussion:
      
\ No newline at end of file
diff --git a/public/tags/index.html b/public/tags/index.html
index f52ee22..bf6369f 100644
--- a/public/tags/index.html
+++ b/public/tags/index.html
@@ -1,3 +1,3 @@
-Tags - Strolch
      tag ::
-Tags
        
\ No newline at end of file
+Tags - Strolch
        tag ::
+Tags
          
\ No newline at end of file
diff --git a/public/tutorial/configuration/index.html b/public/tutorial/configuration/index.html
index 248544a..031902f 100644
--- a/public/tutorial/configuration/index.html
+++ b/public/tutorial/configuration/index.html
@@ -1,6 +1,6 @@
-Configuration - Strolch
          Configuration
          Configuration
          Let’s start by creating a new Apache Maven project. We’ll need a POM with the
+Configuration - Strolch
          Configuration
          Configuration
          Let’s start by creating a new Apache Maven project. We’ll need a POM with the
 proper dependencies. We expect you to be familiar with Apache Maven, so we’ll
 just show you a working POM file:
          pom.xml
          <?xml version="1.0"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
@@ -716,4 +716,4 @@ you should see the following in the logs:
          This log tells us the name of the app as defined in the StrolchConfiguration.xml
 file as well as which environment was loaded. Further we can see that 8
 components were configured and started.
          This concludes the initial setup of a new Strolch project. We can now go ahead
-and start building the business logic.
          
\ No newline at end of file
+and start building the business logic.
          
\ No newline at end of file
diff --git a/public/tutorial/crud-book/index.html b/public/tutorial/crud-book/index.html
index 385ad61..de8f275 100644
--- a/public/tutorial/crud-book/index.html
+++ b/public/tutorial/crud-book/index.html
@@ -1,6 +1,6 @@
-CRUD Book - Strolch
          CRUD Book
          Preparation
          Since Books are central to the bookshop, we’ll first create the CRUD REST API
+CRUD Book - Strolch
          CRUD Book
          Preparation
          Since Books are central to the bookshop, we’ll first create the CRUD REST API
 for them. The API will be as follows:
          GET ../rest/books?query=,offset=,limit=
 GET ../rest/books/{id}
 POST ../rest/books
@@ -412,4 +412,4 @@ privilege to perform the action.
          The book services are quite simple,
 easy to implement them in the service layer. Thus should a service be required
 to be performed by an integration layer, then they can simply call the services,
 since the input is defined and validation is done there (i.e. NOT in the REST
-API).
          This concludes the CRUD of books.
          
\ No newline at end of file
+API).
          This concludes the CRUD of books.
          
\ No newline at end of file
diff --git a/public/tutorial/index.html b/public/tutorial/index.html
index c88408b..ac2e243 100644
--- a/public/tutorial/index.html
+++ b/public/tutorial/index.html
@@ -1,8 +1,8 @@
-Tutorial - Strolch
          Tutorial
          Let’s build a bookshop!
          In this tutorial we will build a book store using Strolch. This book store will
 be without a UI, but we will do everything using REST APIs, which should make it
 easy to add a UI later using whatever framework suits one most.
          The book store will have the following features:
          • The store owner can add, update and remove books
          • The store owner can edit the stock quantity
          • Users can view a list of books
          • Users can add books to a virtual cart
          • Users can create and verify an account using an e-mail address
          • Users can submit an order for the books in their cart
          • The store owner can see the orders by state (pending, preparing, sent)
          • The store owner can update the state of an order (preparing, sent)
          • Notify the user when the order is sent
          The code to the book can be downloaded
 from GitHub and will be updated
-as this tutorial is updated.
          The tutorial consists of the following parts:
          
\ No newline at end of file
+as this tutorial is updated.
          The tutorial consists of the following parts:
          
\ No newline at end of file
diff --git a/public/tutorial/model/index.html b/public/tutorial/model/index.html
index 4884300..6b3c635 100644
--- a/public/tutorial/model/index.html
+++ b/public/tutorial/model/index.html
@@ -1,6 +1,6 @@
-Model - Strolch
          Model
          Model
          Looking back at our functionality, we can list the following entities that need
+Model - Strolch
          Model
          Model
          Looking back at our functionality, we can list the following entities that need
 to be modelled (We’ll go into detail further down):
          • Book → books can be orderd
          • UserCart → we want to store the cart of the user
          • Account → we need to know where to send the orders
          • PurchaseOrder → we need to know what was ordered and keep track of its state
          • FromStock → we want to use activities to implement the process of an order
          In Strolch we model entities by defining the element as a template. Thus in the
 templates.xml file we can add the templates with the following content:
          Book
          
 <Resource Id="Book" Name="Book Template" Type="Template">
@@ -117,4 +117,4 @@ referencing an ExecutionPolicy implementation.
        • ConfirmationPolicy<
 of an action being performed on this resource by referencing an
 ConfirmationPolicy implementation.
          • Currently these resources reference policies which don’t exist. We will resolve
 this issue later, when we implement the execution of the activity.
          This concludes the model definition. In the next step we’ll start creating
-services and commands for our model.
          
\ No newline at end of file
+services and commands for our model.
          
\ No newline at end of file