@backtest-kit/ui 4.0.1 → 5.1.0

package/README.md

@@ -67,25 +67,127 @@ setLogger({
 
 ## 📐 Dashboard Revenue Math
 
-The **Revenue** metrics on the dashboard are calculated in **dollar terms**, assuming a fixed position size of **$100 per DCA entry**.
+The **Revenue** metrics on the dashboard are calculated in **dollar terms** by summing the `pnlCost` field from all closed signals within each time window.
 
 ### Dollar PnL formula
 
 ```
-dollar_pnl = pnlPercentage × totalEntries
+revenue[window] = Σ signal.pnl.pnlCost   (for all closed signals in that window)
 ```
 
-| `totalEntries` | Effective position | Dollar PnL (example: +5%) |
-|:--------------:|-------------------:|-------------------------:|
-| 1 | $100 | +$5.00 |
-| 2 | $200 | +$10.00 |
-| 3 | $300 | +$15.00 |
+`pnlCost` is computed by the backend (`toProfitLossDto`) as:
 
-- **`pnlPercentage`** — percentage PnL as stored in the signal (e.g. `5` = 5 %). It does **not** change with DCA averaging.
-- **`totalEntries`** — number of DCA buy entries that were executed for the signal (`IPublicSignalRow.totalEntries`). A regular (non-DCA) signal has `totalEntries = 1`, so the formula degrades to the plain percentage.
-- **Fallback** — if `totalEntries` is `0` or absent (legacy data), the raw `pnlPercentage` is used as-is.
+```
+pnlCost = (pnlPercentage / 100) × pnlEntries
+```
+
+| Field | Source | Description |
+|-------|--------|-------------|
+| `pnl.pnlCost` | `IStorageSignalRow` | Absolute P&L in USD — the only value summed for revenue |
+| `pnl.pnlPercentage` | `IStorageSignalRow` | Percentage P&L (accounts for DCA-weighted entry price, slippage, and fees) |
+| `pnl.pnlEntries` | `IStorageSignalRow` | Total invested capital in USD — sum of all entry costs (`Σ entry.cost`) |
+
+**Example** (1 DCA entry at $100, position closed +5%):
+
+| DCA entries | `pnlEntries` | `pnlPercentage` | `pnlCost` |
+|:-----------:|-------------:|----------------:|----------:|
+| 1 | $100 | 5 % | +$5.00 |
+| 2 | $200 | 5 % | +$10.00 |
+| 3 | $300 | 5 % | +$15.00 |
+
+### Time windows
+
+The anchor point depends on execution mode:
+
+- **Backtest mode** — latest `updatedAt` across all closed signals (time windows are relative to the end of the run)
+- **Live mode** — `Date.now()` (wall-clock time)
+
+| Window | Range |
+|--------|-------|
+| Today | `>= startOf(anchorDay)` |
+| Yesterday | `[anchorDay − 1d, anchorDay)` |
+| 7 days | `>= anchorDay − 7d` |
+| 31 days | `>= anchorDay − 31d` |
+
+Revenue and signal count are tracked separately for each window and aggregated across all symbols on the Dashboard.
+
+## 📐 Position PNL Math
+
+### Effective entry price (DCA-weighted)
+
+When multiple DCA entries exist, the effective open price is a **cost-weighted harmonic mean**:
+
+```
+effectivePrice = Σcost / Σ(cost / price)
+```
+
+This is the correct formula for fixed-dollar entries (not simple average), because buying $100 worth at different prices gives different coin quantities.
+
+### Partial closes (PP/PL)
+
+Each partial stores a `costBasisAtClose` snapshot — the running dollar cost-basis **before** that partial fired. This avoids replaying the full entry history on every call.
+
+**Cost-basis replay:**
+
+```
+for each partial[i]:
+    closedDollar      += (percent[i] / 100) × costBasisAtClose[i]
+    remainingCostBasis = costBasisAtClose[i] × (1 - percent[i] / 100)
+
+# DCA entries added AFTER the last partial are appended:
+remainingCostBasis += Σ entry.cost for entries[lastEntryCount..]
+
+totalClosedPercent = closedDollar / totalInvested × 100
+```
+
+**Effective price through partials** is computed iteratively so that a partial sell does not change the entry price of the remaining coins:
+
+```
+# partial[0]:
+  effPrice = costBasisAtClose[0] / Σ(cost/price for entries[0..cnt[0]])
+
+# partial[j]:
+  remainingCB = prev.costBasisAtClose × (1 - prev.percent / 100)
+  oldCoins    = remainingCB / effPrice        ← coins still held
+  newCoins    = Σ(cost/price for DCA entries between j-1 and j)
+  effPrice    = (remainingCB + newCost) / (oldCoins + newCoins)
+```
+
+### toProfitLossDto — weighted PNL with slippage & fees
+
+**Without partials:**
+
+```
+priceOpenSlip  = effectivePrice × (1 ± slippage)
+priceCloseSlip = priceClose     × (1 ∓ slippage)
+
+pnlPercentage = (priceCloseSlip - priceOpenSlip) / priceOpenSlip × 100
+fee           = CC_PERCENT_FEE × (1 + priceCloseSlip / priceOpenSlip)
+pnlPercentage -= fee
+```
+
+**With partials — dollar-weighted sum:**
+
+```
+weight[i] = (percent[i] / 100 × costBasisAtClose[i]) / totalInvested
+
+totalWeightedPnl = Σ weight[i] × pnl[i]           # each partial at its own effectivePrice
+                 + remainingWeight × pnlRemaining   # rest closed at final priceClose
+
+fee = CC_PERCENT_FEE                                              # open (once)
+    + Σ CC_PERCENT_FEE × weight[i] × (closeSlip[i] / openSlip[i])  # per partial
+    + CC_PERCENT_FEE × remainingWeight × (closeSlip / openSlip)     # final close
+
+pnlPercentage = totalWeightedPnl - fee
+pnlCost       = pnlPercentage / 100 × totalInvested
+```
 
-This scaling is applied to all time-window revenue fields: *today*, *yesterday*, *7 days*, and *31 days*.
+| Field | Description |
+|-------|-------------|
+| `totalInvested` | `Σ entry.cost` (or `CC_POSITION_ENTRY_COST` if no `_entry`) |
+| `weight[i]` | Real dollar share of each partial relative to `totalInvested` |
+| `effectivePrice` at partial `i` | Computed via iterative `costBasisAtClose` replay up to `partials[i]` |
+| `priceOpen` in result | `getEffectivePriceOpen(signal)` — DCA-weighted harmonic mean across all entries |
 
 ## 🖥️ Dashboard Views
 

package/build/index.cjs

@@ -68,12 +68,14 @@ const mockServices$1 = {
     storageMockService: Symbol("storageMockService"),
     exchangeMockService: Symbol("exchangeMockService"),
     logMockService: Symbol("logMockService"),
+    statusMockService: Symbol("statusMockService"),
 };
 const viewServices$1 = {
     notificationViewService: Symbol("notificationViewService"),
     storageViewService: Symbol("storageViewService"),
     exchangeViewService: Symbol("exchangeViewService"),
     logViewService: Symbol("logViewService"),
+    statusViewService: Symbol("statusViewService"),
 };
 const TYPES = {
     ...baseServices$1,
@@ -176,9 +178,9 @@ class LoggerService {
     }
 }
 
-const MOCK_PATH$2 = "./mock/notifications.json";
+const MOCK_PATH$3 = "./mock/notifications.json";
 const READ_NOTIFICATION_LIST_FN = functoolsKit.singleshot(async () => {
-    const data = await fs.readFile(MOCK_PATH$2, "utf-8");
+    const data = await fs.readFile(MOCK_PATH$3, "utf-8");
     return JSON.parse(data);
 });
 const DEFAULT_LIMIT$3 = 25;
@@ -238,9 +240,9 @@ class NotificationMockService {
     }
 }
 
-const MOCK_PATH$1 = "./mock/db";
+const MOCK_PATH$2 = "./mock/db";
 const READ_BACKTEST_STORAGE_FN = functoolsKit.singleshot(async () => {
-    const dbPath = path.join(process.cwd(), MOCK_PATH$1);
+    const dbPath = path.join(process.cwd(), MOCK_PATH$2);
     const files = await fs.readdir(dbPath);
     const signals = [];
     for (const file of files) {
@@ -275,6 +277,7 @@ class StorageMockService {
     }
 }
 
+const MS_PER_MINUTE$1 = 60000;
 class ExchangeMockService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
@@ -298,12 +301,31 @@ class ExchangeMockService {
                 interval,
             });
         };
+        this.getLiveCandles = async (signalId, interval) => {
+            this.loggerService.log("exchangeMockService getLiveCandles", {
+                signalId,
+                interval,
+            });
+            const signal = await this.storageMockService.findSignalById(signalId);
+            if (!signal) {
+                throw new Error(`Signal with ID ${signalId} not found`);
+            }
+            const { pendingAt, scheduledAt, minuteEstimatedTime, } = signal;
+            const eventAt = pendingAt || scheduledAt;
+            return await this.exchangeService.getRangeCandles({
+                symbol: signal.symbol,
+                exchangeName: signal.exchangeName,
+                signalStartTime: eventAt,
+                signalStopTime: eventAt + minuteEstimatedTime * MS_PER_MINUTE$1,
+                interval,
+            });
+        };
     }
 }
 
