rule book dup/delete

fix
rulebook name
2026-06-09 23:44:16 +02:00 · 2026-06-09 21:56:12 +02:00 · 2026-06-09 18:00:25 +02:00 · 2026-06-08 18:54:53 +02:00 · 2026-06-08 08:27:42 +02:00 · 2026-06-07 23:18:53 +02:00
84 changed files with 7097 additions and 3237 deletions
@@ -23,3 +23,5 @@ docker-compose.yml
 *.njsproj
 *.sln
 *.sw?
+
+generated/mammon/
@@ -0,0 +1,782 @@
+openapi: 3.1.0
+info:
+  title: OpenAPI definition
+  version: v0
+servers:
+- url: http://localhost:8080
+  description: Generated server url
+paths:
+  /rule-books/{ruleBookId}:
+    get:
+      tags:
+      - rule-book
+      summary: Find a rule book by its id
+      operationId: findRuleBookById
+      parameters:
+      - name: ruleBookId
+        in: path
+        description: Id of the rule book
+        required: true
+        schema:
+          type: string
+          format: uuid
+      responses:
+        "200":
+          description: The rule book
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/RuleBookResponse"
+        "404":
+          description: No rule book with this id
+    put:
+      tags:
+      - rule-book
+      summary: Update a rule book
+      operationId: updateRuleBook
+      parameters:
+      - name: ruleBookId
+        in: path
+        description: Id of the rule book
+        required: true
+        schema:
+          type: string
+          format: uuid
+      requestBody:
+        description: New state of the rule book
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/UpdateRuleBookRequest"
+        required: true
+      responses:
+        "200":
+          description: The updated rule book
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/RuleBookResponse"
+        "400":
+          description: Invalid request (e.g. blank name)
+    delete:
+      tags:
+      - rule-book
+      summary: Delete a rule book
+      operationId: deleteRuleBook
+      parameters:
+      - name: ruleBookId
+        in: path
+        description: Id of the rule book
+        required: true
+        schema:
+          type: string
+          format: uuid
+      responses:
+        "204":
+          description: The rule book was deleted
+        "400":
+          description: The rule book is associated to a character
+  /ledgers/main/{ledgerId}:
+    put:
+      tags:
+      - ledger
+      summary: Update a main ledger
+      operationId: updateMainLedger
+      parameters:
+      - name: ledgerId
+        in: path
+        description: Id of the main ledger
+        required: true
+        schema:
+          type: string
+          format: uuid
+      requestBody:
+        description: New state of the main ledger
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/UpdateMainLedgerRequest"
+        required: true
+      responses:
+        "200":
+          description: The updated main ledger
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/MainLedgerResponse"
+        "400":
+          description: "The ledger is not a main ledger, or the request is invalid"
+        "404":
+          description: No ledger with this id
+  /ledgers/combined/{ledgerId}:
+    put:
+      tags:
+      - ledger
+      summary: Update a combined ledger
+      operationId: updateCombinedLedger
+      parameters:
+      - name: ledgerId
+        in: path
+        description: Id of the combined ledger
+        required: true
+        schema:
+          type: string
+          format: uuid
+      requestBody:
+        description: New state of the combined ledger
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/UpdateCombinedLedgerRequest"
+        required: true
+      responses:
+        "200":
+          description: The updated combined ledger
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/CombinedLedgerResponse"
+        "400":
+          description: "The ledger is not a combined ledger, or the request is invalid"
+        "404":
+          description: No ledger with this id
+  /characters/{characterId}/rule-book:
+    get:
+      tags:
+      - character-rule-book
+      summary: Find the rule book assigned to a character
+      operationId: findCharacterRuleBookByCharacterId
+      parameters:
+      - name: characterId
+        in: path
+        description: Id of the character
+        required: true
+        schema:
+          type: integer
+          format: int64
+      responses:
+        "200":
+          description: The rule book assignment of the character
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/CharacterRuleBookResponse"
+        "400":
+          description: Invalid character id
+        "404":
+          description: No rule book assigned to this character
+    put:
+      tags:
+      - character-rule-book
+      summary: Assign a rule book to a character
+      operationId: setCharacterRuleBookForCharacter
+      parameters:
+      - name: characterId
+        in: path
+        description: Id of the character
+        required: true
+        schema:
+          type: integer
+          format: int64
+      requestBody:
+        description: Rule book and ledger bindings to assign
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/SetCharacterRuleBookRequest"
+        required: true
+      responses:
+        "200":
+          description: The rule book assignment of the character
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/CharacterRuleBookResponse"
+        "400":
+          description: "The referenced rule book or a bound ledger does not exist,\
+            \ or a ledger binding is missing"
+  /rule-books:
+    get:
+      tags:
+      - rule-book
+      summary: Find all rule books
+      operationId: findAllRuleBooks
+      responses:
+        "200":
+          description: All rule books
+          content:
+            '*/*':
+              schema:
+                type: array
+                items:
+                  $ref: "#/components/schemas/RuleBookResponse"
+    post:
+      tags:
+      - rule-book
+      summary: Create a rule book
+      operationId: createRuleBook
+      requestBody:
+        description: Rule book to create
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/CreateRuleBookRequest"
+        required: true
+      responses:
+        "201":
+          description: The created rule book
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/RuleBookResponse"
+        "400":
+          description: Invalid request (e.g. blank name)
+  /process-activities:
+    post:
+      tags:
+      - processing
+      summary: Process new activities for all characters with a usable token
+      operationId: processNewActivities
+      responses:
+        "200":
+          description: New activities processed
+  /ledgers/main:
+    post:
+      tags:
+      - ledger
+      summary: Create a main ledger
+      operationId: createMainLedger
+      requestBody:
+        description: Main ledger to create
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/CreateMainLedgerRequest"
+        required: true
+      responses:
+        "201":
+          description: The created main ledger
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/MainLedgerResponse"
+        "400":
+          description: Invalid request (e.g. blank name)
+  /ledgers/combined:
+    post:
+      tags:
+      - ledger
+      summary: Create a combined ledger
+      operationId: createCombinedLedger
+      requestBody:
+        description: Combined ledger to create
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/CreateCombinedLedgerRequest"
+        required: true
+      responses:
+        "201":
+          description: The created combined ledger
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/CombinedLedgerResponse"
+        "400":
+          description: "Invalid request (e.g. blank name, a member ledger missing\
+            \ or already contained)"
+  /activity/fetch:
+    post:
+      tags:
+      - activity
+      summary: Fetch all new activities for all characters from the EVE API
+      operationId: fetchAllNewActivities
+      responses:
+        "200":
+          description: New activities fetched and stored
+  /activity/fetch/{characterId}:
+    post:
+      tags:
+      - activity
+      summary: Fetch new activities for a character from the EVE API
+      operationId: fetchNewActivitiesForCharacter
+      parameters:
+      - name: characterId
+        in: path
+        description: Id of the character
+        required: true
+        schema:
+          type: integer
+          format: int64
+      responses:
+        "200":
+          description: New activities fetched and stored
+        "400":
+          description: No character with this id
+  /rule-books/script-definitions:
+    get:
+      tags:
+      - rule-book
+      summary: Download the TypeScript definitions for the rule script runtime
+      operationId: getScriptDefinitions
+      responses:
+        "200":
+          description: The rule-runner.d.ts type definitions
+          content:
+            text/plain:
+              schema:
+                type: string
+  /ledgers:
+    get:
+      tags:
+      - ledger
+      summary: Find all ledgers
+      operationId: findAllLedgers
+      responses:
+        "200":
+          description: All ledgers
+          content:
+            '*/*':
+              schema:
+                type: array
+                items:
+                  $ref: "#/components/schemas/LedgerResponse"
+  /ledgers/{ledgerId}:
+    get:
+      tags:
+      - ledger
+      summary: Find a ledger by its id
+      operationId: findLedgerById
+      parameters:
+      - name: ledgerId
+        in: path
+        description: Id of the ledger
+        required: true
+        schema:
+          type: string
+          format: uuid
+      responses:
+        "200":
+          description: The ledger
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/LedgerResponse"
+        "400":
+          description: The ledger cannot be exposed (system ledger)
+        "404":
+          description: No ledger with this id
+  /ledgers/{ledgerId}/transactions:
+    get:
+      tags:
+      - transaction
+      summary: Find all transactions in a ledger
+      operationId: finAllTransactionsInLedger
+      parameters:
+      - name: ledgerId
+        in: path
+        description: Id of the ledger
+        required: true
+        schema:
+          type: string
+          format: uuid
+      responses:
+        "200":
+          description: All transactions in the ledger
+          content:
+            '*/*':
+              schema:
+                type: array
+                items:
+                  $ref: "#/components/schemas/TransactionResponse"
+        "404":
+          description: No ledger with this id
+  /ledgers/{ledgerId}/balance:
+    get:
+      tags:
+      - ledger
+      summary: Find the balance of a ledger
+      operationId: findBalanceByLedgerId
+      parameters:
+      - name: ledgerId
+        in: path
+        description: Id of the ledger
+        required: true
+        schema:
+          type: string
+          format: uuid
+      responses:
+        "200":
+          description: The balance of the ledger
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/BalanceResponse"
+        "404":
+          description: No ledger with this id
+  /characters:
+    get:
+      tags:
+      - character
+      summary: Find all characters with a usable token
+      operationId: findAllCharacters
+      responses:
+        "200":
+          description: All characters with a usable token
+          content:
+            '*/*':
+              schema:
+                type: array
+                items:
+                  $ref: "#/components/schemas/CharacterResponse"
+  /acquisitions:
+    get:
+      tags:
+      - acquisition
+      summary: Find all acquisitions that still have remaining stock
+      operationId: findAllAcquisitions
+      responses:
+        "200":
+          description: The acquisitions with remaining stock
+          content:
+            '*/*':
+              schema:
+                type: array
+                items:
+                  $ref: "#/components/schemas/AcquisitionResponse"
+components:
+  schemas:
+    UpdateRuleBookRequest:
+      type: object
+      properties:
+        name:
+          type: string
+        usedForAcquisitions:
+          type: boolean
+        ledgerRefs:
+          type: array
+          items:
+            type: string
+            pattern: "[a-z][a-zA-Z0-9]*"
+        script:
+          type: string
+      required:
+      - ledgerRefs
+      - name
+      - script
+      - usedForAcquisitions
+    RuleBookResponse:
+      type: object
+      properties:
+        ruleBookId:
+          type: string
+          format: uuid
+        name:
+          type: string
+        usedForAcquisitions:
+          type: boolean
+        ledgerRefs:
+          type: array
+          items:
+            type: string
+            pattern: "[a-z][a-zA-Z0-9]*"
+        script:
+          type: string
+      required:
+      - ledgerRefs
+      - name
+      - ruleBookId
+      - script
+      - usedForAcquisitions
+    UpdateMainLedgerRequest:
+      type: object
+      properties:
+        name:
+          type: string
+      required:
+      - name
+    MainLedgerResponse:
+      allOf:
+      - $ref: "#/components/schemas/LedgerResponse"
+      - type: object
+        properties:
+          ledgerId:
+            type: string
+            format: uuid
+          name:
+            type: string
+          balance:
+            type: number
+      required:
+      - balance
+      - ledgerId
+      - name
+    UpdateCombinedLedgerRequest:
+      type: object
+      properties:
+        name:
+          type: string
+        memberLedgerIds:
+          type: array
+          items:
+            type: string
+            format: uuid
+      required:
+      - memberLedgerIds
+      - name
+    CombinedLedgerResponse:
+      allOf:
+      - $ref: "#/components/schemas/LedgerResponse"
+      - type: object
+        properties:
+          ledgerId:
+            type: string
+            format: uuid
+          name:
+            type: string
+          balance:
+            type: number
+          memberLedgerIds:
+            type: array
+            items:
+              type: string
+              format: uuid
+      required:
+      - balance
+      - ledgerId
+      - memberLedgerIds
+      - name
+    SetCharacterRuleBookRequest:
+      type: object
+      properties:
+        ruleBookId:
+          type: string
+          format: uuid
+        bindings:
+          type: object
+          additionalProperties:
+            type: string
+            format: uuid
+      required:
+      - bindings
+      - ruleBookId
+    CharacterRuleBookResponse:
+      type: object
+      properties:
+        characterId:
+          type: integer
+          format: int64
+        ruleBookId:
+          type: string
+          format: uuid
+        bindings:
+          type: object
+          additionalProperties:
+            type: string
+            format: uuid
+      required:
+      - bindings
+      - characterId
+      - ruleBookId
+    CreateRuleBookRequest:
+      type: object
+      properties:
+        name:
+          type: string
+        usedForAcquisitions:
+          type: boolean
+        ledgerRefs:
+          type: array
+          items:
+            type: string
+            pattern: "[a-z][a-zA-Z0-9]*"
+        script:
+          type: string
+      required:
+      - ledgerRefs
+      - name
+      - script
+      - usedForAcquisitions
+    CreateMainLedgerRequest:
+      type: object
+      properties:
+        name:
+          type: string
+      required:
+      - name
+    CreateCombinedLedgerRequest:
+      type: object
+      properties:
+        name:
+          type: string
+        memberLedgerIds:
+          type: array
+          items:
+            type: string
+            format: uuid
+      required:
+      - memberLedgerIds
+      - name
+    LedgerResponse:
+      discriminator:
+        propertyName: type
+        mapping:
+          MAIN: "#/components/schemas/MainLedgerResponse"
+          COMBINED: "#/components/schemas/CombinedLedgerResponse"
+      oneOf:
+      - $ref: "#/components/schemas/MainLedgerResponse"
+      - $ref: "#/components/schemas/CombinedLedgerResponse"
+      properties:
+        type:
+          type: string
+      required:
+      - type
+    IskTransferResponse:
+      allOf:
+      - $ref: "#/components/schemas/TransferResponse"
+      - type: object
+        properties:
+          fromLedgerId:
+            type: string
+            format: uuid
+          toLedgerId:
+            type: string
+            format: uuid
+          amount:
+            type: number
+      required:
+      - amount
+      - fromLedgerId
+      - toLedgerId
+    ItemTransferResponse:
+      allOf:
+      - $ref: "#/components/schemas/TransferResponse"
+      - type: object
+        properties:
+          fromLedgerId:
+            type: string
+            format: uuid
+          toLedgerId:
+            type: string
+            format: uuid
+          marketTypeId:
+            type: integer
+            format: int64
+          quantity:
+            type: integer
+            format: int64
+      required:
+      - fromLedgerId
+      - marketTypeId
+      - quantity
+      - toLedgerId
+    TransactionResponse:
+      type: object
+      properties:
+        transactionId:
+          type: string
+          format: uuid
+        characterId:
+          type: integer
+          format: int64
+        datetime:
+          type: string
+          format: date-time
+        description:
+          type: string
+        transfers:
+          type: array
+          items:
+            $ref: "#/components/schemas/TransferResponse"
+      required:
+      - characterId
+      - datetime
+      - description
+      - transactionId
+      - transfers
+    TransferResponse:
+      discriminator:
+        propertyName: type
+        mapping:
+          ISK: "#/components/schemas/IskTransferResponse"
+          ITEM: "#/components/schemas/ItemTransferResponse"
+      oneOf:
+      - $ref: "#/components/schemas/IskTransferResponse"
+      - $ref: "#/components/schemas/ItemTransferResponse"
+      properties:
+        type:
+          type: string
+      required:
+      - type
+    BalanceResponse:
+      type: object
+      properties:
+        iskBalance:
+          type: number
+        itemBalances:
+          type: array
+          items:
+            $ref: "#/components/schemas/ItemBalanceResponse"
+      required:
+      - iskBalance
+      - itemBalances
+    ItemBalanceResponse:
+      type: object
+      properties:
+        typeId:
+          type: integer
+          format: int64
+        quantity:
+          type: integer
+          format: int64
+      required:
+      - quantity
+      - typeId
+    CharacterResponse:
+      type: object
+      properties:
+        characterId:
+          type: integer
+          format: int64
+        name:
+          type: string
+      required:
+      - characterId
+      - name
+    AcquisitionResponse:
+      type: object
+      properties:
+        acquisitionId:
+          type: string
+          format: uuid
+        characterId:
+          type: integer
+          format: int64
+        marketTypeId:
+          type: integer
+          format: int64
+        source:
+          type: string
+          enum:
+          - BOUGHT
+          - MANUAL
+        datetime:
+          type: string
+          format: date-time
+        quantity:
+          type: integer
+          format: int64
+        remaining:
+          type: integer
+          format: int64
+        unitCost:
+          type: number
+      required:
+      - acquisitionId
+      - characterId
+      - datetime
+      - marketTypeId
+      - quantity
+      - remaining
+      - source
+      - unitCost
@@ -11,28 +11,30 @@
  },
  "dependencies": {
    "@heroicons/vue": "^2.0.18",
-    "@vueuse/components": "^10.5.0",
-    "@vueuse/core": "^10.2.1",
-    "@vueuse/integrations": "^10.2.1",
+    "@vueuse/components": "^14.3.0",
+    "@vueuse/core": "^14.3.0",
+    "@vueuse/integrations": "^14.3.0",
+    "@vueuse/router": "^14.3.0",
    "axios": "^1.4.0",
    "axios-rate-limit": "^1.3.1",
+    "gemory": "file:",
    "loglevel": "^1.8.1",
    "loglevel-plugin-prefix": "^0.8.4",
-    "oidc-client-ts": "^3.0.1",
-    "pinia": "^2.1.6",
+    "monaco-editor": "^0.55.1",
+    "pinia": "^3.0.4",
+    "sortablejs": "^1.15.7",
    "vue": "^3.3.4",
-    "vue-router": "^4.2.4"
+    "vue-router": "^5.0.7"
  },
  "devDependencies": {
-    "@types/node": "^20.4.5",
-    "@vitejs/plugin-vue": "^5.0.4",
-    "autoprefixer": "^10.4.14",
-    "postcss": "^8.4.27",
-    "tailwindcss": "^3.3.3",
-    "typescript": "^5.0.2",
-    "vite": "^5.2.11",
-    "vite-plugin-runtime-env": "^0.1.1",
-    "vitest": "^1.6.0",
-    "vue-tsc": "^2.0.18"
+    "@tailwindcss/vite": "^4.3.0",
+    "@types/node": "^25.8.0",
+    "@vitejs/plugin-vue": "^6.0.7",
+    "tailwindcss": "^4.3.0",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.13",
+    "vite-plugin-runtime-env": "^1.0.0",
+    "vitest": "^4.1.6",
+    "vue-tsc": "^3.2.9"
  }
 }
