Genesis Application Platform

https://docs.genesis.global/docs/
Admin
Genesis Application Platform is a comprehensive development framework for building fast, compliant,...
Tokens:865,693
Snippets:7,145
Trust Score:9.6
Update:7 months ago
Show doc for...
Tokens:
Raw
### Install Hook Script Example: Bash calling Kotlin

Source: https://docs.genesis.global/docs/build-deploy-operate/operate/commands

This example demonstrates an install hook written in bash that executes a Kotlin script. The bash script echoes a message, calls the Kotlin script using 'GenesisRun', and exits with the Kotlin script's status code.

```bash
#!/bin/bash
echo "InstallHook migrating EXCHANGE records with CODE null or empty, to be 'N/A'"

GenesisRun exchangeCodeNA-script.kts

exit $?
```

--------------------------------

### Angular Component Setup

Source: https://docs.genesis.global/docs/develop/client-capabilities/state-management/foundation-store/client-state-management-legacy-setup

Basic Angular component setup using the `@Component` decorator. This snippet shows the selector, template URL, and style URL for an Angular component, serving as a starting point for integrating store functionality.

```typescript
@Component({
  selector: 'fixedincome-root',
  templateUrl: './app.component.html',
  styleUrl: './app.component.css',
})

```

--------------------------------

### Initialize Store and Dispatch Events in Genesis

Source: https://docs.genesis.global/docs/develop/client-capabilities/state-management/foundation-store/client-state-management-legacy-setup

Example of a Genesis main application class that initializes the store and dispatches 'store-connected' and 'store-ready' events. It utilizes decorators for dependency injection and observable properties. This snippet focuses on the core store initialization logic.

```typescript
/**  
 * @fires store-connected - Fired when the store is connected.  
 * @fires store-ready - Fired when the store is ready.  
 */  
@customElement({
  name,
  template,
  styles,
})
export class MainApplication extends EventEmitter<StoreEventDetailMap>(GenesisElement) {
  @App app: App;
  @Connect connect!: Connect;
  @Container container!: Container;
  @Store store: Store;

  @inject(MainRouterConfig) config!: MainRouterConfig;

  @observable provider!: any;
  @observable ready: boolean = false;
  @observable data: any = null;

  async connectedCallback() {
    this.registerDIDependencies();
    super.connectedCallback();
    this.addEventListeners();
    this.readyStore();
    DOM.queueUpdate(() => {
      configureDesignSystem(this.provider, designTokens);
    });
  }

  disconnectedCallback() {
    super.disconnectedCallback();
    this.removeEventListeners();
    this.disconnectStore();
  }

  selectTemplate() {
    return this.ready ? MainTemplate : LoadingTemplate;
  }

  protected addEventListeners() {
    this.addEventListener('store-connected', this.store.onConnected);
  }

  protected removeEventListeners() {
    this.removeEventListener('store-connected', this.store.onConnected);
  }

  protected readyStore() {
    // @ts-ignore
    this.$emit('store-connected', this);
    this.$emit('store-ready', true);
  }

  protected disconnectStore() {
    this.$emit('store-disconnected');
  }
}
```

--------------------------------

### Custom JSDOM Setup

Source: https://docs.genesis.global/docs/develop/client-capabilities/testing

Provides an example of a custom JSDOM setup file. This allows for specific configurations or extensions to the JSDOM environment used during testing, ensuring compatibility and desired behavior.

```typescript
// custom code
export * from '@genesislcap/foundation-testing/jsdom';
```

--------------------------------

### Start Server on Specific Node and Ignore Daemon

Source: https://docs.genesis.global/docs/build-deploy-operate/operate/commands

This example shows how to start the server on a specific node ('node1') while preventing the daemon from being killed or started. This requires the EnableDaemonScriptController property to be true.

```bash
startServer  -s node1 -i  
```

--------------------------------

### Accessing Store in React Components

Source: https://docs.genesis.global/docs/develop/client-capabilities/state-management/foundation-store/client-state-management-legacy-setup

Example of how to import and use the `storeService` to access the foundation store from your React components. This provides a convenient way to manage and interact with the store's state.

```typescript
import { storeService } from './path/to/store';

storeService.getStore(); // access the store
```

--------------------------------

### Initialize Store and Dispatch Events in React

Source: https://docs.genesis.global/docs/develop/client-capabilities/state-management/foundation-store/client-state-management-legacy-setup

An example of a React main application component that initializes the store and dispatches custom events like 'store-connected' and 'store-ready'. It uses React hooks (`useState`, `useEffect`) for managing state and side effects, and a helper function `customEventFactory` for event creation.

