Examples with FlowType io.fixprotocol._2020.orchestra.repository.FlowType used on opensource projects

Example 1 with FlowType

use of io.fixprotocol._2020.orchestra.repository.FlowType in project fix-orchestra by FIXTradingCommunity.

the class DocGenerator method generate.

/**
 * Generates documentation
 *
 * @throws Exception if input cannot be read or output cannot be written to a file
 */
public void generate() throws Exception {
    this.repository = unmarshal(inputStream);
    // Implementation note: consideration was given to supporting "jar:file:" scheme, but the
    // supporting FileSystem is not guaranteed to be installed.
    pathManager = getPathManager(outputRootDir);
    final Path baseOutputPath = pathManager.makeRootPath(outputRootDir);
    createCss(baseOutputPath);
    generateMain(baseOutputPath, getTitle());
    generateMetadata(baseOutputPath, repository, repository.getMetadata().getAny());
    final Path datatypesOutputPath = pathManager.makeDirectory(baseOutputPath.resolve("datatypes"));
    generateDatatypeList(datatypesOutputPath, repository.getDatatypes().getDatatype());
    repository.getDatatypes().getDatatype().forEach(d -> {
        try {
            generateDatatype(datatypesOutputPath, d);
        } catch (final Exception e) {
            throw new RuntimeException(e);
        }
    });
    final Path fieldsOutputPath = pathManager.makeDirectory(baseOutputPath.resolve("fields"));
    final List<FieldType> sortedFieldList = repository.getFields().getField().stream().sorted(Comparator.comparing(FieldType::getName)).collect(Collectors.toList());
    generateFieldsList(fieldsOutputPath, sortedFieldList);
    repository.getFields().getField().forEach(f -> {
        try {
            generateFieldDetail(fieldsOutputPath, f);
        } catch (final Exception e) {
            throw new RuntimeException(e);
        }
    });
    final List<CodeSetType> allCodeSets = repository.getCodeSets().getCodeSet();
    generateCodeSetList(datatypesOutputPath, allCodeSets.stream().sorted(Comparator.comparing(CodeSetType::getName)).collect(Collectors.toList()));
    repository.getCodeSets().getCodeSet().forEach(cs -> {
        try {
            generateCodeSetDetail(datatypesOutputPath, cs);
        } catch (final Exception e) {
            throw new RuntimeException(e);
        }
    });
    final Path messagesDocPath = pathManager.makeDirectory(baseOutputPath.resolve("messages"));
    final Path messagesImgPath = pathManager.makeDirectory(messagesDocPath.resolve("img"));
    final Optional<Categories> optCategories = Optional.ofNullable(repository.getCategories());
    final List<CategoryType> sortedCategoryList = optCategories.orElse(new Categories()).getCategory().stream().filter(c -> c.getComponentType() == CatComponentTypeT.MESSAGE).sorted((o1, o2) -> {
        final String sectionValue1 = o1.getSection() != null ? o1.getSection() : "";
        final String sectionValue2 = o2.getSection() != null ? o2.getSection() : "";
        int retv = sectionValue1.compareTo(sectionValue2);
        if (retv == 0) {
            retv = o1.getName().compareTo(o2.getName());
        }
        return retv;
    }).collect(Collectors.toList());
    generateCategories(messagesDocPath, "Message Categories", sortedCategoryList);
    final List<MessageType> sortedMessageList = repository.getMessages().getMessage().stream().sorted(Comparator.comparing(MessageType::getName).thenComparing(MessageType::getScenario)).collect(Collectors.toList());
    final Optional<Actors> actors = Optional.ofNullable(repository.getActors());
    final List<ActorType> actorList = actors.orElse(new Actors()).getActorOrFlow().stream().filter(af -> af instanceof ActorType).map(af -> (ActorType) af).collect(Collectors.toList());
    generateActorsList(messagesDocPath, actorList);
    actorList.forEach(a -> {
        try {
            generateActorDetail(messagesDocPath, messagesImgPath, a);
        } catch (final Exception e) {
            throw new RuntimeException(e);
        }
    });
    final List<FlowType> flowList = actors.orElse(new Actors()).getActorOrFlow().stream().filter(af -> af instanceof FlowType).map(af -> (FlowType) af).collect(Collectors.toList());
    generateFlowsList(messagesDocPath, flowList);
    flowList.forEach(f -> {
        try {
            generateFlowDetail(messagesDocPath, f);
            generateMessageListByFlow(messagesDocPath, f, sortedMessageList);
        } catch (final Exception e) {
            throw new RuntimeException(e);
        }
    });
    generateAllMessageList(messagesDocPath, sortedMessageList);
    sortedCategoryList.forEach(c -> {
        try {
            generateMessageListByCategory(messagesDocPath, c, sortedMessageList);
        } catch (final Exception e) {
            throw new RuntimeException(e);
        }
    });
    final List<ComponentType> componentList = repository.getComponents().getComponent();
    final List<ComponentType> sortedComponentList = componentList.stream().sorted(Comparator.comparing(ComponentType::getName).thenComparing(ComponentType::getScenario)).collect(Collectors.toList());
    generateAllComponentsList(messagesDocPath, sortedComponentList);
    componentList.forEach(c -> {
        try {
            generateComponentDetail(messagesDocPath, c);
        } catch (final Exception e) {
            throw new RuntimeException(e);
        }
    });
    final List<GroupType> groupList = repository.getGroups().getGroup();
    final List<GroupType> sortedGroupList = groupList.stream().sorted(Comparator.comparing(GroupType::getName).thenComparing(GroupType::getScenario)).collect(Collectors.toList());
    generateAllGroupsList(messagesDocPath, sortedGroupList);
    groupList.forEach(c -> {
        try {
            generateGroupDetail(messagesDocPath, c);
        } catch (final Exception e) {
            throw new RuntimeException(e);
        }
    });
    repository.getMessages().getMessage().forEach(m -> {
        try {
            generateMessageDetail(messagesDocPath, messagesImgPath, m);
        } catch (final Exception e) {
            throw new RuntimeException(e);
        }
    });
    pathManager.close();
}

