Update submodule references (#46)

Author: wborn

docs/developer-guide/creating-a-custom-project.md

@@ -5,12 +5,14 @@ sidebar_position: 8
 # Creating a custom project
 
 ## Quickstart
+
 We have a repo which can be used as a template for a custom project; simply clone the [custom-project](https://github.com/openremote/custom-project) repo and start adding your custom code; see the [Endpoints and file paths](../architecture/manager-endpoints-and-file-paths.md) documentation to understand how to override the various parts of the system.
 
 ## What is a custom project
+
 A custom project is a way of extending OpenRemote to provide custom functionality without modifying the main OpenRemote code, thus the custom code can be separately version controlled possibly in a private repo. Possible use cases:
 
-* Custom protocols (to interface with some service/device in a customised way)
+* Custom protocols (to interface with some service/device in a customized way)
 * Custom setup code (to automatically provision realms, users, assets, rules, etc. during a clean install)
 * Custom asset types
 * Custom Docker Compose profiles
@@ -27,50 +29,53 @@ The guide consists of the following sections and you will need to have a working
 
 It is recommended to put custom project code in directory/module called `deployment` this can then be built as a Docker image and used as a Docker volume to map into our `manager` and `keycloak` containers to override/enhance their behaviour; if there is a large amount of code then multiple directories/modules might be desired to logically separate the code, in this case it is advised to follow the same naming convention as the main OpenRemote repo and to ensure the `gradle` build `installDist` task is configured in order to copy the compiled code into the `deployment` `build` directory in preparation for building the `deployment` Docker image.
 
-
-
 ## OpenRemote Dependencies
-Depending on what parts of the OpenRemote system are being customised will determine the code dependencies on the main OpenRemote code base; as the main OpenRemote code base is a monolith repo it is possible to add a `git submodule` to the main OpenRemote repo and directly reference the `gradle` projects within, this gives a very tight development process which is particularly useful if making code changes within the OpenRemote code base at the same time, to do this use the standard `git submodule` command (refer to Git documentation for working with submodules):
-```shell
-git submodule add -b master https://github.com/openremote/openremote.git openremote/
-```
 
-An alternative is to reference release artefacts of our various modules:
+Depending on what parts of the OpenRemote system are being customized will determine the code dependencies on the main OpenRemote code base.
+
+A custom project always depends on the following released OpenRemote artefacts:
 
-* java modules - see maven repo (TODO)
-* UI components - see [npm](https://www.npmjs.com/~openremotedeveloper)
+* Docker images - see [Docker Hub](https://hub.docker.com/u/openremote)
+* Java modules - see [Maven Central](https://search.maven.org/search?q=g:io.openremote)
+* UI components - see [npmjs](https://www.npmjs.com/~openremotedeveloper)
 
+The [Release Management](../user-guide/deploying/release-management) documentation describes how to update the OpenRemote version of these artefacts.
 
 ## Custom Project Template
-The [custom-project](https://github.com/openremote/custom-project) repo acts as a template for a custom project that references the OpenRemote dependencies using a `submodule`; you can clone this repo as a starting point for a new custom project, the layout of this repo is as follows:
+
+The [custom-project](https://github.com/openremote/custom-project) repo acts as a template for a custom project that uses the OpenRemote dependencies; you can clone this repo as a starting point for a new custom project, the layout of this repo is as follows:
 
 * `/deployment` - Directory/module for custom code/files
 * `/gradle` - Gradle files
-* `/openremote` - OpenRemote repo submodule
 * `.gitignore` - Typical `.gitignore` file to exclude common build related files/directories (also excluded `*.mbtiles` as these can be very large binary files not suitable for a git repo)
 * `gradlew`/`gradlew.bat` - Gradle wrapper execution script
 * `build.gradle` - Gradle root project build config
 * `gradle.properties` - Gradle properties file
-* `settings.gradle` - Gradle multi project config (loads OpenRemote submodule projects)
+* `settings.gradle` - Gradle multi project config
 * `LICENSE.txt` - Copy of `LICENSE.txt` from main OpenRemote repo
 
 ### Deployment directory/module
-This module is used to generate a `deployment` Docker image which can be volume mapped into the manager and/or Keycloak containers to customise their behaviour. The `installDist` gradle task of this module will generate output in the `/deployment/build` directory in particular:
+
+This module is used to generate a `deployment` Docker image which can be volume mapped into the manager and/or Keycloak containers to customize their behaviour. The `installDist` Gradle task of this module will generate output in the `/deployment/build` directory in particular:
 
 * `/deployment/build/image` - Content to be added to the deployment Docker image at `/deployment`
 * `/deployment/build/Dockerfile` - Docker build file used to build `deployment` Docker image (copied from `/deployment` during `installDist`) 
 
 ### Adding new modules
-Create directory with appropriate name and copy `/deployment/build.gradle` into it, customise this new `build.gradle` as required and start adding your code/files, ensuring that the `installDist` gradle task copies any output into the appropriate location within the deployment Docker image build directory (see the [Manager endpoints and file paths](../architecture/manager-endpoints-and-file-paths.md)).
+
+Create directory with appropriate name and copy `/deployment/build.gradle` into it, customize this new `build.gradle` as required and start adding your code/files, ensuring that the `installDist` Gradle task copies any output into the appropriate location within the deployment Docker image build directory (see the [Manager endpoints and file paths](../architecture/manager-endpoints-and-file-paths.md)).
 
 ### Adding UI apps/components
-It is recommended to use the same directory layout as found in the `openremote` submodule, and put all UI code in a directory called `ui`; as our UI code uses `yarn workspaces` you will need to copy the `/openremote/package.json` into the root of the custom project and then modify the workspace paths within this new file (adding `openremote/` in front of existing paths and also adding new paths for any components or apps created in the custom project).
+
+It is recommended to use the same directory layout as found in the `openremote` repository, and add additional UI code in the `ui` directory.
+Our UI code uses `yarn workspaces` so you can add any additional workspace paths to the `package.json` file in the root directory of the custom project.
 
 ### Custom Keycloak themes
-It's possible to provide custom Keycloak themes see [custom-project](https://github.com/openremote/custom-project/blob/main/deployment/keycloak/themes/README.md) for details.
 
+It's possible to provide custom Keycloak themes see [custom-project](https://github.com/openremote/custom-project/blob/main/deployment/keycloak/themes/README.md) for details.
 
 ## Setup code
+
 Custom setup code allows for programmatic configuration of a clean installation including the provisioning of `Agents`, `Assets`, `users`, `rules`, etc. This means that the system loads in a pre-configured state that can easily be reproduced after a clean install. Setup code is executed via the `SetupService` and is only executed if the `OR_SETUP_RUN_ON_RESTART` environment variable is set to `true` or if the database that the instance uses is empty.
 
 To write custom setup code then you need to create implementations of `SetupTasks` these are then discovered using the standard java `ServiceLoader` mechanism and must therefore be registered via `META-INF/services` mechanism, generally implementations should extend the `EmptySetupTasks` which will do basic configuration of `keycloak` which is essential, see [custom-project](https://github.com/openremote/custom-project/blob/main/setup/src/main/java/org/openremote/manager/setup/custom/CustomSetupTasks.java) for details.

docs/developer-guide/setting-up-an-ide.md

@@ -10,8 +10,7 @@ This is not necessary if you prefer [Working on the UI](working-on-ui-and-apps.m
 
 ## Download custom-project
 
-1. Using Git, clone the [custom-project](https://github.com/openremote/custom-project) repo
-2. `cd` into the custom-project directory, and add the [openremote](https://github.com/openremote/openremote) submodule, using the `git submodule init` and `git submodule update` commands
+Using Git, clone the [custom-project](https://github.com/openremote/custom-project) repository.
 
 ## Run Docker container
 
@@ -109,7 +108,7 @@ For custom working directory or launch settings, you may need to configure `.vsc
 
 All Docker and Gradle commands **must be executed in the project root directory**. If you are working on the main OpenRemote repository, this means the root of the repository. If you are [Creating a custom project](creating-a-custom-project.md), this means the root of your project's repository.
 
-The working directory in your IDE however must always be set to the **OpenRemote project directory**. All configuration settings in source code default to this location. This means if you are [Creating a custom project](creating-a-custom-project.md), your IDE will work in the `openremote` submodule directory.
+The working directory in your IDE must also always be set to your project root directory.
 
 We recommend you set this as the default directory in your IDE for all *Run Configurations*. To improve creation and execution of ad-hoc tests in the IDE you should set the default working directory for JUnit Run Configurations:
 

docs/user-guide/deploying/custom-deployment.md

@@ -13,7 +13,7 @@ In this guide we will go through the first time setting up your [custom project]
 ## Follow these steps to run your custom project
 1. Prepare your [environment](../../developer-guide/preparing-the-environment.md)
 2. Clone your repository from the [custom-project template](https://github.com/openremote/custom-project).\
-Then initialize and update the openremote submodule with `git submodule init` and `git submodule update --rebase --remote` from your custom project directory after cloning the repo. This is easiest if you have an [SSH-key in your Github account](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent)
+This is easiest if you have an [SSH-key in your GitHub account](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent)
 3. [Set up your IDE](../../developer-guide/setting-up-an-ide.md). Note that Application run configurations are already prepared when using this template. \
 Use `docker-compose -f profile\dev-testing.yml up --build -d` and run the 'Custom Deployment' configuration. You should have two containers running in Docker, and the manager through your IDE.
 4. Run the modelWatch gradle task to build the typescript model `./gradlew modelWatch`