```javascript
interface AppProps {
  rootElement: HTMLElement;
}

const App: React.FC<AppProps> = ({ rootElement }) => {
  const [isStoreConnected, setIsStoreConnected] = useState(false);
  const dispatchCustomEvent = (type: string, detail?: any) => {
    rootElement.dispatchEvent(customEventFactory(type, detail));
  };
  const handleStoreConnected = (event: CustomEvent) => {
    storeService.onConnected(event);
  };

  setApiHost();
  genesisRegisterComponents();
  configureFoundationLogin({ router: history });

  useEffect(() => {
    registerStylesTarget(document.body, 'main');
    if (!isStoreConnected) {
      rootElement.addEventListener('store-connected', handleStoreConnected);
      dispatchCustomEvent('store-connected', rootElement);
      dispatchCustomEvent('store-ready', true);
      setIsStoreConnected(true);
    }

    return () => {
      if (isStoreConnected) {
        rootElement.removeEventListener('store-connected', handleStoreConnected);
        dispatchCustomEvent('store-disconnected');
      }
    };
  }, [isStoreConnected]);

  return (
    <AuthProvider>
      <RoutesProvider>
        <HistoryRouter history={history as any}>
          <Routes>
            <Route path="*" element={<DynamicLayout />} />
          </Routes>
        </HistoryRouter>
      </RoutesProvider>
    </AuthProvider>
  );
};

```

--------------------------------

### Accessing Store in Angular Components

Source: https://docs.genesis.global/docs/develop/client-capabilities/state-management/foundation-store/client-state-management-legacy-setup

Example of how to import and use the `getStore` function to access the foundation store from your Angular components. This allows you to interact with the store's state and methods.

```typescript
import { getStore } from './path/to/store';

getStore(); // access the store
```

--------------------------------

### Configure Foundation Login Routes in Genesis

Source: https://docs.genesis.global/docs/develop/client-capabilities/login

This example focuses on the setup necessary for enabling Login functionality in your Genesis application. It includes all the required elements related to the login setup, such as route definitions and navigation contributors. Place this code in the `routes/config.ts` file.

```typescript
// Import required dependencies from the foundation-login package  
import { Login } from '@genesislcap/foundation-login';  
// Import required dependencies from the foundation-comms package  
// You could also import analytics events and set them up in the NavigationContributor  
import { Auth, Session } from '@genesislcap/foundation-comms';  
  
type RouterSettings = {  
  public?: boolean;  
  autoAuth?: boolean;  
}  
  
// Define your router config  
export class MainRouterConfig extends RouterConfiguration<RouterSettings> {  
  // Ensure you inject in required dependencies  
  constructor(  
    @Auth private auth: Auth,  
    @Session private session: Session  
  ) {  
    super();  
  }  
  
  // Add Login as a route  
  public configure() {  
    ...  
    this.routes.map(  
      { path: '', redirect: 'login' },  
      {  
        path: 'login',  
        element: Login,  
        title: 'Login',  
        name: 'login',  
        layout: loginLayout,  
        settings: { public: true },  
        childRouters: true,  
      },  
      ... // Other routes config here  
    );  
  
    const session = this.session;  
    const auth = this.auth;  
  
    // Example of a FallbackRouteDefinition  
    this.routes.fallback(() =>  
      auth.isLoggedIn ? { redirect: 'not-found' } : { redirect: 'login' }  
    );  
  
     // Example of a NavigationContributor  
    this.contributors.push({  
      navigate: async (phase) => {  
        const settings = phase.route.settings;  
  
        // Could add in processes such as analytics here  
  
        // If public route don't block  
        if (settings && settings.public) {  
          return;  
        }  
  
        // If logged in don't block  
        if (auth.isLoggedIn) {  
          return;  
        }  
  
        // If autoAuth and session is valid try to connect+auto-login  
        if (settings && settings.autoAuth && (await auth.reAuthFromSession())) {  
          return;  
        }  
  
        // Otherwise route them to login  
        phase.cancel(() => {  
          session.captureReturnUrl();  
          Route.name.replace(phase.router, 'login');  
        });  
      },  
    });  
  }  
  
  ... // Other configuration/methods  
}  

```

--------------------------------

### Install Hook Script Example: Bash calling Executable

Source: https://docs.genesis.global/docs/build-deploy-operate/operate/commands

This bash script serves as an install hook that executes a compiled program named 'MigrateDictionary'. It passes the '-dst DB' argument to the executable and exits with the program's return status.

```bash
#!/bin/bash

MigrateDictionary -dst DB

exit $?
```

--------------------------------

### Initialize New App with Notifications (GenX CLI)

Source: https://docs.genesis.global/docs/develop/business-components/notifications/notifications-installation

Initializes a new application named 'myapp' and adds the Notifications component using GenX CLI. This command is suitable for new projects. It requires the GenX CLI to be installed.

```powershell
npx -y @genesislcap/genx@latest init myapp -x --no-shell; npx -y @genesislcap/genx@latest add myapp -x -s genesislcap/pbc-notify-seed  
```

```bash
npx -y @genesislcap/genx@latest init myapp -x --no-shell && npx -y @genesislcap/genx@latest add myapp -x -s genesislcap/pbc-notify-seed  
```

