func (b *Bind) Act() func(s stream.Stream) error {
return func(s stream.Stream) (err error) {
bind := &entity.Bind{}
*bind = entity.BindPrototype
bind.Resource = b.Rsrc
iq := entity.IQ(entity.SET, bind)
if err = s.Write(entity.ProduceStatic(iq)); err == nil {
s.Ring(func(b *bytes.Buffer) (done bool) {
var _e entity.Entity
if _e, err = entity.ConsumeStatic(b); err == nil {
switch e := _e.(type) {
case *entity.Iq:
switch {
case e.Id == iq.Id && e.Type == entity.RESULT:
stream.Bind(s, e.Inner.(*entity.Bind).Jid)
done = true
}
default:
log.Println(reflect.TypeOf(e))
}
}
return
}, 0)
}
return
}
}
func (exc *Executor) SendMessageToBot(msg *Message) {
m := entity.MSG(entity.GROUPCHAT)
m.To = "*****@*****.**"
m.Body = msg.IncomingEvent.Data["body"]
err := exc.xmppStream.Write(entity.ProduceStatic(m))
if err != nil {
exc.logger.Printf("failed to write message to xmpp stream: %v", err)
}
}
func PresenceTo(jid string, show entity.PresenceShow, status string) func(stream.Stream) error {
return func(s stream.Stream) error {
pr := &entity.Presence{}
*pr = entity.PresencePrototype
pr.To = jid
pr.Show = show
pr.Status = status
return s.Write(entity.ProduceStatic(pr))
}
}
func (e *Executor) sendingRoutine() {
for msg := range e.outgoingMsgs {
m := entity.MSG(entity.GROUPCHAT)
m.To = "*****@*****.**"
m.Body = msg
err := e.xmppStream.Write(entity.ProduceStatic(m))
if err != nil {
fmt.Printf("send error: %s", err)
}
time.Sleep(sleepDuration)
}
}
func (e *Executor) execute() {
for script := range e.incomingScripts {
e.stateMutex.Lock()
err := lua.DoString(e.state, script)
if err != nil {
fmt.Printf("lua f*****g shit error: %s\n", err)
m := entity.MSG(entity.GROUPCHAT)
m.To = "*****@*****.**"
m.Body = err.Error()
e.xmppStream.Write(entity.ProduceStatic(m))
}
e.stateMutex.Unlock()
}
}
func (e *Executor) processIncomingEvents() {
for evt := range e.incomingEvents {
e.stateMutex.Lock()
obj, _ := e.vm.Object("({})")
for key, value := range evt.Data {
obj.Set(key, value)
}
for _, handler := range e.eventHandlers[evt.Type] {
_, err := handler.Call(obj.Value(), obj.Value())
if err != nil {
fmt.Printf("js f*****g shit error: %s\n", err)
m := entity.MSG(entity.GROUPCHAT)
m.To = "*****@*****.**"
m.Body = err.Error()
e.xmppStream.Write(entity.ProduceStatic(m))
}
}
e.stateMutex.Unlock()
}
}
func Session(s stream.Stream) (err error) {
iq := entity.IQ(entity.SET, &entity.SessionPrototype)
if err = s.Write(entity.ProduceStatic(iq)); err == nil {
s.Ring(func(b *bytes.Buffer) (done bool) {
var _e entity.Entity
if _e, err = entity.ConsumeStatic(b); err == nil {
switch e := _e.(type) {
case *entity.Iq:
switch {
case e.Id == iq.Id && e.Type == entity.RESULT:
done = true
}
default:
log.Println(reflect.TypeOf(e))
}
}
return
}, 0)
}
return
}
func (e *Executor) processIncomingEvents() {
for evt := range e.incomingEvents {
e.stateMutex.Lock()
// get events table
e.state.PushString(callbacksLocation)
e.state.Table(lua.RegistryIndex)
// get callbacks table for the specific event
e.state.PushString(evt.Type)
e.state.Table(-2)
// loop over callbacks
if !e.state.IsNil(-1) {
e.state.PushNil()
for e.state.Next(-2) {
if e.state.IsFunction(-1) {
// create the table which will be passed to the handler
e.state.NewTable()
// loop over the event data, populating the table
for k, v := range evt.Data {
e.state.PushString(k)
e.state.PushString(v)
e.state.SetTable(-3)
}
err := e.state.ProtectedCall(1, 0, 0)
if err != nil {
m := entity.MSG(entity.GROUPCHAT)
m.To = "*****@*****.**"
m.Body, _ = e.state.ToString(-1)
e.xmppStream.Write(entity.ProduceStatic(m))
e.state.Pop(1)
}
} else {
e.state.Pop(1)
}
}
}
// pop callbacks table or nil value
e.state.Pop(1)
e.stateMutex.Unlock()
}
}
func (p *PlainAuth) Act() func(stream.Stream) error {
return func(s stream.Stream) (err error) {
auth := &entity.PlainAuth{}
*auth = entity.PlainAuthPrototype
auth.Init(p.Client.Name, p.Pwd)
if err = s.Write(entity.ProduceStatic(auth)); err == nil {
s.Ring(func(b *bytes.Buffer) (done bool) {
var _e entity.Entity
if _e, err = entity.ConsumeStatic(b); err == nil {
switch e := _e.(type) {
case *entity.Success:
done = true
default:
log.Println(reflect.TypeOf(e))
}
}
return
}, 0)
}
return
}
}
func InitialPresence(s stream.Stream) (err error) {
err = s.Write(entity.ProduceStatic(&entity.PresencePrototype))
return
}
