Edge Index ElasticSearch

// Класс SchemaLoader
class SchemaLoader(private val project: Project) {

    suspend fun loadSchema(
        schema: Schema,
        task: Task? = null
    ) {
        logger.info("Начало загрузки схемы")

        task?.let {
            task.switchStage(newStage = TaskStage.UPLOADING_SCHEMA)
            task.changeTotal(newTotal = schema.properties.size)
        }

        project.mgmtSuspendTransaction { mgmt ->

            val vertexIndex = project.projectKey + "_vertex_index"
            mgmt.buildIndex(vertexIndex, Vertex::class.java).also { builderIndex ->
                mgmt.createOntologyTags(builderIndex)

                mgmt.createMetaEntity(builderIndex)

                mgmt.createProperties(
                    builderIndex = builderIndex,
                    properties = schema.properties,
                    task = task
                )

                logger.info("Ожидание создания индекса вершин ${project.projectKey}")
            }.buildMixedIndex("search")
            logger.info("Индекс $vertexIndex для вершин создан")


            val edgeIndex = project.projectKey + "_edge_index"
            mgmt.buildIndex(edgeIndex, Edge::class.java).also { builderIndex ->
                mgmt.createEdge(builderIndex)

                logger.info("Ожидание создания индекса ребер ${project.projectKey}")
            }.buildMixedIndex("search")
            logger.info("Индекс $edgeIndex для ребер создан")
        }

        project.schema = schema

        logger.info("Конец загрузки и индексации схемы")
        task?.let { task.switchStage(newStage = TaskStage.Ready) }
    }

    /**
     * Создание свойства для хранения списка онтологических тэгов
     */
    private fun JanusGraphManagement.createOntologyTags(
        builderIndex: JanusGraphManagement.IndexBuilder
    ) {
        //TODO можно создать ONTOLOGICAL_TAGS-single для хранения конечного тэга, кем является сущность.
        // Это может немного оптимизировать конвертацию из Vertex в NodeData

        val propertyNameOntologyTags = "${ONTOLOGICAL_TAGS.name}-list"
        val propertyOntologyTags = makePropertyKey(propertyNameOntologyTags)
            .dataType(DataType.STRING.jvmClass)
            .cardinality(Cardinality.LIST).make()

        builderIndex.addKey(propertyOntologyTags, Mapping.STRING.asParameter())
    }

    /**
     * Создание мета свойств, используемых в истории
     */
    private fun JanusGraphManagement.createMetaEntity(
        builderIndex: JanusGraphManagement.IndexBuilder
    ) {
        //TODO есть возможность индексации Property у VertexProperty,
        // теоретически это может ускорить поиск по временным промежуткам

        val metaEntity = listOf(
            MANDATE_LABEL.name to DataType.BYTE,
            NODE_CREATED.name to DataType.LONG,
            LABEL_HISTORY_PROPERTY_LOAD_DATE.name to DataType.LONG,
            LABEL_HISTORY_PROPERTY_COLLECTION_DATE.name to DataType.LONG,
            LABEL_HISTORY_PROPERTY_DATE_OF_DOCUMENT_CREATION.name to DataType.LONG,
            LABEL_USER_CHANGE_PROPERTY_NAME.name to DataType.STRING,
            NON_HIERARCHICAL_PRIVACY_CATEGORIES.name to DataType.BYTE,
            LOADING_ID.name to DataType.STRING,
        )

        metaEntity.forEach { (name, type) ->
            val validNameMetaProperty = name.replace("/", "")

            val metaPropertyName = "$validNameMetaProperty-single"

            val metaProperty = makePropertyKey(metaPropertyName)
                .dataType(type.jvmClass)
                .cardinality(Cardinality.SINGLE).make()

            builderIndex.addKey(metaProperty)

            logger.debug("Добавлено МЕТА-СВОЙСТВО: $validNameMetaProperty")
        }
    }