-const MOCK_PATH = "./mock/logs.json";
+const MOCK_PATH$1 = "./mock/logs.json";
 const READ_LOG_LIST_FN = functoolsKit.singleshot(async () => {
-    const data = await fs.readFile(MOCK_PATH, "utf-8");
+    const data = await fs.readFile(MOCK_PATH$1, "utf-8");
     return JSON.parse(data);
 });
 const DEFAULT_LIMIT$2 = 25;
@@ -351,6 +373,68 @@ class LogMockService {
     }
 }
 
+const MOCK_PATH = "./mock/status.json";
+const READ_STATUS_LIST_FN = functoolsKit.singleshot(async () => {
+    const data = await fs.readFile(MOCK_PATH, "utf-8");
+    return JSON.parse(data);
+});
+class StatusMockService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.getStatusList = async () => {
+            this.loggerService.log("statusMockService getStatusList");
+            const list = await READ_STATUS_LIST_FN();
+            return list.map(({ id, symbol, strategyName, exchangeName }) => ({
+                id,
+                symbol,
+                strategyName,
+                exchangeName,
+                status: "pending",
+            }));
+        };
+        this.getStatusMap = async () => {
+            this.loggerService.log("statusMockService getStatusMap");
+            const list = await this.getStatusList();
+            return list.reduce((acm, cur) => ({ ...acm, [cur.id]: cur }), {});
+        };
+        this.getStatusOne = async (id) => {
+            this.loggerService.log("statusMockService getStatusOne", { id });
+            const list = await READ_STATUS_LIST_FN();
+            const signal = list.find((s) => s.id === id);
+            if (!signal) {
+                return null;
+            }
+            const positionEntries = signal._entry ?? [];
+            const positionLevels = positionEntries.map((e) => e.price);
+            const positionPartials = signal._partial ?? [];
+            return {
+                signalId: signal.signalId,
+                position: signal.position,
+                symbol: signal.symbol,
+                exchangeName: signal.exchangeName,
+                strategyName: signal.strategyName,
+                totalEntries: signal.totalEntries,
+                totalPartials: signal.totalPartials,
+                originalPriceStopLoss: signal.originalPriceStopLoss,
+                originalPriceTakeProfit: signal.originalPriceTakeProfit,
+                originalPriceOpen: signal.originalPriceOpen,
+                priceOpen: signal.priceOpen,
+                priceTakeProfit: signal.priceTakeProfit,
+                priceStopLoss: signal.priceStopLoss,
+                pnlPercentage: signal.pnl.pnlPercentage,
+                pnlCost: signal.pnl.pnlCost,
+                pnlEntries: signal.pnl.pnlEntries,
+                partialExecuted: signal.partialExecuted,
+                minuteEstimatedTime: signal.minuteEstimatedTime,
+                pendingAt: signal.pendingAt,
+                positionLevels,
+                positionEntries,
+                positionPartials,
+            };
+        };
+    }
+}
+
 const DEFAULT_LIMIT$1 = 25;
 const DEFAULT_OFFSET$1 = 0;
 const CREATE_FILTER_LIST_FN$1 = (filterData) => Object.keys(filterData).map((key) => (row) => new RegExp(filterData[key], "i").test(row[key]));
