Macbook
785 lines
36 KiB
Java
785 lines
36 KiB
Java
package com.goldenchart.service;
|
|
|
|
import com.fasterxml.jackson.databind.JsonNode;
|
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
|
import com.fasterxml.jackson.databind.node.ObjectNode;
|
|
import com.goldenchart.dto.BacktestResponse;
|
|
import com.goldenchart.dto.LiveConditionRowDto;
|
|
import com.goldenchart.dto.LiveConditionStatusDto;
|
|
import com.goldenchart.dto.OhlcvBar;
|
|
import com.goldenchart.entity.GcStrategy;
|
|
import com.goldenchart.repository.GcStrategyRepository;
|
|
import com.goldenchart.storage.Ta4jStorage;
|
|
import com.goldenchart.websocket.DynamicSubscriptionManager;
|
|
import lombok.RequiredArgsConstructor;
|
|
import lombok.extern.slf4j.Slf4j;
|
|
import org.springframework.stereotype.Service;
|
|
import org.ta4j.core.BarSeries;
|
|
import org.ta4j.core.Rule;
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
|
|
import java.util.*;
|
|
|
|
/**
|
|
* 가상투자 — 종목×전략별 조건 충족 현황 (Ta4j Rule.isSatisfied).
|
|
*/
|
|
@Service
|
|
@RequiredArgsConstructor
|
|
@Slf4j
|
|
public class LiveConditionStatusService {
|
|
|
|
private static final Map<String, String> CONDITION_LABEL = Map.ofEntries(
|
|
Map.entry("GT", "초과(>)"),
|
|
Map.entry("LT", "미만(<)"),
|
|
Map.entry("GTE", "이상(≥)"),
|
|
Map.entry("LTE", "이하(≤)"),
|
|
Map.entry("EQ", "같음(=)"),
|
|
Map.entry("NEQ", "다름(≠)"),
|
|
Map.entry("CROSS_UP", "상향 돌파"),
|
|
Map.entry("CROSS_DOWN", "하향 돌파"),
|
|
Map.entry("SLOPE_UP", "상승 중"),
|
|
Map.entry("LOWEST_LTE", "N봉 최저 ≤"),
|
|
Map.entry("LOWEST_GTE", "N봉 최저 ≥"),
|
|
Map.entry("SLOPE_DOWN", "하락 중")
|
|
);
|
|
|
|
private record PendingCond(String id, JsonNode condition, String timeframe, String side) {}
|
|
|
|
private final GcStrategyRepository strategyRepo;
|
|
private final Ta4jStorage ta4jStorage;
|
|
private final StrategyDslToTa4jAdapter adapter;
|
|
private final IndicatorSettingsService indicatorSettingsService;
|
|
private final ObjectMapper objectMapper;
|
|
private final DynamicSubscriptionManager subscriptionManager;
|
|
private final StrategyDslTimeframeNormalizer timeframeNormalizer;
|
|
|
|
@Transactional(readOnly = true)
|
|
public LiveConditionStatusDto evaluate(Long userId, String deviceId,
|
|
String market, long strategyId) {
|
|
return evaluate(userId, deviceId, market, strategyId, null);
|
|
}
|
|
|
|
@Transactional(readOnly = true)
|
|
public LiveConditionStatusDto evaluate(Long userId, String deviceId,
|
|
String market, long strategyId,
|
|
Long barTimeSec) {
|
|
return evaluate(userId, deviceId, market, strategyId, barTimeSec, null);
|
|
}
|
|
|
|
@Transactional(readOnly = true)
|
|
public LiveConditionStatusDto evaluate(Long userId, String deviceId,
|
|
String market, long strategyId,
|
|
Long barTimeSec,
|
|
Map<String, Map<String, Object>> indicatorParamsOverride) {
|
|
return evaluate(userId, deviceId, market, strategyId, barTimeSec, indicatorParamsOverride, null, null);
|
|
}
|
|
|
|
@Transactional(readOnly = true)
|
|
public LiveConditionStatusDto evaluate(Long userId, String deviceId,
|
|
String market, long strategyId,
|
|
Long barTimeSec,
|
|
Map<String, Map<String, Object>> indicatorParamsOverride,
|
|
List<OhlcvBar> chartBars,
|
|
String chartTimeframe) {
|
|
Optional<GcStrategy> opt = strategyRepo.findById(strategyId);
|
|
if (opt.isEmpty()) {
|
|
return empty(market, strategyId);
|
|
}
|
|
GcStrategy strategy = opt.get();
|
|
|
|
Map<String, Map<String, Object>> params =
|
|
mergeIndicatorParams(
|
|
indicatorSettingsService.getAll(userId, deviceId),
|
|
indicatorParamsOverride);
|
|
Map<String, Map<String, Object>> visual =
|
|
indicatorSettingsService.getAllVisual(userId, deviceId);
|
|
|
|
List<PendingCond> pending = new ArrayList<>();
|
|
collectConditions(strategy.getBuyConditionJson(), "1m", "buy", pending);
|
|
collectConditions(strategy.getSellConditionJson(), "1m", "sell", pending);
|
|
|
|
if (pending.isEmpty()) {
|
|
return empty(market, strategyId);
|
|
}
|
|
|
|
if (chartBars != null && !chartBars.isEmpty() && chartTimeframe != null && !chartTimeframe.isBlank()) {
|
|
return evaluateOnChartBars(strategy, market, strategyId, chartBars, chartTimeframe,
|
|
barTimeSec, params, visual);
|
|
}
|
|
|
|
// 마켓 구독 + warm-up — 과거 봉 평가 시 더 많은 이력 확보
|
|
int warmupBars = barTimeSec != null ? 500 : 60;
|
|
Set<String> timeframes = new LinkedHashSet<>();
|
|
for (PendingCond p : pending) {
|
|
String tf = LiveStrategyTimeframeService.normalize(p.timeframe());
|
|
timeframes.add(tf);
|
|
subscriptionManager.ensureBarsReadySync(market, tf, warmupBars);
|
|
}
|
|
subscriptionManager.ensureBarsReadySync(market, "1m", warmupBars);
|
|
|
|
List<LiveConditionRowDto> rows = new ArrayList<>();
|
|
int met = 0;
|
|
int evaluable = 0;
|
|
Integer primaryEvalIndex = null;
|
|
|
|
for (PendingCond p : pending) {
|
|
String tf = LiveStrategyTimeframeService.normalize(p.timeframe());
|
|
if (!ta4jStorage.exists(market, tf)) {
|
|
rows.add(toRowUnevaluated(p, visual));
|
|
continue;
|
|
}
|
|
BarSeries series = ta4jStorage.getOrCreate(market, tf);
|
|
if (series.isEmpty()) {
|
|
rows.add(toRowUnevaluated(p, visual));
|
|
continue;
|
|
}
|
|
int index = resolveBarIndex(series, barTimeSec);
|
|
if (primaryEvalIndex == null) primaryEvalIndex = index;
|
|
try {
|
|
ObjectNode wrapper = objectMapper.createObjectNode();
|
|
wrapper.put("type", "CONDITION");
|
|
wrapper.set("condition", p.condition());
|
|
|
|
StrategyDslToTa4jAdapter.RuleBuildContext ctx =
|
|
new StrategyDslToTa4jAdapter.RuleBuildContext(
|
|
series, params, visual, market, ta4jStorage, false, java.util.Map.of());
|
|
Rule rule = adapter.toRule(wrapper, ctx);
|
|
boolean satisfied = rule.isSatisfied(index, null);
|
|
Double current = adapter.readConditionFieldValue(
|
|
p.condition(), series, params, index, true);
|
|
Double target = readTargetNumeric(p.condition(), visual);
|
|
if (target == null) {
|
|
target = adapter.readConditionFieldValue(
|
|
p.condition(), series, params, index, false);
|
|
}
|
|
rows.add(toRow(p, current, target, satisfied, series, params, index));
|
|
evaluable++;
|
|
if (satisfied) met++;
|
|
} catch (Exception e) {
|
|
log.debug("[LiveCondition] eval fail {} {}: {}", market, p.id(), e.getMessage());
|
|
rows.add(toRowUnevaluated(p, visual));
|
|
}
|
|
}
|
|
|
|
int matchRate = evaluable > 0 ? Math.round(100f * met / evaluable) : 0;
|
|
String tfSummary = String.join(", ", timeframes);
|
|
|
|
// [항목6] 전체 논리 트리 평가 — matchRate 와 달리 AND/OR/NOT 게이트 완전 반영
|
|
Boolean overallEntryMet = evaluateOverallRule(
|
|
strategy.getBuyConditionJson(), market, params, visual, barTimeSec);
|
|
Boolean overallExitMet = evaluateOverallRule(
|
|
strategy.getSellConditionJson(), market, params, visual, barTimeSec);
|
|
|
|
return LiveConditionStatusDto.builder()
|
|
.market(market)
|
|
.strategyId(strategyId)
|
|
.timeframe(tfSummary)
|
|
.matchRate(matchRate)
|
|
.overallEntryMet(overallEntryMet)
|
|
.overallExitMet(overallExitMet)
|
|
.rows(rows)
|
|
.updatedAt(System.currentTimeMillis())
|
|
.barTimeSec(barTimeSec)
|
|
.evalBarIndex(primaryEvalIndex)
|
|
.build();
|
|
}
|
|
|
|
/**
|
|
* barTimeSec(초)에 가장 가까운 bar index — null 이면 최신 봉.
|
|
* 차트·업비트 API 와 동일하게 봉 시작(open) 시각 기준으로 매칭한다.
|
|
*/
|
|
private int resolveBarIndex(BarSeries series, Long barTimeSec) {
|
|
if (barTimeSec == null) return series.getEndIndex();
|
|
int bestIdx = series.getEndIndex();
|
|
long bestDist = Long.MAX_VALUE;
|
|
for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) {
|
|
long openSec = barOpenEpochSec(series, i);
|
|
long dist = Math.abs(openSec - barTimeSec);
|
|
if (dist < bestDist) {
|
|
bestDist = dist;
|
|
bestIdx = i;
|
|
}
|
|
}
|
|
return bestIdx;
|
|
}
|
|
|
|
/** Ta4j Bar → 차트용 봉 시작 시각(초) — BacktestingService.barStartEpoch 와 동일 */
|
|
private static long barOpenEpochSec(BarSeries series, int index) {
|
|
var bar = series.getBar(index);
|
|
return bar.getEndTime().getEpochSecond() - bar.getTimePeriod().getSeconds();
|
|
}
|
|
|
|
/**
|
|
* 차트·백테스트와 동일 OHLCV 로 조건 평가 — Ta4jStorage 와의 불일치 방지.
|
|
*/
|
|
private LiveConditionStatusDto evaluateOnChartBars(
|
|
GcStrategy strategy,
|
|
String market,
|
|
long strategyId,
|
|
List<OhlcvBar> chartBars,
|
|
String chartTimeframe,
|
|
Long barTimeSec,
|
|
Map<String, Map<String, Object>> params,
|
|
Map<String, Map<String, Object>> visual) {
|
|
try {
|
|
JsonNode buyDslRaw = timeframeNormalizer.normalize(
|
|
objectMapper.readTree(
|
|
strategy.getBuyConditionJson() != null ? strategy.getBuyConditionJson() : "null"),
|
|
strategy.getName());
|
|
JsonNode sellDslRaw = timeframeNormalizer.normalize(
|
|
objectMapper.readTree(
|
|
strategy.getSellConditionJson() != null ? strategy.getSellConditionJson() : "null"),
|
|
strategy.getName());
|
|
|
|
String primaryTf = OhlcvBarSeriesSupport.normalizeTf(chartTimeframe);
|
|
JsonNode buyDsl = timeframeNormalizer.remapForChartTimeframe(buyDslRaw, primaryTf);
|
|
JsonNode sellDsl = timeframeNormalizer.remapForChartTimeframe(sellDslRaw, primaryTf);
|
|
|
|
List<PendingCond> pending = new ArrayList<>();
|
|
collectConditionsFromNode(buyDsl, "1m", "buy", pending);
|
|
collectConditionsFromNode(sellDsl, "1m", "sell", pending);
|
|
|
|
BarSeries primarySeries = OhlcvBarSeriesSupport.buildSeries(chartBars, primaryTf);
|
|
if (primarySeries.isEmpty()) {
|
|
return empty(market, strategyId);
|
|
}
|
|
|
|
Map<String, BarSeries> seriesOverrides = OhlcvBarSeriesSupport.buildSeriesOverrides(
|
|
primarySeries, primaryTf, buyDsl, sellDsl);
|
|
|
|
List<LiveConditionRowDto> rows = new ArrayList<>();
|
|
int met = 0;
|
|
int evaluable = 0;
|
|
Integer primaryEvalIndex = OhlcvBarSeriesSupport.resolveBarIndex(primarySeries, barTimeSec);
|
|
|
|
for (PendingCond p : pending) {
|
|
String tf = LiveStrategyTimeframeService.normalize(p.timeframe());
|
|
BarSeries series = resolveChartSeries(tf, primaryTf, primarySeries, seriesOverrides, market);
|
|
if (series == null || series.isEmpty()) {
|
|
rows.add(toRowUnevaluated(p, visual));
|
|
continue;
|
|
}
|
|
int index = OhlcvBarSeriesSupport.resolveBarIndex(series, barTimeSec);
|
|
try {
|
|
ObjectNode wrapper = objectMapper.createObjectNode();
|
|
wrapper.put("type", "CONDITION");
|
|
wrapper.set("condition", p.condition());
|
|
|
|
StrategyDslToTa4jAdapter.RuleBuildContext ctx =
|
|
new StrategyDslToTa4jAdapter.RuleBuildContext(
|
|
series, params, visual, market, null, false, seriesOverrides);
|
|
Rule rule = adapter.toRule(wrapper, ctx);
|
|
boolean satisfied = rule.isSatisfied(index, null);
|
|
Double current = adapter.readConditionFieldValue(
|
|
p.condition(), series, params, index, true);
|
|
Double target = readTargetNumeric(p.condition(), visual);
|
|
if (target == null) {
|
|
target = adapter.readConditionFieldValue(
|
|
p.condition(), series, params, index, false);
|
|
}
|
|
rows.add(toRow(p, current, target, satisfied, series, params, index));
|
|
evaluable++;
|
|
if (satisfied) met++;
|
|
} catch (Exception e) {
|
|
log.debug("[LiveCondition:chart] eval fail {} {}: {}", market, p.id(), e.getMessage());
|
|
rows.add(toRowUnevaluated(p, visual));
|
|
}
|
|
}
|
|
|
|
int matchRate = evaluable > 0 ? Math.round(100f * met / evaluable) : 0;
|
|
Boolean overallEntryMet = evaluateOverallRuleOnChart(
|
|
buyDsl, primarySeries, seriesOverrides, market, params, visual, barTimeSec);
|
|
Boolean overallExitMet = evaluateOverallRuleOnChart(
|
|
sellDsl, primarySeries, seriesOverrides, market, params, visual, barTimeSec);
|
|
|
|
return LiveConditionStatusDto.builder()
|
|
.market(market)
|
|
.strategyId(strategyId)
|
|
.timeframe(primaryTf)
|
|
.matchRate(matchRate)
|
|
.overallEntryMet(overallEntryMet)
|
|
.overallExitMet(overallExitMet)
|
|
.rows(rows)
|
|
.updatedAt(System.currentTimeMillis())
|
|
.barTimeSec(barTimeSec)
|
|
.evalBarIndex(primaryEvalIndex)
|
|
.build();
|
|
} catch (Exception e) {
|
|
log.warn("[LiveCondition:chart] evaluate fail market={}: {}", market, e.getMessage());
|
|
return empty(market, strategyId);
|
|
}
|
|
}
|
|
|
|
private BarSeries resolveChartSeries(String tf, String primaryTf, BarSeries primarySeries,
|
|
Map<String, BarSeries> overrides, String market) {
|
|
String normalized = OhlcvBarSeriesSupport.normalizeTf(tf);
|
|
if (overrides.containsKey(normalized)) {
|
|
return overrides.get(normalized);
|
|
}
|
|
if (normalized.equals(primaryTf)) {
|
|
return primarySeries;
|
|
}
|
|
// 차트봉 평가 — overrides 가 있으면 storage 와 혼합하지 않음
|
|
if (!overrides.isEmpty()) {
|
|
return primarySeries;
|
|
}
|
|
if (ta4jStorage.exists(market, normalized)) {
|
|
return ta4jStorage.getOrCreate(market, normalized);
|
|
}
|
|
return primarySeries;
|
|
}
|
|
|
|
/** 백테스트·scan-signals 와 동일 — 마지막 evalCount 봉만 스캔 */
|
|
private static int resolveChartScanStartIndex(BarSeries series, int evalCount) {
|
|
if (series == null || series.isEmpty() || evalCount <= 0) {
|
|
return series != null ? series.getBeginIndex() : 0;
|
|
}
|
|
int total = series.getBarCount();
|
|
if (evalCount >= total) return series.getBeginIndex();
|
|
return series.getEndIndex() - evalCount + 1;
|
|
}
|
|
|
|
private Boolean evaluateOverallRuleOnChart(JsonNode dsl, BarSeries primarySeries,
|
|
Map<String, BarSeries> seriesOverrides,
|
|
String market,
|
|
Map<String, Map<String, Object>> params,
|
|
Map<String, Map<String, Object>> visual,
|
|
Long barTimeSec) {
|
|
if (dsl == null || dsl.isNull()) return null;
|
|
try {
|
|
if (primarySeries == null || primarySeries.isEmpty()) return null;
|
|
|
|
StrategyDslToTa4jAdapter.RuleBuildContext ctx =
|
|
new StrategyDslToTa4jAdapter.RuleBuildContext(
|
|
primarySeries, params, visual, market, null, false, seriesOverrides);
|
|
Rule rule = adapter.toRule(dsl, ctx);
|
|
int index = OhlcvBarSeriesSupport.resolveBarIndex(primarySeries, barTimeSec);
|
|
return rule.isSatisfied(index, null);
|
|
} catch (Exception e) {
|
|
log.debug("[LiveCondition:chart] overall rule fail market={}: {}", market, e.getMessage());
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private void collectConditionsFromNode(JsonNode node, String timeframe, String side,
|
|
List<PendingCond> out) {
|
|
if (node == null || node.isNull()) return;
|
|
walk(node, timeframe, side, out, new HashSet<>());
|
|
}
|
|
|
|
private LiveConditionStatusDto empty(String market, long strategyId) {
|
|
return LiveConditionStatusDto.builder()
|
|
.market(market)
|
|
.strategyId(strategyId)
|
|
.timeframe("")
|
|
.matchRate(0)
|
|
.rows(List.of())
|
|
.updatedAt(System.currentTimeMillis())
|
|
.build();
|
|
}
|
|
|
|
// ── [항목6] 전체 논리 트리 평가 ────────────────────────────────────────────
|
|
|
|
/**
|
|
* 전략 DSL 전체를 Ta4j Rule 로 변환하여 현재 시계열에 대해 평가한다.
|
|
*
|
|
* <p>기존 {@code matchRate} 는 단순 CONDITION 리프 충족 비율이지만,
|
|
* 이 메서드는 AND/OR/NOT 게이트까지 완전히 반영하여 실제 시그널과 동일한
|
|
* 논리 결과를 반환한다.
|
|
*
|
|
* @return {@code true} = 현재 조건 충족, {@code false} = 미충족,
|
|
* {@code null} = 데이터 부족·평가 불가
|
|
*/
|
|
private Boolean evaluateOverallRule(String conditionJson, String market,
|
|
Map<String, Map<String, Object>> params,
|
|
Map<String, Map<String, Object>> visual,
|
|
Long barTimeSec) {
|
|
if (conditionJson == null || conditionJson.isBlank()) return null;
|
|
try {
|
|
com.fasterxml.jackson.databind.JsonNode dsl =
|
|
objectMapper.readTree(conditionJson);
|
|
if (dsl == null || dsl.isNull()) return null;
|
|
|
|
// DSL 루트의 주 시간봉 추출 (TIMEFRAME 노드가 있으면 해당 봉 사용)
|
|
// 5m 전략에서 1m 시리즈로 평가하면 CROSS_UP 등이 부정확해지는 버그 수정
|
|
String primaryTf = extractPrimaryTimeframe(dsl);
|
|
if (!ta4jStorage.exists(market, primaryTf)) {
|
|
// 지정 봉이 없으면 1m으로 폴백
|
|
primaryTf = "1m";
|
|
if (!ta4jStorage.exists(market, "1m")) return null;
|
|
}
|
|
BarSeries series = ta4jStorage.getOrCreate(market, primaryTf);
|
|
if (series.isEmpty()) return null;
|
|
|
|
StrategyDslToTa4jAdapter.RuleBuildContext ctx =
|
|
new StrategyDslToTa4jAdapter.RuleBuildContext(
|
|
series, params, visual, market, ta4jStorage, false, java.util.Map.of());
|
|
org.ta4j.core.Rule rule = adapter.toRule(dsl, ctx);
|
|
return rule.isSatisfied(resolveBarIndex(series, barTimeSec), null);
|
|
} catch (Exception e) {
|
|
log.debug("[LiveCondition] overall rule eval fail market={}: {}", market, e.getMessage());
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* DSL 트리에서 주 시간봉을 추출한다.
|
|
* TIMEFRAME 노드가 있으면 그 candleType을 반환, 없으면 "1m".
|
|
* 복수의 TIMEFRAME이 있으면 가장 길게 등장하는 봉 우선 (다수결).
|
|
*/
|
|
private String extractPrimaryTimeframe(com.fasterxml.jackson.databind.JsonNode dsl) {
|
|
Map<String, Integer> tfCount = new java.util.LinkedHashMap<>();
|
|
collectTimeframes(dsl, tfCount);
|
|
if (tfCount.isEmpty()) return "1m";
|
|
return tfCount.entrySet().stream()
|
|
.max(java.util.Map.Entry.comparingByValue())
|
|
.map(java.util.Map.Entry::getKey)
|
|
.orElse("1m");
|
|
}
|
|
|
|
private void collectTimeframes(com.fasterxml.jackson.databind.JsonNode node,
|
|
Map<String, Integer> out) {
|
|
if (node == null || node.isNull()) return;
|
|
String type = node.path("type").asText("CONDITION");
|
|
if ("TIMEFRAME".equals(type)) {
|
|
String tf = LiveStrategyTimeframeService.normalize(
|
|
node.path("candleType").asText("1m"));
|
|
out.merge(tf, 1, Integer::sum);
|
|
}
|
|
com.fasterxml.jackson.databind.JsonNode children = node.path("children");
|
|
if (children.isArray()) {
|
|
for (com.fasterxml.jackson.databind.JsonNode c : children) collectTimeframes(c, out);
|
|
}
|
|
com.fasterxml.jackson.databind.JsonNode child = node.path("child");
|
|
if (!child.isMissingNode()) collectTimeframes(child, out);
|
|
}
|
|
|
|
private void collectConditions(String json, String timeframe, String side,
|
|
List<PendingCond> out) {
|
|
if (json == null || json.isBlank()) return;
|
|
try {
|
|
walk(objectMapper.readTree(json), timeframe, side, out, new HashSet<>());
|
|
} catch (Exception e) {
|
|
log.warn("[LiveCondition] JSON walk fail: {}", e.getMessage());
|
|
}
|
|
}
|
|
|
|
private void walk(JsonNode node, String timeframe, String side,
|
|
List<PendingCond> out, Set<String> seen) {
|
|
if (node == null || node.isNull()) return;
|
|
// StrategyDslToTa4jAdapter 와 동일하게 type 미설정 시 "CONDITION" 기본값 적용
|
|
String type = node.path("type").asText("CONDITION");
|
|
|
|
if ("TIMEFRAME".equals(type)) {
|
|
String tf = LiveStrategyTimeframeService.normalize(
|
|
node.path("candleType").asText(timeframe));
|
|
JsonNode children = node.path("children");
|
|
if (children.isArray()) {
|
|
for (JsonNode c : children) walk(c, tf, side, out, seen);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if ("AND".equals(type) || "OR".equals(type)) {
|
|
JsonNode children = node.path("children");
|
|
if (children.isArray()) {
|
|
for (JsonNode c : children) walk(c, timeframe, side, out, seen);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if ("NOT".equals(type)) {
|
|
walk(node.path("child"), timeframe, side, out, seen);
|
|
return;
|
|
}
|
|
|
|
if ("CONDITION".equals(type) && node.has("condition")) {
|
|
JsonNode cond = node.path("condition");
|
|
String nodeId = node.path("id").asText("");
|
|
String id = !nodeId.isBlank()
|
|
? nodeId + "-" + side
|
|
: side + ":" + timeframe + ":" + cond.hashCode();
|
|
String key = id + ":" + cond.toString();
|
|
if (seen.add(key)) {
|
|
out.add(new PendingCond(id, cond, timeframe, side));
|
|
}
|
|
return;
|
|
}
|
|
|
|
// START·구버전 DSL 등 — 자식 노드 재귀 (프론트 extractVirtualConditions 와 동일)
|
|
JsonNode children = node.path("children");
|
|
if (children.isArray()) {
|
|
for (JsonNode c : children) walk(c, timeframe, side, out, seen);
|
|
}
|
|
}
|
|
|
|
private LiveConditionRowDto toRowUnevaluated(PendingCond p,
|
|
Map<String, Map<String, Object>> visual) {
|
|
JsonNode c = p.condition();
|
|
String indType = c.path("indicatorType").asText("");
|
|
String plotKey = plotKeyFromCondition(c, indType);
|
|
String condType = c.path("conditionType").asText("GT");
|
|
String baseLabel = CONDITION_LABEL.getOrDefault(condType, condType);
|
|
String rangePrefix = StrategyDslToTa4jAdapter.candleRangeConditionPrefix(c);
|
|
String condLabel = rangePrefix.isBlank() ? baseLabel : rangePrefix + baseLabel;
|
|
Double target = readTargetNumeric(c, visual);
|
|
return LiveConditionRowDto.builder()
|
|
.id(p.id())
|
|
.indicatorType(indType)
|
|
.displayName(indType)
|
|
.conditionType(condType)
|
|
.conditionLabel(condLabel)
|
|
.thresholdLabel(formatThresholdStatic(c, target, visual))
|
|
.currentValue(null)
|
|
.targetValue(target)
|
|
.satisfied(null)
|
|
.timeframe(p.timeframe())
|
|
.side(p.side())
|
|
.plotKey(plotKey)
|
|
.build();
|
|
}
|
|
|
|
private String formatThresholdStatic(JsonNode cond, Double target,
|
|
Map<String, Map<String, Object>> params) {
|
|
if (target != null && !target.isNaN()) {
|
|
String ct = cond.path("conditionType").asText("GT");
|
|
String v = formatNum(target);
|
|
return switch (ct) {
|
|
case "LT", "CROSS_DOWN" -> "< " + v;
|
|
case "GT", "CROSS_UP" -> "> " + v;
|
|
case "GTE" -> "≥ " + v;
|
|
case "LTE" -> "≤ " + v;
|
|
case "EQ" -> "= " + v;
|
|
default -> cond.path("rightField").asText(v);
|
|
};
|
|
}
|
|
String rf = cond.path("rightField").asText("");
|
|
if (rf != null && !rf.isBlank() && !"NONE".equals(rf)) {
|
|
return adapter.formatMovingAverageFieldLabel(rf, params);
|
|
}
|
|
return "—";
|
|
}
|
|
|
|
private LiveConditionRowDto toRow(PendingCond p, Double current, Double target,
|
|
Boolean satisfied, BarSeries series,
|
|
Map<String, Map<String, Object>> params, int index) {
|
|
JsonNode c = p.condition();
|
|
String indType = c.path("indicatorType").asText("");
|
|
String plotKey = plotKeyFromCondition(c, indType);
|
|
String condType = c.path("conditionType").asText("GT");
|
|
String baseLabel = CONDITION_LABEL.getOrDefault(condType, condType);
|
|
String rangePrefix = StrategyDslToTa4jAdapter.candleRangeConditionPrefix(c);
|
|
String condLabel = rangePrefix.isBlank() ? baseLabel : rangePrefix + baseLabel;
|
|
|
|
return LiveConditionRowDto.builder()
|
|
.id(p.id())
|
|
.indicatorType(indType)
|
|
.displayName(indType)
|
|
.conditionType(condType)
|
|
.conditionLabel(condLabel)
|
|
.thresholdLabel(formatThreshold(c, target, series, params, index))
|
|
.currentValue(current)
|
|
.targetValue(target)
|
|
.satisfied(satisfied)
|
|
.timeframe(p.timeframe())
|
|
.side(p.side())
|
|
.plotKey(plotKey)
|
|
.build();
|
|
}
|
|
|
|
private String formatThreshold(JsonNode cond, Double target, BarSeries series,
|
|
Map<String, Map<String, Object>> params, int index) {
|
|
String ct = cond.path("conditionType").asText("GT");
|
|
if (target != null && !target.isNaN()) {
|
|
String v = formatNum(target);
|
|
return switch (ct) {
|
|
case "LT", "CROSS_DOWN" -> "< " + v;
|
|
case "GT", "CROSS_UP" -> "> " + v;
|
|
case "GTE" -> "≥ " + v;
|
|
case "LTE" -> "≤ " + v;
|
|
case "EQ" -> "= " + v;
|
|
default -> cond.path("rightField").asText(v);
|
|
};
|
|
}
|
|
String rf = cond.path("rightField").asText("");
|
|
if (rf != null && !rf.isBlank() && !"NONE".equals(rf)) {
|
|
Double rightLive = adapter.readConditionFieldValue(cond, series, params, index, false);
|
|
if (rightLive != null && !rightLive.isNaN()) {
|
|
String v = formatNum(rightLive);
|
|
String fieldLabel = adapter.formatMovingAverageFieldLabel(rf, params);
|
|
return switch (ct) {
|
|
case "LT", "CROSS_DOWN" -> "< " + v;
|
|
case "GT", "CROSS_UP" -> "> " + v;
|
|
case "GTE" -> "≥ " + v;
|
|
case "LTE" -> "≤ " + v;
|
|
case "EQ" -> "= " + v;
|
|
default -> fieldLabel + " (" + v + ")";
|
|
};
|
|
}
|
|
return adapter.formatMovingAverageFieldLabel(rf, params);
|
|
}
|
|
return "—";
|
|
}
|
|
|
|
private static String formatNum(double v) {
|
|
if (Math.abs(v) >= 1000) return String.format("%.0f", v);
|
|
return String.format("%.2f", v);
|
|
}
|
|
|
|
private Double readTargetNumeric(JsonNode cond, Map<String, Map<String, Object>> visual) {
|
|
String indType = cond.path("indicatorType").asText("");
|
|
String rf = cond.path("rightField").asText("");
|
|
Double resolved = IndicatorHlineResolver.resolveThresholdField(cond, rf, indType, visual);
|
|
if (resolved != null) return resolved;
|
|
if (cond.has("targetValue") && !cond.path("targetValue").isNull()) {
|
|
return cond.path("targetValue").asDouble();
|
|
}
|
|
if (cond.has("compareValue") && !cond.path("compareValue").isNull()) {
|
|
return cond.path("compareValue").asDouble();
|
|
}
|
|
if (rf.startsWith("K_")) {
|
|
try { return Double.parseDouble(rf.substring(2)); } catch (NumberFormatException ignored) {}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static String plotKeyFromCondition(JsonNode cond, String indicatorType) {
|
|
String left = cond.path("leftField").asText("");
|
|
if (left != null && !left.isBlank() && !"none".equalsIgnoreCase(left)) {
|
|
return left;
|
|
}
|
|
return indicatorType;
|
|
}
|
|
|
|
private static Map<String, Map<String, Object>> mergeIndicatorParams(
|
|
Map<String, Map<String, Object>> base,
|
|
Map<String, Map<String, Object>> override) {
|
|
if (override == null || override.isEmpty()) return base;
|
|
if (base == null || base.isEmpty()) return override;
|
|
|
|
Map<String, Map<String, Object>> merged = new LinkedHashMap<>(base);
|
|
override.forEach((type, overrideParams) -> {
|
|
Map<String, Object> baseParams = merged.get(type);
|
|
if (baseParams == null || baseParams.isEmpty()) {
|
|
merged.put(type, overrideParams);
|
|
} else {
|
|
Map<String, Object> inner = new LinkedHashMap<>(baseParams);
|
|
inner.putAll(overrideParams);
|
|
merged.put(type, inner);
|
|
}
|
|
});
|
|
return merged;
|
|
}
|
|
|
|
/**
|
|
* 차트 봉 구간을 스캔하여 매수/매도 시그널 목록을 반환한다.
|
|
* {@link #evaluateOnChartBars} 의 {@code overallEntryMet}/{@code overallExitMet} 와
|
|
* 동일 Rule 엔진을 사용하므로 조건 패널 "충족" 과 차트 마커가 일치한다.
|
|
*/
|
|
@Transactional(readOnly = true)
|
|
public List<BacktestResponse.Signal> scanSignalsOnChartBars(
|
|
long userId,
|
|
String deviceId,
|
|
String market,
|
|
long strategyId,
|
|
List<OhlcvBar> chartBars,
|
|
String chartTimeframe,
|
|
Map<String, Map<String, Object>> indicatorParamsOverride,
|
|
Integer evaluationBarCount) {
|
|
Optional<GcStrategy> opt = strategyRepo.findById(strategyId);
|
|
if (opt.isEmpty() || chartBars == null || chartBars.isEmpty()
|
|
|| chartTimeframe == null || chartTimeframe.isBlank()) {
|
|
return List.of();
|
|
}
|
|
GcStrategy strategy = opt.get();
|
|
|
|
Map<String, Map<String, Object>> params =
|
|
mergeIndicatorParams(
|
|
indicatorSettingsService.getAll(userId, deviceId),
|
|
indicatorParamsOverride);
|
|
Map<String, Map<String, Object>> visual =
|
|
indicatorSettingsService.getAllVisual(userId, deviceId);
|
|
|
|
try {
|
|
String strategyName = strategy.getName();
|
|
JsonNode buyDslRaw = timeframeNormalizer.normalize(
|
|
objectMapper.readTree(
|
|
strategy.getBuyConditionJson() != null ? strategy.getBuyConditionJson() : "null"),
|
|
strategyName);
|
|
JsonNode sellDslRaw = timeframeNormalizer.normalize(
|
|
objectMapper.readTree(
|
|
strategy.getSellConditionJson() != null ? strategy.getSellConditionJson() : "null"),
|
|
strategyName);
|
|
|
|
String primaryTf = OhlcvBarSeriesSupport.normalizeTf(chartTimeframe);
|
|
JsonNode buyDsl = timeframeNormalizer.remapForChartTimeframe(buyDslRaw, primaryTf);
|
|
JsonNode sellDsl = timeframeNormalizer.remapForChartTimeframe(sellDslRaw, primaryTf);
|
|
BarSeries primarySeries = OhlcvBarSeriesSupport.buildSeries(chartBars, primaryTf);
|
|
if (primarySeries.isEmpty()) {
|
|
return List.of();
|
|
}
|
|
|
|
Map<String, BarSeries> seriesOverrides = OhlcvBarSeriesSupport.buildSeriesOverrides(
|
|
primarySeries, primaryTf, buyDsl, sellDsl);
|
|
|
|
int evalCount = evaluationBarCount != null && evaluationBarCount > 0
|
|
? evaluationBarCount
|
|
: primarySeries.getBarCount();
|
|
int startIdx = resolveChartScanStartIndex(primarySeries, evalCount);
|
|
|
|
StrategyDslToTa4jAdapter.RuleBuildContext ruleCtx =
|
|
new StrategyDslToTa4jAdapter.RuleBuildContext(
|
|
primarySeries, params, visual, market, null, false, seriesOverrides);
|
|
Rule entryRule = (buyDsl != null && !buyDsl.isNull())
|
|
? adapter.toRule(buyDsl, ruleCtx)
|
|
: new org.ta4j.core.rules.BooleanRule(false);
|
|
Rule exitRule = (sellDsl != null && !sellDsl.isNull())
|
|
? adapter.toRule(sellDsl, ruleCtx)
|
|
: new org.ta4j.core.rules.BooleanRule(false);
|
|
|
|
List<BacktestResponse.Signal> signals = new ArrayList<>();
|
|
int buyHits = 0;
|
|
int sellHits = 0;
|
|
for (int i = startIdx; i <= primarySeries.getEndIndex(); i++) {
|
|
long barTimeSec = barOpenEpochSec(primarySeries, i);
|
|
double close = primarySeries.getBar(i).getClosePrice().doubleValue();
|
|
|
|
if (entryRule.isSatisfied(i, null)) {
|
|
buyHits++;
|
|
signals.add(BacktestResponse.Signal.builder()
|
|
.time(barTimeSec)
|
|
.type("BUY")
|
|
.price(close)
|
|
.barIndex(i)
|
|
.quantity(0)
|
|
.build());
|
|
}
|
|
if (exitRule.isSatisfied(i, null)) {
|
|
sellHits++;
|
|
signals.add(BacktestResponse.Signal.builder()
|
|
.time(barTimeSec)
|
|
.type("SELL")
|
|
.price(close)
|
|
.barIndex(i)
|
|
.quantity(0)
|
|
.build());
|
|
}
|
|
}
|
|
if (signals.isEmpty()) {
|
|
log.info("[LiveCondition:scan] 0 signals market={} strategy={} tf={} bars={} eval={}..{}",
|
|
market, strategyId, primaryTf, primarySeries.getBarCount(), startIdx,
|
|
primarySeries.getEndIndex());
|
|
} else {
|
|
log.debug("[LiveCondition:scan] market={} strategy={} tf={} buy={} sell={}",
|
|
market, strategyId, primaryTf, buyHits, sellHits);
|
|
}
|
|
return signals;
|
|
} catch (Exception e) {
|
|
log.warn("[LiveCondition:scan] fail market={} strategy={}: {}",
|
|
market, strategyId, e.getMessage(), e);
|
|
return List.of();
|
|
}
|
|
}
|
|
|
|
}
|