@powerhousedao/academy 0.1.0-dev.0

package/docs/academy/02-AdvancedTutorial/04-WorkWithData/05-AnalyticsProcessorTutorial/01-SetupBuilderEnvironment.md

@@ -0,0 +1,215 @@
+# Setup Builder Environment
+
+Let's set up your computer to start with any of the Powerhouse Connect tutorials. Don't worry if this is your first time setting up a development environment - we'll guide you through each step!
+
+:::warning
+If you've already setup git, node, and npm, your most important step is to install the Powerhouse CLI with the command `npm install ph-cmd`. A global install is recommended if you want to use the command from any directory as a power user. The Powerhouse CLI is used to create, build, and run your Document Models and give you direct access to a series of Powerhouse ecosystem tools.
+:::
+
+## Table of Contents
+- [Prerequisites](#prerequisites)
+- [Installing node.js 22](#installing-nodejs)
+  - [For Windows](#for-windows)
+  - [For macOS](#for-macos)
+  - [For Linux (Ubuntu/Debian)](#for-linux-ubuntudebian)
+- [Installing Visual Studio Code](#installing-visual-studio-code)
+  - [For Windows](#for-windows-1)
+  - [For macOS](#for-macos-1)
+  - [For Linux (Ubuntu/Debian)](#for-linux-ubuntudebian-1)
+- [Install Git](#install-git)
+  - [For Windows](#for-windows-2)
+  - [For macOS](#for-macos-2)
+  - [For Linux (Ubuntu/Debian)](#for-linux-ubuntudebian-2)
+- [Configure Git](#configure-git-all-systems)
+- [Verify Installation](#verify-installation)
+
+## Prerequisites
+
+Before we begin with any of the Powerhouse Connect tutorials, we need to install some software on your computer. We'll need three main tools: node.js 22, which helps us run our code, Visual Studio Code (VS Code), which is where we'll write our code, and Git, which helps us manage our code. Follow the steps below based on your computer's operating system.
+
+### Installing node.js 22
+
+node.js 22 is a tool that lets us run our application. Let's install it step by step.
+
+#### For Windows:
+1. **Set up PowerShell for running commands:**
+   - Press the Windows key
+   - Type "PowerShell"
+   - Right-click on "Windows PowerShell" and select "Run as administrator"
+   - In the PowerShell window, type this command and press Enter:
+   ```powershell
+   Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
+   ```
+   - Type 'A' when prompted to confirm
+   - You can now close this window and open PowerShell normally for the remaining steps
+
+2. **Install node.js 22:**
+   - Visit the [node.js 22 official website](https://nodejs.org/)
+   - Click the big green button that says "LTS" (this means Long Term Support - it's the most stable version)
+   - Once the installer downloads, double-click it to start installation
+   - Click "Next" through the installation wizard, leaving all settings at their defaults
+
+3. **Verify Installation:**
+   - Open PowerShell (no need for admin mode)
+   - Type these commands one at a time and press Enter after each:
+   ```powershell
+   node --version
+   pnpm --version
+   ```
+   - You should see version numbers appear after each command (e.g., v18.17.0). If you do, congratulations - node.js 22 is installed!
+
+> **Note**: If node.js 22 commands don't work in VS Code, restart VS Code to refresh environment variables.
+
+#### For macOS:
+1. **Install Homebrew:**
+   - Open Terminal (press Command + Space and type "Terminal")
+   - Copy and paste this command into Terminal and press Enter:
+   ```bash
+   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+   ```
+   - Follow any additional instructions that appear
+
+2. **Install node.js 22:**
+   - In the same Terminal window, type this command and press Enter:
+   ```bash
+   brew install node
+   ```
+
+3. **Verify Installation:**
+   - In Terminal, type these commands one at a time and press Enter after each:
+   ```bash
+   node --version
+   pnpm --version
+   ```
+   - If you see version numbers, you've successfully installed node.js 22!
+
+#### For Linux (Ubuntu/Debian):
+1. **Open Terminal:**
+   - Press Ctrl + Alt + T on your keyboard, or
+   - Click the Activities button and type "Terminal"
+
+2. **Update Package List:**
+   ```bash
+   sudo apt update
+   ```
+
+3. **Install node.js 22 and npm:**
+   ```bash
+   sudo apt install nodejs npm
+   ```
+
+4. **Verify Installation:**
+   - Type these commands one at a time and press Enter after each:
+   ```bash
+   node --version
+   pnpm --version
+   ```
+   - If you see version numbers, you're all set!
+
+### Installing Visual Studio Code
+
+VS Code is the editor we'll use to write our code. Here's how to install it:
+
+#### For Windows:
+1. Visit the [Visual Studio Code website](https://code.visualstudio.com/)
+2. Click the blue "Download for Windows" button
+3. Once the installer downloads, double-click it
+4. Accept the license agreement and click "Next"
+5. Leave the default installation location and click "Next"
+6. In the Select Additional Tasks window, make sure "Add to PATH" is checked
+7. Click "Next" and then "Install"
+8. When installation is complete, click "Finish"
+
+#### For macOS:
+1. Visit the [Visual Studio Code website](https://code.visualstudio.com/)
+2. Click the blue "Download for Mac" button
+3. Once the .zip file downloads, double-click it to extract
+4. Drag Visual Studio Code.app to the Applications folder
+5. Double-click the app to launch it
+6. To make VS Code available in your terminal:
+   - Open VS Code
+   - Press Command + Shift + P
+   - Type "shell command" and select "Install 'code' command in PATH"
+
+#### For Linux (Ubuntu/Debian):
+1. Open Terminal (Ctrl + Alt + T)
+2. First, update the packages list:
+   ```bash
+   sudo apt update
+   ```
+3. Install the dependencies needed to add Microsoft's repository:
+   ```bash
+   sudo apt install software-properties-common apt-transport-https wget
+   ```
+4. Import Microsoft's GPG key:
+   ```bash
+   wget -q https://packages.microsoft.com/keys/microsoft.asc -O- | sudo apt-key add -
+   ```
+5. Add the VS Code repository:
+   ```bash
+   sudo add-apt-repository "deb [arch=amd64] https://packages.microsoft.com/repos/vscode stable main"
+   ```
+6. Install VS Code:
+   ```bash
+   sudo apt install code
+   ```
+7. Once installed, you can launch VS Code by:
+   - Typing `code` in the terminal, or
+   - Finding it in your Applications menu
+
+### Install Git
+
+#### Windows
+1. Open PowerShell (press Windows key, type "PowerShell", and press Enter)
+2. Visit the [Git website](https://git-scm.com/)
+3. Download the latest version for Windows
+4. Run the installer and use the recommended settings
+5. Verify installation by opening PowerShell:
+   ```powershell
+   git --version
+   ```
+
+#### macOS
+1. Install using Homebrew:
+   ```bash
+   brew install git
+   ```
+2. Verify installation:
+   ```bash
+   git --version
+   ```
+
+#### Linux (Ubuntu/Debian)
+1. Update package list:
+   ```bash
+   sudo apt update
+   ```
+2. Install Git:
+   ```bash
+   sudo apt install git
+   ```
+3. Verify installation:
+   ```bash
+   git --version
+   ```
+
+### Configure Git (All Systems)
+
+Open your terminal (command prompt) and run the following commands to set up Git:
+
+After installation, set up your identity:
+```bash
+git config --global user.name "Your Name"
+git config --global user.email "your.email@example.com"
+```
+
+### Verify Installation
+
+Open your terminal (command prompt) and run the following commands to verify your setup:
+```bash
+node --version
+pnpm --version
+git --version
+```
+
+You should see version numbers displayed for all commands. You're now ready to start with any of the Powerhouse Connect tutorials!

package/docs/academy/02-AdvancedTutorial/04-WorkWithData/05-AnalyticsProcessorTutorial/02-CreateNewPowerhouseProject.md

@@ -0,0 +1,55 @@
+# Create New Powerhouse Project
+
+Before we start diving into the tutorial, lets have a quick look at all the steps we'll go through. 
+
+1. We'll set up a powerhouse project and navigate to the newly created project directory to launch an analytics processor. 
+2. Afterwards we'll run a new Reactor instance. A Reactor instance is a local (or remote) node in the Powerhouse network.
+3. We'll create a new Real World Asset (RWA) Portfolio document model on the reactor node and add multiple purchase transactions to it. 
+4. We'll observe how the analytics processor receives the operations we've added to the document in the previous step. 
+5. We'll stop the reactor & replace our default code with the analytics processor code so it can calculate the different metrics & dimensions we want to see.
+4. Finally we'll run the analytics processor engine on the document model and look at the total value of specific asset classses on a monthly basis, add more data and adjust the granularity of the data we want to see.
+
+This tuturial should give you a good understanding of how the analytics processor works and how you can use it to listen, query and combine data from multiple document models or dimensions.
+Offering you the option to cut and slice your data in any way you want.
+
+Let's start with step 1 & 2 in the next section of the tutorial!
+
+To create a new Powerhouse Document Model Library project, you can use the `ph init` command in your terminal. This command will create a new project in the current directory.
+
+## Create New Powerhouse Document Model Library Project
+
+:::info
+This command will create a new project in the current directory.
+You can run the command in the terminal window of your OS or you open the newly installed VSCode and run the command in the terminal window of VSCode.
+You will need VSCode later in the tutorial once you have generated the document model.
+Make sure the terminal reflects the directory where you want to create the new project.
+To open a directory in a terminal, you use the cd command to change your current directory. The cd command takes an argument, usually the name of the folder you want to move to, so the full command is 
+```bash
+cd your-directory
+```
+This essentially opens that folder and places you in it.
+:::
+
+Once you've navigated to the directory where you want to create the new project and in your terminal, run the following command:
+
+```bash
+`ph init`
+```
+
+In the terminal, you will be asked to enter the project name. Fill in the project name and press enter.
+Since we'll be using the Analytics Processor on a Real World Asset report (RWA), we'll name the project `rwa-analytics`.
+
+```bash
+? What is the project name? ‣ rwa-analytics
+```	
+
+Once the project is created and the dependencies are installed (which can take a few minutes), you will see the following output:
+
+```bash
+ The installation is done!
+
+ You can start by typing:
+    cd rwa-analytics-demo
+```
+
+Great! You've created a new powerhouse project, let's move on to the next step.

package/docs/academy/02-AdvancedTutorial/04-WorkWithData/05-AnalyticsProcessorTutorial/03-GenerateAnAnalyticsProcessor.md

@@ -0,0 +1,173 @@
+# Generate the Reactor & Analytics Processor
+
+### Launch the Reactor
+
+**First**, navigate to the project directory with `cd rwa-analytics` to start the reactor from the project directory.
+Now open the directory with your code editor with the command `code . `
+
+Next, launch the reactor by running the following command in your terminal. 
+`ph reactor` . A Reactor instance is a local (or remote) node in the Powerhouse network that can hold & sychronize data. You'll see the following output in your terminal while the reactor is starting up and a new browser window opens with the Connect application. The reactor you've created will become available as a public drive in Connect's left hand side bar, named `Powerhouse`.
+
+```bash
+[Reactor]: Initializing ReactorRouterManager...
+[Reactor]: > Registered system subgraph.
+[Reactor]: > Registered d/:drive subgraph.
+[Reactor]:   ➜  Reactor:   http://localhost:4001/d/powerhouse
+[Reactor]: > Registered analytics subgraph.
+[Reactor]: > Loading document models from /Users/yourmachine/rwa-analytics-demo/document-models
+[Reactor]: > Loading processors from /Users/yourmachine/rwa-analytics-demo/processors
+[Reactor]: > Loading subgraphs from /Users/yourmachine/rwa-analytics-demo/subgraphs
+[Connect]: Watching local document models at '/Users/yourmachine/rwa-analytics-demo/document-models'...
+[Connect]: Watching local document editors at '/Users/yourmachine/rwa-analytics-demo/editors'...
+[Connect]:   ➜  Local:   http://localhost:3000/
+```
+
+As you can see the reactor registered the default system subgraph but also the `d/:drive` subgraph for fetching documents and pushing updates. It also registered the analytics subgraph, which we'll use later for running analytics queries on the document model in the next steps. 
+
+### Generate the Analytics Processor
+**Next** we'll open up a second terminal window and generate the analytics processor.
+Use the following command to generate the analytics processor in a seperate terminal window.
+```bash
+npm run generate -- --processor rwa-analytics --document-types makerdao/rwa-portfolio
+```
+In your project directory you'll now see the folder 'processors' being created. 
+Later we'll see how this processor is actively listening for the operations on a document model.
+Eventually we'll replace the default code of the generated processor with our own custom analytics processor code to listen to specific operations, dimensions and metrics.
+
+### Add data to the document model in the Reactor
+
+Now that we've generated the analytics processor we need to give it some data to listen to.
+For this we've created the local reactor instance, which will represent a node in the Powerhouse network. 
+It represents a node that is usually hosted as a remote server, but in our case we run it locally on our machine. 
+The document model data will be stored in the local reactor instance and be analyzed by the analytics processor. 
+
+Let's move on to the next step where we'll create a new RWA document model and add data to it.
+
+### A brief introduction to the RWA document model
+
+:::info
+An RWA document model helps an arranger for Sky (previously MakerDAO) to accurately track the value of a Real World Asset (RWA) such as US treasury bills by tracking the purchase, sale and other transactions on the asset. 
+In the case of Sky these real world assets are used to back the Sky/MakerDAO stablecoin. 
+Let's pretend we're an arranger and we want to track the value of a new RWA asset and analyze the total value of the assetclass on a monthly basis. 
+Aside from setting up an analytics processor you'll now also become familiar with how the RWA reporting workflow is captured in a document model. 
+:::
+
+We'll run through the following scenario:			
+	1. Add the Asset "T-Bill 4565446" with CUSIP : TB4565446, maturity 01/12/2024. So we have a new asset to track and work with in the document model.		
+	2. Make a "principal draw" of $10,000,000 on May 1. We're simulating an arranger borrowing $10,000,000 from Sky to purchase the asset.				
+	3. Make a purchase of 2,500,000 TB4565446 bills for $2,490,000 on May 15.				
+	4. Make a purchase of 2,000,000 TB4565446 bills for $1,995,000 on June 15.				
+	5. Make a sale of 4,000,000 TB4565446 bills for $4,000,000 on July 1.				
+	6. Verify that the document data is correctly entered.					
+	7. Inspect the document history.
+
+### Create a new RWA document model in Connect
+
+Under the 'New Document' section in Connect, click on the 'RWA Portfolio' document. 
+Name your document model `Sky Rwa's` and click on 'Create'.
+
+![Create a new RWA document](./images/create-a-new-RWA-document.gif)
+
+You'll immmediaty see that you've arrived in the portfolio editor with the option to add a new asset. 
+Since this document model is a portfolio for tracking the value of different assets, we'll first need to create the asset to be able to add any transaction history to them and track the value of the assets. 
+
+Hit the 'create asset' button. Which will offer you an overview of all the fields you need to fill in. 
+Before we can add an asset, we need to create a new "Special purpose vehicle" (SPV) for the asset. 
+A SPV is a legal entity that is created to hold the real world asset such as a US treasury bill. 
+For the sake of easily remembering the SPV let's name it 'SPV A'. 
+
+![Create a new SPV](./images/Create-SPV.gif)
+
+Let's add the asset details now and fill in the following details:
+
+- Asset name: T-Bill 4565446
+- CUSIP: TB4565446
+- ISIN: US0045654460
+- Maturity: 12/31/2024
+- Asset Type: Treasury Bill
+- SPV: SPV A
+
+Click on the 'Save' button to save the asset.
+Your new asset should look like this:
+
+![RWA Portfolio](./images/Create-a-new-asset.png)
+
+### Add a transaction to the asset
+
+We're now going to add a transaction to the asset and therefor simulate an arranger borrowing $10,000,000 through a loan from Sky to purchase the asset. 
+
+To do this, move to the transaction tab and click on the 'create transaction' button below the table. 
+
+Fill in the following details to complete the transaction of $10,000,000 from Sky to the SPV, known as a principal draw.
+
+- Transaction type: Principal Draw
+- Entry Time: 01/05/2024
+- Cash Amount: $10,000,000
+- Transaction reference: 0x123 (this is a reference to the transaction on the blockchain)
+
+Click on the 'Save' button to save the transaction.
+
+![Create a transaction](./images/Create-a-transaction.gif)
+
+You'll now see the transaction appear in the transaction table.
+
+### Let's buy & sell some T-bills!
+
+Now that we've created the T-bill asset and took out a loan from Sky to purchase it, we can start buying some T-bills. 
+Let's buy 2,500,000 T-bills for $2,490,000 on May 15.
+
+Create a new transaction and fill in the following details:
+
+- Transaction type: Asset Purchase
+- Entry Time: 15/05/2024
+- Asset name: T-Bill 4565446 - US0045654460 - TB4565446
+- Quantity: 2,500,000
+- Asset proceeds: $2,490,000 (this is the price of the T-bills, the price at maturity is $2,500,000, so the profit is $10,000)
+- Transaction reference: 0x123456 (this is a reference to the transaction on the blockchain)
+
+Click on the 'Save' button to save the transaction.
+
+To make the analysis slightly more interesting, let's also buy 2,000,000 T-bills for $1,995,000 on June 15.
+
+Create a new transaction and fill in the following details:
+
+- Transaction type: Asset Purchase
+- Entry Time: 15/06/2024
+- Asset name: T-Bill 4565446 - US0045654460 - TB4565446
+- Quantity: 2,000,000
+- Asset proceeds: $1,995,000
+- Transaction reference: 0x123456789 
+
+Click on the 'Save' button to save the transaction.
+
+Our last transaction will be a sale of 4,000,000 T-bills for $4,000,000 on July 1.
+
+Create a new transaction and fill in the following details:
+
+- Transaction type: Asset Sale
+- Entry Time: 01/07/2024
+- Asset name: T-Bill 4565446 - US0045654460 - TB4565446
+- Quantity: 4,000,000
+- Asset proceeds: $4,000,000
+- Transaction reference: 0x1234567890
+
+Click on the 'Save' button to save the transaction.
+
+Your table of transactions should now look like this:
+
+![RWA Portfolio](./images/Transaction-table.png)
+
+### Verify that the document data is correctly entered & inspect the document history		
+
+Connect offers you with a few ways to inspect the document data and history. Click on the 'revision history' button in the top right corner of your document model in Connect to see the history of your operations on the document model.
+
+Here you'll see that the logic and intelligence of the document model has created a group transaction for the asset, which is the sum of all the sub transactions for the T-bill asset. When you hover over the 'CREATE_GROUP_TRANSACTION' operation you'll see the exact logic that was used to create the group transaction. It's this data that will be used by the analytics processor to calculate the value of the asset over time.
+
+Additionally, Connect has a seamless integration with Switchboard, which offer a graphql interface to the document model.
+This allows you to inspect the document data and history in a structured way. Currently we're making use of the Apollo GraphQL sandbox to inspect the document data as it's the easiest way to get started.
+
+To inspect the document data, click on the 'Switchboard' icon in the top right corner of your document model in Connect.
+
+This will open a new tab with the graphql interface to the document model. If you click 'run' the base query will be executed and you'll see the document data and history. You'll find all the transactions we've added to the asset in the document model previously. 
+
+Now let's move on to the next step where we'll update the analytics processor code to listen to the document model and calculate the total value of the asset class on a monthly basis.

package/docs/academy/02-AdvancedTutorial/04-WorkWithData/05-AnalyticsProcessorTutorial/04-UpdateAnalyticsProcessor.md

@@ -0,0 +1,223 @@
+# Update the Analytics Processor
+
+Now let's implement our custom analytics processor code to calculate the total value of the asset class on a monthly basis.
+You will likely already be in the desired directory, but if not, navigate to the project directory and open it.
+
+```bash
+cd rwa-analytics
+```
+
+Now open the directory with your code editor. 
+
+```bash
+code .
+```
+
+Open the file `processors/rwa-analytics/index.ts` and replace the existing code with the following below:
+
+To get a better understanding of how the analytics processor work specific for this tutorial, we've added some comments to the code that might help you understand the different parts of the code.
+
+```typescript
+import {
+  AnalyticsPath,
+  type IAnalyticsStore,
+  AnalyticsSeriesInput,
+} from "@powerhousedao/reactor-api";
+import {
+  CreateGroupTransactionInput,
+} from "document-model-libs/real-world-assets";
+import { DateTime } from "luxon";
+import { IProcessor } from "document-drive/processors/types";
+import { InternalTransmitterUpdate } from "document-drive/server/listener/transmitter/internal";
+import { PHDocument } from "document-model";
+
+export class RwaAnalyticsProcessor implements IProcessor {
+  constructor(private readonly analyticsStore: IAnalyticsStore) {
+    //
+  }
+  
+  // This is the function that is called when the processor receives a new strand.
+  async onStrands<TDocument extends PHDocument>(
+    strands: InternalTransmitterUpdate<TDocument>[]
+  ): Promise<void> {
+    if (strands.length === 0) {
+      return;
+    }
+
+    const values: AnalyticsSeriesInput[] = [];
+    for (const strand of strands) {
+      // A strand is a collection of operations that are related to a single document and contain the data for the document.
+      if (strand.operations.length === 0) {
+        continue;
+      }
+
+      const documentId = strand.documentId.replace("/", "-");
+
+      // This is the first operation in the strand.
+      const firstOp = strand.operations[0];
+      const source = AnalyticsPath.fromString(
+        // This is the source of the operation, in our case it is the driveId, documentId, branch and scope.
+        `ph/${strand.driveId}/${documentId}/${strand.branch}/${strand.scope}`,
+      );
+
+      if (firstOp.index === 0) { // This is the index of the operation in the strand.
+        // This is the function that clears the source of the operation since there could be data existing from previous runs for the same document to avoid double counting.
+        await this.analyticsStore.clearSeriesBySource(source, true);
+      }
+
+      for (const operation of strand.operations) {	
+        // This is the type of the operation that is being displayed in the terminal.
+        console.log(">>> ", operation.type);
+
+        // This is the type of the operation that is being displayed in the terminal.
+        if (operation.type === "CREATE_GROUP_TRANSACTION") {
+          // This is the input of the operation. See how we're using the GroupTransactionInput type from the document model.
+          const groupTransaction =
+            operation.input as CreateGroupTransactionInput;
+          if (
+            ![
+              // Although an RWA portfolio could have multiple types of transactions, we're only interested in the ones that are relevant to our analytics.
+              "AssetPurchase",
+              "AssetSale",
+              "PrincipalDraw",
+              "PrincipalReturn",
+            ].includes(groupTransaction.type)
+          ) {
+            continue;
+          }
+
+          // Up next we'll go through the crucial design decision of defining the different dimensions or categories that are relevant to our analytics and queries. In this case we'll create 2 series values for each transaction type. Cash and Fixed Income transactions.
+          const { fixedIncomeTransaction, cashTransaction } =
+            groupTransaction;
+
+          if (fixedIncomeTransaction) {
+            const dimensions = {
+              // We're selecting T-bills as one of the dimensions.
+              asset: AnalyticsPath.fromString(
+                `sky/rwas/assets/t-bills/${fixedIncomeTransaction.assetId}`
+              ),
+              // We're selecting the portfolio as another dimension.	
+              portfolio: AnalyticsPath.fromString(
+                `sky/rwas/portfolios/${documentId}`,
+              ),
+            };
+
+            values.push({
+              dimensions,
+              metric: "AssetBalance",	// We're selecting the AssetBalance metric.
+              source,
+              start: DateTime.fromISO(fixedIncomeTransaction.entryTime),	// We're selecting the entryTime as the start of the series value.
+              value:
+                groupTransaction.type === "AssetPurchase"
+                  ? fixedIncomeTransaction.amount
+                  : -fixedIncomeTransaction.amount,
+            });
+          }
+
+          // We're doing the same thing for cash transactions.
+          if (cashTransaction) {
+            const dimensions = {
+              asset: AnalyticsPath.fromString(`sky/rwas/assets/cash`), // We're selecting cash as one of the dimensions.
+              portfolio: AnalyticsPath.fromString(
+                `sky/rwas/portfolios/${documentId}`, // We're selecting the portfolio as another dimension since we want to know the cash balance for each portfolio. Each portfolio has a unique documentId. We can then later group or separate by this analytics dimension. We will then also be able to use this dimension to query the cash balance for each portfolio or select a specific portfolio but combine it with other dimensions to get more specific data such as the cash balance for each portfolio for each month. We'll be able to make any combination of hierarchies of dimensions to cut & slice the data we want.
+              ),
+            };
+
+            values.push({
+              dimensions,
+              metric: "AssetBalance",	// We're selecting the AssetBalance metric for our tutorial scenario
+              source,
+              start: DateTime.fromISO(cashTransaction.entryTime),	// We're selecting the entryTime as the start of the series value.
+              value:
+                groupTransaction.type === "AssetPurchase" ||
+                groupTransaction.type === "PrincipalReturn"
+                  ? -cashTransaction.amount	
+                  : cashTransaction.amount,	
+            });
+          }
+        }
+      }
+    }
+
+    // Insert all the values into the analytics store at once.
+    await this.analyticsStore.addSeriesValues(values);
+  }
+
+  async onDisconnect() {}
+}
+```
+
+Now that we've implemented the analytics processor, we can make it receive the correct data by running the reactor again in our other terminal window. We currently don't support hot reloading yet so we'll need to stop the reactor and start it again. Press `Ctrl + C` in the terminal window of the reactor to stop it and then run `ph reactor` again.
+
+You should now be able to see in the terminal output of the reactor that the processor has received the operations and their details and they are available in the subgraphs. In case you would register a new listener for the analytics processor with a new ID, it would display all the operations from operation 0
+
+Now let's move over to the graphql playground to see the data that has been added to the analytics store.
+You'll need to use this specific endpoint to access the graphql playground `http://localhost:4001/analytics`
+
+Then, use this query to get the data from the analytics store, but don't forget to also add the variables below.
+
+```graphql
+query analytics ($filter: AnalyticsFilter) {
+  analytics {
+    series(filter: $filter) {
+      start
+      period
+      rows {
+        metric
+        sum
+        value
+        dimensions {
+          path
+        }
+      }
+    }
+  }
+}
+```
+With the following variables: 
+
+```graphql
+{
+  "filter": {
+    "metrics": ["AssetBalance"],
+    "granularity": "monthly",
+    "start": "2024-05-01",
+    "end": " 2024-12-31",
+    "dimensions": [
+      {
+        "lod": 4,
+        "name": "asset",
+        "select": "sky"
+      }
+    ]
+  }  
+}
+```
+
+You'll see that the data is now being displayed per month for each of the asset classes. 
+
+`sum`: Displays the total cumulative sum of the asset class for the month.
+
+`value`: Displays the total change in value of the asset class for that month.
+
+You'll also see that in the month of july the AssetBalance for the "path": "sky/rwas/assets/cash" has increased by 4.000.000 since we sold 4.000.000 worth of T-bills in July.
+
+When you play around with the variables of our query you can see the different granularity of the data that is being displayed on the image below.
+
+![Analytics](./images/granularity.png)
+
+If you would take 'total' you would see the total value left in the portfolio.
+
+To see more changes become present in the analytics store, you could add more transactions to the portfolio. We could do this by adding a rwa portfolio with a different documentId. 
+Imagine that this is similar to real time updates that might happen to a live environment when new transactions are added to a porftolio. 
+
+Now you know how to implement a custom analytics processor and how to query the data from the analytics store! 
+In case you'd want to try it out on another document model follow the steps below.
+
+1. Generate the processor
+2. Update the processor code
+3. Launch the processor
+4. Launch the reactor (again) and add your data
+5. Query the data from the analytics store
+
+Enjoy! 

package/docs/academy/02-AdvancedTutorial/04-WorkWithData/05-AnalyticsProcessorTutorial/_category_.json

@@ -0,0 +1,8 @@
+{
+  "label": "Analytics Processor Tutorial",
+  "position": 4,
+  "link": {
+    "type": "generated-index",
+    "description": "Learn how to make use of an Analytics Processor in this tutorial!"
+  }
+}