294 lines
8.1 KiB
Go
294 lines
8.1 KiB
Go
package commands
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
clientproto "github.com/anytypeio/go-anytype-infrastructure-experiments/client/api/apiproto"
|
|
"github.com/spf13/cobra"
|
|
)
|
|
|
|
func (s *service) registerClientCommands() {
|
|
cmdCreateSpace := &cobra.Command{
|
|
Use: "create-space",
|
|
Short: "create the space",
|
|
Args: cobra.RangeArgs(0, 0),
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
cli, _ := cmd.Flags().GetString("client")
|
|
addr, ok := s.peers[cli]
|
|
if !ok {
|
|
fmt.Println("no such client")
|
|
return
|
|
}
|
|
resp, err := s.client.CreateSpace(context.Background(), addr, &clientproto.CreateSpaceRequest{})
|
|
if err != nil {
|
|
fmt.Println("couldn't create a space", err)
|
|
return
|
|
}
|
|
fmt.Println(resp.Id)
|
|
},
|
|
}
|
|
s.clientCommands = append(s.clientCommands, cmdCreateSpace)
|
|
|
|
cmdLoadSpace := &cobra.Command{
|
|
Use: "load-space [space]",
|
|
Short: "load the space",
|
|
Args: cobra.RangeArgs(1, 1),
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
cli, _ := cmd.Flags().GetString("client")
|
|
addr, ok := s.peers[cli]
|
|
if !ok {
|
|
fmt.Println("no such client")
|
|
return
|
|
}
|
|
|
|
_, err := s.client.LoadSpace(context.Background(), addr, &clientproto.LoadSpaceRequest{
|
|
SpaceId: args[0],
|
|
})
|
|
if err != nil {
|
|
fmt.Println("couldn't load the space", err)
|
|
return
|
|
}
|
|
fmt.Println("space loaded", args[0])
|
|
},
|
|
}
|
|
s.clientCommands = append(s.clientCommands, cmdLoadSpace)
|
|
|
|
cmdDeriveSpace := &cobra.Command{
|
|
Use: "derive-space",
|
|
Short: "derive the space from account data",
|
|
Args: cobra.RangeArgs(0, 0),
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
cli, _ := cmd.Flags().GetString("client")
|
|
addr, ok := s.peers[cli]
|
|
if !ok {
|
|
fmt.Println("no such client")
|
|
return
|
|
}
|
|
|
|
resp, err := s.client.DeriveSpace(context.Background(), addr, &clientproto.DeriveSpaceRequest{})
|
|
if err != nil {
|
|
fmt.Println("couldn't derive a space", err)
|
|
return
|
|
}
|
|
fmt.Println(resp.Id)
|
|
},
|
|
}
|
|
s.clientCommands = append(s.clientCommands, cmdDeriveSpace)
|
|
|
|
cmdCreateDocument := &cobra.Command{
|
|
Use: "create-document [space]",
|
|
Short: "create the document in a particular space",
|
|
Args: cobra.RangeArgs(1, 1),
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
cli, _ := cmd.Flags().GetString("client")
|
|
addr, ok := s.peers[cli]
|
|
if !ok {
|
|
fmt.Println("no such client")
|
|
return
|
|
}
|
|
resp, err := s.client.CreateDocument(context.Background(), addr, &clientproto.CreateDocumentRequest{
|
|
SpaceId: args[0],
|
|
})
|
|
if err != nil {
|
|
fmt.Println("couldn't create a document", err)
|
|
return
|
|
}
|
|
fmt.Println(resp.Id)
|
|
},
|
|
}
|
|
s.clientCommands = append(s.clientCommands, cmdCreateDocument)
|
|
|
|
cmdDeleteDocument := &cobra.Command{
|
|
Use: "delete-document [document]",
|
|
Short: "delete the document in a particular space",
|
|
Args: cobra.RangeArgs(1, 1),
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
cli, _ := cmd.Flags().GetString("client")
|
|
space, _ := cmd.Flags().GetString("space")
|
|
addr, ok := s.peers[cli]
|
|
if !ok {
|
|
fmt.Println("no such client")
|
|
return
|
|
}
|
|
_, err := s.client.DeleteDocument(context.Background(), addr, &clientproto.DeleteDocumentRequest{
|
|
SpaceId: space,
|
|
DocumentId: args[0],
|
|
})
|
|
if err != nil {
|
|
fmt.Println("couldn't delete the document", err)
|
|
return
|
|
}
|
|
fmt.Println("deleted", args[0])
|
|
},
|
|
}
|
|
cmdDeleteDocument.Flags().String("space", "", "the space where something is happening :-)")
|
|
cmdDeleteDocument.MarkFlagRequired("space")
|
|
s.clientCommands = append(s.clientCommands, cmdDeleteDocument)
|
|
|
|
cmdAddText := &cobra.Command{
|
|
Use: "add-text [text]",
|
|
Short: "add text to the document in the particular space",
|
|
Args: cobra.RangeArgs(1, 1),
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
cli, _ := cmd.Flags().GetString("client")
|
|
space, _ := cmd.Flags().GetString("space")
|
|
document, _ := cmd.Flags().GetString("document")
|
|
snapshot, _ := cmd.Flags().GetBool("snapshot")
|
|
addr, ok := s.peers[cli]
|
|
if !ok {
|
|
fmt.Println("no such client")
|
|
return
|
|
}
|
|
|
|
resp, err := s.client.AddText(context.Background(), addr, &clientproto.AddTextRequest{
|
|
SpaceId: space,
|
|
DocumentId: document,
|
|
Text: args[0],
|
|
IsSnapshot: snapshot,
|
|
})
|
|
if err != nil {
|
|
fmt.Println("couldn't add text to the document", err)
|
|
return
|
|
}
|
|
fmt.Println("added text", resp.DocumentId, "root:", resp.RootId, "head:", resp.HeadId)
|
|
},
|
|
}
|
|
cmdAddText.Flags().String("space", "", "the space where something is happening :-)")
|
|
cmdAddText.Flags().String("document", "", "the document where something is happening :-)")
|
|
cmdAddText.Flags().Bool("snapshot", false, "tells if the snapshot should be created")
|
|
cmdAddText.MarkFlagRequired("space")
|
|
cmdAddText.MarkFlagRequired("document")
|
|
s.clientCommands = append(s.clientCommands, cmdAddText)
|
|
|
|
cmdAllTrees := &cobra.Command{
|
|
Use: "all-trees [space]",
|
|
Short: "print all trees in space and their heads",
|
|
Args: cobra.RangeArgs(1, 1),
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
cli, _ := cmd.Flags().GetString("client")
|
|
addr, ok := s.peers[cli]
|
|
if !ok {
|
|
fmt.Println("no such client")
|
|
return
|
|
}
|
|
|
|
resp, err := s.client.AllTrees(context.Background(), addr, &clientproto.AllTreesRequest{
|
|
SpaceId: args[0],
|
|
})
|
|
if err != nil {
|
|
fmt.Println("couldn't print all the trees", err)
|
|
return
|
|
}
|
|
var res string
|
|
for treeIdx, tree := range resp.Trees {
|
|
treeStr := tree.Id + ":["
|
|
for headIdx, head := range tree.Heads {
|
|
treeStr += head
|
|
if headIdx != len(tree.Heads)-1 {
|
|
treeStr += ","
|
|
}
|
|
}
|
|
treeStr += "]"
|
|
res += treeStr
|
|
if treeIdx != len(resp.Trees)-1 {
|
|
res += "\n"
|
|
}
|
|
}
|
|
fmt.Println(res)
|
|
},
|
|
}
|
|
s.clientCommands = append(s.clientCommands, cmdAllTrees)
|
|
|
|
cmdDumpTree := &cobra.Command{
|
|
Use: "dump-tree [document]",
|
|
Short: "get graphviz description of the tree",
|
|
Args: cobra.RangeArgs(1, 1),
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
cli, _ := cmd.Flags().GetString("client")
|
|
space, _ := cmd.Flags().GetString("space")
|
|
addr, ok := s.peers[cli]
|
|
if !ok {
|
|
fmt.Println("no such client")
|
|
return
|
|
}
|
|
|
|
resp, err := s.client.DumpTree(context.Background(), addr, &clientproto.DumpTreeRequest{
|
|
SpaceId: space,
|
|
DocumentId: args[0],
|
|
})
|
|
if err != nil {
|
|
fmt.Println("couldn't dump the tree", err)
|
|
return
|
|
}
|
|
fmt.Println(resp.Dump)
|
|
},
|
|
}
|
|
cmdDumpTree.Flags().String("space", "", "the space where something is happening :-)")
|
|
cmdDumpTree.MarkFlagRequired("space")
|
|
s.clientCommands = append(s.clientCommands, cmdDumpTree)
|
|
|
|
cmdTreeParams := &cobra.Command{
|
|
Use: "tree-params [document]",
|
|
Short: "print heads and root of the tree",
|
|
Args: cobra.RangeArgs(1, 1),
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
cli, _ := cmd.Flags().GetString("client")
|
|
space, _ := cmd.Flags().GetString("space")
|
|
addr, ok := s.peers[cli]
|
|
if !ok {
|
|
fmt.Println("no such client")
|
|
return
|
|
}
|
|
|
|
resp, err := s.client.TreeParams(context.Background(), addr, &clientproto.TreeParamsRequest{
|
|
SpaceId: space,
|
|
DocumentId: args[0],
|
|
})
|
|
if err != nil {
|
|
fmt.Println("couldn't print params of the tree", err)
|
|
return
|
|
}
|
|
res := resp.RootId + "->"
|
|
for headIdx, head := range resp.HeadIds {
|
|
res += head
|
|
if headIdx != len(resp.HeadIds)-1 {
|
|
res += ","
|
|
}
|
|
}
|
|
fmt.Println(res)
|
|
},
|
|
}
|
|
cmdTreeParams.Flags().String("space", "", "the space where something is happening :-)")
|
|
cmdTreeParams.MarkFlagRequired("space")
|
|
s.clientCommands = append(s.clientCommands, cmdTreeParams)
|
|
|
|
cmdAllSpaces := &cobra.Command{
|
|
Use: "all-spaces",
|
|
Short: "print all spaces",
|
|
Args: cobra.RangeArgs(0, 0),
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
cli, _ := cmd.Flags().GetString("client")
|
|
addr, ok := s.peers[cli]
|
|
if !ok {
|
|
fmt.Println("no such client")
|
|
return
|
|
}
|
|
|
|
resp, err := s.client.AllSpaces(context.Background(), addr, &clientproto.AllSpacesRequest{})
|
|
if err != nil {
|
|
fmt.Println("couldn't print all the spaces", err)
|
|
return
|
|
}
|
|
var res string
|
|
for treeIdx, spaceId := range resp.SpaceIds {
|
|
res += spaceId
|
|
if treeIdx != len(resp.SpaceIds)-1 {
|
|
res += "\n"
|
|
}
|
|
}
|
|
fmt.Println(res)
|
|
},
|
|
}
|
|
s.clientCommands = append(s.clientCommands, cmdAllSpaces)
|
|
}
|