    /**
     * Создание всех свойств в схеме
     */
    private suspend fun JanusGraphManagement.createProperties(
        builderIndex: JanusGraphManagement.IndexBuilder,
        properties: List<PropertySchema>,
        task: Task? = null
    ) {
        properties.forEach { property ->
            val validName = property.key.replace("/", "")

            val propertyNameSingle = "$validName-single"
            val propertyNameList = "$validName-list"

            val propertySingle = makePropertyKey(propertyNameSingle)
                .dataTypeConverter(property)
                .cardinality(Cardinality.SINGLE).make()

            val propertyList = makePropertyKey(propertyNameList)
                .dataTypeConverter(property)
                .cardinality(Cardinality.LIST).make()

            if (property.isIndex) {

                when (property.dataType) {
                    DataType.STRING -> {
                        builderIndex.addKey(propertySingle, Mapping.TEXTSTRING.asParameter())
                        builderIndex.addKey(propertyList, Mapping.TEXTSTRING.asParameter())
                    }

                    DataType.GEOSHAPE -> {
                        builderIndex.addKey(propertySingle, Mapping.BKD.asParameter())
                        builderIndex.addKey(propertyList, Mapping.BKD.asParameter())
                    }

                    else -> {
                        builderIndex.addKey(propertySingle, Mapping.DEFAULT.asParameter())
                        builderIndex.addKey(propertyList, Mapping.DEFAULT.asParameter())
                    }
                }

            }

            task?.let { task.increment() }

            logger.debug("Добавлено СВОЙСТВО: $validName")
        }
    }

    /**
     * Создание ребра
     */
    private fun JanusGraphManagement.createEdge(
        builderIndex: JanusGraphManagement.IndexBuilder,
    ) {

        builderIndex.addKey(edgeNameProperty)
        //builderIndex.addKey(edgeNameProperty, Mapping.TEXTSTRING.asParameter())


        val metaProperty = makePropertyKey(EDGE_NAME.name)
            .dataType(DataType.STRING.jvmClass)
            .cardinality(Cardinality.SINGLE).make()

        val edge = makeEdgeLabel(EDGE.name).multiplicity(Multiplicity.MULTI).make()
        buildEdgeIndex(edge, "edge-index", Direction.BOTH, Order.desc, metaProperty)

        val metaEntity = listOf(
            EDGE_NAME.name to DataType.STRING,
        )

        metaEntity.forEach { (name, type) ->
            val validNameMetaProperty = name.replace("/", "")

            val metaPropertyName = "$validNameMetaProperty-single"

            val metaProperty = makePropertyKey(metaPropertyName)
                .dataType(type.jvmClass)
                .cardinality(Cardinality.SINGLE).make()

            builderIndex.addKey(metaProperty, Mapping.TEXTSTRING.asParameter())

            logger.debug("Добавлено РЕБРО: ${validNameMetaProperty}")
        }

    }

    private fun PropertyKeyMaker.dataTypeConverter(property: PropertySchema): PropertyKeyMaker =
        when (property.dataType) {
            DataType.GEOSHAPE -> dataType(Geoshape::class.java)
            else -> dataType(property.dataType.jvmClass)
        }

}


// Класс EdgeRepository
class EdgeRepository {
    fun createEdge(
        edgeKey: String,
        edgeSourceId: String,
        edgeTargetId: String,
        traversal: GraphTraversalSource,
    ): String =
        traversal
            .addE(EDGE.name)
            .property(EDGE_NAME.single, edgeKey) // добавление мета свойства с именем ребра
            .from(step.V<Edge>(edgeSourceId))
            .to(step.V<Edge>(edgeTargetId))
            .next()
            .id()
            .toString()
}


// Метод isExistEdge()
 fun isExistEdge() = traversal
            .V().has(LOADING_ID.single, edge.source.id)
            .bothE().has(EDGE_NAME.single, edge.key)
            .otherV().has(LOADING_ID.single, edge.target.id)
            .hasNext()