@@ -1,8 +0,0 @@
-export default {
-  plugins: {
-    'postcss-import': {},
-    'tailwindcss/nesting': {},
-    tailwindcss: {},
-    autoprefixer: {},
-  },
-}
@@ -1,14 +1,14 @@
 <script setup lang="ts">
-import { useAuthStore } from '@/auth';
-import { computed } from 'vue';
-import { RouterView, useRoute } from 'vue-router';
-import { Sidebar } from './sidebar';
+import {computed} from 'vue';
+import {RouterView, useRoute} from 'vue-router';
+import {Sidebar} from './sidebar';
+import {ConfirmModal} from '@/confirm';
+import {routeNames} from '@/routes';

 const route = useRoute();
-const authStore = useAuthStore();

 const hideSidebar = computed(() => {
-    return !authStore.isLoggedIn || route.name === 'callback' || route.name === 'about';
+    return route.name === routeNames.callback || route.name === routeNames.about;
 });
 </script>

@@ -22,9 +22,12 @@ const hideSidebar = computed(() => {
            <RouterView />
        </div>
    </template>
+    <ConfirmModal />
 </template>

-<style scoped lang="postcss">
+<style scoped>
+@reference "@/style.css";
+
 div.main-container {
    @apply px-4 sm:ml-64;
 }
@@ -1,49 +0,0 @@
-import log from "loglevel";
-import { Log, User, UserManager, WebStorageStateStore } from "oidc-client-ts";
-import { defineStore } from "pinia";
-import { computed, ref } from "vue";
-
-Log.setLogger(log);
-
-export const useAuthStore = defineStore('auth', () => {
-    const userManager = new UserManager({
-        authority: import.meta.env.VITE_AUTH_AUTHORITY,
-        client_id: import.meta.env.VITE_AUTH_CLIENT_ID,
-        client_secret: import.meta.env.VITE_AUTH_CLIENT_SECRET,
-        redirect_uri: import.meta.env.VITE_AUTH_REDIRECT_URI,
-        scope: import.meta.env.VITE_AUTH_SCOPE,
-        stateStore: new WebStorageStateStore({ store: window.localStorage }),
-        userStore: new WebStorageStateStore({ store: window.localStorage })
-    });
-
-    const user = ref<User>();
-    const isLoggedIn = computed(() => !!user.value);
-    const accessToken = computed(() => user.value?.access_token);
-    const username = computed(() => user.value?.profile.name ?? "");
-    const userId = computed(() => user.value?.profile.sub ?? "");
-
-    const redirect = async () => {
-        await userManager.signinRedirect();
-        log.info("Redirecting to login page");
-    }
-    const login = async () => {
-        await userManager.signinCallback();
-        log.debug("Logged in");
-    }
-    const logout = async () => {
-        await userManager.signoutRedirect();
-        log.debug("Logged out");
-    }
-
-    const setUser = (u?: User | null) => {
-        if (u) {
-            user.value = u;
-            log.debug("User loaded", u.profile.name);
-        } else {
-            user.value = undefined;
-        }
-    }
-    userManager.events.addUserLoaded(setUser);
-    userManager.getUser().then(setUser);
-    return { redirect, login, logout, isLoggedIn, accessToken, username, userId };
-});
@@ -0,0 +1,20 @@
+<script setup lang="ts">
+
+import {Character} from "./chartacters.ts";
+
+interface Props {
+  character: Character;
+  size?: number;
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  size: 32
+})
+</script>
+
+<template>
+  <div class="flex">
+    <img class="me-2" :src="`https://images.evetech.net/characters/${character.characterId}/portrait?size=${size}`" />
+    <span>{{ character.name }}</span>
+  </div>
+</template>
@@ -0,0 +1,28 @@
+import {activityApi, characterApi} from "@/mammon";
+import {defineStore} from "pinia";
+import {ref} from "vue";
+import {CharacterResponse} from "@/generated/mammon";
+
+export type Character = CharacterResponse
+
+export const useCharactersStore = defineStore('characters', () => {
+    const characters = ref<Character[]>([]);
+
+    const findById = async (characterId: number): Promise<Character | undefined> => {
+        let character = characters.value.find(c => c.characterId === characterId);
+
+        if (!character) {
+            await refresh(); // TODO call api instead of refresh
+            character = characters.value.find(c => c.characterId === characterId);
+        }
+        return character;
+    }
+
+    const reloadActivities = (characterId: number): Promise<void> => activityApi.fetchNewActivitiesForCharacter(characterId) as Promise<void>;
+
+    const refresh = () => characterApi.findAllCharacters().then(response => characters.value = response.data);
+
+    refresh();
+
+    return {characters, findById, reloadActivities, refresh};
+})
@@ -0,0 +1,3 @@
+export * from './chartacters.ts'
+
+export {default as CharacterLabel} from './CharacterLabel.vue';
@@ -1,59 +1,96 @@
 <script setup lang="ts">
-import { ChevronDownIcon, ChevronUpIcon } from '@heroicons/vue/24/outline';
-import { vOnClickOutside } from '@vueuse/components';
-import { useEventListener } from '@vueuse/core';
-import { ref } from 'vue';
+import {ChevronDownIcon, ChevronUpIcon} from '@heroicons/vue/24/outline';
+import {vOnClickOutside} from '@vueuse/components';
+import {useElementBounding, useEventListener} from '@vueuse/core';
+import {computed, ref} from 'vue';
+
+interface Props {
+  inline?: boolean;
+  autoClose?: boolean;
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  inline: false,
+  autoClose: true
+})

 const isOpen = ref(false);
+const root = ref<HTMLElement | null>(null);
+const floating = ref<HTMLElement | null>(null);
+
+const { left, bottom, width } = useElementBounding(root);
+
+const floatingStyle = computed(() => ({
+  left: `${left.value}px`,
+  top: `${bottom.value}px`,
+  minWidth: `${width.value}px`,
+}));
+
+const doAutoClose = () => {
+  if (props.autoClose) {
+    isOpen.value = false;
+  }
+}

 useEventListener('keyup', e => {
    if (e.key === 'Escape') {
-        isOpen.value = false;
+      doAutoClose();
    }
 });
 </script>

 <template>
-    <div class="dropdown" :class="{'dropdown-open': isOpen, 'dropdown-close': !isOpen}" v-on-click-outside="() => isOpen = false">
-        <button @click="isOpen = !isOpen">
-            <slot name="button" />
-            <Transition name="flip">
+    <div ref="root" class="dropdown" :class="{'dropdown-open': isOpen, 'dropdown-close': !isOpen}" v-on-click-outside="[doAutoClose, { ignore: [floating] }]">
+        <button @click="isOpen = !isOpen" class="cursor-pointer">
+            <Transition
+                enter-active-class="transition-transform"
+                enter-from-class="rotate-180"
+                leave-active-class="hidden"
+                leave-to-class="rotate-180">
                <ChevronDownIcon v-if="!isOpen" class="chevron" />
                <ChevronUpIcon v-else class="chevron" />
            </Transition>
+          <slot name="button" />
        </button>

-        <Transition name="fade">
-            <div v-if="isOpen" class="relative">
-                <div class="z-10 divide-y rounded-b-md absolute">
-                    <slot />
-                </div>
+        <Transition
+            enter-active-class="transition-opacity"
+            enter-from-class="opacity-0"
+            leave-from-class="transition-opacity"
+            leave-to-class="opacity-0">
+            <div v-if="inline && isOpen">
+              <slot />
            </div>
        </Transition>
+      
+        <Teleport to="body">
+          <Transition
+              enter-active-class="transition-opacity"
+              enter-from-class="opacity-0"
+              leave-from-class="transition-opacity"
+              leave-to-class="opacity-0">
+            <div v-if="!inline && isOpen" ref="floating" class="dropdown-floating" :style="floatingStyle">
+              <div class="divide-y rounded-b-md">
+                <slot />
+              </div>
+            </div>
+          </Transition>
+        </Teleport>
    </div>
 </template>

-<style scoped lang="postcss">
+<style scoped>
+@reference "@/style.css";
+
 .chevron {
-    @apply w-4 h-4 ms-1;
+    @apply w-4 h-4 me-1;
 }