@@ -495,6 +579,7 @@ class StorageViewService {
     }
 }
 
+const MS_PER_MINUTE = 60000;
 class ExchangeViewService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
@@ -522,6 +607,28 @@ class ExchangeViewService {
                 interval,
             });
         };
+        this.getLiveCandles = async (signalId, interval) => {
+            this.loggerService.log("exchangeViewService getLiveCandles", {
+                signalId,
+                interval,
+            });
+            if (CC_ENABLE_MOCK) {
+                return await this.exchangeMockService.getLiveCandles(signalId, interval);
+            }
+            const signal = await this.storageViewService.findSignalById(signalId);
+            if (!signal) {
+                throw new Error(`Signal with ID ${signalId} not found`);
+            }
+            const { pendingAt, scheduledAt, minuteEstimatedTime, } = signal;
+            const eventAt = pendingAt || scheduledAt;
+            return await this.exchangeService.getRangeCandles({
+                symbol: signal.symbol,
+                exchangeName: signal.exchangeName,
+                signalStartTime: eventAt,
+                signalStopTime: eventAt + minuteEstimatedTime * MS_PER_MINUTE,
+                interval,
+            });
+        };
     }
 }
 
@@ -580,6 +687,100 @@ class LogViewService {
     }
 }
 
+class StatusViewService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.statusMockService = inject(TYPES.statusMockService);
+        this.getStatusList = async () => {
+            this.loggerService.log("statusViewService getStatusList");
+            if (CC_ENABLE_MOCK) {
+                const liveList = await this.statusMockService.getStatusList();
+                return liveList.filter(({ status }) => status === "pending");
+            }
+            return await backtestKit.Live.list();
+        };
+        this.getStatusMap = async () => {
+            this.loggerService.log("statusViewService getStatusMap");
+            if (CC_ENABLE_MOCK) {
+                return await this.statusMockService.getStatusMap();
+            }
+            const liveList = await backtestKit.Live.list();
+            return liveList
+                .filter(({ status }) => status === "pending")
+                .reduce((acm, cur) => ({ ...acm, [cur.id]: cur }), {});
+        };
+        this.getStatusOne = async (id) => {
+            this.loggerService.log("statusViewService getStatusOne", {
+                id,
+            });
+            if (CC_ENABLE_MOCK) {
+                return await this.statusMockService.getStatusOne(id);
+            }
+            const liveList = await backtestKit.Live.list();
+            const liveOne = liveList.find((live) => live.id === id);
+            if (!liveOne) {
+                throw new Error(`Live with id ${id} not found`);
+            }
+            const { symbol, strategyName, exchangeName } = liveOne;
+            const currentPrice = await backtestKit.Exchange.getAveragePrice(symbol, {
+                exchangeName,
+            });
+            const pendingSignal = await backtestKit.Live.getPendingSignal(symbol, currentPrice, {
+                strategyName,
+                exchangeName,
+            });
+            if (!pendingSignal) {
+                return null;
+            }
+            const positionLevels = await backtestKit.Live.getPositionLevels(symbol, {
+                strategyName,
+                exchangeName,
+            });
+            if (!positionLevels) {
+                return null;
+            }
+            const positionEntries = await backtestKit.Live.getPositionEntries(symbol, {
+                strategyName,
+                exchangeName,
+            });
+            if (!positionEntries) {
+                return null;
+            }
+            const positionPartials = await backtestKit.Live.getPositionPartials(symbol, {
+                strategyName,
+                exchangeName,
+            });
+            if (!positionPartials) {
+                return null;
+            }
+            return {
+                signalId: pendingSignal.id,
+                position: pendingSignal.position,
+                symbol: pendingSignal.symbol,
+                exchangeName: pendingSignal.exchangeName,
+                strategyName: pendingSignal.strategyName,
+                totalEntries: pendingSignal.totalEntries,
+                totalPartials: pendingSignal.totalPartials,
+                originalPriceStopLoss: pendingSignal.originalPriceStopLoss,
+                originalPriceTakeProfit: pendingSignal.originalPriceTakeProfit,
+                originalPriceOpen: pendingSignal.originalPriceOpen,
+                priceOpen: pendingSignal.priceOpen,
+                priceTakeProfit: pendingSignal.priceTakeProfit,
+                priceStopLoss: pendingSignal.priceStopLoss,
+                pnlPercentage: pendingSignal.pnl.pnlPercentage,
+                pnlCost: pendingSignal.pnl.pnlCost,
+                pnlEntries: pendingSignal.pnl.pnlEntries,
+                partialExecuted: pendingSignal.partialExecuted,
+                pendingAt: pendingSignal.pendingAt,
+                minuteEstimatedTime: pendingSignal.minuteEstimatedTime,
+                positionEntries,
+                positionLevels,
+                positionPartials,
+            };
+        };
+    }
+}
+
 const symbol_list = [
     {
         icon: "/icon/btc.png",
@@ -705,22 +906,6 @@ class SymbolMetaService {
     }
 }
 
-const PRICE_TIMEOUT = 120000;
-const CREATE_KEY_FN = (symbol, strategyName, exchangeName, frameName, backtest) => {
-    const parts = [symbol, strategyName, exchangeName];
-    if (frameName)
-        parts.push(frameName);
-    parts.push(backtest ? "backtest" : "live");
-    return parts.join(":");
-};
-const GET_SUBJECT_FN = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN(symbol, strategyName, exchangeName, frameName, backtest), () => new functoolsKit.BehaviorSubject());
-const GET_PRICE_FN = async (symbol, strategyName, exchangeName, frameName, backtest) => {
-    const priceSubject = GET_SUBJECT_FN(symbol, strategyName, exchangeName, frameName, backtest);
-    if (priceSubject.data) {
-        return priceSubject.data;
-    }
-    return await functoolsKit.waitForNext(priceSubject, (data) => !!data, PRICE_TIMEOUT);
-};
 class PriceConnectionService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