--------------------------------

### Emit 'store-ready' Event

Source: https://docs.genesis.global/docs/develop/client-capabilities/state-management/foundation-store/client-state-management-legacy-setup

Emits the 'store-ready' event after the store is connected. This event is useful for performing additional work between store initialization and application use. If no additional work is needed, it can be emitted immediately after 'store-connected'.

```javascript
this.$emit('store-connected', this);
/**
 * Do some other work if needed.
 */
this.$emit('store-ready', true);
```

--------------------------------

### Injecting Store into Genesis Main Application Class

Source: https://docs.genesis.global/docs/develop/client-capabilities/state-management/foundation-store/client-state-management-legacy-setup

This TypeScript code demonstrates how to inject the foundation store into the `MainApplication` class in a Genesis project. This is a prerequisite for wiring the store into the application router.

```typescript
@customElement({
  name,
  template,
  styles,
})
export class MainApplication extends EventEmitter<StoreEventDetailMap>(GenesisElement) {
  @App app: App;
  @Connect connect!: Connect;
  @Container container!: Container;
  @Store store: Store;
}
```

--------------------------------

### Wiring Foundation Store into Genesis Router Template

Source: https://docs.genesis.global/docs/develop/client-capabilities/state-management/foundation-store/client-state-management-legacy-setup

This HTML template snippet shows how to bind the `store` property of the `MainApplication` class to the `foundation-router` component. This ensures the router has access to the store for managing navigation state.

```html
<foundation-router
  :config=${(x) => x.config}
  :store=${(x) => x.store}
></foundation-router>
```

--------------------------------

### Configure Foundation Login in React

Source: https://docs.genesis.global/docs/develop/client-capabilities/login

This example focuses on the setup necessary for enabling Login functionality in your React application. It includes configuration for the micro frontend, such as auto-connection, auto-authentication, and a redirect handler. Place this code in the file where you define your login component.

```typescript
import {configure, define} from '@genesislcap/foundation-login';  
import { AUTH_PATH } from '../config';  
import { DI } from '@microsoft/fast-foundation';  
import { history } from '../utils/history';  
  
/**  
 * Configure the micro frontend  
 */  
export const configureFoundationLogin = () => {  
  configure(DI.getOrCreateDOMContainer(), {  
    autoConnect: true,  
    autoAuth: true,  
    hostPath: AUTH_PATH,  
    redirectHandler: () => {  
      history.push('/order-mgmt');  
    },  
  });  
  
  return define({  
    name: `client-app-login`,  
  });  
};  

```

--------------------------------

### Start DbMon Session

Source: https://docs.genesis.global/docs/build-deploy-operate/operate/commands/dbmon

This snippet shows how to initiate a DbMon session. It requires switching to the user that owns the Genesis installation and then typing 'DbMon' at the command prompt. The output displays the welcome message and the DbMon prompt.

```shell
[titian] /home/titian >DbMon  
  
==================================  
Genesis database Monitor  
Enter 'help' for a list of commands  
==================================  
DbMon>  

```

--------------------------------

### Start Server Command

Source: https://docs.genesis.global/docs/build-deploy-operate/operate/commands

This code snippet demonstrates the basic usage of the startServer command to initiate all defined application processes.

```bash
startServer  
```

--------------------------------

### Bootstrap React App and Get Root Element

Source: https://docs.genesis.global/docs/develop/client-capabilities/state-management/foundation-store/client-state-management-legacy-setup

This React snippet demonstrates how to get a reference to the root DOM element (typically with id 'root') and pass it as a prop to the main App component. This is crucial for rendering the React application and interacting with the DOM.

```javascript
function bootstrapApp() {
  const rootEelement = document.getElementById('root');
  if (rootEelement) {
    ReactDOM.createRoot(rootEelement!).render(
      <React.StrictMode>
        <App rootElement={rootEelement} />
      </React.StrictMode>,
    )
  }
}
```

--------------------------------

### Start a Genesis Process

Source: https://docs.genesis.global/docs/build-deploy-operate/operate/commands

The startProcess command initiates a Genesis process as defined in the processes.xml file. It accepts the process name as a mandatory argument and offers optional arguments like -s for specifying a hostname, -v for verbose mode, and --dump for debugging information. The command logs standard error streams to a file named <process_name>.log.err in the $L directory by default.

```bash
startProcess APP_EVALUATOR
```

```bash
startProcess GENESIS_CLUSTER --dump
```

```bash
startProcess APP_NOTIFY -s node1
```

```java
java -Xmx256m -DXSD_VALIDATE=false global.genesis.process.GenesisProcessBootstrap -name GENESIS_AUTH_DATASERVER -scan global.genesis.dataserver.pal -module genesis-pal-dataserver -script genesis-dataserver.kts -loggingLevel INFO,DATADUMP_OFF >/dev/null 2> $L/GENESIS_AUTH_DATASERVER.log.err &
```