-.fade-enter-from, .fade-leave-to {
-  opacity: 0;
+.dropdown-floating {
+    @apply fixed z-10;
 }

-.fade-enter-active, .fade-leave-active {
-    @apply transition-opacity;
-}
-
-.flip-enter-from, .flip-leave-to {
-  transform: rotate(180deg);
-}
-
-.flip-enter-active {
-  @apply transition-transform;
-}
-.flip-leave-active {
-   display: none; 
+.dropdown-floating > div {
+    @apply bg-slate-800 rounded-b-md shadow-lg;
 }
 </style>
@@ -1,7 +1,7 @@
 <script setup lang="ts">
-import { vOnClickOutside } from '@vueuse/components';
-import { useEventListener } from '@vueuse/core';
-import { watch } from 'vue';
+import {vOnClickOutside} from '@vueuse/components';
+import {useEventListener} from '@vueuse/core';
+import {watch} from 'vue';

 const open = defineModel('open', { default: false });

@@ -34,7 +34,8 @@ useEventListener('keyup', e => {
    </Transition>
 </template>

-<style scoped lang="postcss">
+<style scoped>
+@reference "@/style.css";
 .fade-enter-from, .fade-leave-to {
    @apply opacity-0;
 }
@@ -0,0 +1,19 @@
+<script setup lang="ts">
+import { computed } from 'vue';
+
+
+interface Props {
+    value: number;
+    total: number;
+}
+
+const props = defineProps<Props>();
+
+const percentage = computed(() => (props.value / props.total) * 100);
+</script>
+
+<template>
+    <div class="w-full bg-gray-600 rounded-full h-2.5">
+        <div class="bg-emerald-600 h-2.5 rounded-full" :style="{ width: percentage + '%'}" />
+    </div>
+</template>
@@ -0,0 +1,71 @@
+<script setup lang="ts" generic="T">
+import {vOnClickOutside} from '@vueuse/components';
+import {useVirtualList} from '@vueuse/core';
+import {computed, ref} from 'vue';
+
+interface Props {
+  items: T[];
+  itemHeight?: number;
+}
+
+const props = withDefaults(defineProps<Props>(), {
+    itemHeight: 24,
+});
+
+const modelValue = defineModel<T>();
+
+const isOpen = ref(false);
+const currentIndex = ref(-1);
+const {list, scrollTo, containerProps, wrapperProps} = useVirtualList(computed(() => props.items), {
+    itemHeight: () => props.itemHeight,
+    overscan: 3,
+});
+
+const moveDown = () => {
+    currentIndex.value = currentIndex.value >= props.items.length - 1 ? 0 : currentIndex.value + 1;
+    scrollTo(currentIndex.value);
+};
+const moveUp = () => {
+    currentIndex.value = currentIndex.value <= 0 ? props.items.length - 1 : currentIndex.value - 1;
+    scrollTo(currentIndex.value);
+};
+const select = (item?: T) => {
+    modelValue.value = item;
+    currentIndex.value = -1;
+    isOpen.value = false;
+};
+const submit = () => {
+    if (currentIndex.value >= 0 && currentIndex.value < props.items.length) {
+        select(props.items[currentIndex.value]);
+    } else if (modelValue.value === undefined && props.items.length > 0) {
+        select(props.items[0]);
+    }
+};
+</script>
+
+<template>
+    <div @click="isOpen = true" v-on-click-outside="() => isOpen = false">
+      <div class="fake-input" @keyup.enter="submit" @keyup.down="moveDown" @keyup.up="moveUp">
+        <slot name="input" :value="modelValue" />
+      </div>
+        <div v-if="isOpen && items.length" class="z-20 absolute">
+            <div v-bind="containerProps" class="rounded-b" style="height: 300px">
+                <div v-bind="wrapperProps">
+                    <div v-for="s in list" :key="s.index"
+                        class="hover:bg-slate-700 cursor-pointer"
+                        :class="s.index === currentIndex ? 'bg-emerald-500' : 'bg-slate-500'"
+                        @click.stop="select(s.data)">
+                        <slot name="item" :item="s.data" />
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+</template>
+
+<style scoped>
+@reference "@/style.css";
+.fake-input {
+    @apply flex border bg-slate-500 rounded px-1 py-0.5;
+}
+</style>
@@ -10,8 +10,10 @@ const modelValue = defineModel({ default: false });
    </label>
 </template>

-<style scoped lang="postcss">
-    input:checked ~ span:last-child {
-        --tw-translate-x: 1.25rem;
-    }
+<style scoped>
+@reference "@/style.css";
+
+input:checked ~ span:last-child {
+  transform: translateX(1.25rem);
+}
 </style>
@@ -2,6 +2,8 @@ export { default as ClipboardButton } from './ClipboardButton.vue';
 export { default as Dropdown } from './Dropdown.vue';
 export { default as LoadingSpinner } from './LoadingSpinner.vue';
 export { default as Modal } from './Modal.vue';
+export { default as ProgressBar } from './ProgressBar.vue';
+export { default as SelectInput } from './SelectInput.vue';
 export { default as SliderCheckbox } from './SliderCheckbox.vue';
 export { default as Tooltip } from './tooltip/Tooltip.vue';

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { HeaderComponent, SortDirection } from './sort';
+import {HeaderComponent, SortDirection} from './sort';

 interface Props {
    currentSortKey: string | null;
@@ -32,7 +32,8 @@ const emit = defineEmits<Emit>();
    </component>
 </template>

-<style scoped lang="postcss">
+<style scoped>
+@reference "@/style.css";
 .sort-header {
    @apply relative h-8 pe-3;
 }
@@ -1,12 +1,13 @@
 <script setup lang="ts">
-import { useElementBounding, useVirtualList } from '@vueuse/core';
-import { computed, ref } from 'vue';
+import {useElementBounding, useVirtualList} from '@vueuse/core';
+import {computed, ref} from 'vue';

 interface Props {
    list?: any[];
    itemHeight: number;
    headerHeight?: number;
-    bottom?: string;
+    footerHeight?: number;
+    bottom?: string; // FIXME: use css variable
 }


@@ -35,11 +36,16 @@ const computedHeaderHeight = computed(() => {
    
    return h + 'px';
 })
+const computedFooterHeight = computed(() => {
+    const h = props.footerHeight ?? 0;
+    
+    return h + 'px';
+})
 const computedWrapperProps = computed(() => ({
    ...wrapperProps.value,
    style: {
        ...wrapperProps.value.style,
-        height: `calc(${wrapperProps.value.style.height} + ${computedHeaderHeight.value} + 1px)`
+        height: `calc(${wrapperProps.value.style.height} + ${computedHeaderHeight.value} + ${computedFooterHeight.value} + 1px)`
    }
 }))
 const itemHeightStyle = computed(() => {
@@ -61,24 +67,32 @@ const itemHeightStyle = computed(() => {
    <slot v-else name="empty" />
 </template>

-<style scoped lang="postcss">
+<style scoped>
+@reference "@/style.css";
+
 div.table-container {
-    @apply bg-slate-600;
-    max-height: calc(100vh - v-bind(ypx));
-    :deep(>div) {
-        @apply bg-slate-800;
-        >table {
-            >thead {
-                @apply sticky z-10;
-                top: -1px;
-            }
-            >*>tr, >*>tr>td {
-                height: v-bind(itemHeightStyle);
-            }
+  @apply bg-slate-600;
+  max-height: calc(100vh - v-bind(ypx));
+
+  &::-webkit-scrollbar-track {
+    margin-top: v-bind(computedHeaderHeight);
+    margin-bottom: v-bind(computedFooterHeight);
+  }
+}
+div.table-container:deep(>div) {
+    @apply bg-slate-800;
+    >table {
+        >thead {
+            @apply sticky z-10;
+            top: -1px;
+        }
+        >tfoot {
+            @apply bg-slate-600 sticky z-10;
+            bottom: -1px;
+        }
+        >*>tr, >*>tr>td {
+            height: v-bind(itemHeightStyle);
        }
-    }
-    &::-webkit-scrollbar-track {
-        margin-top: v-bind(computedHeaderHeight);
    }
 }
 </style>
@@ -1,8 +1,8 @@
 <script setup lang="ts">
-import { vElementHover } from '@vueuse/components';
-import { useElementBounding } from '@vueuse/core';
-import { computed, ref } from 'vue';
-import { useSharedWindowSize } from './tooltip';
+import {vElementHover} from '@vueuse/components';
+import {useElementBounding} from '@vueuse/core';
+import {computed, ref} from 'vue';
+import {useSharedWindowSize} from './tooltip';

 const open = defineModel('open', { default: false });

@@ -25,7 +25,7 @@ const positions = computed(() => {
 </script>

 <template>
-    <div ref="mainDiv" clas="flex flex-col items-center justify-center" :class="{
+    <div ref="mainDiv" class="flex flex-col items-center justify-center" :class="{
        'open': open,
        'tooltip-top': positions.includes('top'),
        'tooltip-bottom': positions.includes('bottom'),
@@ -0,0 +1,45 @@
+<script setup lang="ts">
+import {computed} from "vue";
+import {storeToRefs} from "pinia";
+import {Modal} from "@/components";
+import {useConfirmStore} from "./useConfirm";
+
+const confirmStore = useConfirmStore();
+const {open, options} = storeToRefs(confirmStore);
+const {accept, cancel} = confirmStore;
+
+const modalOpen = computed({
+  get: () => open.value,
+  set: value => {
+    if (!value) {
+      cancel();
+    }
+  },
+});
+</script>
+
+<template>
+  <Modal v-model:open="modalOpen">
+    <div class="bg-slate-800 rounded pb-4 w-96">
+      <span class="m-2">{{ options.title ?? "Confirm" }}</span>
+      <hr />
+      <div class="m-4">{{ options.message }}</div>
+      <div class="flex justify-end">
+        <button class="me-2" @click="cancel">{{ options.cancelLabel ?? "Cancel" }}</button>
+        <button class="confirm me-4" :class="options.danger ? 'danger' : ''" @click="accept">{{ options.confirmLabel ?? "Confirm" }}</button>
+      </div>
+    </div>
+  </Modal>
+</template>
+
+<style scoped>
+@reference "@/style.css";
+
+button.confirm {
+  @apply border-emerald-500 bg-emerald-500 hover:bg-emerald-600;
+
+  &.danger {
+    @apply border-amber-900 bg-amber-900 hover:bg-amber-800;
+  }
+}
+</style>
@@ -0,0 +1,3 @@
+export { default as ConfirmModal } from './ConfirmModal.vue';
+export { confirm, useConfirmStore } from './useConfirm';
+export type { ConfirmOptions } from './useConfirm';
@@ -0,0 +1,37 @@
+import {defineStore} from "pinia";
+import {ref} from "vue";
+
+export interface ConfirmOptions {
+    title?: string;
+    message: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    danger?: boolean;
+}
+
+export const useConfirmStore = defineStore('confirm', () => {
+    const open = ref(false);
+    const options = ref<ConfirmOptions>({message: ""});
+    let resolver: ((value: boolean) => void) | undefined;
+
+    const settle = (value: boolean) => {
+        open.value = false;
+        resolver?.(value);
+        resolver = undefined;
+    };
+
+    const confirm = (opts: ConfirmOptions | string): Promise<boolean> => {
+        options.value = typeof opts === "string" ? {message: opts} : opts;
+        open.value = true;
+        return new Promise<boolean>(resolve => {
+            resolver = resolve;
+        });
+    };
+
+    const accept = () => settle(true);
+    const cancel = () => settle(false);
+
+    return {open, options, confirm, accept, cancel};
+});
+
+export const confirm = (opts: ConfirmOptions | string): Promise<boolean> => useConfirmStore().confirm(opts);
@@ -11,7 +11,6 @@ export const percentFormater = new Intl.NumberFormat("en-US", {
    maximumFractionDigits: 0
 });

-
 const timeFormat = new Intl.NumberFormat("en-US", {
    minimumFractionDigits: 0,
    maximumFractionDigits: 0,
@@ -0,0 +1,62 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+import type { Configuration } from './configuration';
+// Some imports not used depending on template conditions
+// @ts-ignore
+import type { AxiosPromise, AxiosInstance, RawAxiosRequestConfig } from 'axios';
+import globalAxios from 'axios';
+
+export const BASE_PATH = "http://localhost:8080".replace(/\/+$/, "");
+
+export const COLLECTION_FORMATS = {
+    csv: ",",
+    ssv: " ",
+    tsv: "\t",
+    pipes: "|",
+};
+
+export interface RequestArgs {
+    url: string;
+    options: RawAxiosRequestConfig;
+}
+
+export class BaseAPI {
+    protected configuration: Configuration | undefined;
+
+    constructor(configuration?: Configuration, protected basePath: string = BASE_PATH, protected axios: AxiosInstance = globalAxios) {
+        if (configuration) {
+            this.configuration = configuration;
+            this.basePath = configuration.basePath ?? basePath;
+        }
+    }
+};
+
+export class RequiredError extends Error {
+    constructor(public field: string, msg?: string) {
+        super(msg);
+        this.name = "RequiredError"
+    }
+}
+
+interface ServerMap {
+    [key: string]: {
+        url: string,
+        description: string,
+    }[];
+}
+
+export const operationServerMap: ServerMap = {
+}
@@ -0,0 +1,127 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import type { Configuration } from "./configuration";
+import type { RequestArgs } from "./base";
+import type { AxiosInstance, AxiosResponse } from 'axios';
+import { RequiredError } from "./base";
+
+export const DUMMY_BASE_URL = 'https://example.com'
+
+/**
+ *
+ * @throws {RequiredError}
+ */
+export const assertParamExists = function (functionName: string, paramName: string, paramValue: unknown) {
+    if (paramValue === null || paramValue === undefined) {
+        throw new RequiredError(paramName, `Required parameter ${paramName} was null or undefined when calling ${functionName}.`);
+    }
+}
+
+export const setApiKeyToObject = async function (object: any, keyParamName: string, configuration?: Configuration) {
+    if (configuration && configuration.apiKey) {
+        const localVarApiKeyValue = typeof configuration.apiKey === 'function'
+            ? await configuration.apiKey(keyParamName)
+            : await configuration.apiKey;
+        object[keyParamName] = localVarApiKeyValue;
+    }
+}
+
+export const setBasicAuthToObject = function (object: any, configuration?: Configuration) {
+    if (configuration && (configuration.username || configuration.password)) {
+        object["auth"] = { username: configuration.username, password: configuration.password };
+    }
+}
+
+export const setBearerAuthToObject = async function (object: any, configuration?: Configuration) {
+    if (configuration && configuration.accessToken) {
+        const accessToken = typeof configuration.accessToken === 'function'
+            ? await configuration.accessToken()
+            : await configuration.accessToken;
+        object["Authorization"] = "Bearer " + accessToken;
+    }
+}
+
+export const setOAuthToObject = async function (object: any, name: string, scopes: string[], configuration?: Configuration) {
+    if (configuration && configuration.accessToken) {
+        const localVarAccessTokenValue = typeof configuration.accessToken === 'function'
+            ? await configuration.accessToken(name, scopes)
+            : await configuration.accessToken;
+        object["Authorization"] = "Bearer " + localVarAccessTokenValue;
+    }
+}
+
+
+function setFlattenedQueryParams(urlSearchParams: URLSearchParams, parameter: any, key: string = ""): void {
+    if (parameter == null) return;
+    if (typeof parameter === "object") {
+        if (Array.isArray(parameter) || parameter instanceof Set) {
+            (parameter as any[]).forEach(item => setFlattenedQueryParams(urlSearchParams, item, key));
+        }
+        else {
+            Object.keys(parameter).forEach(currentKey =>
+                setFlattenedQueryParams(urlSearchParams, parameter[currentKey], `${key}${key !== '' ? '.' : ''}${currentKey}`)
+            );
+        }
+    }
+    else {
+        if (urlSearchParams.has(key)) {
+            urlSearchParams.append(key, parameter);
+        }
+        else {
+            urlSearchParams.set(key, parameter);
+        }
+    }
+}
+
+export const setSearchParams = function (url: URL, ...objects: any[]) {
+    const searchParams = new URLSearchParams(url.search);
+    setFlattenedQueryParams(searchParams, objects);
+    url.search = searchParams.toString();
+}
+
+/**
+ * JSON serialization helper function which replaces instances of unserializable types with serializable ones.
+ * This function will run for every key-value pair encountered by JSON.stringify while traversing an object.
+ * Converting a set to a string will return an empty object, so an intermediate conversion to an array is required.
+ */
+// @ts-ignore
+export const replaceWithSerializableTypeIfNeeded = function(key: string, value: any) {
+    if (value instanceof Set) {
+        return Array.from(value);
+    } else {
+        return value;
+    }
+}
+
+export const serializeDataIfNeeded = function (value: any, requestOptions: any, configuration?: Configuration) {
+    const nonString = typeof value !== 'string';
+    const needsSerialization = nonString && configuration && configuration.isJsonMime
+        ? configuration.isJsonMime(requestOptions.headers['Content-Type'])
+        : nonString;
+    return needsSerialization
+        ? JSON.stringify(value !== undefined ? value : {}, replaceWithSerializableTypeIfNeeded)
+        : (value || "");
+}
+
+export const toPathString = function (url: URL) {
+    return url.pathname + url.search + url.hash
+}
+
+export const createRequestFunction = function (axiosArgs: RequestArgs, globalAxios: AxiosInstance, BASE_PATH: string, configuration?: Configuration) {
+    return <T = unknown, R = AxiosResponse<T>>(axios: AxiosInstance = globalAxios, basePath: string = BASE_PATH) => {
+        const axiosRequestArgs = {...axiosArgs.options, url: (axios.defaults.baseURL ? '' : configuration?.basePath ?? basePath) + axiosArgs.url};
+        return axios.request<T, R>(axiosRequestArgs);
+    };
+}
@@ -0,0 +1,121 @@
+/* tslint:disable */
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+interface AWSv4Configuration {
+  options?: {
+    region?: string
+    service?: string
+  }
+  credentials?: {
+    accessKeyId?: string
+    secretAccessKey?: string,
+    sessionToken?: string
+  }
+}
+
+export interface ConfigurationParameters {
+    apiKey?: string | Promise<string> | ((name: string) => string) | ((name: string) => Promise<string>);
+    username?: string;
+    password?: string;
+    accessToken?: string | Promise<string> | ((name?: string, scopes?: string[]) => string) | ((name?: string, scopes?: string[]) => Promise<string>);
+    awsv4?: AWSv4Configuration;
+    basePath?: string;
+    serverIndex?: number;
+    baseOptions?: any;
+    formDataCtor?: new () => any;
+}
+
+export class Configuration {
+    /**
+     * parameter for apiKey security
+     * @param name security name
+     */
+    apiKey?: string | Promise<string> | ((name: string) => string) | ((name: string) => Promise<string>);
+    /**
+     * parameter for basic security
+     */
+    username?: string;
+    /**
+     * parameter for basic security
+     */
+    password?: string;
+    /**
+     * parameter for oauth2 security
+     * @param name security name
+     * @param scopes oauth2 scope
+     */
+    accessToken?: string | Promise<string> | ((name?: string, scopes?: string[]) => string) | ((name?: string, scopes?: string[]) => Promise<string>);
+    /**
+     * parameter for aws4 signature security
+     * @param {Object} AWS4Signature - AWS4 Signature security
+     * @param {string} options.region - aws region
+     * @param {string} options.service - name of the service.
+     * @param {string} credentials.accessKeyId - aws access key id
+     * @param {string} credentials.secretAccessKey - aws access key
+     * @param {string} credentials.sessionToken - aws session token
+     * @memberof Configuration
+     */
+    awsv4?: AWSv4Configuration;
+    /**
+     * override base path
+     */
+    basePath?: string;
+    /**
+     * override server index
+     */
+    serverIndex?: number;
+    /**
+     * base options for axios calls
+     */
+    baseOptions?: any;
+    /**
+     * The FormData constructor that will be used to create multipart form data
+     * requests. You can inject this here so that execution environments that
+     * do not support the FormData class can still run the generated client.
+     *
+     * @type {new () => FormData}
+     */
+    formDataCtor?: new () => any;
+
+    constructor(param: ConfigurationParameters = {}) {
+        this.apiKey = param.apiKey;
+        this.username = param.username;
+        this.password = param.password;
+        this.accessToken = param.accessToken;
+        this.awsv4 = param.awsv4;
+        this.basePath = param.basePath;
+        this.serverIndex = param.serverIndex;
+        this.baseOptions = {
+            ...param.baseOptions,
+            headers: {
+                ...param.baseOptions?.headers,
+            },
+        };
+        this.formDataCtor = param.formDataCtor;
+    }
+
+    /**
+     * Check if the given MIME is a JSON MIME.
+     * JSON MIME examples:
+     *   application/json
+     *   application/json; charset=UTF8
+     *   APPLICATION/JSON
+     *   application/vnd.company+json
+     * @param mime - MIME (Multipurpose Internet Mail Extensions)
+     * @return True if the given MIME is JSON, false otherwise.
+     */
+    public isJsonMime(mime: string): boolean {
+        const jsonMime: RegExp = /^(application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(;.*)?$/i;
+        return mime !== null && jsonMime.test(mime);
+    }
+}
@@ -0,0 +1,18 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+export * from "./api";
+export * from "./configuration";
+
@@ -0,0 +1,147 @@
+<script setup lang="ts">
+
+import {computed, ref} from "vue";
+import {storeToRefs} from "pinia";
+import {isCombined, Ledger, LedgerType, LedgerTypes, useLedgersStore} from "./ledger";
+import {Modal} from "@/components";
+import LedgerLabel from "./LedgerLabel.vue";
+import {PlusIcon, TrashIcon} from '@heroicons/vue/24/outline';
+import LedgerSelect from "@/ledger/LedgerSelect.vue";
+
+interface Props {
+  ledgerId?: string;
+}
+
+const props = defineProps<Props>();
+
+const ledgersStore = useLedgersStore();
+const {ledgers} = storeToRefs(ledgersStore);
+const {findById, findAllById, createMain, createCombined, updateMain, updateCombined} = ledgersStore;
+
+const modalOpen = ref<boolean>(false);
+
+const type = ref<LedgerType>(LedgerTypes.Main);
+const name = ref("");
+const members = ref<Ledger[]>([]);
+const selectedLedger = ref<Ledger>();
+const availableLedgers = computed(() => ledgers.value
+    .filter(l => l.ledgerId !== props.ledgerId)
+    .filter(l => !members.value.includes(l)));
+
+
+const addMember = () => {
+  if (selectedLedger.value && !members.value.includes(selectedLedger.value)) {
+    members.value = [...members.value, selectedLedger.value];
+    selectedLedger.value = undefined;
+  }
+}
+
+const open = () => {
+  const ledger = isCreating.value ? undefined : findById(props.ledgerId);
+
+  if (ledger) {
+    type.value = ledger.type;
+    name.value = ledger.name;
+    members.value = isCombined(ledger) ? findAllById(ledger.memberLedgerIds) : [];
+  } else {
+    type.value = LedgerTypes.Main;
+    name.value = "";
+    members.value = [];
+  }
+  modalOpen.value = true;
+}
+
+const canSave = computed(() => name.value.trim().length > 0);
+const isCreating = computed(() => props.ledgerId === undefined || props.ledgerId.length === 0);
+const title = computed(() => {
+  if (isCreating.value) {
+    return `Creating ${type.value === LedgerTypes.Main ? 'Main' : 'Combined'} Ledger`
+  }
+  return `Updating ${name.value}`
+})
+
+const create = () => {
+  if (type.value === LedgerTypes.Main) {
+    createMain({name: name.value})
+  } else {
+    createCombined({name: name.value, memberLedgerIds: members.value.map(l => l.ledgerId)})
+  }
+}
+
+const update = () => {
+  if (type.value === LedgerTypes.Main) {
+    updateMain(props.ledgerId, {name: name.value})
+  } else {
+    updateCombined(props.ledgerId, {name: name.value, memberLedgerIds: members.value.map(l => l.ledgerId)})
+  }
+}
+
+const save = () => {
+  if (!canSave.value) {
+    return;
+  }
+
+  if (isCreating.value) {
+    create();
+  } else {
+    update();
+  }
+  modalOpen.value = false;
+}
+
+defineExpose({ open });
+</script>
+
+<template>
+  <Modal v-model:open="modalOpen">
+    <div class="bg-slate-800 rounded pb-4 w-96">
+      <span class="m-2">{{ title }}</span>
+      <hr />
+      <div class="mt-4">
+        <div v-if="!ledgerId" class="flex justify-center">
+          <div class="flex bg-slate-600 rounded-s-md p-1">
+            <button class="switch" :class="{active: type === LedgerTypes.Main}" @click="type = LedgerTypes.Main">Main</button>
+          </div>
+          <div class="switch flex bg-slate-600 rounded-e-md p-1">
+            <button class="switch" :class="{active: type === LedgerTypes.Combined}" @click="type = LedgerTypes.Combined">Combined</button>
+          </div>
+        </div>
+        <div class="m-4">
+          Name:
+          <div class="flex">
+            <input type="text" class="flex grow" v-model="name" />
+          </div>
+        </div>
+      </div>
+      <div v-if="type === LedgerTypes.Combined" class="ms-4 mb-4">
+        Member Ledgers:
+        <div v-for="ledger in members" :key="ledger.ledgerId" class="flex">
+          <LedgerLabel class="flex grow mb-2" :ledger="ledger" />
+          <div class="flex justify-end me-4 ms-2">
+            <button class="btn-icon" @click="members = members.filter(m => m !== ledger)"><TrashIcon /></button>
+          </div>
+        </div>
+        <div v-if="availableLedgers.length" class="flex">
+          <LedgerSelect v-model="selectedLedger" class="grow" :ledgers="availableLedgers" />
+          <div class="flex justify-end me-4 ms-2">
+            <button class="btn-icon" @click="addMember"><PlusIcon /></button>
+          </div>
+        </div>
+      </div>
+      <div class="flex justify-end">
+        <button class="me-4" @click="save" :disabled="!canSave">Save</button>
+      </div>
+    </div>
+  </Modal>
+</template>
+
+<style scoped>
+@reference "@/style.css";
+
+button.switch {
+  @apply flex items-center px-4 rounded-md bg-slate-600;
+  &.active {
+    @apply bg-emerald-500;
+  }
+}
+</style>
@@ -0,0 +1,31 @@
+<script setup lang="ts">
+
+import {isCombined, Ledger, systemLedger} from "@/ledger/ledger.ts";
+import {FolderOpenIcon} from '@heroicons/vue/24/outline';
+import {RouterLink} from "vue-router";
+import {routeNames} from "@/routes";
+
+interface Props {
+  ledger: Ledger;
+  link?: boolean;
+}
+
+const props = defineProps<Props>();
+</script>
+
+<template>
+  <div class="flex">
+    <FolderOpenIcon v-if="isCombined(ledger)" class="w-4 me-1" />
+    <div v-else class="w-4 me-1"/>
+    <RouterLink v-if="link" :to="{name: routeNames.viewLedger, params: {ledgerId: ledger.ledgerId}}">{{ ledger.name }}</RouterLink>
+    <span v-else :class="{'system-ledger': ledger === systemLedger}">{{ ledger.name }}</span>
+  </div>
+</template>
+
+<style scoped>
+@reference "@/style.css";
+
+.system-ledger {
+  @apply text-emerald-400;
+}
+</style>
@@ -0,0 +1,34 @@
+<script setup lang="ts">
+import {Ledger, systemLedger, useLedgersStore} from "@/ledger/ledger.ts";
+import {storeToRefs} from "pinia";
+import {computed} from "vue";
+
+interface Props {
+  ledgers?: Ledger[];
+}
+
+const props = defineProps<Props>()
+const ledger = defineModel<Ledger>();
+const {ledgers: allLedgers} = storeToRefs(useLedgersStore());
+
+const ledgersToUse = computed(() => props.ledgers || allLedgers);
+const ledgerId = computed({
+  get: () => ledger.value?.ledgerId,
+  set: value => ledger.value = ledgersToUse.value.find(l => l.ledgerId === value)
+})
+
+</script>
+
+<template>
+  <select v-model="ledgerId" :class="{'system-ledger': ledger === systemLedger}">
+    <option v-for="l in ledgersToUse" :key="l.ledgerId" :value="l.ledgerId" :class="{'system-ledger': l === systemLedger}">{{ l.name }}</option>
+  </select>
+</template>
+
+<style scoped>
+@reference "@/style.css";
+
+.system-ledger {
+  @apply text-emerald-400;
+}
+</style>
@@ -0,0 +1,5 @@
+export * from './ledger';
+
+export {default as LedgerLabel} from './LedgerLabel.vue';
+export {default as LedgerSelect} from './LedgerSelect.vue';
+export {default as EditLedgerModal} from './EditLedgerModal.vue';
@@ -0,0 +1,88 @@
+import {
+    BalanceResponse,
+    CombinedLedgerResponse,
+    CreateCombinedLedgerRequest,
+    CreateMainLedgerRequest,
+    LedgerResponse,
+    MainLedgerResponse,
+    TransactionResponse,
+    UpdateCombinedLedgerRequest,
+    UpdateMainLedgerRequest
+} from "@/generated/mammon";
+import {defineStore} from "pinia";
+import {computed, ref, triggerRef} from "vue";
+import {ledgerApi, transactionApi} from "@/mammon";
+import {useRouteParams} from "@vueuse/router";
+
+export const LedgerTypes = {
+    Main: 'MAIN',
+    Combined: 'COMBINED',
+};
+
+export type LedgerType = LedgerResponse['type'];
+export type MainLedger = MainLedgerResponse
+export type CombinedLedger = CombinedLedgerResponse
+export type Ledger = MainLedger | CombinedLedger;
+
+export const systemLedgerRef = 'system';
+export const systemLedger = {
+    type: LedgerTypes.Main,
+    ledgerId: "00000000-0000-0000-0000-000000000001",
+    name: "Eve Economy",
+    balance: 0,
+    _system: true
+} as MainLedger;
+
+export const isMain = (ledger: Ledger): ledger is MainLedger => {
+    return ledger.type === LedgerTypes.Main;
+}
+export const isCombined = (ledger: Ledger): ledger is CombinedLedger => {
+    return ledger.type === LedgerTypes.Combined;
+}
+
+export const useLedgersStore = defineStore('ledgers', () => {
+    const ledgers = ref<Ledger[]>([]);
+
+    const addLedger = (ledger: Ledger) => {
+        ledgers.value.push(ledger);
+        triggerRef(ledgers);
+        return ledger;
+    };
+
+    const replaceLedger = (ledger: Ledger) => {
+        const index = ledgers.value.findIndex(l => l.ledgerId === ledger.ledgerId);
+
+        if (index !== -1) {
+            ledgers.value[index] = ledger;
+        }
+        triggerRef(ledgers);
+        return ledger;
+    };
+
+    const findById = (ledgerId: string): Ledger | undefined => ledgers.value.find(l => l.ledgerId === ledgerId);
+    const findAllById = (ledgerIds: string[]): Ledger[] => ledgerIds.map(findById).filter((x): x is Ledger => x !== undefined)
+
+    const createMain = (ledger: CreateMainLedgerRequest) => ledgerApi.createMainLedger(ledger).then(response => addLedger(response.data as Ledger));
+    const createCombined = (ledger: CreateCombinedLedgerRequest) => ledgerApi.createCombinedLedger(ledger).then(response => addLedger(response.data as Ledger));
+    const updateMain = (ledgerId: string, ledger: UpdateMainLedgerRequest) => ledgerApi.updateMainLedger(ledgerId, ledger).then(response => replaceLedger(response.data as Ledger));
+    const updateCombined = (ledgerId: string, ledger: UpdateCombinedLedgerRequest) => ledgerApi.updateCombinedLedger(ledgerId, ledger).then(response => replaceLedger(response.data as Ledger));
+
+    const refresh = () => ledgerApi.findAllLedgers().then(response => ledgers.value = response.data as Ledger[]);
+
+    refresh();
+
+    return {ledgers, findById, findAllById, createMain, createCombined, updateMain, updateCombined, refresh};
+})
+
+const getLedgerId = (ledger: Ledger | string): string => typeof ledger == 'string' ? ledger : ledger.ledgerId;
+
+export const findAllTransactionInLeger = (ledger: Ledger | string): Promise<TransactionResponse[]> => transactionApi.finAllTransactionsInLedger(getLedgerId(ledger)).then(response => response.data)
+export const getLedgerBalance = (ledger: Ledger | string): Promise<BalanceResponse> => ledgerApi.findBalanceByLedgerId(getLedgerId(ledger)).then(response => response.data)
+
+export const useLedgerParam = () => {
+    const {findById} = useLedgersStore();
+    const ledgerId = useRouteParams<string, string>('ledgerId', '', { transform: v => typeof v === 'string' ? v : v[0]});
+    const ledger = computed(() => findById(ledgerId.value))
+
+    return {ledgerId, ledger};
+}
@@ -1,4 +1,3 @@
-import { useAuthStore } from "@/auth";
 import { createPinia } from 'pinia';
 import { createApp } from 'vue';
 import { createRouter, createWebHistory } from 'vue-router';
@@ -17,18 +16,6 @@ const router = createRouter({
 });

 app.use(pinia);
-
-const authStore = useAuthStore();
-
-router.beforeEach(async to => {
-    if (to.name === 'callback') {
-        await authStore.login();
-        return { name: 'home' };
-    } else if (!authStore.isLoggedIn) {
-        await authStore.redirect();
-    }
-});
-
 app.use(router);

 app.mount('#app');
@@ -0,0 +1 @@
+export * from './mammonService'
@@ -0,0 +1,33 @@
+import {logResource} from "@/service";
+import axios from "axios";
+import {
+    AcquisitionApi,
+    ActivityApi,
+    CharacterApi,
+    CharacterRuleBookApi,
+    LedgerApi,
+    ProcessingApi,
+    RuleBookApi,
+    TransactionApi
+} from "@/generated/mammon";
+
+export const mammonUrl = import.meta.env.VITE_MAMMON_URL;
+export const mammonAddCharacterUrl = mammonUrl + "oauth2/authorization/esi"
+
+const mammonAxiosInstance = axios.create({
+    baseURL: mammonUrl,
+    headers: {
+        'Accept': 'application/json',
+        "Content-Type": "application/json",
+    },
+})
+logResource(mammonAxiosInstance)
+
+export const ledgerApi = new LedgerApi(undefined, mammonUrl, mammonAxiosInstance);
+export const transactionApi = new TransactionApi(undefined, mammonUrl, mammonAxiosInstance);
+export const characterApi = new CharacterApi(undefined, mammonUrl, mammonAxiosInstance);
+export const ruleBookApi = new RuleBookApi(undefined, mammonUrl, mammonAxiosInstance);
+export const characterRuleBookApi = new CharacterRuleBookApi(undefined, mammonUrl, mammonAxiosInstance);
+export const activityApi = new ActivityApi(undefined, mammonUrl, mammonAxiosInstance);
+export const processingApi = new ProcessingApi(undefined, mammonUrl, mammonAxiosInstance);
+export const acquisitionApi = new AcquisitionApi(undefined, mammonUrl, mammonAxiosInstance);
@@ -1,3 +0,0 @@
-export type MarbasObject = {
-    id: number;
-}
@@ -1,3 +0,0 @@
-export * from './MarbasObject';
-export * from './marbasService';
-
@@ -1,50 +0,0 @@
-import { useAuthStore } from "@/auth";
-import { logResource } from "@/service";
-import axios from "axios";
-
-export const marbasAxiosInstance = axios.create({
-    baseURL: import.meta.env.VITE_MARBAS_URL,
-    headers: {
-        'Accept': 'application/json',
-        "Content-Type": "application/json",
-    },
-})
-
-marbasAxiosInstance.interceptors.request.use(r => {
-    const authStore = useAuthStore();
-
-    if (!authStore.isLoggedIn) {
-        throw new Error("Not logged in");
-    }
-    
-    const accessToken = authStore.accessToken;
-
-    if (accessToken) {
-        r.headers.Authorization = `Bearer ${accessToken}`;
-    }
-    if (!r.params?.page_size) {
-        r.params = { ...r.params, page_size: 250 };
-    }
-    return r;
-})
-logResource(marbasAxiosInstance)
-marbasAxiosInstance.interceptors.response.use(async r => {
-    let next: string = r.data?.next;
-    let results = r.data?.results;
-
-    if (next) {
-        if (!next.startsWith(import.meta.env.VITE_MARBAS_URL)) { // FIME remove once the API is fixed
-            next = import.meta.env.VITE_MARBAS_URL + next.replace(/http(s)?:\/\/[^/]+\//g, '');
-        }
-
-        results = results.concat((await marbasAxiosInstance.request({
-            ...r.config,
-            url: next,
-            baseURL: '',
-        })).data);
-    }
-    if (results) {
-        r.data = results;
-    }
-    return r;
-})
@@ -0,0 +1,25 @@
+<script setup lang="ts">
+import {formatIsk} from "@/formaters";
+import {computed} from "vue";
+
+interface Props {
+  amount: number;
+  colored?: boolean;
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  colored: true,
+});
+
+const computedClass = computed(() => {
+  if (!props.colored) {
+    return "";
+  }
+
+  return props.amount >= 0 ? 'text-emerald-400' : 'text-amber-700';
+})
+</script>
+
+<template>
+  <span :class="computedClass">{{ formatIsk(amount) }}</span>
+</template>
@@ -1,7 +1,7 @@
 import { MarketType } from "..";
-import { MarbasAcquiredType } from "./acquisition";
+import { RawAcquiredType } from "./acquisition";

-export type AcquiredType = Omit<MarbasAcquiredType, 'type'> & {
+export type AcquiredType = Omit<RawAcquiredType, 'type'> & {
    type: MarketType,
    buy: number,
    sell: number
@@ -1,10 +1,10 @@
 <script setup lang="ts">
-import { LoadingSpinner, Tooltip } from '@/components';
-import { formatIsk } from '@/formaters';
-import { getHistory, getHistoryQuartils } from '@/market';
-import { ArrowTrendingDownIcon, ArrowTrendingUpIcon } from '@heroicons/vue/24/outline';
-import { computedAsync } from '@vueuse/core';
-import { ref, watchEffect } from 'vue';
+import {LoadingSpinner, Tooltip} from '@/components';
+import {formatIsk} from '@/formaters';
+import {getHistory, getHistoryQuartils} from '@/market';
+import {ArrowTrendingDownIcon, ArrowTrendingUpIcon} from '@heroicons/vue/24/outline';
+import {computedAsync} from '@vueuse/core';
+import {ref, watchEffect} from 'vue';

 const trendingScale = 3;

@@ -74,7 +74,9 @@ watchEffect(async () => {
    </Tooltip>
 </template>

-<style scoped lang="postcss">
+<style scoped>
+@reference "@/style.css";
+
 .tooltip {
    @apply ms-auto;
    >:deep(div.header) {
@@ -1,15 +1,15 @@
 <script setup lang="ts">
-import { SortableHeader, useSort, VirtualScrollTable } from '@/components/table';
-import { formatEveDate, formatIsk, percentFormater } from '@/formaters';
-import { MarketType, MarketTypeLabel, TaxInput, useMarketTaxStore } from "@/market";
-import { MinusIcon, PlusIcon } from '@heroicons/vue/24/outline';
-import { useStorage } from '@vueuse/core';
-import { computed, ref } from 'vue';
-import { AcquiredType } from './AcquiredType';
+import {SortableHeader, useSort, VirtualScrollTable} from '@/components/table';
+import {MarketType, MarketTypeLabel, TaxInput, useMarketTaxStore} from "@/market";
+import {MinusIcon, PlusIcon} from '@heroicons/vue/24/outline';
+import {useStorage} from '@vueuse/core';
+import {computed, ref} from 'vue';
+import {AcquiredType} from './AcquiredType';
 import AcquisitionQuantilsTooltip from './AcquisitionQuantilsTooltip.vue';
+import {formatEveDate, formatIsk, percentFormater} from "@/formaters.ts";

 type Result = {
-    id: number;
+    id: string;
    type: MarketType;
    name: string;
    buy: number;
@@ -98,7 +98,7 @@ const { sortedArray, headerProps, showColumn } = useSort<Result>(computed(() =>
        const precentProfit = marketTaxStore.calculateProfit(price, first.sell);

        list.push({
-            id: typeID,
+            id: typeID.toString(),
            type: first.type,
            name: first.type.name,
            buy: first.buy,
@@ -126,6 +126,33 @@ const getLineColor = (result: Result) => {
    }
    return '';
 }
+const total = computed(() => {
+    if (sortedArray.value.length <= 1) {
+        return null;
+    }
+
+    const first = sortedArray.value[0];
+
+    if (!first) {
+        return null;
+    }
+
+    const sameItem = sortedArray.value.every(r => r.type.id === first.type.id);
+    const quantity = sameItem ? sortedArray.value.reduce((acc, r) => acc + r.quantity, 0) : 0;
+    const totalRemaining = sameItem ? sortedArray.value.reduce((acc, r) => acc + r.remaining, 0) : 0;
+    const price = sortedArray.value.reduce((acc, r) => acc + r.price * r.remaining, 0) / totalRemaining;
+    const precentProfit = marketTaxStore.calculateProfit(price, first.sell);
+    const iskProfit = sortedArray.value.reduce((acc, r) => acc + r.iskProfit, 0);
+
+    return {
+        sameItem,
+        price,
+        remaining: totalRemaining,
+        quantity,
+        precentProfit,
+        iskProfit
+    };
+});
 </script>

 <template>
@@ -142,7 +169,7 @@ const getLineColor = (result: Result) => {
            </div>
        </div>
    </div>
-    <VirtualScrollTable :list="sortedArray" :itemHeight="33"  bottom="1rem">
+    <VirtualScrollTable :list="sortedArray" :itemHeight="33" :footerHeight="!!total ? 33 : 0" bottom="1rem">
        <template #default="{ list }">
            <thead>
                <tr>
@@ -178,6 +205,37 @@ const getLineColor = (result: Result) => {
                    </td>
                </tr>
            </tbody>
+            <tfoot v-if="!!total">
+                <tr>
+                    <td v-if="showColumn('name')">Total</td>
+                    <td v-if="showColumn('buy')">
+                        <template v-if="!showColumn('name')">Total</template>
+                    </td>
+                    <td v-if="showColumn('sell')">
+                        <template v-if="!showColumn('name') && !showColumn('buy')">Total</template>
+                    </td>
+                    <td v-if="showColumn('date')">
+                        <template v-if="!showColumn('name') && !showColumn('buy') && !showColumn('sell')">Total</template>
+                    </td>
+                    <td v-if="showColumn('price')"  class="text-right">
+                        <template v-if="total.sameItem">
+                            {{ formatIsk(total.price) }}
+                        </template>
+                    </td>
+                    <td v-if="showColumn('remaining')"  class="text-right">
+                        <template v-if="total.sameItem">
+                            {{ total.remaining }}/{{ total.quantity }}
+                        </template>
+                    </td>
+                    <td v-if="showColumn('precentProfit')"  class="text-right">
+                        <template v-if="total.sameItem">
+                            {{ percentFormater.format(total.precentProfit) }}
+                        </template>
+                    </td>
+                    <td v-if="showColumn('iskProfit')"  class="text-right">{{ formatIsk(total.iskProfit) }}</td>
+                    <td v-if="showColumn('buttons')" />
+                </tr>
+            </tfoot>
        </template>
        <template #empty>
            <div class="text-center mt-4">
@@ -187,7 +245,8 @@ const getLineColor = (result: Result) => {
    </VirtualScrollTable>
 </template>

-<style scoped lang="postcss">
+<style scoped>
+@reference "@/style.css";
 div.end {
    @apply justify-self-end ms-2;
 }
@@ -1,10 +1,9 @@
 <script setup lang="ts">
-import { Modal } from '@/components';
-import { formatIsk } from '@/formaters';
-import { MarketType, MarketTypeLabel } from '@/market';
-import { ref } from 'vue';
-import { useAcquiredTypesStore } from './acquisition';
-
+import {Modal} from '@/components';
+import {formatIsk} from '@/formaters';
+import {MarketType, MarketTypeLabel} from '@/market';
+import {ref} from 'vue';
+import {useAcquiredTypesStore} from './acquisition';

 const acquiredTypesStore = useAcquiredTypesStore();

@@ -1,74 +1,43 @@
-import { marbasAxiosInstance, MarbasObject } from "@/marbas";
-import { AxiosResponse } from "axios";
-import log from "loglevel";
-import { defineStore } from "pinia";
-import { computed, ref } from "vue";
+import {defineStore} from "pinia";
+import {computed, ref} from "vue";
+import {acquisitionApi} from "@/mammon";
+import {AcquisitionResponse, AcquisitionResponseSourceEnum} from "@/generated/mammon";

 export type AcquiredTypeSource = 'bo' | 'so' | 'prod' | 'misc';

-export type MarbasAcquiredType = MarbasObject & {
+export type RawAcquiredType = {
+    id: string;
    type: number;
    quantity: number;
    remaining: number;
    price: number;
    date: Date;
-    source: AcquiredTypeSource;
-    user: number;
+    source: AcquisitionResponseSourceEnum;
 }

-type RawMarbasAcquiredType =  Omit<MarbasAcquiredType, 'date'> & {
-    date: string;
-}
-
-type InsertableRawMarbasAcquiredType =  Omit<MarbasAcquiredType, 'id' | 'user' | 'date'>;
-
-const mapRawMarbasAcquiredType = (raw: RawMarbasAcquiredType): MarbasAcquiredType => ({
-    ...raw,
-    date: raw.date ? new Date(raw.date) : new Date()
+const toAcquiredType = (a: AcquisitionResponse): RawAcquiredType => ({
+    id: a.acquisitionId,
+    type: a.marketTypeId,
+    quantity: a.quantity,
+    remaining: a.remaining,
+    price: a.unitCost,
+    date: new Date(a.datetime),
+    source: a.source,
 });

-const endpoint = '/api/acquisitions/';
-
 export const useAcquiredTypesStore = defineStore('market-acquisition', () => {
-    const acquiredTypes = ref<MarbasAcquiredType[]>([]);
+    const acquiredTypes = ref<RawAcquiredType[]>([]);

    const types = computed(() => acquiredTypes.value.filter(item => item.remaining > 0));
-    const addAcquiredType = async (type: number, quantity: number, price: number, source?: AcquiredTypeSource) => { 
-        const newItem = mapRawMarbasAcquiredType((await marbasAxiosInstance.post<RawMarbasAcquiredType, AxiosResponse<RawMarbasAcquiredType>, InsertableRawMarbasAcquiredType>(endpoint, {
-            type: type,
-            quantity: quantity,
-            remaining: quantity,
-            price: price,
-            source: source ?? 'misc', 
-        })).data);

-        acquiredTypes.value = [...acquiredTypes.value, newItem];
-        log.info(`Acquired type ${newItem.id} with quantity ${newItem.quantity} and price ${newItem.price}`, newItem);
-    };
-    const removeAcquiredType = async (id: number, quantity: number) => {
-        const found = acquiredTypes.value.find(t => t.id === id);
+    // Display-only: the backend exposes no write endpoint yet, so buy/sell are no-ops.
+    const addAcquiredType = async (_type: number, _quantity: number, _price: number, _source?: AcquiredTypeSource) => {};
+    const removeAcquiredType = async (_id: string, _quantity: number) => {};

-        if (!found) {
-            return 0;
-        }
+    const refresh = () => acquisitionApi.findAllAcquisitions()
+        .then(response => acquiredTypes.value = response.data.map(toAcquiredType));

-        const item = {
-            ...found,
-            remaining: Math.max(0, found.remaining - quantity)
-        };
+    refresh();

-        acquiredTypes.value = acquiredTypes.value.map(i => {
-            if (i.id === item.id) {
-                return item;
-            } else {
-                return i;
-            }
-        });
-        await marbasAxiosInstance.put(`${endpoint}${item.id}/`, item);
-        log.info(`Acquired type ${item.id} remaining: ${item.remaining}`, item);
-    };
-    
-    marbasAxiosInstance.get<RawMarbasAcquiredType[]>(endpoint).then(res => acquiredTypes.value = res.data.map(mapRawMarbasAcquiredType));
-
-    return { acquiredTypes: types, addAcquiredType, removeAcquiredType };
+    return { acquiredTypes: types, addAcquiredType, removeAcquiredType, refresh };
 });
@@ -23,8 +23,8 @@ const historyCache: RegionalMarketCache<EsiMarketOrderHistory[]> = new RegionalM
    return date;
 });

-export const getHistory = async (tyeId: number, regionId?: number): Promise<EsiMarketOrderHistory[]> => {
+export const getHistory = async (typeId: number, regionId?: number): Promise<EsiMarketOrderHistory[]> => {
    const rId = regionId ?? jitaId;

-    return historyCache.computeIfAbsent(rId, tyeId, async () => (await esiAxiosInstance.get(`/markets/${rId}/history/`, { params: { type_id: tyeId } })).data);
+    return historyCache.computeIfAbsent(rId, typeId, async () => (await esiAxiosInstance.get(`/markets/${rId}/history/`, { params: { type_id: typeId } })).data);
 }
@@ -6,3 +6,5 @@ export * from './type';
 export * from './appraisal';
 export * from './market';

+export { default as IskLabel } from './IskLabel.vue';
+
@@ -1,3 +1 @@
-
 export const jitaId = 10000002;
-
@@ -1,6 +1,6 @@
 <script setup lang="ts">
-import { storeToRefs } from "pinia";
-import { useMarketTaxStore } from "./tax";
+import {storeToRefs} from "pinia";
+import {useMarketTaxStore} from "./tax";

 const { brokerFee, scc } = storeToRefs(useMarketTaxStore());

@@ -17,7 +17,8 @@ const { brokerFee, scc } = storeToRefs(useMarketTaxStore());
    </div>
 </template>

-<style scoped lang="postcss">
+<style scoped>
+@reference "@/style.css";
 div.end {
    @apply justify-self-end ms-2;
 }
@@ -1,12 +1,12 @@
 <script setup lang="ts">
-import { SliderCheckbox } from '@/components';
-import { SortableHeader, useSort, VirtualScrollTable } from '@/components/table';
-import { formatIsk, percentFormater } from '@/formaters';
-import { getHistoryQuartils, MarketType, MarketTypeLabel, TaxInput, useMarketTaxStore } from "@/market";
-import { BookmarkSlashIcon, ShoppingCartIcon } from '@heroicons/vue/24/outline';
-import { useStorage } from '@vueuse/core';
-import { computed, ref } from 'vue';
-import { TrackingResult } from './tracking';
+import {SliderCheckbox} from '@/components';
+import {SortableHeader, useSort, VirtualScrollTable} from '@/components/table';
+import {getHistoryQuartils, MarketType, MarketTypeLabel, TaxInput, useMarketTaxStore} from "@/market";
+import {BookmarkSlashIcon, ShoppingCartIcon} from '@heroicons/vue/24/outline';
+import {useStorage} from '@vueuse/core';
+import {computed, ref} from 'vue';
+import {useAcquiredTypesStore} from '../acquisition';
+import {TrackingResult} from './tracking';

 type Result = {
    type: MarketType;
@@ -17,6 +17,7 @@ type Result = {
    q1: number;
    median: number;
    q3: number;
+    acquisitions: number;
    profit: number;
    score: number;
 }
@@ -44,6 +45,7 @@ const props = withDefaults(defineProps<Props>(), {
 defineEmits<Emits>();

 const marketTaxStore = useMarketTaxStore();
+const acquiredTypesStore = useAcquiredTypesStore();

 const days = useStorage('market-tracking-days', 365);
 const threshold = useStorage('market-tracking-threshold', 10);
@@ -63,6 +65,9 @@ const { sortedArray, headerProps, showColumn } = useSort<Result>(computed(() =>
        const quartils = getHistoryQuartils(r.history, days.value);
        const profit = quartils.q1 === 0 ||  quartils.q3 === 0 ? 0 : marketTaxStore.calculateProfit(quartils.q1, quartils.q3);
        const score = profit <= 0 ? 0 : Math.sqrt((Math.pow(quartils.totalVolume, 1.1) * Math.pow(quartils.q1, 1.2) *  Math.pow(profit, 0.5) * Math.pow(Math.max(1, r.orderCount), -0.7)) / days.value);
+        const acquisitions = columnsToIgnore.value.includes('acquisitions') ? 0 : acquiredTypesStore.acquiredTypes
+            .filter(t => t.type === r.type.id)
+            .reduce((a, b) => a + b.remaining, 0);

        return {
            type: r.type,
@@ -73,6 +78,7 @@ const { sortedArray, headerProps, showColumn } = useSort<Result>(computed(() =>
            q1: quartils.q1,
            median: quartils.median,
            q3: quartils.q3,
+            acquisitions,
            profit,
            score
        };
@@ -128,6 +134,7 @@ const getLineColor = (result: Result) => {
                    <SortableHeader v-bind="headerProps" sortKey="q3">Q3</SortableHeader>
                    <SortableHeader v-bind="headerProps" sortKey="profit">Profit</SortableHeader>
                    <SortableHeader v-bind="headerProps" sortKey="score">Score</SortableHeader>
+                    <SortableHeader v-bind="headerProps" sortKey="acquisitions">Acquisitions</SortableHeader>
                    <SortableHeader v-bind="headerProps" sortKey="buttons" unsortable />
                </tr>
            </thead>
@@ -143,6 +150,7 @@ const getLineColor = (result: Result) => {
                    <td v-if="showColumn('q3')" class="text-right">{{ formatIsk(r.data.q3) }}</td>
                    <td v-if="showColumn('profit')" class="text-right">{{ percentFormater.format(r.data.profit) }}</td>
                    <td v-if="showColumn('score')" class="text-right">{{ scoreFormater.format(r.data.score) }}</td>
+                    <td v-if="showColumn('acquisitions')" class="text-right">{{ r.data.acquisitions }}</td>
                    <td v-if="showColumn('buttons')" class="text-right">
                        <button class="btn-icon me-1" title="Add acquisitions" @click="$emit('buy', r.data.type, r.data.buy, r.data.sell)"><ShoppingCartIcon /></button>
                        <button class="btn-icon me-1" title="Untrack" @click="$emit('remove', r.data.type)"><BookmarkSlashIcon /></button>
@@ -158,7 +166,8 @@ const getLineColor = (result: Result) => {
    </VirtualScrollTable>
 </template>

-<style scoped lang="postcss">
+<style scoped>
+@reference "@/style.css";
 div.end {
    @apply justify-self-end ms-2;
 }
@@ -1,4 +1,3 @@
-import { marbasAxiosInstance, MarbasObject } from "@/marbas";
 import { EsiMarketOrderHistory, getHistory, MarketType, MarketTypePrice } from "@/market";
 import log from "loglevel";
 import { defineStore } from "pinia";
@@ -12,21 +11,16 @@ export type TrackingResult = {
    orderCount: number,
 }

-export type MarbasTrackedType = MarbasObject & {
-    type: number
-};
-
 const endpoint = '/api/types_tracking/';

 export const useMarketTrackingStore = defineStore('marketTracking', () => {
-    const trackedTypes = ref<MarbasTrackedType[]>([]);
+    const trackedTypes = ref<any[]>([]); // TODO

    const types = computed(() => trackedTypes.value.map(item => item.type) ?? []);
    const addType = async (type: number) => {
        const found = trackedTypes.value.find(item => item.type === type);

        if (!found) {
-            trackedTypes.value = [...trackedTypes.value, (await marbasAxiosInstance.post<MarbasTrackedType>(endpoint, { type })).data];
            log.info(`Tracking type ${type}`);
        }
    }
@@ -38,12 +32,8 @@ export const useMarketTrackingStore = defineStore('marketTracking', () => {
        }

        trackedTypes.value = trackedTypes.value.filter(t => t.id !== found.id);
-        await marbasAxiosInstance.delete(`${endpoint}${found.id}`);
-        log.info(`Stopped tracking type ${type}`);
    }

-    marbasAxiosInstance.get<MarbasTrackedType[]>(endpoint).then(res => trackedTypes.value = res.data);
-
    return { types, addType, removeType };
 });

@@ -1,35 +1,42 @@
-import { marbasAxiosInstance } from "@/marbas";
+import {esiAxiosInstance} from '@/service';

 export type MarketType = {
    id: number;
    group_id: number;
-    marketgroup_id: number;
+    market_group_id: number;
    name: string;
    published: boolean;
    description: string;
-    basePrice: number;
+    base_price: number;
    icon_id: number;
    volume: number;
-    portionSize: number;
+    portion_size: number;
 }

+const cache = new Map<number, MarketType>(); // TODO move to pinia store
+
+const fetchType = (id: number): Promise<MarketType> => {
+    if (cache.has(id)) {
+        return Promise.resolve(cache.get(id)!);
+    }
+    return esiAxiosInstance.get<Omit<MarketType, 'id'> & { type_id: number }>(`/universe/types/${id}/`).then(r => {
+        const { type_id, ...rest } = r.data;
+        const marketType: MarketType = { id: type_id, ...rest };
+        cache.set(id, marketType);
+        return marketType;
+    });
+};
+
 export const getMarketType = async (type: string | number): Promise<MarketType> => (await getMarketTypes([type]))[0];
 export const getMarketTypes = async (types: (string | number)[]): Promise<MarketType[]> => {
    if (types.length === 0) {
        return [];
-    } else if (types.length === 1 && typeof types[0] === "number") {
-        return [(await marbasAxiosInstance.get<MarketType>(`/sde/types/${types[0]}/`)).data];
    }
-    return (await marbasAxiosInstance.post<MarketType[]>("/api/types/search", types.map(t => {
-        if (typeof t === "number") {
-            return { id: t };
-        } else {
-            return { name: t };
-        }
-    }))).data;
+    const ids = types.filter((t): t is number => typeof t === 'number');
+    return Promise.all(ids.map(fetchType));
 }

-const blueprintMarketGrous = [ // TODO add all groups
+const blueprintMarketGroups = [ // TODO add all groups
    2,
    2157,
    2159,
@@ -49,9 +56,5 @@ const blueprintMarketGrous = [ // TODO add all groups
 ]

 export const searchMarketTypes = async (search: string): Promise<MarketType[]> => {
-    return (await marbasAxiosInstance.post<MarketType[]>("/api/types/search", [{
-        name__icontains: search,
-        marketgroup_id___not: null,
-        marketgroup_id__in___not: blueprintMarketGrous,
-    }])).data;
+    return []
 }
@@ -1,9 +1,9 @@
 <script setup lang="ts">
-import { vOnClickOutside } from '@vueuse/components';
-import { useVirtualList } from '@vueuse/core';
+import {vOnClickOutside} from '@vueuse/components';
+import {useVirtualList} from '@vueuse/core';
 import log from 'loglevel';
-import { nextTick, ref, watch, watchEffect } from 'vue';
-import { MarketType, searchMarketTypes } from './MarketType';
+import {nextTick, ref, watch, watchEffect} from 'vue';
+import {MarketType, searchMarketTypes} from './MarketType';
 import MarketTypeLabel from "./MarketTypeLabel.vue";

 interface Emits {
@@ -89,7 +89,7 @@ watchEffect(async () => {
 <template>
    <div @click="() => isOpen = true" v-on-click-outside="() => isOpen = false">
        <div class="fake-input">
-            <img v-if="modelValue?.id" :src="`https://images.evetech.net/types/${modelValue.id}/icon?size=32`" alt="" />
+            <img v-if="modelValue?.type_id" :src="`https://images.evetech.net/types/${modelValue.type_id}/icon?size=32`" alt="" />
            <input type="text" v-model="name" @keyup.enter="submit" @keyup.down="moveDown" @keyup.up="moveUp" />
        </div>
        <div v-if="suggestions.length > 1" class="z-20 absolute w-96">
@@ -104,7 +104,8 @@ watchEffect(async () => {
    </div>
 </template>

-<style scoped lang="postcss">
+<style scoped>
+@reference "@/style.css";
 .fake-input {
    @apply w-96 flex border bg-slate-500 rounded px-1 py-0.5;

@@ -1,6 +1,9 @@
 <script setup lang="ts">
-import { ClipboardButton } from '@/components';
-import { InformationCircleIcon } from '@heroicons/vue/24/outline';
+import {ClipboardButton} from '@/components';
+import {InformationCircleIcon} from '@heroicons/vue/24/outline';
+import {routeNames} from '@/routes';
+import {computedAsync} from "@vueuse/core";
+import {getMarketType} from "@/market";


 interface Props {
@@ -9,28 +12,39 @@ interface Props {
    hideCopy?: boolean;
 }

-withDefaults(defineProps<Props>(), {
+const props = withDefaults(defineProps<Props>(), {
    name: "",
    id: 0,
    hideCopy: false
 });
+
+const computedName = computedAsync<string>(async () => {
+  if (props.name) {
+    return props.name;
+  } else if (props.id) {
+    return await getMarketType(props.id).then(marketType => marketType.name);
+  }
+  return "";
+}, "");
 </script>

 <template>
-    <div v-if="id || name" class="flex flex-row">
+    <div v-if="id || computedName" class="flex flex-row">
        <img v-if="id" :src="`https://images.evetech.net/types/${id}/icon?size=32`" class="inline-block w-5 h-5 me-1 mt-1" alt="" />
-        <template v-if="name">
-            {{ name }}
-            <RouterLink v-if="id" :to="{ name: 'market-types', params: { type: id } }" class="button btn-icon ms-1 me-1 mt-1" title="Show item info">
+        <template v-if="computedName">
+          {{ computedName }}
+          <RouterLink v-if="id" :to="{ name: routeNames.marketTypes, params: { type: id } }" class="btn-icon ms-1 me-1 mt-1" title="Show item info">
                <InformationCircleIcon  />
            </RouterLink>
-            <ClipboardButton v-if="!hideCopy" :value="name" />
+            <ClipboardButton v-if="!hideCopy" :value="computedName" />
        </template>
    </div>
 </template>

-<style scoped lang="postcss">
-button:deep(>svg), .button:deep(>svg) {
+<style scoped>
+@reference "@/style.css";
+
+button:deep(>svg), .btn-icon:deep(>svg) {
    @apply !w-4 !h-4;
 }
 </style>
@@ -1,11 +1,27 @@
 <script setup lang="ts">
+
+import {mammonAddCharacterUrl} from "@/mammon";
+import {storeToRefs} from "pinia";
+import {CharacterLabel, useCharactersStore} from "@/characters";
+import {ArrowPathIcon} from '@heroicons/vue/24/outline';
+
+const charactersStore = useCharactersStore()
+const {characters} = storeToRefs(charactersStore);
+const {reloadActivities} = charactersStore;
+
 const addCharacter = () => {
-    // TODO
+    window.location.replace(mammonAddCharacterUrl);
 }
 </script>

 <template>
    <div class="grid mb-2 mt-4">
-        <button class="justify-self-end" @click="addCharacter">Add chacarcter</button>
+      <div class="mb-4 border-b-1 flex justify-end">
+        <button class="mb-2" @click="addCharacter">Add chacarcter</button>
+      </div>
+      <div v-for="character in characters" :key="character.characterId" class="flex items-center mb-2">
+        <CharacterLabel class="grow" :character="character" />
+        <button class="btn-icon" @click="reloadActivities(character.characterId)"><ArrowPathIcon /></button>
+      </div>
    </div>
 </template>
@@ -0,0 +1,27 @@
+<script setup lang="ts">
+import {RouterView} from 'vue-router';
+import {EditLedgerModal, useLedgersStore} from "@/ledger";
+import {ref} from "vue";
+import {activityApi, processingApi} from "@/mammon";
+
+const {refresh} = useLedgersStore();
+
+const editLedgerModal = ref<typeof EditLedgerModal>();
+
+const processActivities = async () => {
+  await activityApi.fetchAllNewActivities();
+  await processingApi.processNewActivities();
+  await refresh();
+}
+</script>
+
+<template>
+    <div class="mt-4">
+      <div class="mb-4 border-b-1 flex justify-end">
+        <button class="mb-2 ms-2" @click="processActivities">Process Activities</button>
+        <button class="mb-2 ms-2" @click="editLedgerModal?.open()">New Ledger</button>
+      </div>
+      <EditLedgerModal ref="editLedgerModal" />
+      <RouterView />
+    </div>
+</template>
@@ -1,12 +1,12 @@
 <script setup lang="ts">
-import { RouterLink, RouterView } from 'vue-router';
-
+import {RouterLink, RouterView} from 'vue-router';
+import {routeNames} from '@/routes';
 </script>

 <template>
    <div class="mt-4">
        <div class="flex border-b-2 border-emerald-500">
-            <RouterLink :to="{name: 'market-types'}" class="tab">
+            <RouterLink :to="{name: routeNames.marketTypes}" class="tab">
                <span>Item Info</span>
            </RouterLink>
            <RouterLink to="/market/tracking" class="tab">
@@ -19,12 +19,3 @@ import { RouterLink, RouterView } from 'vue-router';
        <RouterView />
    </div>
 </template>
-
-<style scoped lang="postcss">
-a.tab {
-    @apply flex items-center px-4 me-2 rounded-t-md bg-slate-600 hover:bg-slate-700;
-    &.router-link-active {
-        @apply bg-emerald-500 hover:bg-emerald-700;
-    }
-}
-</style>
@@ -0,0 +1,18 @@
+<script setup lang="ts">
+import {RouterLink, RouterView} from "vue-router";
+import {routeNames} from '@/routes';
+</script>
+
+<template>
+  <div class="mt-4">
+    <div class="flex border-b-2 border-emerald-500">
+      <RouterLink :to="{ name: routeNames.listRuleBooks }" class="tab">
+        <span>Rule Books</span>
+      </RouterLink>
+      <RouterLink to="/characters/rules" class="tab">
+        <span>Characters Rules</span>
+      </RouterLink>
+    </div>
+    <RouterView />
+  </div>
+</template>
@@ -0,0 +1,106 @@
+<script setup lang="ts">
+
+import {findAllTransactionInLeger, useLedgerParam} from "@/ledger";
+import {computedAsync} from "@vueuse/core";
+import {TransactionResponse} from "@/generated/mammon";
+import {IskLabel} from "@/market";
+import {SortableHeader, useSort, VirtualScrollTable} from "@/components/table";
+import {TransferList, TransferTypes} from "@/transaction";
+import {Dropdown} from "@/components";
+import {CharacterLabel, useCharactersStore} from "@/characters";
+import {formatEveDate} from "@/formaters.ts";
+
+const {ledgerId} = useLedgerParam();
+const {findById} = useCharactersStore();
+
+const transactions = computedAsync<TransactionResponse[]>(async () => {
+  if (ledgerId.value) {
+    return await findAllTransactionInLeger(ledgerId.value);
+  }
+  return [];
+}, []);
+
+const { sortedArray, headerProps } = useSort(computedAsync(() => Promise.all(transactions.value.map(async transaction => {
+  const character = await findById(transaction.characterId);
+  return {
+    character,
+    characterName: character?.name ?? "",
+    transactionId: transaction.transactionId,
+    description: transaction.description,
+    date: new Date(transaction.datetime),
+    balance: getIskBalance(transaction),
+    transfers: transaction.transfers
+  }
+})), []), { defaultSortKey: 'date', defaultSortDirection: 'desc' });
+
+const getIskBalance = (transaction: TransactionResponse) => {
+  if (!ledgerId.value) {
+    return 0;
+  }
+
+  let balance = 0;
+
+  for (const transfer of transaction.transfers) {
+    if (transfer.type === TransferTypes.Isk) {
+      if (transfer.toLedgerId === ledgerId.value) {
+        balance += transfer.amount;
+      } else if (transfer.fromLedgerId === ledgerId.value) {
+        balance -= transfer.amount;
+      }
+    }
+  }
+  return balance;
+}
+</script>
+
+<template>
+  <div class="mt-4">
+    <VirtualScrollTable :list="sortedArray" :itemHeight="33" bottom="1rem">
+      <template #default="{ list }">
+        <thead>
+        <tr>
+          <SortableHeader v-bind="headerProps" sortKey="characterName">Character</SortableHeader>
+          <SortableHeader v-bind="headerProps" sortKey="date">Date</SortableHeader>
+          <SortableHeader v-bind="headerProps" sortKey="balance">Isk Change</SortableHeader>
+          <SortableHeader v-bind="headerProps" sortKey="description">Description</SortableHeader>
+        </tr>
+        </thead>
+        <tbody>
+        <tr v-for="t in list" :key="t.data.transactionId">
+          <td>
+            <CharacterLabel v-if="t.data.character" :character="t.data.character" />
+          </td>
+          <td>
+            <Dropdown class="transfer-dropdown">
+              <template #button>
+                {{formatEveDate(t.data.date)}}
+              </template>
+              <TransferList :transfers="t.data.transfers" />
+            </Dropdown>
+          </td>
+          <td class="text-right">
+            <IskLabel :amount="t.data.balance" />
+          </td>
+          <td>{{t.data.description}}</td>
+        </tr>
+        </tbody>
+      </template>
+    </VirtualScrollTable>
+  </div>
+</template>
+
+<style scoped>
+@reference "@/style.css";
+
+tr:hover>td>.transfer-dropdown :deep(>button) {
+  @apply bg-slate-900;
+}
+
+.transfer-dropdown :deep(>button) {
+  @apply bg-slate-800 hover:bg-slate-900 border-none flex items-center w-full;
+}
+
+.transfer-dropdown.dropdown-open :deep(>button) {
+  @apply bg-slate-800 rounded-b-none;
+}
+</style>
@@ -0,0 +1,58 @@
+<script setup lang="ts">
+
+import {EditLedgerModal, Ledger, LedgerLabel, useLedgersStore} from "@/ledger";
+import {storeToRefs} from "pinia";
+import {nextTick, ref} from "vue";
+import {PencilSquareIcon} from "@heroicons/vue/24/outline";
+import {IskLabel} from "@/market";
+import {SortableHeader, useSort, VirtualScrollTable} from "@/components/table";
+
+const {ledgers} = storeToRefs(useLedgersStore());
+
+const { sortedArray, headerProps } = useSort<Ledger>(ledgers);
+
+const editModal = ref<typeof EditLedgerModal>();
+const editingLedgerId = ref("");
+
+const openEdit = async (ledgerId: string) => {
+  editingLedgerId.value = ledgerId;
+  await nextTick();
+  editModal.value?.open();
+};
+
+</script>
+
+<template>
+  <div class="mt-4">
+    <VirtualScrollTable :list="sortedArray" :itemHeight="33" bottom="1rem">
+      <template #default="{ list }">
+        <thead>
+        <tr>
+          <SortableHeader v-bind="headerProps" sortKey="name">Ledger</SortableHeader>
+          <SortableHeader v-bind="headerProps" sortKey="balance">Isk Balance</SortableHeader>
+          <SortableHeader v-bind="headerProps" sortKey="buttons" unsortable />
+        </tr>
+        </thead>
+        <tbody>
+        <tr v-for="l in list" :key="l.data.ledgerId">
+          <td>
+            <LedgerLabel :ledger="l.data" :link="true" />
+          </td>
+          <td class="text-right">
+            <IskLabel class="ms-2" :amount="l.data.balance" />
+          </td>
+          <td class="text-right">
+            <button class="btn-icon ms-2" @click="openEdit(l.data.ledgerId)"><PencilSquareIcon /></button>
+          </td>
+        </tr>
+        </tbody>
+      </template>
+      <template #empty>
+        <div class="text-center mt-4">
+          <span>No ledgers found</span>
+        </div>
+      </template>
+    </VirtualScrollTable>
+  </div>
+  <EditLedgerModal ref="editModal" :ledger-id="editingLedgerId" />
+</template>
@@ -0,0 +1,22 @@
+<script setup lang="ts">
+import {RouterLink, RouterView} from 'vue-router';
+import {isMain, useLedgerParam} from "@/ledger";
+import {routeNames} from "@/routes.ts";
+
+const {ledgerId, ledger} = useLedgerParam();
+
+</script>
+
+<template>
+  <div v-if="ledger" class="mt-4">
+    <div class="flex border-b-2 border-emerald-500">
+      <RouterLink :to="{name: routeNames.viewLedgerBalance}" class="tab">
+        <span>Balance</span>
+      </RouterLink>
+      <RouterLink v-if="isMain(ledger)" :to="{name: routeNames.listLedgerTransactions}" class="tab">
+        <span>Transactions</span>
+      </RouterLink>
+    </div>
+    <RouterView />
+  </div>
+</template>
@@ -0,0 +1,60 @@
+<script setup lang="ts">
+import {getLedgerBalance, useLedgerParam} from "@/ledger";
+import {computedAsync} from "@vueuse/core";
+import {BalanceResponse} from "@/generated/mammon";
+import {getMarketType, IskLabel, MarketTypeLabel} from "@/market";
+import {SortableHeader, useSort, VirtualScrollTable} from "@/components/table";
+
+const {ledgerId} = useLedgerParam();
+
+const balance = computedAsync<BalanceResponse>(async () => {
+  if (ledgerId.value) {
+    return await getLedgerBalance(ledgerId.value);
+  }
+  return undefined;
+});
+
+const { sortedArray, headerProps } = useSort(computedAsync(async () => {
+  const itemBalances = balance.value?.itemBalances;
+
+  if (!itemBalances) {
+    return [];
+  }
+
+  return await Promise.all(itemBalances.map(async i => {
+    const item = await getMarketType(i.typeId);
+
+    return {
+      ...i,
+      name: item.name
+    };
+  }));
+}, []));
+
+</script>
+
+<template>
+  <div v-if="balance" class="mt-4">
+    <div class="flex justify-end w-full">
+      <IskLabel class="mb-2" :amount="balance.iskBalance" />
+    </div>
+    <VirtualScrollTable :list="sortedArray" :itemHeight="33" bottom="1rem">
+      <template #default="{ list }">
+        <thead>
+        <tr>
+          <SortableHeader v-bind="headerProps" sortKey="name">Item</SortableHeader>
+          <SortableHeader v-bind="headerProps" sortKey="quantity">Balance</SortableHeader>
+        </tr>
+        </thead>
+        <tbody>
+        <tr v-for="i in list" :key="i.data.typeId">
+          <td>
+            <MarketTypeLabel :id="i.data.typeId" :name="i.data.name" />
+          </td>
+          <td class="text-right">{{i.data.quantity}}</td>
+        </tr>
+        </tbody>
+      </template>
+    </VirtualScrollTable>
+  </div>
+</template>
@@ -1,16 +1,22 @@
 <script setup lang="ts">
-import { MarketTypePrice, getMarketTypes, useApraisalStore } from "@/market";
-import { AcquiredType, AcquisitionResultTable, BuyModal, SellModal, useAcquiredTypesStore } from '@/market/acquisition';
-import { ref, watch } from 'vue';
+import {getMarketTypes, MarketTypePrice, useApraisalStore} from "@/market";
+import {AcquiredType, AcquisitionResultTable, BuyModal, SellModal, useAcquiredTypesStore} from '@/market/acquisition';
+import {ref, watch} from 'vue';
+import {activityApi, processingApi} from "@/mammon";

 const buyModal = ref<typeof BuyModal>();
 const sellModal = ref<typeof SellModal>();

-
 const apraisalStore = useApraisalStore();
 const acquiredTypesStore = useAcquiredTypesStore();
 const items = ref<AcquiredType[]>([]);

+const refresh = async () => {
+  await activityApi.fetchAllNewActivities();
+  await processingApi.processNewActivities();
+  await acquiredTypesStore.refresh();
+}
+
 watch(() => acquiredTypesStore.acquiredTypes, async itms => {
    if (itms.length === 0) {
        return;
@@ -34,6 +40,9 @@ watch(() => acquiredTypesStore.acquiredTypes, async itms => {

 <template>
    <div class="mt-4">
+        <div class="flex">
+            <button class="ms-auto" @click="refresh">Refresh</button>
+        </div>
        <template v-if="items.length > 0">
            <AcquisitionResultTable :items="items" @buy="(types, price, buy, sell) => buyModal?.open(types[0].type, { 'Price': price, 'Buy': buy, 'Sell': sell })" @sell="types => sellModal?.open(types)" ignoredColums="date" />
            <BuyModal ref="buyModal" />
@@ -1,4 +1,5 @@
 <script setup lang="ts">
+import { Modal, ProgressBar } from "@/components";
 import { MarketType, MarketTypeInput, MarketTypePrice, getHistory, getMarketTypes, useApraisalStore } from "@/market";
 import { BuyModal } from '@/market/acquisition';
 import { TrackingResult, TrackingResultTable, createResult, useMarketTrackingStore } from '@/market/tracking';
@@ -56,10 +57,6 @@ watch(() => marketTrackingStore.types, async t => {

    const prices = await apraisalStore.getPrices(await getMarketTypes(typesToLoad));

-    items.value = [
-        ...items.value
-    ];
-
    typesToLoad.forEach(async i => items.value.push(await createResult(i, prices.find(p => p.type.id === i) as MarketTypePrice)));
 }, { immediate: true });
 </script>
@@ -76,5 +73,10 @@ watch(() => marketTrackingStore.types, async t => {
        <hr />
        <TrackingResultTable :items="items" @buy="(type, buy, sell) => buyModal?.open(type, { 'Buy': buy, 'Sell': sell })" @remove="removeItem" />
        <BuyModal ref="buyModal" />
+        <Modal :open="items.length > 0 && items.length < marketTrackingStore.types.length">
+            <div class="ms-auto me-auto mb-2 w-96">
+                <ProgressBar :value="items.length" :total="marketTrackingStore.types.length" />
+            </div>
+        </Modal>
    </template>
 </template>
@@ -1,13 +1,14 @@
 <script setup lang="ts">
-import { ClipboardButton } from '@/components';
-import { MarketType, MarketTypeInput, getMarketType, useApraisalStore } from "@/market";
-import { AcquisitionResultTable, BuyModal, useAcquiredTypesStore } from '@/market/acquisition';
-import { TrackingResultTable, createResult, useMarketTrackingStore } from '@/market/tracking';
-import { BookmarkIcon, BookmarkSlashIcon, ShoppingCartIcon } from '@heroicons/vue/24/outline';
-import { computedAsync } from '@vueuse/core/index.cjs';
+import {ClipboardButton} from '@/components';
+import {getMarketType, MarketType, MarketTypeInput, useApraisalStore} from "@/market";
+import {AcquisitionResultTable, BuyModal, useAcquiredTypesStore} from '@/market/acquisition';
+import {createResult, TrackingResultTable, useMarketTrackingStore} from '@/market/tracking';
+import {BookmarkIcon, BookmarkSlashIcon, ShoppingCartIcon} from '@heroicons/vue/24/outline';
 import log from "loglevel";
-import { computed, ref, watch } from "vue";
-import { useRoute, useRouter } from "vue-router";
+import {computed, ref, watch} from "vue";
+import {useRoute, useRouter} from "vue-router";
+import {routeNames} from "@/routes";
+import {computedAsync} from "@vueuse/core";

 const buyModal = ref<typeof BuyModal>();

@@ -52,7 +53,7 @@ const view = () => {
    }

    router.push({
-        name: 'market-types',
+        name: routeNames.marketTypes,
        params: {
            type: inputItem.value.id
        }
@@ -103,7 +104,7 @@ watch(useRoute(), async route => {
        </div>
        <div v-if="result" class="mb-4">
            <span>Market Info:</span>
-            <TrackingResultTable :items="[result]" infoOnly ignoredColums="name" />
+            <TrackingResultTable :items="[result]" infoOnly :ignoredColums="['name', 'acquisitions']" />
        </div>
        <div v-if="acquisitions && acquisitions.length > 0">
            <span>Acquisitions:</span>
@@ -113,7 +114,9 @@ watch(useRoute(), async route => {
    <BuyModal ref="buyModal" />
 </template>

-<style scoped lang="postcss">
+<style scoped>
+@reference "@/style.css";
+
 img.type-image {
    width: 64px;
    height: 64px;
@@ -0,0 +1,96 @@
+<script setup lang="ts">
+import {Character, CharacterLabel, useCharactersStore} from "@/characters";
+import {useRoute} from "vue-router";
+import {computed, ref, watch, watchEffect} from "vue";
+import log from "loglevel";
+import {
+  findCharacterRuleBookByCharacterId,
+  RuleBook,
+  setCharacterRuleBookForCharacter,
+  useRuleBooksStore
+} from "@/rules";
+import {storeToRefs} from "pinia";
+import {isMain, Ledger, LedgerSelect, systemLedger, useLedgersStore} from "@/ledger";
+
+type Bindings = { [key: string]: Ledger; };
+
+const ruleBookStore = useRuleBooksStore();
+const {findById: findRuleBookById} = ruleBookStore;
+const {ruleBooks} = storeToRefs(ruleBookStore);
+const {findById: findCharacterById} = useCharactersStore();
+const {ledgers} = storeToRefs(useLedgersStore());
+
+const ledgersToUse = computed(() => [systemLedger, ...ledgers.value.filter(isMain)]);
+
+const character = ref<Character>();
+const ruleBook = ref<RuleBook>();
+const bindings = ref<Bindings>({});
+const ledgerRefs = computed<string[]>(() => ruleBook.value?.ledgerRefs ?? [])
+
+watchEffect(async () => {
+  const characterId = character.value?.characterId;
+
+  if (characterId) {
+    const characterRuleBook = await findCharacterRuleBookByCharacterId(characterId);
+
+    ruleBook.value = findRuleBookById(characterRuleBook.ruleBookId);
+    bindings.value = Object.fromEntries(
+      Object.entries(characterRuleBook.bindings)
+        .map(([key, id]) => [key, ledgersToUse.value.find(l => l.ledgerId === id) ?? systemLedger])
+    );
+  }
+});
+
+const save = () => {
+  const characterId = character.value?.characterId;
+  const ruleBookId = ruleBook.value?.ruleBookId;
+
+  if (characterId && ruleBookId) {
+    setCharacterRuleBookForCharacter(characterId, {
+      ruleBookId,
+      bindings: Object.fromEntries(
+        Object.entries(bindings.value)
+          .map(([key, ledger]) => [key, ledger.ledgerId])
+      )
+    })
+  }
+}
+
+watch(useRoute(), async route => {
+  if (route.params.characterId) {
+    const id = parseInt(typeof route.params.characterId === 'string' ? route.params.characterId : route.params.characterId[0]);
+
+    character.value = await findCharacterById(id);
+    log.info('Loaded character:', character.value);
+  } else {
+    character.value = undefined;
+    log.info('No character to load');
+  }
+}, { immediate: true })
+</script>
+
+<template>
+  <div v-if="character" class="grid mb-2 mt-4">
+    <div class="mb-2 border-b-1 flex">
+      <CharacterLabel class="flex grow mb-2" :character="character" :size="64" />
+      <div>
+        <button @click="save">Save</button>
+      </div>
+    </div>
+    <div class="flex-col border-b-1">
+      Rule Book:
+      <select class="me-2 mb-2 w-50" v-model="ruleBook">
+        <option v-for="rb in ruleBooks" :key="rb.ruleBookId" :value="rb">{{ rb.name }}</option>
+      </select>
+    </div>
+    <div class="flex-col border-b-1">
+      Ledger Bindings:
+      <div class="flex flex-wrap items-center mb-2 mt-2">
+        <div class="me-2" v-for="ref in ledgerRefs" :ref="ref">
+          <span class="me-1">{{ref}}:</span>
+          <LedgerSelect :ledgers="ledgersToUse" :modelValue="bindings[ref] ?? systemLedger" @update:modelValue="value => { if (value) bindings[ref] = value }" />
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
@@ -0,0 +1,119 @@
+<script setup lang="ts">
+import {useRoute, useRouter} from "vue-router";
+import {ref, watch} from "vue";
+import {useDebounceFn, useEventListener} from "@vueuse/core";
+import log from "loglevel";
+import {ScriptEditor, useRuleBooksStore} from "@/rules";
+import {PlusIcon, TrashIcon} from "@heroicons/vue/24/outline";
+import {routeNames} from "@/routes";
+import {SliderCheckbox} from "@/components";
+
+const ruleBookId = ref<string>();
+const name = ref<string>('');
+const usedForAcquisitions = ref<boolean>(false);
+const ledgerRefs = ref<string[]>([]);
+const script = ref<string>('');
+
+const {findById, create, update, refresh} = useRuleBooksStore();
+const router = useRouter();
+
+const save = async () => {
+  if (!ruleBookId.value) {
+    const created = await create({
+      name: name.value,
+      usedForAcquisitions: usedForAcquisitions.value,
+      ledgerRefs: ledgerRefs.value,
+      script: script.value
+    })
+    await router.push({ name: routeNames.editRuleBook, params: {ruleBookId: created.ruleBookId}})
+
+  } else {
+    await update(ruleBookId.value, {
+      name: name.value,
+      usedForAcquisitions: usedForAcquisitions.value,
+      ledgerRefs: ledgerRefs.value,
+      script: script.value
+    })
+  }
+}
+
+useEventListener(window, 'keydown', (event: KeyboardEvent) => {
+  if ((event.metaKey || event.ctrlKey) && event.key.toLowerCase() === 's') {
+    event.preventDefault();
+    save();
+  }
+}, {capture: true});
+
+const addLedgerRef = () => {
+  ledgerRefs.value = [...ledgerRefs.value, '']
+}
+const updateLedgerRef = useDebounceFn((index: number, value: string) => {
+  ledgerRefs.value[index] = value;
+}, 500);
+
+const removeLedgerRef = (index: number) => {
+  ledgerRefs.value = ledgerRefs.value.toSpliced(index, 1)
+}
+
+watch(useRoute(), async route => {
+  if (route.params.ruleBookId) {
+    const promise = refresh(); // FIXME don't call refresh
+
+    const id = typeof route.params.ruleBookId === 'string' ? route.params.ruleBookId : route.params.ruleBookId[0];
+
+    await promise;
+
+    const ruleBook = findById(id);
+
+    ruleBookId.value = id;
+    name.value = ruleBook?.name ?? '';
+    usedForAcquisitions.value = ruleBook?.usedForAcquisitions ?? false;
+    ledgerRefs.value = [...(ruleBook?.ledgerRefs ?? [])];
+    script.value = ruleBook?.script ?? '';
+    log.info('Loaded rule book:', ruleBook);
+  } else {
+    ruleBookId.value = undefined;
+    name.value = '';
+    usedForAcquisitions.value = false;
+    ledgerRefs.value = [];
+    script.value = '';
+    log.info('No rule book to load');
+  }
+}, { immediate: true })
+</script>
+
+<template>
+  <div  class="flex flex-col mb-2 mt-4 h-[calc(100vh-4.5rem)]">
+    <div class="flex flex-col grow min-h-0">
+      <div class="flex grow border-b-1">
+        Name:
+        <input class="mb-2 ms-2" type="text" v-model="name" />
+        <label class="flex items-center ms-2 mb-2">
+          <SliderCheckbox class="me-2" v-model="usedForAcquisitions"  />
+          Used for acquisitions
+        </label>
+      </div>
+      <div class="border-b-1">
+        Ledgers References:
+        <div class="flex flex-wrap items-center mt-2">
+          <div class="flex items-center mb-2" v-for="(ledgerRef, index) in ledgerRefs" :key="index">
+            <input class="me-1" type="text" :value="ledgerRef" @input="updateLedgerRef(index, ($event.target as HTMLInputElement).value)" />
+            <button class="btn-icon me-2" @click="removeLedgerRef(index)"><TrashIcon /></button>
+          </div>
+          <div class="flex items-center mb-2">
+            <button class="btn-icon" @click="addLedgerRef"><PlusIcon /></button>
+          </div>
+        </div>
+      </div>
+      <div class="flex flex-col grow min-h-0 border-b-1">
+        Script:
+        <ScriptEditor class="mt-2 mb-2" v-model="script" :ledgerRefs="ledgerRefs" />
+      </div>
+    </div>
+    <div class="mt-2 justify-end flex">
+      <div>
+        <button @click="save">Save</button>
+      </div>
+    </div>
+  </div>
+</template>
@@ -0,0 +1,57 @@
+<script setup lang="ts">
+import {storeToRefs} from "pinia";
+import {Character, CharacterLabel, useCharactersStore} from "@/characters";
+import {PencilSquareIcon} from "@heroicons/vue/24/outline";
+import {findCharacterRuleBookByCharacterId, useRuleBooksStore} from "@/rules";
+import {computedAsync} from "@vueuse/core";
+import {routeNames} from "@/routes.ts";
+import {SortableHeader, useSort} from "@/components/table";
+
+type CharacterRuleBookView = {
+  character: Character;
+  characterName: string;
+  characterId: number;
+  ruleBookName: string;
+}
+
+const {characters} = storeToRefs(useCharactersStore());
+const {findById: findRuleBookById} = useRuleBooksStore();
+
+
+const { sortedArray, headerProps } = useSort(computedAsync<CharacterRuleBookView[]>(async () => await Promise.all(characters.value.map(async (character: Character): Promise<CharacterRuleBookView> => {
+  const characterRuleBook = await findCharacterRuleBookByCharacterId(character.characterId);
+  const ruleBook = findRuleBookById(characterRuleBook.ruleBookId);
+
+  return {
+    character,
+    characterName: character.name,
+    characterId: character.characterId,
+    ruleBookName: ruleBook?.name ?? ''
+  }
+})), []))
+</script>
+
+<template>
+  <div class="grid mb-2 mt-4">
+    <table>
+      <thead>
+      <tr>
+        <SortableHeader v-bind="headerProps" sortKey="characterName">Character</SortableHeader>
+        <SortableHeader v-bind="headerProps" sortKey="ruleBookName">Rule Book</SortableHeader>
+        <SortableHeader v-bind="headerProps" sortKey="buttons" unsortable />
+      </tr>
+      </thead>
+      <tbody>
+      <tr v-for="characterRuleBookView in sortedArray" :key="characterRuleBookView.characterId" >
+        <td>
+          <CharacterLabel :character="characterRuleBookView.character" />
+        </td>
+        <td>{{characterRuleBookView.ruleBookName}}</td>
+        <td class="text-right">
+          <RouterLink class="btn-icon" :to="{ name: routeNames.editCharacterRulebook, params: { characterId: characterRuleBookView.characterId } }"><PencilSquareIcon /></RouterLink>
+        </td>
+      </tr>
+      </tbody>
+    </table>
+  </div>
+</template>
@@ -0,0 +1,37 @@
+<script setup lang="ts">
+import {storeToRefs} from "pinia";
+import {DocumentDuplicateIcon, PencilSquareIcon, TrashIcon} from "@heroicons/vue/24/outline";
+import {confirm} from "@/confirm";
+import {RuleBook, useRuleBooksStore} from "@/rules";
+import {routeNames} from "@/routes";
+
+const ruleBooksStore = useRuleBooksStore();
+const {ruleBooks} = storeToRefs(ruleBooksStore);
+
+const duplicate = async (ruleBook: RuleBook) => {
+  if (await confirm({title: "Duplicate Rule Book", message: `Duplicate ${ruleBook.name}?`, confirmLabel: "Duplicate"})) {
+    await ruleBooksStore.duplicate(ruleBook);
+  }
+};
+
+const remove = async (ruleBook: RuleBook) => {
+  if (await confirm({title: "Delete Rule Book", message: `Delete ${ruleBook.name}?`, confirmLabel: "Delete", danger: true})) {
+    await ruleBooksStore.remove(ruleBook.ruleBookId);
+  }
+};
+
+</script>
+
+<template>
+  <div class="grid mb-2 mt-4">
+    <div class="flex justify-end border-b-1">
+      <RouterLink class="button mb-2 ms-2" :to="{ name: routeNames.newRuleBook}">New Rule Book</RouterLink>
+    </div>
+    <div v-for="ruleBook in ruleBooks" :key="ruleBook.ruleBookId" class="flex items-center mt-2">
+      <span class="flex grow me-2">{{ruleBook.name}}</span>
+      <RouterLink class="btn-icon me-1" :to="{ name: routeNames.editRuleBook, params: { ruleBookId: ruleBook.ruleBookId } }"><PencilSquareIcon /></RouterLink>
+      <button class="btn-icon me-1" @click="duplicate(ruleBook)"><DocumentDuplicateIcon /></button>
+      <button class="btn-icon text-amber-700 hover:text-amber-600" @click="remove(ruleBook)"><TrashIcon /></button>
+    </div>
+  </div>
+</template>
@@ -12,7 +12,8 @@ const modelValue = defineModel({ default: false });
    </label>
 </template>

-<style scoped lang="postcss">
+<style scoped>
+@reference "@/style.css";
    input:checked ~ span:last-child {
        --tw-translate-x: 1.75rem;
    }
@@ -1,5 +1,3 @@
-import { marbasAxiosInstance } from "@/marbas";
-
 export type ReprocessItemValues = {
    typeID: number;
    name: string;
@@ -22,7 +20,5 @@ export const reprocess = async (items: string, minerals: string, efficiency?: nu
    };
    const source = JSON.stringify(sourceJson);

-    const response = await marbasAxiosInstance.post('/reprocess/', source, {params: {efficiency: efficiency ?? 0.55}});
-
-    return response.data;
+    return []
 };
@@ -1,16 +1,56 @@
-import { RouteRecordRaw } from 'vue-router';
+import {RouteRecordRaw} from 'vue-router';
+
+export const routeNames = {
+    home: 'home',
+    callback: 'callback',
+    viewLedger: 'view-ledger',
+    viewLedgerBalance: 'view-ledger-balance',
+    listLedgerTransactions: 'list-ledger-transactions',
+    listRuleBooks: 'list-rule-books',
+    newRuleBook: 'new-rule-book',
+    editRuleBook: 'edit-rule-book',
+    editCharacterRulebook: 'edit-character-rule-book',
+    marketTypes: 'market-types',
+    about: 'about',
+} as const;

 export const routes: RouteRecordRaw[] = [
-    { path: '/', name: 'home', component: () => import('@/pages/Index.vue') },
-    { path: '/callback', name: 'callback', component: () => import('@/pages/Index.vue') },
-    { path: '/reprocess', component: () => import('@/pages/Reprocess.vue') },
-    { path: '/market', component: () => import('@/pages/Market.vue'), children: [
-        { path: '', redirect: '/market/types' },
-        { path: 'types/:type?', name: 'market-types', component: () => import('@/pages/market/TypeInfo.vue') },
-        { path: 'tracking', component: () => import('@/pages/market/Tracking.vue') },
-        { path: 'acquisitions', component: () => import('@/pages/market/Acquisitions.vue') },
-    ] },
-    { path: '/tools', component: () => import('@/pages/Tools.vue') },
-    { path: '/characters', component: () => import('@/pages/Characters.vue') },
-    { path: '/about', name: 'about', component: () => import('@/pages/About.vue') },
-];
+    {path: '/', name: routeNames.home, component: () => import('@/pages/Index.vue')},
+    {path: '/callback', name: routeNames.callback, component: () => import('@/pages/Index.vue')},
+
+    {path: '/ledgers', component: () => import('@/pages/Ledgers.vue'), children: [
+        {path: '', component: () => import('@/pages/ledger/ListLedgers.vue')},
+        {path: ':ledgerId',  component: () => import('./pages/ledger/ViewLedger.vue'), children: [
+            {path: '', name: routeNames.viewLedger, redirect: {name: routeNames.viewLedgerBalance}},
+            {path: 'balance', name: routeNames.viewLedgerBalance, component: () => import('@/pages/ledger/ViewLedgerBalance.vue')},
+            {path: 'transactions', name: routeNames.listLedgerTransactions, component: () => import('@/pages/ledger/ListLedgerTransactions.vue')},
+        ]},
+    ]},
+
+    {path: '/rules', component: () => import('@/pages/Rules.vue'), children: [
+        {path: '', redirect: {name: routeNames.listRuleBooks}},
+        {path: '/rule-books', children: [
+            {path: '', name: routeNames.listRuleBooks, component: () => import('@/pages/rules/ListRuleBooks.vue')},
+            {path: 'new', name: routeNames.newRuleBook, component: () => import('@/pages/rules/EditRuleBook.vue')},
+            {path: ':ruleBookId', name: routeNames.editRuleBook, component: () => import('@/pages/rules/EditRuleBook.vue')},
+        ]},
+        {path: '/characters/rules', children: [
+            {path: '', component: () => import('@/pages/rules/ListCharacterRuleBooks.vue')},
+            {path: '/characters/:characterId/rules', name: routeNames.editCharacterRulebook, component: () => import('@/pages/rules/EditCharacterRuleBook.vue')},
+        ]}
+    ]},
+
+    {path: '/market', component: () => import('@/pages/Market.vue'), children: [
+        {path: '', redirect: {name: routeNames.marketTypes}},
+        {path: 'types/:type?', name: routeNames.marketTypes, component: () => import('@/pages/market/TypeInfo.vue')},
+        {path: 'tracking', component: () => import('@/pages/market/Tracking.vue')},
+        {path: 'acquisitions', component: () => import('@/pages/market/Acquisitions.vue')},
+    ]},
+
+    {path: '/reprocess', component: () => import('@/pages/Reprocess.vue')},
+
+    {path: '/tools', component: () => import('@/pages/Tools.vue')},
+
+    {path: '/characters', component: () => import('@/pages/Characters.vue')},
+    {path: '/about', name: routeNames.about, component: () => import('@/pages/About.vue')},
+] as const;
@@ -0,0 +1,104 @@
+<script setup lang="ts">
+import * as monaco from 'monaco-editor';
+import editorWorker from 'monaco-editor/esm/vs/editor/editor.worker?worker';
+import tsWorker from 'monaco-editor/esm/vs/language/typescript/ts.worker?worker';
+import {onBeforeUnmount, onMounted, ref, watch} from 'vue';
+import {fetchScriptDefinitions} from './rules';
+
+(self as unknown as { MonacoEnvironment: { getWorker(workerId: string, label: string): Worker } }).MonacoEnvironment = {
+  getWorker(_workerId: string, label: string) {
+    if (label === 'typescript' || label === 'javascript') {
+      return new tsWorker();
+    }
+    return new editorWorker();
+  }
+};
+
+let extraLibLoaded = false;
+
+const loadScriptDefinitions = async () => {
+  if (extraLibLoaded) {
+    return;
+  }
+  try {
+    const definitions = await fetchScriptDefinitions();
+    monaco.typescript.javascriptDefaults.addExtraLib(definitions, 'ts:rule-runner.d.ts');
+    extraLibLoaded = true;
+  } catch {
+    // type definitions are optional — the editor still works without autocomplete
+  }
+};
+
+const props = defineProps<{ ledgerRefs?: string[] }>();
+
+let ledgersLib: monaco.IDisposable | undefined;
+
+const updateLedgerRefs = (refs: readonly string[]) => {
+  ledgersLib?.dispose();
+  const members = refs
+      .filter(ref => ref && ref !== 'system')
+      .map(ref => `    readonly ${JSON.stringify(ref)}: Ledger;`)
+      .join('\n');
+  ledgersLib = monaco.typescript.javascriptDefaults.addExtraLib(
+      `declare interface Ledgers {\n${members}\n}\n`,
+      'ts:rule-runner.ledgers.d.ts'
+  );
+};
+
+const model = defineModel<string>({default: ''});
+const container = ref<HTMLElement>();
+let editor: monaco.editor.IStandaloneCodeEditor | undefined;
+
+onMounted(async () => {
+  await loadScriptDefinitions();
+  updateLedgerRefs(props.ledgerRefs ?? []);
+
+  if (!container.value) {
+    return;
+  }
+
+  editor = monaco.editor.create(container.value, {
+    value: model.value,
+    language: 'javascript',
+    theme: 'vs-dark',
+    automaticLayout: true,
+    minimap: {enabled: false},
+    scrollBeyondLastLine: false,
+    fontSize: 13,
+    tabSize: 2,
+  });
+
+  editor.onDidChangeModelContent(() => {
+    const value = editor!.getValue();
+
+    if (value !== model.value) {
+      model.value = value;
+    }
+  });
+});
+
+watch(model, value => {
+  if (editor && value !== editor.getValue()) {
+    editor.setValue(value ?? '');
+  }
+});
+
+watch(() => props.ledgerRefs, refs => updateLedgerRefs(refs ?? []), {deep: true});
+
+onBeforeUnmount(() => {
+  editor?.dispose();
+  ledgersLib?.dispose();
+});
+</script>
+
+<template>
+  <div ref="container" class="script-editor"></div>
+</template>
+
+<style scoped>
+.script-editor {
+  width: 100%;
+  flex: 1 1 auto;
+  min-height: 12rem;
+}
+</style>
@@ -0,0 +1,3 @@
+export * from "./rules";
+
+export {default as ScriptEditor} from './ScriptEditor.vue';
@@ -0,0 +1,61 @@
+import {characterRuleBookApi, ruleBookApi} from "@/mammon";
+import {
+    CharacterRuleBookResponse,
+    CreateRuleBookRequest,
+    RuleBookResponse,
+    SetCharacterRuleBookRequest
+} from "@/generated/mammon";
+import {defineStore} from "pinia";
+import {ref, triggerRef} from "vue";
+
+export type RuleBook = RuleBookResponse;
+
+export const useRuleBooksStore = defineStore('rule-books', () => {
+    const ruleBooks = ref<RuleBook[]>([]);
+
+    const addRuleBook = (ruleBook: RuleBook) => {
+        ruleBooks.value.push(ruleBook);
+        triggerRef(ruleBooks);
+        return ruleBook;
+    };
+
+    const replaceRuleBook = (ruleBook: RuleBook) => {
+        const index = ruleBooks.value.findIndex(rb => rb.ruleBookId === ruleBook.ruleBookId);
+
+        if (index !== -1) {
+            ruleBooks.value[index] = ruleBook;
+        }
+        triggerRef(ruleBooks);
+        return ruleBook;
+    };
+
+    const findById = (ruleBookId: string): RuleBook | undefined => ruleBooks.value.find(rb => rb.ruleBookId === ruleBookId);
+    const create = (ruleBook: CreateRuleBookRequest) => ruleBookApi.createRuleBook(ruleBook).then(response => addRuleBook(response.data));
+    const update = (ruleBookId: string, ruleBook: CreateRuleBookRequest) => ruleBookApi.updateRuleBook(ruleBookId, ruleBook).then(response => replaceRuleBook(response.data));
+    const duplicate = (ruleBook: RuleBook) => create({
+        name: `${ruleBook.name} (copy)`,
+        usedForAcquisitions: ruleBook.usedForAcquisitions,
+        ledgerRefs: [...ruleBook.ledgerRefs],
+        script: ruleBook.script,
+    });
+
+    const remove = (ruleBookId: string) => ruleBookApi.deleteRuleBook(ruleBookId).then(() => {
+        ruleBooks.value = ruleBooks.value.filter(rb => rb.ruleBookId !== ruleBookId);
+    });
+
+    const refresh = () => ruleBookApi.findAllRuleBooks().then(response => ruleBooks.value = response.data);
+
+    refresh();
+
+    return {ruleBooks, findById, create, update, duplicate, remove, refresh};
+})
+
+export const findCharacterRuleBookByCharacterId = (characterId: number): Promise<CharacterRuleBookResponse> => characterRuleBookApi.findCharacterRuleBookByCharacterId(characterId)
+    .then(response => response.data)
+    .catch(() => ({characterId, ruleBookId: '', bindings: {}}));
+
+export const setCharacterRuleBookForCharacter = (characterId: number, ruleBook: SetCharacterRuleBookRequest): Promise<CharacterRuleBookResponse> => characterRuleBookApi.setCharacterRuleBookForCharacter(characterId, ruleBook)
+    .then(response => response.data);
+
+export const fetchScriptDefinitions = (): Promise<string> =>
+    ruleBookApi.getScriptDefinitions({responseType: 'text'}).then(response => response.data);
@@ -1,73 +1,73 @@
 <script setup lang="ts">
-import { useAuthStore } from '@/auth';
-import { Dropdown } from '@/components';
-import { RouterLink } from 'vue-router';
+import {Dropdown} from '@/components';
+import {RouterLink} from 'vue-router';
+import {routeNames} from '@/routes';

 const links = [
-    { name: "Market", path: "/market" },
-    { name: "Reprocess", path: "/reprocess" },
-    { name: "Tools", path: "/tools" }
+  {name: "Market", path: "/market"},
+  {name: "Ledger", path: "/ledgers"},
+  {name: "Rules", path: "/rules"},
+  {name: "Reprocess", path: "/reprocess"},
+  {name: "Tools", path: "/tools"}
 ];

-const authStore = useAuthStore();

 const logout = async () => {
-    await authStore.logout();
 }
 </script>

 <template>
-    <aside class="fixed top-0 left-0 w-64 h-screen transition-transform -translate-x-full sm:translate-x-0">
-        <div class="h-full px-3 py-4 overflow-y-auto bg-slate-700 flex flex-col">
-            <div class="mb-2 border-b-2 border-emerald-500">
-                <Dropdown class="mb-2 user-dropdown">
-                    <template #button>
-                        <span>{{ authStore.username }}</span>
-                    </template>
-                    <ul>
-                        <li>
-                            <RouterLink class="sidebar-button py-0.5 px-2" to="/characters">Characters</RouterLink>
-                        </li>
-                        <li>
-                            <RouterLink class="sidebar-button py-0.5 px-2" :to="{name: 'about'}">About EVE Online</RouterLink>
-                        </li>
-                        <li>
-                            <a class="sidebar-button py-0.5 px-2 text-amber-700" @click="logout">Logout</a>
-                        </li>
-                    </ul>
-                </Dropdown>
-            </div>
-            <ul class="space-y-2 font-medium">
-                <li v-for="link in links" :key="link.name">
-                    <RouterLink :to="link.path" class="sidebar-button p-2">
-                        <span>{{ link.name }}</span>
-                    </RouterLink>
-                </li>
-            </ul>
-        </div>
-    </aside>
+  <aside class="fixed top-0 left-0 w-64 h-screen transition-transform -translate-x-full sm:translate-x-0">
+    <div class="h-full px-3 py-4 overflow-y-auto bg-slate-700 flex flex-col">
+      <div class="mb-2 border-b-2 border-emerald-500">
+        <Dropdown class="mb-2 user-dropdown">
+          <template #button>
+            <span>NAME</span>
+          </template>
+          <ul>
+            <li>
+              <RouterLink class="sidebar-button py-0.5 px-2" to="/characters">Characters</RouterLink>
+            </li>
+            <li>
+              <RouterLink class="sidebar-button py-0.5 px-2" :to="{name: routeNames.about}">About EVE Online</RouterLink>
+            </li>
+            <li>
+              <a class="sidebar-button py-0.5 px-2 text-amber-700" @click="logout">Logout</a>
+            </li>
+          </ul>
+        </Dropdown>
+      </div>
+      <ul class="space-y-2 font-medium">
+        <li v-for="link in links" :key="link.name">
+          <RouterLink :to="link.path" class="sidebar-button p-2">
+            <span>{{ link.name }}</span>
+          </RouterLink>
+        </li>
+      </ul>
+    </div>
+  </aside>
 </template>

-<style scoped lang="postcss">
+<style scoped>
+@reference "@/style.css";
+
 .sidebar-button {
-    @apply flex items-center rounded-md hover:bg-slate-800 cursor-pointer;
+  @apply flex items-center rounded-md hover:bg-slate-800 cursor-pointer;
 }
+
 .router-link-active {
-    @apply bg-emerald-500 hover:bg-emerald-700;
+  @apply bg-emerald-500 hover:bg-emerald-700;
 }
+
 .user-dropdown {
-    @apply w-full;
-    :deep(>div) {
-        @apply w-full;
-        >div {
-            @apply w-full bg-slate-800;
-        }
-    }
-    :deep(>button) {
-        @apply bg-slate-700 hover:bg-slate-800 border-none flex items-center w-full;
-    }
-    &.dropdown-open:deep(>button) {
-        @apply bg-slate-800 rounded-b-none;
-    }
+  @apply w-full;
+}
+
+.user-dropdown :deep(>button) {
+  @apply bg-slate-700 hover:bg-slate-800 border-none flex items-center w-full;
+}
+
+.user-dropdown.dropdown-open :deep(>button) {
+  @apply bg-slate-800 rounded-b-none;
 }
 </style>
@@ -1,9 +1,15 @@
-@tailwind base;
-@tailwind components;
-@tailwind utilities;
+@import "tailwindcss";

+@custom-variant search-cancel (&::-webkit-search-cancel-button);
+
+@utility btn-icon {
+    @apply p-0 border-none bg-transparent hover:text-slate-400 hover:bg-transparent cursor-pointer;
+    > svg {
+        @apply w-6 h-6;
+    }
+}
@layer base {
-    span, table, input, th, tr, td, button, div, hr {
+    span, table, input, th, tr, td, button, a.button, div, hr {
        @apply border-slate-600 text-slate-100 placeholder-slate-400;
    }

@@ -11,12 +17,15 @@
        @apply bg-slate-800;
    }

-    button {
+    button, a.button {
        @apply py-0.5 px-2 border rounded bg-slate-600 hover:bg-slate-700;
    }
-    input {
+    input, select {
        @apply border bg-slate-500 rounded px-1;
    }
+    option {
+        @apply bg-slate-500;
+    }
    textarea {
        @apply border rounded bg-slate-500 w-full;
    }
@@ -49,6 +58,9 @@
            @apply bg-emerald-500 hover:bg-emerald-600;
        }
    }
+    tfoot>tr>td {
+        @apply font-semibold;
+    }


    ::-webkit-scrollbar {
@@ -66,9 +78,14 @@
    }

    .btn-icon {
-        @apply p-0 border-none bg-transparent hover:text-slate-400 hover:bg-transparent;
-        > svg {
-            @apply w-6 h-6;
+        @apply btn-icon;
+    }
+
+    a.tab {
+        @apply flex items-center px-4 me-2 rounded-t-md bg-slate-600 hover:bg-slate-700;
+
+        &.router-link-active {
+            @apply bg-emerald-500 hover:bg-emerald-700;
        }
    }
 }
@@ -0,0 +1,78 @@
+<script setup lang="ts">
+
+import {TransferTypes} from "@/transaction/transaction.ts";
+import {LedgerLabel, systemLedger, useLedgersStore} from "@/ledger";
+import {getMarketType, IskLabel, MarketTypeLabel} from "@/market";
+import {computedAsync} from "@vueuse/core";
+import {TransferResponse} from "@/generated/mammon";
+
+type TransferWithValue = TransferResponse & { marketTypeId: number; };
+
+interface Props {
+  transfers?: TransferResponse[]
+}
+
+const props = defineProps<Props>();
+
+const {findById} = useLedgersStore();
+
+const sortedArray = computedAsync(async () => {
+  if (!props.transfers) {
+    return [];
+  }
+
+  return (await Promise.all(props.transfers.map(async (transfer: TransferWithValue, index) => {
+    const fromLedger = findById(transfer.fromLedgerId) ?? systemLedger
+    const toLedger = findById(transfer.toLedgerId) ?? systemLedger
+
+    const item = transfer.marketTypeId ? await getMarketType(transfer.marketTypeId) : undefined;
+
+    return {
+      ...transfer,
+      order: index,
+      fromLedger,
+      toLedger,
+      itemName: item ? item.name : '',
+      fromLedgerName: fromLedger.name,
+      toLedgerName: toLedger.name
+    }
+  }))).sort((a, b) => a.order - b.order)
+}, []);
+
+</script>
+
+<template>
+  <div>
+    <table>
+      <thead>
+      <tr>
+        <th>From</th>
+        <th>To</th>
+        <th>Item</th>
+        <th>Quantity/Amount</th>
+      </tr>
+      </thead>
+      <tbody>
+      <tr v-for="t in sortedArray">
+        <td>
+          <LedgerLabel :ledger="t.fromLedger" />
+        </td>
+        <td>
+          <LedgerLabel :ledger="t.toLedger" />
+        </td>
+        <template v-if="t.type === TransferTypes.Item">
+          <td>
+            <MarketTypeLabel :id="t.marketTypeId" :name="t.itemName" />
+          </td>
+          <td class="text-right">{{ t.quantity }}</td>
+        </template>
+        <template v-else-if="t.type === TransferTypes.Isk">
+          <td colspan="2" class="text-right">
+            <IskLabel :amount="t.amount" :colored="false" />
+          </td>
+        </template>
+      </tr>
+      </tbody>
+    </table>
+  </div>
+</template>
@@ -0,0 +1,3 @@
+export * from './transaction'
+
+export {default as TransferList} from './TransferList.vue';
@@ -0,0 +1,7 @@
+import {TransferResponse} from "@/generated/mammon";
+
+export const TransferTypes = {
+    Isk: 'ISK',
+    Item: 'ITEM',
+} as const;
+export type TransferType = TransferResponse['type'];
@@ -1,16 +0,0 @@
-/** @type {import('tailwindcss').Config} */
-export default {
-  content: [
-    "./index.html",
-    "./src/**/*.{vue,js,ts,jsx,tsx}",
-  ],
-  theme: {
-    extend: {},
-  },
-  plugins: [
-    require('tailwindcss/plugin')(({ addVariant }) => {
-      addVariant('search-cancel', '&::-webkit-search-cancel-button');
-    }),
-  ],
-}
-
@@ -26,7 +26,8 @@
      "src/*": [
        "./src/*"
      ]
-    }
+    },
+    "allowSyntheticDefaultImports": true
  },
  "include": ["src/**/*.ts", "src/**/*.d.ts", "src/**/*.tsx", "src/**/*.vue"],
  "references": [{ "path": "./tsconfig.node.json" }]
@@ -2,11 +2,13 @@ import vue from '@vitejs/plugin-vue';
 import * as path from "path";
 import { defineConfig } from 'vite';
 import runtimeEnv from 'vite-plugin-runtime-env';
+import tailwindcss from '@tailwindcss/vite'

 export default defineConfig({
    plugins: [
        runtimeEnv(),
        vue(),
+        tailwindcss(),
    ],
    resolve: {
        alias: {
Author	SHA1	Message	Date
Sirttas	9cd0d5fb5e	rule book dup/delete	2026-06-09 23:44:16 +02:00
Sirttas	5ac369a643	fix	2026-06-09 21:56:12 +02:00
Sophie-Gaëlle CALLOCH	b2c97c1327	rulebook name	2026-06-09 18:00:25 +02:00
Sirttas	4ae044dace	win size	2026-06-08 18:54:53 +02:00
Sirttas	c444f51423	js editor + fix js runner	2026-06-08 08:27:42 +02:00
Sirttas	a201a95756	js editor + fix js runner	2026-06-07 23:18:53 +02:00
Sirttas	b32169f433	js editor	2026-06-07 22:37:18 +02:00
Sirttas	023693c4c8	text area	2026-06-07 22:06:53 +02:00
Sirttas	47bd728530	cleanup	2026-06-06 23:52:50 +02:00
Sirttas	7e0ea10d68	corporation transactions + cleanup	2026-06-06 23:44:09 +02:00
Sirttas	cd1965acc4	transfer list order	2026-06-06 20:30:58 +02:00
Sirttas	653f7dbeeb	acquisition ui	2026-06-06 15:53:54 +02:00
Sirttas	5506125b2e	cleanup	2026-06-06 14:56:03 +02:00
Sirttas	e6ee697508	acquisition presentation	2026-06-06 14:49:28 +02:00
Sirttas	bef14bcdcc	character in transaction list	2026-06-05 18:41:59 +02:00
Sophie-Gaëlle CALLOCH	8d0e5ffc1a	cleanup	2026-06-05 16:41:08 +02:00
Sophie-Gaëlle CALLOCH	680e8d8b95	system ledger entity	2026-06-05 16:23:57 +02:00
Sirttas	13ba8556a4	rename	2026-06-05 08:15:03 +02:00
Sirttas	46a2538bef	no color in transfers	2026-06-04 19:51:04 +02:00
Sirttas	57b9ec17de	fix things	2026-06-04 11:24:55 +02:00
Sirttas	af3b26a273	fix things	2026-06-04 11:12:26 +02:00
Sophie-Gaëlle CALLOCH	5da9003b14	bounty activities	2026-06-02 17:54:42 +02:00
Sirttas	ba548583ba	ledger label system green	2026-06-01 23:05:23 +02:00
Sirttas	5c12a8af43	dropdown floating	2026-06-01 22:29:06 +02:00
Sirttas	05210fea4b	transfer list	2026-06-01 22:19:26 +02:00
Sirttas	f28201e711	tables display	2026-06-01 21:04:39 +02:00
Sirttas	c23ec0cb53	ledger balance	2026-06-01 19:22:27 +02:00
Sirttas	42c7e59d63	balance endpoint	2026-06-01 17:39:14 +02:00
Sirttas	192cf7d9cb	ledger view page structure	2026-06-01 16:24:35 +02:00
Sirttas	3235cf21ba	transaction list display	2026-05-31 23:10:50 +02:00
Sirttas	47ee14319d	transaction list api	2026-05-31 21:54:56 +02:00
Sirttas	457d2a5161	cleanup rules	2026-05-31 18:57:10 +02:00
Sirttas	1358aaa705	cleanup routes names	2026-05-31 18:33:35 +02:00
Sirttas	d7bae268da	character rule book front	2026-05-31 18:20:46 +02:00
Sirttas	9310397320	character rule book front	2026-05-31 18:19:45 +02:00
Sirttas	ba81d7b6a8	rule book front	2026-05-31 17:00:49 +02:00
Sirttas	676ff961ed	rename rule set to rule	2026-05-28 13:15:15 +02:00
Sirttas	b40b58f866	rename rule to rule clause	2026-05-28 11:37:09 +02:00
Sirttas	9acbc101e1	post processing call from front	2026-05-26 22:32:43 +02:00
Sirttas	ccc6b827f0	upate dependancies	2026-05-25 18:37:12 +02:00
Sirttas	0a2894b378	sortable	2026-05-25 18:36:18 +02:00
Sirttas	2d6930d38d	from to at	2026-05-24 17:04:02 +02:00
Sirttas	11fbe847f2	pretyness	2026-05-24 17:00:34 +02:00
Sirttas	72933ada6e	fix rules bugs	2026-05-24 16:22:39 +02:00
Sirttas	e10d58d231	rule book ui	2026-05-24 14:28:12 +02:00
Sirttas	4b39d491d2	rule book ui	2026-05-24 13:39:35 +02:00
Sirttas	a1dbe41b6c	character rules	2026-05-23 23:47:06 +02:00
Sirttas	e233e609e6	character endpoint	2026-05-23 23:19:45 +02:00
Sirttas	d64b718573	character endpoint	2026-05-23 21:33:23 +02:00
Sirttas	153dff6bc7	rules endpoint	2026-05-23 16:03:48 +02:00
Sirttas	4fbced2c70	ledger balance	2026-05-23 14:29:25 +02:00
Sophie-Gaëlle CALLOCH	2970f48e65	rename combining ledger to combined	2026-05-22 14:53:33 +02:00
Sirttas	e137bec8dd	ledger uuid	2026-05-20 00:18:27 +02:00
Sirttas	3ca0cf23f1	edit ledger	2026-05-18 21:19:01 +02:00
Sirttas	02466eea14	ledger empty name	2026-05-17 21:26:23 +02:00
Sirttas	f4b590bc3b	rename leger label	2026-05-17 21:14:04 +02:00
Sirttas	65bb13aa3b	ledger list clean + fix	2026-05-17 21:03:56 +02:00
Sirttas	2332ad2216	ledger list and modal	2026-05-17 19:53:55 +02:00
Sirttas	8005e7a45b	ledger list and modal	2026-05-17 19:19:01 +02:00
Sirttas	f9ae0d142a	ledger gemory draft	2026-05-17 12:42:25 +02:00
Sirttas	e81fdc24bb	fix is logged in check	2025-05-10 09:33:43 +02:00
Sirttas	778de8ca14	update an fix login	2025-05-10 09:30:16 +02:00
Sirttas	00c37c0a37	update an cleanup	2025-03-08 14:38:05 +01:00
Sirttas	a56580ce27	refresh acquisitions	2024-06-18 12:02:56 +02:00
Sirttas	11f886cd71	Add total if name is missing	2024-06-04 16:18:52 +02:00
Sirttas	ac07236936	total in acquisition table	2024-06-04 14:39:48 +02:00
Sirttas	9aa37b355e	tracking progress bar	2024-06-02 16:51:06 +02:00
Sirttas	12ad7d36ff	cleanup acquisitions	2024-06-02 15:50:17 +02:00
Sirttas	c77a6ff811	acquisitions in tracking	2024-06-02 08:16:20 +02:00