public StateMachine parse()

in saga/seata-saga-statelang/src/main/java/org/apache/seata/saga/statelang/parser/impl/StateMachineParserImpl.java [58:134]
66 lines of code
15 McCabe index (conditional complexity)

    public StateMachine parse(String json) {

        JsonParser jsonParser = JsonParserFactory.getJsonParser(jsonParserName);
        if (jsonParser == null) {
            throw new RuntimeException("Cannot find JsonParer by name: " + jsonParserName);
        }
        Map<String, Object> node = jsonParser.parse(json, Map.class, true);
        if (DesignerJsonTransformer.isDesignerJson(node)) {
            node = DesignerJsonTransformer.toStandardJson(node);
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("===== Transformed standard state language:\n{}", jsonParser.toJsonString(node, true));
            }
        }

        StateMachineImpl stateMachine = new StateMachineImpl();
        stateMachine.setName((String) node.get("Name"));
        stateMachine.setComment((String) node.get("Comment"));
        stateMachine.setVersion((String) node.get("Version"));
        stateMachine.setStartState((String) node.get("StartState"));
        String recoverStrategy = (String) node.get("RecoverStrategy");
        if (StringUtils.isNotBlank(recoverStrategy)) {
            stateMachine.setRecoverStrategy(RecoverStrategy.valueOf(recoverStrategy));
        }
        Object isPersist = node.get("IsPersist");
        if (Boolean.FALSE.equals(isPersist)) {
            stateMachine.setPersist(false);
        }

        // customize if update origin or append new retryStateInstLog
        Object isRetryPersistModeUpdate = node.get("IsRetryPersistModeUpdate");
        if (isRetryPersistModeUpdate instanceof Boolean) {
            stateMachine.setRetryPersistModeUpdate(Boolean.TRUE.equals(isRetryPersistModeUpdate));
        }

        // customize if update last or append new compensateStateInstLog
        Object isCompensatePersistModeUpdate = node.get("IsCompensatePersistModeUpdate");
        if (isCompensatePersistModeUpdate instanceof Boolean) {
            stateMachine.setCompensatePersistModeUpdate(Boolean.TRUE.equals(isCompensatePersistModeUpdate));
        }

        Map<String, Object> statesNode = (Map<String, Object>) node.get("States");
        statesNode.forEach((stateName, value) -> {
            Map<String, Object> stateNode = (Map<String, Object>) value;
            StateType stateType = StateType.getStateType((String) stateNode.get("Type"));
            StateParser<?> stateParser = StateParserFactory.getStateParser(stateType);
            if (stateParser == null) {
                throw new IllegalArgumentException("State Type [" + stateType + "] is not support");
            }
            State state = stateParser.parse(stateNode);
            if (state instanceof BaseState) {
                ((BaseState) state).setName(stateName);
            }

            if (stateMachine.getState(stateName) != null) {
                throw new IllegalArgumentException("State[name:" + stateName + "] is already exists");
            }
            stateMachine.putState(stateName, state);
        });

        Map<String, State> stateMap = stateMachine.getStates();
        for (State state : stateMap.values()) {
            if (state instanceof AbstractTaskState) {
                AbstractTaskState taskState = (AbstractTaskState) state;
                if (StringUtils.isNotBlank(taskState.getCompensateState())) {
                    taskState.setForUpdate(true);

                    State compState = stateMap.get(taskState.getCompensateState());
                    if (compState instanceof AbstractTaskState) {
                        ((AbstractTaskState) compState).setForCompensation(true);
                    }
                }
            }
        }

        validator.validate(stateMachine);
        return stateMachine;
    }