--------------------------------

### Emit 'store-disconnected' Event

Source: https://docs.genesis.global/docs/develop/client-capabilities/state-management/foundation-store/client-state-management-legacy-setup

Emits the 'store-disconnected' event when the component is disconnected. This action removes all previously bound event listeners. The example shows its implementation within a disconnectedCallback lifecycle method.

```typescript
// ./main/main.ts

disconnectedCallback() {
  super.disconnectedCallback();
  this.$emit('store-disconnected');
}
```

--------------------------------

### Start Application Server

Source: https://docs.genesis.global/docs/build-deploy-operate/operate/commands__highlight=mon

This command starts the application server. It reads the $GC/processes.xml file to determine which processes to start and how to start them. No arguments are required for a basic start.

```bash
startServer
```

--------------------------------

### Create Server Directory and Symlink (Bash)

Source: https://docs.genesis.global/docs/build-deploy-operate/deploy/hosting-infrastructure/initial-application-install

This script creates a directory for server-side code, organized by installation date, and establishes a symbolic link for the run directory. It requires specifying the username the application will run as.

```bash
installDate=$(date +%Y%m%d)
runUser=<provide the username the application will run as>

# make the server directory and maintain a symlink in the runUser's homedir
mkdir -p /data/${runUser}/server/${installDate}/run
rm -f /home/${runUser}/run
ln -s /data/${runUser}/server/${installDate}/run /home/${runUser}/run
```

--------------------------------

### Import Legacy Reporting Component Manually (TypeScript)

Source: https://docs.genesis.global/docs/develop/business-components/reporting/developer-guide

This snippet demonstrates how to import the `LegacyReporting` component for manual installations. It shows the necessary import statement and how to access the `RapidReporting` property. This is an alternative to the route configuration for manual setups.

```typescript
// Register the component. You could instead do this in a file such as components.ts
import { LegacyReporting } from '@genesislcap/pbc-reporting-ui'
LegacyReporting.RapidReporting;

```

--------------------------------

### Initialize GenesisHttpClient

Source: https://docs.genesis.global/docs/develop/server-capabilities/integrations/external-rest-apis

Demonstrates the basic initialization of the GenesisHttpClient.

```kotlin
import global.genesis.httpclient.GenesisHttpClient

val client = GenesisHttpClient()
```

--------------------------------

### Create Web Directory and Symlink (Bash)

Source: https://docs.genesis.global/docs/build-deploy-operate/deploy/hosting-infrastructure/initial-application-install

This script sets up the directory structure for web code, which is served by nginx. It creates a versioned directory for each installation date and a stable symlink for the nginx document root. The username for the application run is a required input.

```bash
installDate=$(date +%Y%m%d)
runUser=<provide the username the application will run as>

# make the directory and create a stable path for the nginx document root
mkdir -p /data/${runUser}/web-${installDate}
rm -f /data/${runUser}/web
ln -s /data/${runUser}/web-${installDate} /data/${runUser}/web
```

--------------------------------

### Execute Specific Install Hooks with genesisInstallHooks

Source: https://docs.genesis.global/docs/build-deploy-operate/operate/commands

The 'genesisInstallHooks' command allows targeted execution of install hooks. It supports specifying hook types like POST_INSTALL (default), PRE_INSTALL, and POST_REMAP, and can initialize hooks without running them using the '--init' flag.

```bash
# Run POST_INSTALL hooks (default)
gensisInstallHooks

# Run PRE_INSTALL hooks
gensisInstallHooks --hookType=PRE_INSTALL

# Run POST_REMAP hooks
gensisInstallHooks --hookType=POST_REMAP

# Initialize all hooks without running them
gensisInstallHooks --init=true
```

--------------------------------

### Add Genesis Start plugin to build.gradle.kts

Source: https://docs.genesis.global/docs/develop/development-environment/genesis-start

This snippet demonstrates how to apply the `global.genesis.genesis-start-gui` plugin in a `build.gradle.kts` file. This enables the Genesis Start functionality for the project. The specified version `0.1.6` should be used.

```kotlin
plugins {
    // other plugins..
    id("global.genesis.genesis-start-gui") version "0.1.6"
}
```

--------------------------------

### StateMachine Operations Example (Kotlin)

Source: https://docs.genesis.global/docs/develop/server-capabilities/workflow-state-machine

Demonstrates common StateMachine operations such as creating, updating, and modifying entities. It showcases how to interact with the StateMachine for different update scenarios.

```kotlin
suspend fun insert(trade: Trade): Transition<Trade, TradeStatus, TradeEffect> = internalState.create(trade)
  
suspend fun modify(tradeId: String, modify: suspend (Trade) -> Unit): Transition<Trade, TradeStatus, TradeEffect>? =  
        internalState.update(Trade.ById(tradeId)) { trade, _ -> modify(trade) }  
  
suspend fun modify(trade: Trade): Transition<Trade, TradeStatus, TradeEffect>? = internalState.update(trade)
```

