110 lines
3.5 KiB
Go
110 lines
3.5 KiB
Go
package main
|
|
|
|
import (
|
|
"net/http"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
// loadSchemaSnapshot 读全量 schema(类型+属性+链接)组装导出快照。
|
|
// 存量库 iri 为空时按当前 base 兜底生成(与启动回填同一规则)。
|
|
func (a *app) loadSchemaSnapshot(c *gin.Context) (schemaSnapshot, error) {
|
|
s := schemaSnapshot{BaseIRI: a.cfg.BaseIRI}
|
|
iriOf := func(stored, apiName string) string {
|
|
if stored != "" {
|
|
return stored
|
|
}
|
|
return buildIRI(a.cfg.BaseIRI, apiName)
|
|
}
|
|
tRows, err := a.pool.Query(c,
|
|
`SELECT ot.api_name, COALESCE(ot.iri,''), ot.display_name, ot.description,
|
|
COALESCE(ot.axioms,'{}'::jsonb),
|
|
COALESCE(par.api_name,'') AS parent_api_name,
|
|
COALESCE(ot.display_name_lang,'{}'::jsonb)
|
|
FROM object_types ot LEFT JOIN object_types par ON par.id=ot.parent_id
|
|
ORDER BY ot.api_name`)
|
|
if err != nil {
|
|
return s, err
|
|
}
|
|
byName := map[string]string{} // api_name → iri,供链接解析
|
|
for tRows.Next() {
|
|
var t schemaTypeExport
|
|
var axBytes, dispLangBytes []byte
|
|
if err := tRows.Scan(&t.APIName, &t.IRI, &t.DisplayName, &t.Description, &axBytes, &t.ParentAPIName, &dispLangBytes); err != nil {
|
|
return s, err
|
|
}
|
|
t.IRI = iriOf(t.IRI, t.APIName)
|
|
if ax := parseAxiomsLenient(axBytes); ax != nil {
|
|
t.Axioms = *ax
|
|
}
|
|
t.DisplayNameLang = parseStringMap(dispLangBytes)
|
|
byName[t.APIName] = t.IRI
|
|
s.Types = append(s.Types, t)
|
|
}
|
|
tRows.Close()
|
|
// 属性按类型归组(schema 规模小,N+1 查询可接受;避免拼接 SQL 的列歧义)
|
|
for i := range s.Types {
|
|
pRows, err := a.pool.Query(c,
|
|
`SELECT api_name, COALESCE(iri,''), display_name, description, data_type,
|
|
COALESCE(display_name_lang,'{}'::jsonb) FROM properties
|
|
WHERE object_type_id=(SELECT id FROM object_types WHERE api_name=$1) ORDER BY api_name`,
|
|
s.Types[i].APIName)
|
|
if err != nil {
|
|
return s, err
|
|
}
|
|
for pRows.Next() {
|
|
var p schemaPropExport
|
|
var dispLangBytes []byte
|
|
if err := pRows.Scan(&p.APIName, &p.IRI, &p.DisplayName, &p.Description, &p.DataType, &dispLangBytes); err != nil {
|
|
pRows.Close()
|
|
return s, err
|
|
}
|
|
p.IRI = iriOf(p.IRI, p.APIName)
|
|
p.DisplayNameLang = parseStringMap(dispLangBytes)
|
|
s.Types[i].Properties = append(s.Types[i].Properties, p)
|
|
}
|
|
pRows.Close()
|
|
}
|
|
lRows, err := a.pool.Query(c,
|
|
`SELECT api_name, COALESCE(iri,''), display_name, description, source_type, target_type,
|
|
COALESCE(display_name_lang,'{}'::jsonb)
|
|
FROM link_types ORDER BY api_name`)
|
|
if err != nil {
|
|
return s, err
|
|
}
|
|
for lRows.Next() {
|
|
var l schemaLinkExport
|
|
var dispLangBytes []byte
|
|
if err := lRows.Scan(&l.APIName, &l.IRI, &l.DisplayName, &l.Description,
|
|
&l.SourceIRI, &l.TargetIRI, &dispLangBytes); err != nil { // SourceIRI/TargetIRI 先收 api_name
|
|
return s, err
|
|
}
|
|
l.IRI = iriOf(l.IRI, l.APIName)
|
|
l.DisplayNameLang = parseStringMap(dispLangBytes)
|
|
if v, ok := byName[l.SourceIRI]; ok {
|
|
l.SourceIRI = v
|
|
}
|
|
if v, ok := byName[l.TargetIRI]; ok {
|
|
l.TargetIRI = v
|
|
}
|
|
s.Links = append(s.Links, l)
|
|
}
|
|
lRows.Close()
|
|
return s, nil
|
|
}
|
|
|
|
// ontologyExport 本体 schema 标准序列化导出(当前仅 format=turtle)。
|
|
func (a *app) ontologyExport(c *gin.Context) {
|
|
format := c.DefaultQuery("format", "turtle")
|
|
if format != "turtle" {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "当前仅支持 format=turtle"})
|
|
return
|
|
}
|
|
snap, err := a.loadSchemaSnapshot(c)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
c.Data(http.StatusOK, "text/turtle; charset=utf-8", []byte(buildTurtle(snap)))
|
|
}
|