Example 2 with FlowType

use of io.fixprotocol._2020.orchestra.repository.FlowType in project fix-orchestra by FIXTradingCommunity.

the class DocGenerator method generateMessageListByFlow.

private void generateMessageListByFlow(final Path messagesDocPath, final FlowType flow, final List<MessageType> messageList) throws Exception {
    final ST st = stGroup.getInstanceOf("messages");
    final List<MessageType> filteredMessageList = messageList.stream().filter(m -> flow.getName().equals(m.getFlow())).collect(Collectors.toList());
    st.add("messages", filteredMessageList);
    st.add("title", String.format("%s Messages", flow.getName()));
    final Path path = messagesDocPath.resolve(String.format("%sMessages.html", flow.getName()));
    try (final STWriterWrapper writer = getWriter(path)) {
        st.write(writer, templateErrorListener);
    }
}

Example 3 with FlowType

use of io.fixprotocol._2020.orchestra.repository.FlowType in project fix-orchestra by FIXTradingCommunity.

the class DocGenerator method generateMessageDetail.

private void generateMessageDetail(final Path messagesDocPath, final Path messagesImgPath, final MessageType message) throws Exception {
    final ST stMessageStart = stGroup.getInstanceOf("messageStart");
    final ST stMessagePart2 = stGroup.getInstanceOf("messagePart2");
    final ST stMessageEnd = stGroup.getInstanceOf("messageEnd");
    stMessageStart.add("message", message);
    stMessagePart2.add("message", message);
    stMessageEnd.add("message", message);
    List<ResponseType> responses = null;
    final Responses responses2 = message.getResponses();
    if (responses2 != null) {
        responses = responses2.getResponse();
    }
    final List<Object> members = message.getStructure().getComponentRefOrGroupRefOrFieldRef();
    final Path path = messagesDocPath.resolve(String.format("%s-%s.html", message.getName(), message.getScenario()));
    try (final STWriterWrapper writer = getWriter(path)) {
        stMessageStart.write(writer, templateErrorListener);
        if (responses != null) {
            generateResponses(responses, writer);
        }
        stMessagePart2.write(writer, templateErrorListener);
        generateMembers(members, writer);
        stMessageEnd.write(writer, templateErrorListener);
    }
    if (responses != null) {
        final FlowType flow = getFlow(message.getFlow());
        imgGenerator.generateUMLSequence(messagesImgPath, pathManager, message, flow, responses, templateErrorListener);
    }
}