--------------------------------

### Global Service Definitions Example (XML)

Source: https://docs.genesis.global/docs/develop/server-capabilities/runtime-configuration/service-definition

An example of a system-wide `global-service-definitions.xml` file, generated after `genesisInstall`, showing services from multiple installed products.

```xml
<configuration>
  <service external="false" host="localhost" name="GENESIS_AUTH_DATASERVER" port="8502" secure="false"/>
  <service external="false" host="localhost" name="GENESIS_AUTH_MANAGER" port="8501" secure="false"/>
  <service external="false" host="localhost" name="GENESIS_AUTH_PERMS" port="8503" secure="false"/>
  <service external="false" host="localhost" name="GENESIS_CLUSTER" port="8510" secure="false"/>
  <service external="false" host="localhost" name="GENESIS_WEBMON" port="8511" secure="false"/>
  <service external="false" host="localhost" name="GENESIS_ROUTER" port="8512" secure="false"/>
  <service external="false" host="localhost" name="GCOM_DATA_SERVER" port="8570" secure="false"/>
  <service external="false" host="localhost" name="GCOM_REQUEST_SERVER" port="8571" secure="false"/>
</configuration>
```

--------------------------------

### Start Application Server on Specific Node and Ignore Daemon

Source: https://docs.genesis.global/docs/build-deploy-operate/operate/commands__highlight=mon

This command starts the application server on a specified node ('node1' in this example) and prevents the daemon from being killed or started. This requires the `EnableDaemonScriptController` system definition property to be enabled.

```bash
startServer -s node1 -i
```

--------------------------------

### Run Genesis Start on Mac OSX / Linux

Source: https://docs.genesis.global/docs/develop/development-environment/genesis-start

Executes the Genesis Start command on Mac OSX or Linux environments. Navigate to the project's `server` directory and run this command to start the local application preview.

```bash
./gradlew genesisStart
```

--------------------------------

### Install Document Management PBC using npx

Source: https://docs.genesis.global/docs/develop/business-components/doc-management/doc-management-installation

Installs and configures the client and server modules for the Document Management PBC in a modern Genesis application using the unified monorepo structure. This command should be run in the project root.

```bash
npx -y @genesislcap/genx@latest add -s pbc-documents-seed -x --no-shell
```

--------------------------------

### Install Reporting PBC using GenX CLI

Source: https://docs.genesis.global/docs/develop/business-components/reporting/developer-guide

Installs and configures the client and server modules for the Reporting PBC using the GenX CLI tool. This is the recommended method for modern Genesis applications.

```bash
npx -y @genesislcap/genx@latest add -s pbc-reporting-seed -x --no-shell
```

--------------------------------

### Install Dependencies and Bootstrap App

Source: https://docs.genesis.global/docs/develop/client-capabilities/framework-integration/client-framework-integration-react

Installs all necessary project dependencies and bootstraps the application. This command is typically run from the project's root folder.

```bash
npm run bootstrap
```

--------------------------------

### REST API Request Example

Source: https://docs.genesis.global/docs/develop/server-capabilities/integrations/custom-endpoints

This example illustrates an HTTP GET request to a custom endpoint within the Genesis Global project, including necessary headers like `Host`, `Content-Type`, and `SESSION_AUTH_TOKEN`.

```http
GET /trade-service/trades?trade-id=1 HTTP/1.1
Host: localhost:9064
Content-Type: application/json
SESSION_AUTH_TOKEN: 83eLYBnlqjIWt1tqtJhKwTXJj2IL2WA0
```

--------------------------------

### Start Development Server

Source: https://docs.genesis.global/docs/develop/client-capabilities/framework-integration/client-framework-integration-react

Starts the application in development mode, launching a local development server. This command makes the project accessible on localhost for testing and development.

```bash
npm run dev
```

--------------------------------

### StartProcess Command

Source: https://docs.genesis.global/docs/build-deploy-operate/operate/commands

The startProcess command initiates a Genesis process defined in the processes.xml file. It allows specifying the process name and optional arguments for hostname, verbose mode, and debugging.

