myid = "U1XXXXXX"

local bot = golbot.newbot("Slack", {

token = "",

log = {"seelog", type="adaptive", mininterval="200000000", maxinterval="1000000000", critmsgcount="5",

{"formats",

{"format", id="main", format="%Date(2006-01-02 15:04:05) [%Level] %Msg"},

},

{"outputs", formatid="main",

{"filter", levels="trace,debug,info,warn,error,critical",

{"console"}

},

}

}

})

bot:on("message", function(e)

local ch = e.channel

local user = e.user

local msg = e.text

if e.sub_type == "" and user ~= myid then

msglog:printf("%s\t%s\t%s", ch, user, msg)

bot:say(ch, msg)

goworker({channel=ch, message=msg, nick=nick})

end

end)

slackobj *slack.Client

rtm *slack.RTM

commonOption *CommonClientOption

logger *log.Logger

userId string

startedAt float64

callbacks map[string][]*lua.LFunction

userId2Name map[string]string

userName2Id map[string]string

channelId2Name map[string]string

channelName2Id map[string]string

if ok, _ := regexp.MatchString(`[CU][0-9].*`, v); ok {

return v

}

if strings.HasPrefix(v, "#") {

if v, ok := client.channelName2Id[v[1:]]; ok {

return v

}

}

if v, ok := client.userName2Id[v]; ok {

return v

}

return v

mutex.Lock()

defer mutex.Unlock()

v, ok := client.callbacks[msg.Type]

if !ok {

return

}

for _, callback := range v {

if e, ok := msg.Data.(*slack.MessageEvent); ok {

f, _ := strconv.ParseFloat(e.Timestamp, 64)

if (f - client.startedAt) < 3 {

return

}

}

pushN(L, callback, luar.New(L, msg.Data))

if err := L.PCall(1, 0, nil); err != nil {

client.logger.Printf("[Error] %s", err.Error())

}

}

mutex.Lock()

defer mutex.Unlock()

v, ok := client.callbacks[typ]

if !ok {

v = []*lua.LFunction{}

client.callbacks[typ] = v

}

client.callbacks[typ] = append(v, callback)

client.On(L, "message", L.NewFunction(func(L *lua.LState) int {

e := L.CheckUserData(1).Value.(*slack.MessageEvent)

matches := pattern.FindAllStringSubmatch(e.Text, -1)

mentionMe, _ := regexp.MatchString("<@"+client.userId+"[^>]*>", e.Text)

if (e.SubType == "me_message" || len(e.SubType) == 0) && len(matches) != 0 && mentionMe {

user := client.userId2Name[e.User]

channel := "#" + client.channelId2Name[e.Channel]

pushN(L, fn, luar.New(L, matches[0]), luar.New(L, NewMessageEvent(user, channel, e.Text, e)))

if err := L.PCall(2, 0, nil); err != nil {

client.logger.Printf("[ERROR] %s", err.Error())

}

}

return 0

}))

rtm := client.rtm

client.startedAt = float64(time.Now().Unix())

go rtm.ManageConnection()

for {

select {

case msg := <-rtm.IncomingEvents:

client.applyCallback(L, &msg)

switch ev := msg.Data.(type) {

case *slack.ChannelCreatedEvent:

client.logger.Printf("[Info] Channel created : %s(ID:%s)", ev.Channel.Name, ev.Channel.ID)

client.channelName2Id[ev.Channel.Name] = ev.Channel.ID

client.channelId2Name[ev.Channel.ID] = ev.Channel.Name

case *slack.ChannelRenameEvent:

client.logger.Printf("[Info] Channel renamed: ID:%s %s -> %s", ev.Channel.ID, client.channelId2Name[ev.Channel.ID], ev.Channel.Name)

delete(client.channelName2Id, client.channelId2Name[ev.Channel.ID])

client.channelName2Id[ev.Channel.Name] = ev.Channel.ID

case *slack.ChannelDeletedEvent:

client.logger.Printf("[Info] Channel deleted: %s(ID:%s)", client.channelId2Name[ev.Channel], ev.Channel)

delete(client.channelName2Id, client.channelId2Name[ev.Channel])

delete(client.channelId2Name, ev.Channel)

case *slack.ConnectedEvent:

channels := []string{}

client.userId = ev.Info.User.ID

for _, c := range ev.Info.Channels {

client.channelName2Id[c.Name] = c.ID

client.channelId2Name[c.ID] = c.Name

channels = append(channels, c.Name)

}

for _, u := range ev.Info.Users {

client.userName2Id[u.Name] = u.ID

client.userId2Name[u.ID] = u.Name

}

client.logger.Printf("[Info] Connected to %s(channels:%s)", ev.Info.Team.Domain, strings.Join(channels, ","))

client.logger.Printf("[Info] My name is %s(ID:%s)", ev.Info.User.Name, client.userId)

default:

// Ignore other events..

}

case msg := <-luaMainChan:

func() {

mutex.Lock()

defer mutex.Unlock()

pushN(L, fn, msg)

L.PCall(1, 0, nil)

}()

}

}

token, ok := getStringField(L, opt, "token")

if !ok {

L.RaiseError("'token' is required")

}

slackobj := slack.New(token)

chatClient := &slackChatClient{slackobj, nil, co, co.Logger, "", 0, make(map[string][]*lua.LFunction), make(map[string]string), make(map[string]string), make(map[string]string), make(map[string]string)}

if co.Logger == nil {

slack.SetLogger(log.New(os.Stdout, "", log.Lshortfile|log.LstdFlags))

} else {

slack.SetLogger(co.Logger)

}

chatClient.rtm = chatClient.slackobj.NewRTM()

L.Push(newChatClient(L, slackChatClientTypeName, chatClient, luar.New(L, chatClient.rtm).(*lua.LUserData)))