@@ -732,19 +917,8 @@ class PriceConnectionService {
                 frameName,
                 backtest,
             });
-            const currentPrice = await GET_PRICE_FN(symbol, strategyName, exchangeName, frameName, backtest);
-            if (typeof currentPrice === "symbol") {
-                throw new Error(`Price for ${CREATE_KEY_FN(symbol, strategyName, exchangeName, frameName, backtest)} not received within timeout`);
-            }
-            return currentPrice;
+            return await backtestKit.lib.priceMetaService.getCurrentPrice(symbol, { strategyName, exchangeName, frameName }, backtest);
         };
-        this.init = functoolsKit.singleshot(async () => {
-            this.loggerService.log("priceConnectionService init");
-            backtestKit.listenSignal((event) => {
-                const priceSubject = GET_SUBJECT_FN(event.symbol, event.strategyName, event.exchangeName, event.frameName, event.backtest);
-                event.currentPrice && priceSubject.next(event.currentPrice);
-            });
-        });
     }
 }
 
@@ -764,12 +938,14 @@ class PriceConnectionService {
     provide(TYPES.storageMockService, () => new StorageMockService());
     provide(TYPES.exchangeMockService, () => new ExchangeMockService());
     provide(TYPES.logMockService, () => new LogMockService());
+    provide(TYPES.statusMockService, () => new StatusMockService());
 }
 {
     provide(TYPES.notificationViewService, () => new NotificationViewService());
     provide(TYPES.storageViewService, () => new StorageViewService());
     provide(TYPES.exchangeViewService, () => new ExchangeViewService());
     provide(TYPES.logViewService, () => new LogViewService());
+    provide(TYPES.statusViewService, () => new StatusViewService());
 }
 
 const baseServices = {
@@ -788,12 +964,14 @@ const mockServices = {
     storageMockService: inject(TYPES.storageMockService),
     exchangeMockService: inject(TYPES.exchangeMockService),
     logMockService: inject(TYPES.logMockService),
+    statusMockService: inject(TYPES.statusMockService),
 };
 const viewServices = {
     notificationViewService: inject(TYPES.notificationViewService),
     storageViewService: inject(TYPES.storageViewService),
     exchangeViewService: inject(TYPES.exchangeViewService),
     logViewService: inject(TYPES.logViewService),
+    statusViewService: inject(TYPES.statusViewService),
 };
 const ioc = {
     ...baseServices,
@@ -1127,6 +1305,92 @@ router$6.post("/api/v1/mock/log_filter", async (req, res) => {
         });
     }
 });
