aidev/goldenChart
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

전략 시간봉 오류 수정

Browse Source
This commit is contained in:
Macbook
2026-05-28 02:01:36 +09:00
parent 01218b99c9
commit 5f9b20d907
9 changed files with 362 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/src/main/java/com/goldenchart/service/StrategyDslTimeframeNormalizer.java
+75 -25
View File
@@ -42,20 +42,7 @@ public class StrategyDslTimeframeNormalizer {
if (root == null || root.isNull()) return root;
if ("TIMEFRAME".equals(root.path("type").asText(""))) {
// START 다중 분봉(candleTypes) — stale 1m 제거 후 candleType 동기화
if (hasCandleTypesArray(root)) {
return syncTimeframePrimary(reconcileStartCandleTypes(root));
}
String current = LiveStrategyTimeframeService.normalize(root.path("candleType").asText("1m"));
// 편집기에서 명시한 단일 분봉(3m, 5m 등)은 조건 노드 기본 1m 추론으로 덮어쓰지 않음
if (!"1m".equals(current)) {
return root;
}
String expected = inferPrimaryCandleType(root, strategyName);
if (!expected.equals(current)) {
return copyTimeframeWithCandleType(root, expected);
}
return root;
return writeResolvedTimeframe(root, strategyName);
}
if (hasTimeframeScope(root)) return root;
@@ -65,6 +52,9 @@ public class StrategyDslTimeframeNormalizer {
wrapped.put("id", UUID.randomUUID().toString());
wrapped.put("type", "TIMEFRAME");
wrapped.put("candleType", primary);
ArrayNode candleTypes = objectMapper.createArrayNode();
candleTypes.add(primary);
wrapped.set("candleTypes", candleTypes);
ArrayNode children = objectMapper.createArrayNode();
children.add(root);
wrapped.set("children", children);
@@ -111,6 +101,9 @@ public class StrategyDslTimeframeNormalizer {
}
private static boolean hasExplicitStartTimeframe(JsonNode buyTf) {
Set<String> resolved = resolveStartCandleTypes(buyTf);
if (resolved.size() > 1) return true;
if (resolved.size() == 1 && !resolved.contains("1m")) return true;
if (hasCandleTypesArray(buyTf)) return true;
String ct = LiveStrategyTimeframeService.normalize(buyTf.path("candleType").asText("1m"));
return !"1m".equals(ct);
@@ -274,17 +267,57 @@ public class StrategyDslTimeframeNormalizer {
}
/**
* START candleTypes 에 남은 레거시 1m 제거.
* <ul>
* <li>[1m, 5m] + 조건 leftCandleType 5m → [5m] (편집기 5m만 선택·1m 기본값 잔존)</li>
* <li>[1m, 3m, 5m] 다중 OR 선택은 유지</li>
* <li>조건에 1m 명시 시 유지</li>
* </ul>
* START 평가 분봉 해석 — 조건 left/rightCandleType · START candleTypes/candleType 통합.
* 1m·3m·5m·15m·1h 등 모든 분봉에 동일 규칙 적용.
*/
public static Set<String> resolveStartCandleTypes(JsonNode timeframeNode) {
ObjectNode reconciled = reconcileStartCandleTypesStatic(timeframeNode);
Set<String> fromStart = readStartCandleTypesFromNode(reconciled);
JsonNode subtree = firstTimeframeChild(timeframeNode);
Set<String> fromConditions = collectExplicitCandleTypes(subtree);
if (fromConditions.isEmpty()) {
return fromStart;
}
if (fromConditions.size() == 1) {
String required = fromConditions.iterator().next();
// 레거시 [1m, X] — 조건이 X 단일 분봉이면 X만
if (fromStart.size() == 2 && fromStart.contains("1m") && fromStart.contains(required)) {
return Set.of(required);
}
// START 1m 기본값만 있고 조건은 다른 분봉
if (isLegacyDefaultStartOnly(fromStart) && !"1m".equals(required)) {
return Set.of(required);
}
// 의도적 다중 OR [1m,3m,5m] 또는 [3m,5m] — START 배열 유지
if (fromStart.size() >= 2 && fromStart.contains(required)) {
return fromStart;
}
if (!fromStart.equals(Set.of(required))) {
return Set.of(required);
}
return fromStart;
}
// 조건에 복수 분봉 명시 — START가 상위집합이면 START 유지 (다중 OR)
if (fromStart.containsAll(fromConditions) && fromStart.size() >= fromConditions.size()) {
return fromStart;
}
return fromConditions;
}
private ObjectNode writeResolvedTimeframe(JsonNode root, String strategyName) {
Set<String> resolved = resolveStartCandleTypes(root);
if (resolved.isEmpty()) {
resolved = Set.of(inferPrimaryCandleType(root, strategyName));
}
return copyTimeframeWithCandleTypes(root, resolved);
}
private static Set<String> readStartCandleTypesFromNode(JsonNode tf) {
Set<String> out = new LinkedHashSet<>();
JsonNode arr = reconciled.path("candleTypes");
JsonNode arr = tf.path("candleTypes");
if (arr.isArray() && !arr.isEmpty()) {
for (JsonNode t : arr) {
String ct = LiveStrategyTimeframeService.normalize(t.asText(""));
@@ -292,11 +325,14 @@ public class StrategyDslTimeframeNormalizer {
}
return out;
}
out.add(LiveStrategyTimeframeService.normalize(
reconciled.path("candleType").asText("1m")));
out.add(LiveStrategyTimeframeService.normalize(tf.path("candleType").asText("1m")));
return out;
}
private static boolean isLegacyDefaultStartOnly(Set<String> fromStart) {
return fromStart.size() == 1 && fromStart.contains("1m");
}
private ObjectNode reconcileStartCandleTypes(JsonNode tf) {
return reconcileStartCandleTypesStatic(tf);
}
@@ -349,9 +385,23 @@ public class StrategyDslTimeframeNormalizer {
return copy;
}
private ObjectNode copyTimeframeWithCandleType(JsonNode tf, String candleType) {
private ObjectNode copyTimeframeWithCandleTypes(JsonNode tf, Set<String> types) {
ObjectNode copy = tf.deepCopy();
copy.put("candleType", LiveStrategyTimeframeService.normalize(candleType));
ArrayNode arr = JsonNodeFactory.instance.arrayNode();
List<String> ordered = new ArrayList<>(types);
for (String ct : ordered) {
arr.add(LiveStrategyTimeframeService.normalize(ct));
}
if (arr.isEmpty()) {
arr.add("1m");
}
copy.set("candleTypes", arr);
copy.put("candleType", arr.get(0).asText());
return copy;
}
/** @deprecated 단일 분봉 — {@link #copyTimeframeWithCandleTypes} 사용 */
private ObjectNode copyTimeframeWithCandleType(JsonNode tf, String candleType) {
return copyTimeframeWithCandleTypes(tf, Set.of(candleType));
}
}
backend/src/test/java/com/goldenchart/service/StrategyConditionTimeframeServiceTest.java
+40
View File
@@ -10,6 +10,7 @@ import org.mockito.Mock;
import org.mockito.Spy;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.List;
import java.util.Optional;
import java.util.Set;
@@ -159,6 +160,45 @@ class StrategyConditionTimeframeServiceTest {
assertFalse(service.usesTimeframe(5L, "1m"));
}
@Test
void collectForStrategy_staleStartUsesConditionTimeframeForAnyTf() {
for (String tf : List.of("3m", "5m", "15m", "1h")) {
GcStrategy strategy = new GcStrategy();
strategy.setId(10L);
strategy.setName("tf test " + tf);
strategy.setBuyConditionJson("""
{
"type": "TIMEFRAME",
"candleType": "1m",
"candleTypes": ["1m", "%s"],
"children": [{
"type": "CONDITION",
"condition": {
"indicatorType": "RSI",
"leftCandleType": "%s",
"rightCandleType": "%s"
}
}]
}
""".formatted(tf, tf, tf));
strategy.setSellConditionJson(null);
when(strategyRepo.findById(10L)).thenReturn(Optional.of(strategy));
when(dslNormalizer.alignSellStartTimeframeToBuy(org.mockito.ArgumentMatchers.any(), org.mockito.ArgumentMatchers.any()))
.thenAnswer(inv -> inv.getArgument(1));
when(dslNormalizer.normalizeJson(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any()))
.thenAnswer(inv -> {
String json = inv.getArgument(0);
String name = inv.getArgument(1);
return new StrategyDslTimeframeNormalizer(objectMapper).normalizeJson(json, name);
});
Set<String> tfs = service.collectForStrategy(10L);
assertEquals(Set.of(tf), tfs, "expected only " + tf);
assertFalse(service.usesTimeframe(10L, "1m"), "1m should not be used for " + tf);
service.invalidate(10L);
}
}
@Test
void collectForStrategy_stale1m5mArrayUses5mOnlyWhenConditionsSay5m() {
GcStrategy strategy = new GcStrategy();
backend/src/test/java/com/goldenchart/service/StrategyDslTimeframeNormalizerTest.java
+66
View File
@@ -4,6 +4,7 @@ import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import java.util.List;
import java.util.Set;
import static org.junit.jupiter.api.Assertions.*;
@@ -75,6 +76,26 @@ class StrategyDslTimeframeNormalizerTest {
assertEquals("5m", root.path("candleType").asText());
}
@Test
void resolveStartCandleTypes_meaningfulOverridesStaleStart1m() throws Exception {
String json = """
{
"type": "TIMEFRAME",
"candleType": "1m",
"children": [{
"type": "CONDITION",
"condition": {
"indicatorType": "CCI",
"leftCandleType": "5m",
"rightCandleType": "5m"
}
}]
}
""";
JsonNode root = objectMapper.readTree(json);
assertEquals(Set.of("5m"), StrategyDslTimeframeNormalizer.resolveStartCandleTypes(root));
}
@Test
void resolveStartCandleTypes_dropsStale1mPair() throws Exception {
String json = """
@@ -95,6 +116,51 @@ class StrategyDslTimeframeNormalizerTest {
assertEquals(Set.of("5m"), StrategyDslTimeframeNormalizer.resolveStartCandleTypes(root));
}
@Test
void resolveStartCandleTypes_resolves3mAnd15mAnd1h() throws Exception {
for (String tf : List.of("3m", "15m", "1h")) {
String json = """
{
"type": "TIMEFRAME",
"candleType": "1m",
"children": [{
"type": "CONDITION",
"condition": {
"indicatorType": "RSI",
"leftCandleType": "%s",
"rightCandleType": "%s"
}
}]
}
""".formatted(tf, tf);
JsonNode root = objectMapper.readTree(json);
assertEquals(Set.of(tf), StrategyDslTimeframeNormalizer.resolveStartCandleTypes(root),
"expected " + tf);
}
}
@Test
void normalize_alignsStaleStartToConditionTimeframe() throws Exception {
String json = """
{
"type": "TIMEFRAME",
"candleType": "1m",
"candleTypes": ["1m", "15m"],
"children": [{
"type": "CONDITION",
"condition": {
"indicatorType": "CCI",
"leftCandleType": "15m"
}
}]
}
""";
JsonNode root = objectMapper.readTree(normalizer.normalizeJson(json, "test"));
assertEquals(1, root.path("candleTypes").size());
assertEquals("15m", root.path("candleTypes").get(0).asText());
assertEquals("15m", root.path("candleType").asText());
}
@Test
void normalize_preservesMultiCandleTypesOnSave() throws Exception {
String json = """
frontend/src/components/LiveStrategyPanel.tsx
+11
View File
@@ -9,9 +9,11 @@ import { createPortal } from 'react-dom';
import type { Theme } from '../types';
import { useDraggablePanel } from '../hooks/useDraggablePanel';
import {
repairStrategyTimeframes,
saveLiveStrategySettings,
type LiveStrategySettingsDto,
} from '../utils/backendApi';
import { warnStrategyTimeframeMismatch } from '../utils/strategyTimeframeSync';
import { getKoreanName } from '../utils/marketNameCache';
interface Strategy {
@@ -70,6 +72,15 @@ const LiveStrategyPanel: React.FC<LiveStrategyPanelProps> = ({
if (virtualDriven) return;
const next: LiveStrategySettingsDto = { ...settings, ...patch, market };
const prev = settings;
if (next.isLiveCheck && next.strategyId != null) {
const ok = await warnStrategyTimeframeMismatch(next.strategyId);
if (!ok) return;
try {
await repairStrategyTimeframes(next.strategyId);
} catch {
/* repair optional */
}
}
onSettingsChange?.(next);
setSaving(true);
try {
frontend/src/components/StrategyEditorPage.tsx
+26
View File
@@ -34,6 +34,7 @@ import {
updateStartCandleTypes,
type EditorConditionState,
} from '../utils/strategyConditionSerde';
import { persistStrategyEvaluationTimeframes } from '../utils/strategyTimeframeSync';
import {
START_NODE_ID,
defaultStartMeta,
@@ -190,8 +191,13 @@ export default function StrategyEditorPage({ theme }: Props) {
}));
const buyLayoutRef = useRef(buyLayout);
const sellLayoutRef = useRef(sellLayout);
const buyConditionRef = useRef(buyCondition);
const sellConditionRef = useRef(sellCondition);
buyLayoutRef.current = buyLayout;
sellLayoutRef.current = sellLayout;
buyConditionRef.current = buyCondition;
sellConditionRef.current = sellCondition;
const timeframeAutosaveRef = useRef<number | null>(null);
const layoutRevisionRef = useRef(0);
const persistLayoutTimerRef = useRef<number | null>(null);
const layoutPersistReadyRef = useRef(false);
@@ -395,6 +401,22 @@ export default function StrategyEditorPage({ theme }: Props) {
schedulePersistFlowLayout(layoutStrategyKey);
}, [setCurrentRoot, setCurrentLayout, layoutStrategyKey, schedulePersistFlowLayout]);
const scheduleTimeframePersist = useCallback(() => {
if (selectedId == null || !stratName.trim()) return;
if (timeframeAutosaveRef.current != null) window.clearTimeout(timeframeAutosaveRef.current);
const id = selectedId;
const name = stratName;
const desc = stratDesc;
timeframeAutosaveRef.current = window.setTimeout(() => {
timeframeAutosaveRef.current = null;
const buy = toEditorState(buyConditionRef.current, buyLayoutRef.current);
const sell = toEditorState(sellConditionRef.current, sellLayoutRef.current);
void persistStrategyEvaluationTimeframes(id, name, desc, buy, sell).catch(err => {
console.warn('[StrategyEditor] START 분봉 자동저장 실패:', err);
});
}, 700);
}, [selectedId, stratName, stratDesc]);
const handleStartCandleTypesChange = useCallback((startId: string, candleTypes: string[]) => {
if (startId === START_NODE_ID) {
const synced = syncBuySellPrimaryStartCandleTypes(buyEditorState, sellEditorState, candleTypes);
@@ -415,16 +437,20 @@ export default function StrategyEditorPage({ theme }: Props) {
startCombineOp: normalizeStartCombineOp(synced.sell.startCombineOp),
}));
schedulePersistFlowLayout(layoutStrategyKey);
scheduleTimeframePersist();
return;
}
const state = signalTab === 'buy' ? buyEditorState : sellEditorState;
handleEditorStateChange(updateStartCandleTypes(state, startId, candleTypes));
scheduleTimeframePersist();
}, [
buyEditorState,
sellEditorState,
handleEditorStateChange,
layoutStrategyKey,
schedulePersistFlowLayout,
scheduleTimeframePersist,
signalTab,
]);
const handleStartCombineOpChange = useCallback((op: StartCombineOp) => {
frontend/src/components/VirtualTradingPage.tsx
+2 -2
View File
@@ -51,8 +51,8 @@ import { coerceFiniteNumber } from '../utils/safeFormat';
import {
syncVirtualTargetsToBackend,
stopVirtualLiveOnBackend,
warnStrategyTimeframeMismatch,
} from '../utils/virtualLiveStrategySync';
import { warnStrategyTimeframeMismatch } from '../utils/strategyTimeframeSync';
import { pinStrategyEvaluationTimeframes } from '../utils/strategyTimeframePin';
import { persistVirtualTargetPinned } from '../utils/virtualTargetMutations';
import {
@@ -284,7 +284,7 @@ const VirtualTradingPage: React.FC<Props> = ({
return;
}
const globalStrat = strategies.find(s => s.id === session.globalStrategyId);
const ok = await warnStrategyTimeframeMismatch(globalStrat, session.globalStrategyId);
const ok = await warnStrategyTimeframeMismatch(session.globalStrategyId, globalStrat);
if (!ok) return;
try {
await syncVirtualTargetsToBackend(targets, session, true);
frontend/src/utils/strategyConditionSerde.ts
+23 -6
View File
@@ -311,7 +311,7 @@ function parseMultiStartWrapper(dsl: LogicNode): EditorConditionState | null {
children.forEach((tf, index) => {
const candleTypes = readTimeframeCandleTypes(tf as LogicNode);
const candleType = candleTypes[0];
const branchRoot = tf.children?.[0] ?? null;
const branchRoot = syncSubtreeCandleTypes(tf.children?.[0] ?? null, candleType);
if (index === 0) {
startMeta[START_NODE_ID] = { candleTypes, candleType };
primaryRoot = branchRoot;
@@ -341,10 +341,11 @@ export function decodeConditionForEditor(dsl: LogicNode | null): EditorCondition
if (dsl.type === 'TIMEFRAME') {
const candleTypes = readTimeframeCandleTypes(dsl);
const primary = candleTypes[0];
return {
root: dsl.children?.[0] ?? null,
root: syncSubtreeCandleTypes(dsl.children?.[0] ?? null, primary),
startMeta: {
[START_NODE_ID]: { candleTypes, candleType: candleTypes[0] },
[START_NODE_ID]: { candleTypes, candleType: primary },
},
extraStartIds: [],
extraRoots: {},
@@ -354,7 +355,7 @@ export function decodeConditionForEditor(dsl: LogicNode | null): EditorCondition
const inferred = inferPrimaryCandleFromTree(dsl);
return {
root: dsl,
root: syncSubtreeCandleTypes(dsl, inferred),
startMeta: {
[START_NODE_ID]: { candleTypes: [inferred], candleType: inferred },
},
@@ -429,8 +430,21 @@ export function collectDslBranches(dsl: LogicNode | null): ConditionBranch[] {
return collectEditorBranches(decodeConditionForEditor(dsl));
}
/** DB가 1m 기본값만 갖고 편집기 localStorage에 다른 분봉이 있을 때 localStorage 우선 */
function pickMergedStartCandleTypes(decoded: string[], stored?: string[]): string[] {
const fromDb = normalizeCandleTypesList(decoded);
const fromStored = stored?.length ? normalizeCandleTypesList(stored) : [];
const dbIsLegacyDefault = fromDb.length === 1 && fromDb[0] === '1m';
const storedDiffers = fromStored.length > 0
&& (fromStored.length !== fromDb.length || fromStored.some((ct, i) => ct !== fromDb[i]));
if (storedDiffers && (dbIsLegacyDefault || fromDb.length === 0)) {
return fromStored;
}
return fromDb;
}
/**
* 전략 로드 시 startMeta 병합 — DB DSL에서 복원한 시간봉이 localStorage보다 우선.
* 전략 로드 시 startMeta 병합 — DB가 1m 기본값만 있고 localStorage에 다른 분봉이 있으면 localStorage 우선.
*/
export function mergeStartMetaForLoad(
decoded: Record<string, StartNodeMeta>,
@@ -441,7 +455,10 @@ export function mergeStartMetaForLoad(
...stored,
};
for (const [startId, meta] of Object.entries(decoded)) {
const types = getStartCandleTypes(meta);
const types = pickMergedStartCandleTypes(
getStartCandleTypes(meta),
stored?.[startId] ? getStartCandleTypes(stored[startId]) : undefined,
);
merged[startId] = { candleTypes: types, candleType: types[0] };
}
return merged;
frontend/src/utils/strategyTimeframeSync.ts
+118
View File
@@ -0,0 +1,118 @@
import { loadStrategyTimeframes, saveStrategy, type StrategyDto } from './backendApi';
import { loadStrategyFlowLayout } from './strategyEditorLayoutStorage';
import {
alignBuySellStartCandleTypesForSave,
collectDslBranches,
collectTimeframesFromEditorState,
encodeConditionForSave,
type EditorConditionState,
} from './strategyConditionSerde';
import { START_NODE_ID, getStartCandleTypes, normalizeStartCandleType } from './strategyStartNodes';
import type { LogicNode } from './strategyTypes';
import type { StrategyFlowLayoutStore } from './strategyEditorLayoutStorage';
function collectFromFlowLayout(strategyId: number): string[] {
const layout = loadStrategyFlowLayout(String(strategyId));
if (!layout) return [];
const set = new Set<string>();
for (const side of ['buy', 'sell'] as const) {
const meta = layout[side]?.startMeta?.[START_NODE_ID];
if (!meta) continue;
for (const ct of getStartCandleTypes(meta)) set.add(normalizeStartCandleType(ct));
}
return [...set];
}
function collectFromStrategyDto(strategy: StrategyDto | null | undefined): string[] {
if (!strategy) return [];
const set = new Set<string>();
const buy = strategy.buyCondition as LogicNode | null | undefined;
const sell = strategy.sellCondition as LogicNode | null | undefined;
for (const b of [
...collectDslBranches(buy ?? null),
...collectDslBranches(sell ?? null),
]) {
const types = b.candleTypes?.length ? b.candleTypes : [b.candleType];
for (const ct of types) set.add(normalizeStartCandleType(ct));
}
return [...set];
}
/** 편집기·flow layout·전략 DTO에서 UI 평가 분봉 수집 (서버 DSL보다 우선) */
export function collectUiEvaluationTimeframes(
strategyId: number,
strategy?: StrategyDto | null,
editorState?: { buy: EditorConditionState; sell: EditorConditionState },
): string[] {
if (editorState) {
const fromEditor = [
...collectTimeframesFromEditorState(editorState.buy),
...collectTimeframesFromEditorState(editorState.sell),
].map(normalizeStartCandleType);
if (fromEditor.length > 0) return [...new Set(fromEditor)];
}
const fromLayout = collectFromFlowLayout(strategyId);
if (fromLayout.length > 0) return fromLayout;
return collectFromStrategyDto(strategy);
}
/**
* UI 분봉과 서버 DSL 불일치 시 안내.
* @returns false — 진행 불가(저장 필요)
*/
export async function warnStrategyTimeframeMismatch(
strategyId: number,
strategy?: StrategyDto | null,
editorState?: { buy: EditorConditionState; sell: EditorConditionState },
): Promise<boolean> {
const uiTfs = collectUiEvaluationTimeframes(strategyId, strategy, editorState);
if (uiTfs.length === 0) return true;
let serverTfs: string[];
try {
serverTfs = await loadStrategyTimeframes(strategyId);
} catch {
return true;
}
const uiSet = new Set(uiTfs.map(tf => normalizeStartCandleType(tf)));
const serverSet = new Set(serverTfs.map(tf => normalizeStartCandleType(tf)));
const missingOnServer = uiTfs.filter(tf => !serverSet.has(normalizeStartCandleType(tf)));
const extraOnServer = [...serverSet].filter(tf => !uiSet.has(tf));
if (missingOnServer.length === 0 && extraOnServer.length === 0) return true;
// 양쪽 모두 1m만 — 일치로 간주
if (uiSet.size === 1 && uiSet.has('1m') && serverSet.size === 1 && serverSet.has('1m')) {
return true;
}
const uiLabel = uiTfs.map(tf => normalizeStartCandleType(tf)).join(', ') || '1m';
const serverLabel = [...serverSet].join(', ') || '1m';
window.alert(
`전략 화면에는 ${uiLabel} 봉으로 설정되어 있지만, 서버에는 ${serverLabel} 만 저장되어 있습니다.\n\n`
+ '전략편집기에서 「저장」을 누르거나 START 분봉을 다시 선택해 자동 저장된 뒤 실시간 체크를 켜 주세요.',
);
return false;
}
/** START 분봉 변경 시 전략 DSL을 서버에 즉시 반영 */
export async function persistStrategyEvaluationTimeframes(
strategyId: number,
name: string,
description: string,
buy: EditorConditionState,
sell: EditorConditionState,
): Promise<void> {
const aligned = alignBuySellStartCandleTypesForSave(buy, sell);
const encodedBuy = encodeConditionForSave(aligned.buy);
const encodedSell = encodeConditionForSave(aligned.sell);
await saveStrategy({
id: strategyId,
name,
description,
buyCondition: encodedBuy,
sellCondition: encodedSell,
enabled: true,
});
}
export type { StrategyFlowLayoutStore };
frontend/src/utils/virtualLiveStrategySync.ts
+1 -49
View File
@@ -1,56 +1,8 @@
import { loadStrategyTimeframes, saveLiveStrategySettings } from './backendApi';
import { collectDslBranches } from './strategyConditionSerde';
import { saveLiveStrategySettings } from './backendApi';
import { pinStrategyEvaluationTimeframes } from './strategyTimeframePin';
import { normalizeStartCandleType } from './strategyStartNodes';
import type { StrategyDto } from './backendApi';
import type { LogicNode } from './strategyTypes';
import type { VirtualSessionConfig, VirtualTargetItem } from './virtualTradingStorage';
import { resolveVirtualTargetStrategyId } from './virtualTargetStrategy';
function collectUiTimeframes(strategy: StrategyDto | null | undefined): string[] {
if (!strategy) return [];
const set = new Set<string>();
const buy = strategy.buyCondition as LogicNode | null | undefined;
const sell = strategy.sellCondition as LogicNode | null | undefined;
for (const b of [
...collectDslBranches(buy ?? null),
...collectDslBranches(sell ?? null),
]) {
const types = b.candleTypes?.length ? b.candleTypes : [b.candleType];
for (const ct of types) set.add(normalizeStartCandleType(ct));
}
return [...set];
}
/**
* UI(편집기)와 서버 DSL의 평가 분봉이 다르면 안내.
* @returns false — 계속 진행 불가(재저장 필요)
*/
export async function warnStrategyTimeframeMismatch(
strategy: StrategyDto | null | undefined,
strategyId: number,
): Promise<boolean> {
if (!strategy) return true;
const uiTfs = collectUiTimeframes(strategy);
if (uiTfs.length === 0 || (uiTfs.length === 1 && uiTfs[0] === '1m')) return true;
let serverTfs: string[];
try {
serverTfs = await loadStrategyTimeframes(strategyId);
} catch {
return true;
}
const serverSet = new Set(serverTfs.map(tf => normalizeStartCandleType(tf)));
const missingOnServer = uiTfs.filter(tf => !serverSet.has(tf));
if (missingOnServer.length === 0) return true;
window.alert(
`전략 화면에는 ${uiTfs.join(', ')} 봉으로 보이지만, 서버에는 ${[...serverSet].join(', ') || '1m'} 만 저장되어 있습니다.\n\n`
+ '전략편집기에서 「저장」을 눌러 다시 저장한 뒤 가상매매를 시작하세요.',
);
return false;
}
/** 가상투자 대상 종목을 백엔드 live strategy 설정과 동기화 */
export async function syncVirtualTargetsToBackend(
targets: VirtualTargetItem[],