```APIDOC
## STARTPROCESS

### Description
Starts a Genesis process defined in the `processes.xml` file. This command allows you to launch specific application processes and control their execution environment.

### Method
Command-line utility

### Endpoint
N/A (Command-line tool)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Command Usage

**Starting a process:**
```
startProcess <process_name>
```

**Starting a process with options:**
```
startProcess <process_name> [options]
```

### Parameters Details

- **<process_name>**: (Mandatory) The name of the process to start, as defined in `processes.xml`.
- **-s HOSTNAME [HOSTNAME ...]**, **--hostname HOSTNAME [HOSTNAME ...]**: (Optional) Specifies the node(s) where the application is running if it's distributed across multiple nodes. Allows starting a process on a different node.
- **-v, --verbose**: (Optional) Starts the process in verbose mode, logging output to the terminal for on-screen viewing.
- **--dump**: (Optional) Displays the progress of the process, which is useful for debugging.

*Note: The `-s` option requires the `EnableDaemonScriptController` system definition property to be enabled and set to `true`.*

### Request Example

**Starting the APP_EVALUATOR process:**
```
startProcess APP_EVALUATOR
```

**Starting the GENESIS_CLUSTER process with debugging information:**
```
startProcess GENESIS_CLUSTER --dump
```

**Starting the APP_NOTIFY process on node1 only:**
```
startProcess APP_NOTIFY -s node1
```

### Response

#### Success Response
This command initiates a process. Successful execution is typically indicated by the process running without immediate errors. Detailed output or errors are usually logged to files.

#### Response Example
N/A

### Logging

- Standard error streams are redirected to a log file named `<process_name>.log.err` in the `$L` directory by default.
- If `RedirectStreamsToLog` is set to `true`, standard error output is written to the standard process log file managed by Log4j2.
- Existing process logs in the `$L` directory are compressed and moved to the `$RL` directory by default, unless `LogArchivingEnabled` is set to `false`.
```

--------------------------------

### SyncEntityDb Get Operation Example (Kotlin)

Source: https://docs.genesis.global/docs/develop/server-capabilities/data-access-apis

Demonstrates how to perform a 'get' operation using the synchronous EntityDb API in Kotlin. It highlights the nullable return type and the necessity of checking for null before accessing the retrieved record.

```kotlin
val trade: Trade? = db.get(Trade.byId("TRADE_1"))
if (trade == null) throw RuntimeException("Unable to find trade")
```

--------------------------------

### GPAL Data Server Compiled Example

Source: https://docs.genesis.global/docs/develop/server-capabilities/gpal-standards/migration-guide-script-to-compiled

Example of a GPAL Data Server definition migrated to a compiled Kotlin class (.kt). It extends GPalDataserver and includes necessary imports for GPAL and views.

```kotlin
package  
  
import global.genesis.dataserver.pal.script.GPalDataserver  
import global.genesis.gen.config.view.TRADE_VIEW  
  
class MyDataServer : GPalDataserver({"  
    query("ALL_TRADES", TRADE_VIEW) {  
        config { compression = true }  
        indices { unique("BY_ID") { TRADE_ID } }  
    }  
})

```

--------------------------------

### Secure GPAL Dataserver Example

Source: https://docs.genesis.global/docs/build-deploy-operate/build/plugins

Illustrates how to define security permissions for a GPAL dataserver query. It shows the use of `permissionCodes` and `auth` blocks to specify required permissions and authentication details.

```kotlin
query("ALL_TRADES", TRADE) {
    permissioning {
        permissionCodes("TRADE_VIEW")
        auth("COUNTERPARTY_VISIBILITY") {
            authKey { key(data.counterpartyId) }
        }
    }
}
```

--------------------------------

### GPAL Data Server Script Example

Source: https://docs.genesis.global/docs/develop/server-capabilities/gpal-standards/migration-guide-script-to-compiled

Example of a GPAL Data Server definition in script form (.kts). This defines a query named 'ALL_TRADES' using 'TRADE_VIEW' with specific compression and indexing configurations.

```kotlin
query("ALL_TRADES", TRADE_VIEW) {  
    config { compression = true }  
    indices { unique("BY_ID") { TRADE_ID } }  
}  

```

--------------------------------

### Sample System Definition with User/Password in URL (SQL Server)

Source: https://docs.genesis.global/docs/build-deploy-operate/deploy/supporting-infrastructure

An example of a system definition in Kotlin DSL where user and password are included directly in the JDBC URL for SQL Server. This is not recommended for production environments due to unencrypted credentials.

```kotlin
systemDefinition {
    global {
        ...
        item(name = "DbLayer", value = "SQL")
        item(name = "DbHost", value = "jdbc:sqlserver://pdb:6060;databaseName=trades;user=MyUserName;password=dbpassword;")
        ...
    }
    ...
}
```

--------------------------------

### Add Notifications to Existing App (GenX CLI)

Source: https://docs.genesis.global/docs/develop/business-components/notifications/notifications-installation

Adds the Notifications component to an existing application using GenX CLI. Replace '_app-folder-name_' with the actual name of your application's folder. This command assumes GenX CLI is installed.

```powershell
npx -y @genesislcap/genx@latest add app-folder-name -x -s genesislcap/pbc-notify-seed  
```

```bash
npx -y @genesislcap/genx@latest add app-folder-name -x -s genesislcap/pbc-notify-seed  
```

--------------------------------

### mcphost Command Line Examples

Source: https://docs.genesis.global/docs/develop/server-capabilities/model_context_protocol

Examples of how to run the mcphost command-line application to connect to the MCP server using different AI models. Requires API keys for Anthropic and OpenAI, but not for Ollama.

