func (s *Server) CreateConnection(newConn ProtoConnection) (*ConnectionLedger, error) {
source, ok := s.blocks[newConn.Source.Id]
if !ok {
return nil, errors.New("source block does not exist")
}
target, ok := s.blocks[newConn.Target.Id]
if !ok {
return nil, errors.New("target block does not exist")
}
sourceRoute := core.RouteIndex(newConn.Source.Route)
targetRoute, err := target.Block.GetInput(core.RouteIndex(newConn.Target.Route))
if err != nil {
return nil, err
}
err = source.Block.Connect(sourceRoute, targetRoute.C)
if err != nil {
return nil, err
}
conn := &ConnectionLedger{
Source: newConn.Source,
Target: newConn.Target,
Id: s.GetNextID(),
}
s.ResetGraph(conn)
s.connections[conn.Id] = conn
s.websocketBroadcast(Update{Action: CREATE, Type: CONNECTION, Data: wsConnection{*conn}})
return conn, nil
}
func (s *Server) DeleteConnection(id int) error {
c, ok := s.connections[id]
if !ok {
return errors.New("could not find connection")
}
source, ok := s.blocks[c.Source.Id]
if !ok {
return errors.New("could not find source block")
}
target, ok := s.blocks[c.Target.Id]
if !ok {
return errors.New("could not find target block")
}
route, err := target.Block.GetInput(core.RouteIndex(c.Target.Route))
if err != nil {
return err
}
err = source.Block.Disconnect(core.RouteIndex(c.Source.Route), route.C)
if err != nil {
return err
}
delete(s.connections, id)
s.ResetGraph(c)
s.websocketBroadcast(Update{Action: DELETE, Type: CONNECTION, Data: wsConnection{wsId{id}}})
return nil
}
func (s *Server) ModifyBlockRoute(id int, route int, v *core.InputValue) error {
b, ok := s.blocks[id]
if !ok {
return errors.New("could not find block")
}
var value *core.InputValue
if v.Exists() {
value = v
}
err := b.Block.SetInput(core.RouteIndex(route), value)
if err != nil {
return err
}
s.blocks[id].Inputs[route].Value = value
s.websocketBroadcast(Update{Action: UPDATE, Type: ROUTE, Data: wsRouteModify{ConnectionNode{id, route}, value}})
return nil
}
