// SendMessage reads the configuration file, and posts a message about Kocho's invocation to Slack.
func SendMessage(version, build string) error {
expanded, err := homedir.Expand(configPath)
if err != nil {
return err
}
if _, err := os.Stat(expanded); os.IsNotExist(err) {
return errgo.Mask(ErrNotConfigured, errgo.Any)
}
slackConfiguration := SlackConfiguration{
NotificationUsername: "******",
EmojiIcon: ":robot_face:",
}
configFile, err := os.Open(expanded)
if err != nil {
return errgo.WithCausef(err, ErrInvalidConfiguration, "couldn't open Slack configuration file")
}
defer configFile.Close()
if err := json.NewDecoder(configFile).Decode(&slackConfiguration); err != nil {
return errgo.WithCausef(err, ErrInvalidConfiguration, "couldn't decode Slack configuration")
}
client := slack.New(slackConfiguration.Token)
params := slack.PostMessageParameters{}
params.Attachments = []slack.Attachment{
slack.Attachment{
Color: "#2484BE",
Text: fmt.Sprintf("*Kocho*: %s ran `%s`", slackConfiguration.Username, strings.Join(os.Args, " ")),
Fields: []slack.AttachmentField{
slack.AttachmentField{
Title: "Kocho Version",
Value: version,
Short: true,
},
slack.AttachmentField{
Title: "Kocho Build",
Value: build,
Short: true,
},
},
MarkdownIn: []string{"text"},
},
}
params.Username = slackConfiguration.NotificationUsername
params.IconEmoji = slackConfiguration.EmojiIcon
if _, _, err := client.PostMessage(slackConfiguration.NotificationChannel, "", params); err != nil {
return err
}
return nil
}
func (sl slackService) listenToMessages(msg PortalMessage) {
if msg.Kind == PORTAL_MESSAGE {
params := slack.PostMessageParameters{}
params.Username = msg.Author
_, time, err := sl.api.PostMessage(sl.channel, msg.Data, params)
if err != nil {
fmt.Println(err)
}
sl.sent[time] = true
}
}
func (s *Slack) handleChat(action string, params map[string]string) (interface{}, error) {
var v interface{}
var err error
switch action {
case "delete":
ch, ts, err := s.s.DeleteMessage(params["channel"], params["ts"])
if err != nil {
return nil, err
}
v = map[string]string{
"channel": ch,
"ts": ts,
}
case "postmessage":
postParam := slack.PostMessageParameters{}
postParam.Username = getStringParam(params, "username", slack.DEFAULT_MESSAGE_USERNAME)
postParam.Parse = getStringParam(params, "parse", slack.DEFAULT_MESSAGE_PARSE)
postParam.LinkNames = getIntParam(params, "link_names", slack.DEFAULT_MESSAGE_LINK_NAMES)
postParam.UnfurlLinks = getBoolParam(params, "unfurl_links", slack.DEFAULT_MESSAGE_UNFURL_LINKS)
postParam.UnfurlMedia = getBoolParam(params, "unfurl_media", slack.DEFAULT_MESSAGE_UNFURL_MEDIA)
postParam.IconURL = getStringParam(params, "icon_url", slack.DEFAULT_MESSAGE_ICON_URL)
postParam.IconEmoji = getStringParam(params, "icon_emoji", slack.DEFAULT_MESSAGE_ICON_EMOJI)
if err = json.Unmarshal([]byte(getStringParam(params, "attachments", "[]")), &postParam.Attachments); err != nil {
return nil, err
}
ch, ts, err := s.s.PostMessage(params["channel"], params["text"], postParam)
if err != nil {
return nil, err
}
v = map[string]string{
"channel": ch,
"ts": ts,
}
case "update":
ch, ts, text, err := s.s.UpdateMessage(params["channel"], params["ts"], params["text"])
if err != nil {
return nil, err
}
v = map[string]string{
"channel": ch,
"ts": ts,
"text": text,
}
default:
return nil, fmt.Errorf("invalid chat action %s", action)
}
return v, err
}
// Message will be passed to server with '-' prefix via various way
// + Direct message with the bots
// + Use slash command `/working <message>`
// + Use cli `working-on <message>`
// + Might use Chrome plugin
// + ...
// Token is secondary param to indicate the user
func addItem(c *gin.Context) {
// Parse token and message
var item Item
text := c.PostForm("text")
text = strings.TrimSpace(text)
if text == "" {
log.Fatalln("Message is nil")
return
}
userID := c.PostForm("user_id")
userName := c.PostForm("user_name")
item.ID = bson.NewObjectId()
item.CreatedAt = time.Now()
item.Name = userName
item.UserID = userID
item.Text = text
ctx, err := db.NewContext()
if err != nil {
panic(err)
}
defer ctx.Close()
// Add Item to database
err = ctx.C("items").Insert(item)
if err != nil {
log.Fatalln(err)
}
// Repost to the target channel
channel := os.Getenv("WORKING_CHANNEL")
botToken := os.Getenv("BOT_TOKEN")
if botToken == "" {
log.Fatal("No token provided")
os.Exit(1)
}
s := slack.New(botToken)
// <@U024BE7LH|bob>
title := "*" + userName + "* is working on: " + text
params := slack.PostMessageParameters{}
params.IconURL = "http://i.imgur.com/fLcxkel.png"
params.Username = "******"
s.PostMessage(channel, title, params)
}
func sendMessage(issue Issue, channel string) error {
params := slack.PostMessageParameters{}
text := fmt.Sprintf("*%s*\n\n *Assignee* %s *Priority* %s ", issue.Fields.Summary, issue.Fields.Assignee.DisplayName, issue.Fields.Priority.Name)
attachment := slack.Attachment{
Title: issue.Key,
TitleLink: fmt.Sprintf("%s/browse/%s", jiraHostURL, issue.Key),
Text: text,
Color: getColor(issue.Fields.Status.Name),
MarkdownIn: []string{"text", "pretext"},
}
params.Attachments = []slack.Attachment{attachment}
params.IconURL = jiraIcon
params.Username = "******"
_, _, err := Slack.PostMessage(channel, "", params)
if err != nil {
fmt.Printf("%s\n", err)
return err
}
return nil
}
func notifier() {
api := slack.New(config.SlackToken)
params := slack.PostMessageParameters{}
if len(config.SlackUserName) >= 0 {
params.Username = config.SlackUserName
}
params.Markdown = true
for {
select {
case notification := <-nChan:
_, _, err := api.PostMessage(config.SlackChannel, notification.Body, params)
if err != nil {
log.Println("Error while sending Slack message:\n", notification.Body)
log.Println("Detail:\n", err)
// TODO: Add a message queue for retry sending
continue
}
log.Println("Message successfully sent")
}
}
}
func main() {
flag.Parse()
// Read config block
config := &configStruct{}
userJSON, err := ioutil.ReadFile(*configFile)
if err != nil {
panic("ReadFile json failed")
}
if err = json.Unmarshal(userJSON, &config); err != nil {
panic("Unmarshal json failed")
}
api := slack.New(config.Token)
api.SetDebug(config.Debug)
rtm := api.NewRTM()
go rtm.ManageConnection()
postParams := slack.PostMessageParameters{}
postParams.Username = "******"
postParams.Parse = "full"
postParams.IconEmoji = ":runner:"
// Get Duty users
Loop:
for {
select {
case msg := <-rtm.IncomingEvents:
switch ev := msg.Data.(type) {
case *slack.HelloEvent:
case *slack.ConnectedEvent:
fmt.Println("Infos:", ev.Info)
fmt.Println("Connection counter:", ev.ConnectionCount)
botID = ev.Info.User.ID
updateDutyGroup(api, config.DutyGroup)
case *slack.MessageEvent:
if ev.SubType == "channel_leave" || ev.SubType == "channel_join" {
updateDutyGroup(api, config.DutyGroup)
fmt.Printf("%s %s\n", ev.SubType, ev.User)
}
if strings.Contains(ev.Text, botID) {
if onDuty.Name != "" {
_, _, err := rtm.PostMessage(ev.Channel, fmt.Sprintf(config.MessageDuty, onDuty.Name), postParams)
if err != nil {
fmt.Printf("%s\n", err)
}
} else {
_, _, err := rtm.PostMessage(ev.Channel, config.MessageNoDuty, postParams)
if err != nil {
fmt.Printf("%s\n", err)
}
}
} else if strings.Contains(ev.Text, "@onduty") {
slackUser, err := rtm.GetUserInfo(ev.User)
if err != nil {
fmt.Printf("%s\n", err)
}
if stringInSlice(slackUser.ID, dutyMembers) {
onDuty = *slackUser
_, _, err = rtm.PostMessage(ev.Channel, fmt.Sprintf(config.MessageOnDuty, onDuty.Name), postParams)
if err != nil {
fmt.Printf("%s\n", err)
}
} else {
_, _, err = rtm.PostMessage(ev.Channel, fmt.Sprintf(config.MessageNotInDutyGroup, slackUser.Name), postParams)
if err != nil {
fmt.Printf("%s\n", err)
}
}
} else if strings.Contains(ev.Text, "@offduty") {
slackUser, err := rtm.GetUserInfo(ev.User)
if err != nil {
fmt.Printf("%s\n", err)
}
if onDuty.ID == ev.User {
_, _, err := rtm.PostMessage(ev.Channel, fmt.Sprintf(config.MessageOffDuty, onDuty.Name), postParams)
if err != nil {
fmt.Printf("%s\n", err)
}
onDuty = slack.User{}
} else {
_, _, err := rtm.PostMessage(ev.Channel, fmt.Sprintf(config.MessageNotDuty, slackUser.Name), postParams)
if err != nil {
fmt.Printf("%s\n", err)
}
}
}
case *slack.RTMError:
fmt.Printf("Error: %s\n", ev.Error())
case *slack.InvalidAuthEvent:
fmt.Printf("Invalid credentials")
break Loop
default:
}
}
}
}
func main() {
amqpConn, err := amqp.Dial(config.AmqpURI)
fatalError(err, "couldn't connect to mq server")
defer amqpConn.Close()
amqpChan, err := amqpConn.Channel()
fatalError(err, "couldn't create mq channel")
defer amqpChan.Close()
amqpQueue, err := amqpChan.QueueDeclare("", false, true, true, false, nil)
fatalError(err, "couldn't create mq queue")
err = amqpChan.QueueBind(amqpQueue.Name, "*.message", config.AmqpExchange, false, nil)
fatalError(err, "couldn't bind mq queue")
amqpMessages, err := amqpChan.Consume(amqpQueue.Name, "", true, true, false, false, nil)
fatalError(err, "couldn't consume mq messages")
api := slack.New(config.SlackToken)
rtm := api.NewRTM()
go rtm.ManageConnection()
for {
select {
case ev := <-rtm.IncomingEvents:
if msg, ok := ev.Data.(*slack.MessageEvent); ok {
if msg.SubType == "bot_message" || msg.Channel != config.SlackChannelID {
break
}
user, err := rtm.GetUserInfo(msg.User)
if err != nil {
break
}
bridgeMsg := BridgeMessage{
Sender: user.Name,
Content: flattenSlackMessage(rtm, msg.Text),
}
jsonData, err := json.Marshal(bridgeMsg)
fatalError(err, "couldn't serialize bridge message")
amqpMsg := amqp.Publishing{
Body: jsonData,
DeliveryMode: amqp.Persistent,
}
fmt.Printf("[<] %s: %s\n", bridgeMsg.Sender, bridgeMsg.Content)
err = amqpChan.Publish(config.AmqpExchange, "slack.message", false, false, amqpMsg)
fatalError(err, "couldn't publish mq message")
}
case ev := <-amqpMessages:
if ev.RoutingKey == "slack.message" {
break
}
bridgeMsg := map[string]interface{}{}
err = json.Unmarshal(ev.Body, &bridgeMsg)
fatalError(err, "couldn't deserialize bridge message")
slackMsg := slack.PostMessageParameters{
Username: bridgeMsg["Sender"].(string),
Text: bridgeMsg["Content"].(string),
}
if senderAvatar, ok := bridgeMsg["SenderAvatar"]; ok {
slackMsg.IconURL = senderAvatar.(string)
}
for _, interop := range config.BridgeInterop {
isInteropMessage := true
for key, value := range interop.MessageMatch {
if !reflect.DeepEqual(bridgeMsg[key], value) {
isInteropMessage = false
break
}
}
if isInteropMessage {
regex := regexp.MustCompile(interop.MessageRegex)
match := regex.FindAllStringSubmatch(slackMsg.Text, -1)
if len(match) == 1 && len(match[0]) == 3 {
slackMsg.Username = match[0][1]
slackMsg.Text = match[0][2]
slackMsg.IconURL = interop.AvatarURLs[slackMsg.Username]
}
}
}
fmt.Printf("[>] %s: %s\n", slackMsg.Username, slackMsg.Text)
_, _, err = rtm.PostMessage(config.SlackChannelID, slackMsg.Text, slackMsg)
fatalError(err, "couldn't post slack message")
}
}
}
// Post summary to Slack channel
func postDigest() {
channel := os.Getenv("DIGEST_CHANNEL")
botToken := os.Getenv("BOT_TOKEN")
if botToken == "" {
log.Fatal("No token provided")
os.Exit(1)
}
s := slack.New(botToken)
users, err := s.GetUsers()
if err != nil {
log.Fatal("Cannot get users")
os.Exit(1)
}
ctx, err := db.NewContext()
if err != nil {
panic(err)
}
defer ctx.Close()
log.Info("Preparing data")
// If count > 0, it means there is data to show
count := 0
title := " >> Yesterday I did: "
params := slack.PostMessageParameters{}
fields := []slack.AttachmentField{}
yesterday := arrow.Yesterday().UTC()
toDate := time.Date(yesterday.Year(), yesterday.Month(), yesterday.Day(), 0, 0, 0, 0, time.UTC)
// Prepare attachment of done items
for _, user := range users {
if user.IsBot || user.Deleted {
continue
}
// log.Info("Process user: "******" - " + user.Id)
// Query done items from Database
var values string
var items []Item
err = ctx.C("items").Find(bson.M{"$and": []bson.M{
bson.M{"user_id": user.Id},
bson.M{"created_at": bson.M{"$gt": toDate}},
},
}).All(&items)
if err != nil {
log.Fatal("Cannot query done items.")
os.Exit(1)
}
for _, item := range items {
values = values + " + " + item.Text + "\n\t"
}
// <@U024BE7LH|bob>
if len(items) > 0 {
count = count + 1
field := slack.AttachmentField{
Title: "@" + user.Name,
Value: values,
}
fields = append(fields, field)
}
}
params.Attachments = []slack.Attachment{
slack.Attachment{
Color: "#7CD197",
Fields: fields,
},
}
params.IconURL = "http://i.imgur.com/fLcxkel.png"
params.Username = "******"
if count > 0 {
s.PostMessage(channel, title, params)
}
}
func (s *Client) sendMessage(issue *redmine.Issue, channel string) (err error) {
params := slackapi.PostMessageParameters{}
params.IconURL = botLogo
params.Username = "******"
fields := make([]slackapi.AttachmentField, 6)
var idx int = 3
fields[0] = slackapi.AttachmentField{
Title: "Project",
Value: issue.Project.Name,
Short: true,
}
fields[1] = slackapi.AttachmentField{
Title: "Status",
Value: issue.Status.Name,
Short: true,
}
fields[2] = slackapi.AttachmentField{
Title: "Author",
Value: issue.Author.Name,
Short: true,
}
if issue.AssignedTo != nil {
fields[idx] = slackapi.AttachmentField{
Title: "Assigned To",
Value: issue.AssignedTo.Name,
Short: true,
}
idx += 1
}
if issue.Category != nil {
fields[idx] = slackapi.AttachmentField{
Title: "Category",
Value: issue.Category.Name,
Short: true,
}
idx += 1
}
if issue.Version != nil {
fields[idx] = slackapi.AttachmentField{
Title: "Version",
Value: issue.Version.Name,
Short: true,
}
}
var title string
if issue.Tracker != nil {
title = fmt.Sprintf("%s #%d: %s", issue.Tracker.Name, issue.Id, issue.Subject)
} else {
title = fmt.Sprintf("#%d: %s", issue.Id, issue.Subject)
}
attachment := slackapi.Attachment{
Title: title,
TitleLink: s.redmine.GetIssueUrl(issue),
Fields: fields,
}
if s.redmine.IssueIsClosed(issue) {
attachment.Color = "good"
} else if s.redmine.IssueInHighPriority(issue) {
attachment.Color = "danger"
}
params.Attachments = []slackapi.Attachment{attachment}
_, _, err = s.slack.PostMessage(channel, "", params)
return err
}