```shell
mcphost -m ollama:<your model>
```

```shell
mcphost -m anthropic:claude-3-5-sonnet-latest --anthropic-api-key <key> --anthropic-url <url>
```

```shell
mcphost -m openai:gpt-4 --openai-api-key <key> --open-ai-url <url>
```

--------------------------------

### Add Foundation Store Dependency to package.json

Source: https://docs.genesis.global/docs/develop/client-capabilities/state-management/foundation-store/client-state-management-legacy-setup

This snippet shows how to add the `@genesislcap/foundation-store` as a dependency in your project's `package.json` file. After modifying dependencies, it's crucial to run `npm run bootstrap` or `npm install`.

```json
{
  "dependencies": {
    "@genesislcap/foundation-store": "latest"
  }
}
```

--------------------------------

### Configure POSITION_CONSOLIDATOR with Cold Start Argument

Source: https://docs.genesis.global/docs/develop/server-capabilities/real-time-aggregation-consolidator

This XML configuration extends the 'POSITION_CONSOLIDATOR' setup by including an `<arguments>` tag with the value '--coldStart'. This ensures that the consolidator performs a cold start upon process initiation, clearing existing data before recalculating.

```xml
<process name="POSITION_CONSOLIDATOR">
  <groupId>POSITION</groupId>
  <description>Consolidates trades to calculate positions</description>
  <start>true</start>
  <options>-Xmx256m -DRedirectStreamsToLog=true -DXSD_VALIDATE=false -XX:MaxHeapFreeRatio=70 -XX:MinHeapFreeRatio=30 -XX:+UseG1GC -XX:+UseStringDeduplication -XX:OnOutOfMemoryError="handleOutOfMemoryError.sh %p"</options>
  <module>genesis-pal-consolidator</module>
  <package>global.genesis.pal.consolidator</package>
  <primaryOnly>true</primaryOnly>
  <script>position-consolidator.kts</script>
  <loggingLevel>DEBUG,DATADUMP_ON</loggingLevel>
  <language>pal</language>
  <arguments>--coldStart</arguments>
</process>
```

--------------------------------

### Use Avatar Component in Angular

Source: https://docs.genesis.global/docs/develop/client-capabilities/presentation/client-presentation-avatar

This example shows how to integrate the avatar component into an Angular application. It includes necessary imports and component setup for rendering the avatar.

```typescript
import { Component, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
import { FormsModule } from '@angular/forms';
@Component({
  selector: 'my-root',
  template: `
        <rapid-avatar shape="circle" fill="green" color="black">JD</rapid-avatar>
      `,
  standalone: true,
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
  imports: [FormsModule],
})
export class AppComponent {
}
```

--------------------------------

### Basic Component Test Suite Example

Source: https://docs.genesis.global/docs/how-to/ht-web-unit-test

Demonstrates how to create a basic unit test suite for a component using UVU and foundation-testing. It includes setting up a component suite, asserting its presence in the DOM, and running the suite.

```typescript
import {Example} from '../../src/routes/example/example'
import {assert, createComponentSuite} from "@genesislcap/foundation-testing";

Example;  // reference to avoid tree shaking.

const Suite = createComponentSuite<Example>('Example', 'example-route');

Suite('Can be created in the DOM', async ({element}) => {
  assert.ok(element);
});

Suite.run();

```

--------------------------------

### Start Development Server

Source: https://docs.genesis.global/docs/develop/development-environment/genx

Starts an incremental development build server that watches for source file changes and refreshes the application. Supports HTTPS, disabling the browser window, and setting environment variables.

```bash
genx dev --builder <builder>
genx dev --https
genx dev --no-open
genx dev --env VAR1=VAL1,VAR2=VAL2
genx serve --help
```

--------------------------------

### Rapid Text Field with Start Slot and Numeric Input

Source: https://docs.genesis.global/docs/develop/client-capabilities/forms/form-inputs/client-interaction-text-field

An example of implementing a Rapid Text Field for numeric input with a '$' symbol in the start slot. It uses 'inputmode="numeric"' and 'pattern="\d*"' for better mobile keyboard experience and input validation.

```html
<rapid-text-field type="text" inputmode="numeric" pattern="\d*">
    <div slot="start">
        $
    </div>
</rapid-text-field>
```

--------------------------------

### Full Example: Testing a Web Component with Mocks and Test Harness

Source: https://docs.genesis.global/docs/develop/client-capabilities/server-communications/comms-testing

A comprehensive example demonstrating the complete process of testing a web component. It includes defining a test component with `@testSpy`, configuring various mocks (Auth, Connect, Datasource, Socket), registering these mocks using `@microsoft/fast-foundation`'s `Registration`, and writing test cases using `createComponentSuite`. The example covers component creation assertions and concludes with running the test suite.

