e2e face recognition
diff --git a/controller/schema/dgraph_schema_store.go b/controller/schema/dgraph_schema_store.go
index 0d345bb..4f434d7 100644
--- a/controller/schema/dgraph_schema_store.go
+++ b/controller/schema/dgraph_schema_store.go
@@ -2,6 +2,7 @@
import (
"bytes"
+ "errors"
"fmt"
"io/ioutil"
"net/http"
@@ -9,44 +10,49 @@
"github.com/golang/glog"
"github.com/itaysk/regogo"
+ "github.com/vektah/gqlparser"
"github.com/vektah/gqlparser/ast"
- "github.com/vektah/gqlparser/parser"
)
const jsonContentType = "application/json"
+const textContentType = "text/plain"
-const getSchemaQuery = `{ "query": "{ getGQLSchema() { schema } }" }`
+const getSchemaQuery = `{ "query": "{ getGQLSchema() { generatedSchema } }" }`
+const runQuery = `{ "query": "%s" }`
-const addSchemaQuery = `{
- "query": "mutation { updateGQLSchema(input: {set: {schema: \"%s\"}}) { gqlSchema { id schema } } }" }`
-
-type DgraphSchemaStore struct {
- dgraphAddress string
+type DgraphClient struct {
+ gqlAdddress string
+ schemaAddress string
gqlSchema string
- schema *ast.SchemaDocument
+ schema *ast.Schema
}
-func NewDgraphSchemaStore(dgraphAddress string) (SchemaStore, error) {
- ret := &DgraphSchemaStore{dgraphAddress: dgraphAddress, gqlSchema: ""}
+func NewDgraphClient(gqlAddress, schemaAddress string) (GraphQLClient, error) {
+ ret := &DgraphClient{
+ gqlAdddress: gqlAddress,
+ schemaAddress: schemaAddress,
+ gqlSchema: ""}
if err := ret.fetchSchema(); err != nil {
return nil, err
}
return ret, nil
}
-func (s *DgraphSchemaStore) Schema() *ast.SchemaDocument {
+func (s *DgraphClient) Schema() *ast.Schema {
return s.schema
}
-func (s *DgraphSchemaStore) AddSchema(gqlSchema string) error {
+func (s *DgraphClient) AddSchema(gqlSchema string) error {
return s.SetSchema(s.gqlSchema + gqlSchema)
}
-func (s *DgraphSchemaStore) SetSchema(gqlSchema string) error {
+func (s *DgraphClient) SetSchema(gqlSchema string) error {
glog.Info("Setting GraphQL schema:")
glog.Info(gqlSchema)
- req := fmt.Sprintf(addSchemaQuery, strings.ReplaceAll(strings.ReplaceAll(gqlSchema, "\n", " "), "\t", " "))
- resp, err := http.Post(s.dgraphAddress, jsonContentType, bytes.NewReader([]byte(req)))
+ resp, err := http.Post(
+ s.schemaAddress+"/schema",
+ textContentType,
+ bytes.NewReader([]byte(gqlSchema)))
if err != nil {
return err
}
@@ -60,9 +66,12 @@
return s.fetchSchema()
}
-func (s *DgraphSchemaStore) fetchSchema() error {
+func (s *DgraphClient) fetchSchema() error {
glog.Infof("Getting GraphQL schema with query: %s", getSchemaQuery)
- resp, err := http.Post(s.dgraphAddress, jsonContentType, bytes.NewReader([]byte(getSchemaQuery)))
+ resp, err := http.Post(
+ s.schemaAddress,
+ jsonContentType,
+ bytes.NewReader([]byte(getSchemaQuery)))
if err != nil {
return err
}
@@ -72,14 +81,56 @@
return err
}
glog.Infof("Result: %s", string(respBody))
- gqlSchema, err := regogo.Get(string(respBody), "input.data.getGQLSchema.schema")
+ gqlSchema, err := regogo.Get(
+ string(respBody),
+ "input.data.getGQLSchema.generatedSchema")
if err != nil {
return err
}
- schema, gqlErr := parser.ParseSchema(&ast.Source{Input: gqlSchema.String()})
+ schema, gqlErr := gqlparser.LoadSchema(&ast.Source{Input: gqlSchema.String()})
if gqlErr != nil {
return gqlErr
}
s.schema = schema
return nil
}
+
+func (s *DgraphClient) RunQuery(query string) (string, error) {
+ _, gqlErr := gqlparser.LoadQuery(s.Schema(), query)
+ if gqlErr != nil {
+ return "", errors.New(gqlErr.Error())
+ }
+ glog.Infof("Running GraphQL query: %s", query)
+ queryJson := fmt.Sprintf(runQuery, sanitizeQuery(query))
+ resp, err := http.Post(
+ s.gqlAdddress,
+ jsonContentType,
+ bytes.NewReader([]byte(queryJson)))
+ if err != nil {
+ return "", err
+ }
+ respBody, err := ioutil.ReadAll(resp.Body)
+ if err != nil {
+ return "", err
+ }
+ respStr := string(respBody)
+ glog.Infof("Result: %s", string(respStr))
+ // errStr, err := regogo.Get(respStr, "input.errors")
+ // if err == nil {
+ // return "", errors.New(errStr.JSON())
+ // }
+ data, err := regogo.Get(respStr, "input.data")
+ if err != nil {
+ return "", err
+ }
+ return data.JSON(), nil
+}
+
+func sanitizeSchema(schema string) string {
+ return strings.ReplaceAll(
+ strings.ReplaceAll(schema, "\n", " "), "\t", " ")
+}
+
+func sanitizeQuery(query string) string {
+ return strings.ReplaceAll(query, "\"", "\\\"")
+}