+router$6.post("/api/v1/mock/candles_live", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { signalId, interval, requestId, serviceName } = request;
+        const data = await ioc.exchangeMockService.getLiveCandles(signalId, interval);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/candles_live ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/candles_live error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+// StatusMockService endpoints
+router$6.post("/api/v1/mock/status_list", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.statusMockService.getStatusList();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/status_list ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/status_list error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$6.post("/api/v1/mock/status_one/:id", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const id = req.params.id;
+        const data = await ioc.statusMockService.getStatusOne(id);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/status_one/:id ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/status_one/:id error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
 
 const router$5 = Router({
     params: true,
@@ -1193,6 +1457,34 @@ router$5.post("/api/v1/view/candles_point", async (req, res) => {
         });
     }
 });
+router$5.post("/api/v1/view/candles_live", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { signalId, interval, requestId, serviceName } = request;
+        const data = await ioc.exchangeViewService.getLiveCandles(signalId, interval);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/candles_live ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/candles_live error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
 // NotificationViewService endpoints
 router$5.post("/api/v1/view/notification_list", async (req, res) => {
     try {
@@ -1451,6 +1743,64 @@ router$5.post("/api/v1/view/log_filter", async (req, res) => {
         });
     }
 });
+// StatusViewService endpoints
+router$5.post("/api/v1/view/status_list", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.statusViewService.getStatusList();
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/status_list ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/status_list error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$5.post("/api/v1/view/status_one/:id", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const id = req.params.id;
+        const data = await ioc.statusViewService.getStatusOne(id);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/status_one/:id ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/status_one/:id error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
 
 const require$2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
 function getModulesPath() {