```typescript
import { customElement, html, ref } from '@microsoft/fast-element';
import { assert, createComponentSuite, sinon, testSpy } from '@genesislcap/foundation-testing';
import { GridProGenesisDatasource } from './grid-pro-genesis-datasource';
import { AuthMock, ConnectMock, DatasourceMock, SocketMock } from '@genesislcap/foundation-comms';
import { Registration } from '@microsoft/fast-foundation';

// Step 1: Define your test components by extending the components to be tested
@customElement({
  name: 'my-example-component-test',
})
@testSpy
export class MyExampleComponentTest extends MyExampleComponent {}

// Step 2: Configure the required mocks for services your component depends on
const authMock = new AuthMock();
const connectMock = new ConnectMock();
const datasourceMock = new DatasourceMock();
const socketMock = new SocketMock();

connectMock.nextMetadata = { TYPE: 'DATASERVER' };
connectMock.socket = socketMock;

// Configuring mocks and test component registration
const mocks = [
  Registration.instance(Auth, authMock),
  Registration.instance(Connect, connectMock),
  Registration.instance(Datasource, datasourceMock),
  Registration.instance(Socket, socketMock),
];

// Step 3: Write test cases using createComponentSuite to define your test suite
const Suite = createComponentSuite<MyExampleComponentTest>(
  'MyExampleComponent Tests',
  () => new MyExampleComponentTest(),
  null,
  mocks,
);

// Example test case: Verify component creation in the DOM
Suite('Can be created in the DOM', async ({ element }) => {
  assert.ok(element, 'Component did not initialize in the DOM');
  // Additional assertions and interactions with the test component
});

// Additional test cases as needed...

Suite.run(); // Don't forget to execute the test suite
```

--------------------------------

### Set fileServerVersion in server gradle.properties

Source: https://docs.genesis.global/docs/develop/business-components/doc-management/doc-management-installation

Specifies the version of the file server component by adding the `fileServerVersion` property to the `server/gradle.properties` file. Replace 'x.y.z' with the actual version.

```properties
fileServerVersion=x.y.z
```

--------------------------------

### Configure and Use Kafka Source in GPAL

Source: https://docs.genesis.global/docs/develop/server-capabilities/integrations/data-pipelines

This example demonstrates how to define and configure a kafkaSource in GPAL, specifying key and value deserializers, bootstrap servers, group ID, topic, and optional security settings. It then shows how to integrate this source into a pipeline.

```kotlin
val source = kafkaSource<String, Int> {
    bootstrapServers = "localhost"
    groupId = "my-group"
    keyDeserializer = StringDeserializer()
    valueDeserializer = IntegerDeserializer()
    topic = "my-topic"
    securityProtocol = "SSL"
    additionalConfig = mapOf("auto.offset.reset" to "earliest")
}

pipelines {
    pipeline("TEST_KAFKA_PIPELINE") {
        source(source)
            .sink(testSink)
    }
}

```

--------------------------------

### Get Entity by Primary Key or Index (Java Blocking)

Source: https://docs.genesis.global/docs/develop/server-capabilities/data-access-apis

Shows how to fetch a single entity using the `get` operation in Java (blocking). Examples include lookups by primary key, by a trade object with its primary key set, by a trade object and a unique index reference, and by directly accessing the index class from the entity.

```java
// we can look up trades by passing in a unique index class:  
final var trade = db.get(Trade.byId("TRADE_1"))  
  
// a trade object with the primary key set  
final var trade = db.get(trade)  
  
// a trade object and a reference to unique index  
final var trade = db.get(trade,Trade.ByTypeId.Companion)  
  
// or you can access the index class from the entity  
final var trade = db.get(trade.byTypeId())  

```

--------------------------------

### Run Genesis Start on Windows

Source: https://docs.genesis.global/docs/develop/development-environment/genesis-start

Executes the Genesis Start command on a Windows environment. This is typically done from the project's `server` directory to launch and preview the application locally.

```batch
.\gradlew.bat genesisStart
```

--------------------------------

### Initialize New App with Reconciliation (PowerShell)

Source: https://docs.genesis.global/docs/develop/business-components/reconciliation/reconciliation-installation

Initializes a new application named 'myapp' and adds the Reconciliation component using GenX CLI in PowerShell. This command is suitable for Windows environments.

```powershell
npx -y @genesislcap/genx@latest init myapp -x --no-shell; npx -y @genesislcap/genx@latest add myapp -x -s genesislcap/pbc-reconciliation-seed  
```

--------------------------------

### Add file-server dependency in server settings.gradle.kts

Source: https://docs.genesis.global/docs/develop/business-components/doc-management/doc-management-installation

Adds the file server component as a dependency within the Genesis project configuration in the `server/settings.gradle.kts` file. It utilizes the `fileServerVersion` defined in `gradle.properties`.

```kotlin
genesis {
    projectType = ProjectType.APPLICATION
    ...
    dependencies {
        ...
        dependency("global.genesis:file-server:${extra.properties["fileServerVersion"]}")
        ...
    }
}
```
Tokens:
Raw