func init() {
chat.Register("campfire", func(r chat.Robot) chat.Adapter {
roomsList := os.Getenv("VICTOR_CAMPFIRE_ROOMS")
account := os.Getenv("VICTOR_CAMPFIRE_ACCOUNT")
token := os.Getenv("VICTOR_CAMPFIRE_TOKEN")
if roomsList == "" || account == "" || token == "" {
log.Println("The following environment variables are required:")
log.Println("VICTOR_CAMPFIRE_ACCOUNT, VICTOR_CAMPFIRE_TOKEN, VICTOR_CAMPFIRE_ROOMS")
os.Exit(1)
}
roomIDStrings := strings.Split(roomsList, ",")
roomIDs := []int{}
for _, id := range roomIDStrings {
j, err := strconv.Atoi(id)
if err != nil {
fmt.Printf("Room is not numeric: %s\n", id)
}
roomIDs = append(roomIDs, j)
}
return &adapter{
robot: r,
client: campfire.NewClient(account, token),
roomIDs: roomIDs,
stop: make(chan struct{}),
}
})
}
func init() {
chat.Register("slack", func(r chat.Robot) chat.Adapter {
team := os.Getenv("VICTOR_SLACK_TEAM")
token := os.Getenv("VICTOR_SLACK_TOKEN")
if team == "" || token == "" {
log.Println("The following environment variables are required:")
log.Println("VICTOR_SLACK_TEAM, VICTOR_CAMPFIRE_TOKEN")
os.Exit(1)
}
return &slack{
robot: r,
team: team,
token: token,
}
})
}
func init() {
chat.Register("slack", func(r chat.Robot) chat.Adapter {
slackOutgoingWebhookPath := os.Getenv("SLACK_OUTGOING_WEBHOOK")
slackIncomingWebhookUri := os.Getenv("SLACK_INCOMING_WEBHOOK_URI")
emoji := os.Getenv("SLACK_EMOJI")
if slackOutgoingWebhookPath == "" || slackIncomingWebhookUri == "" {
log.Println("The following environment variable is required:")
log.Println("SLACK_INCOMING_WEBHOOK_URI, SLACK_OUTGOING_WEBHOOK")
os.Exit(1)
}
return &slack{
robot: r,
outgoingWebhookPath: slackOutgoingWebhookPath,
incomingWebhookUri: slackIncomingWebhookUri,
emoji: emoji,
}
})
}
// init registers SlackAdapter to the victor chat framework.
func init() {
chat.Register(AdapterName, func(r chat.Robot) chat.Adapter {
config, configSet := r.AdapterConfig()
if !configSet {
log.Println("A configuration struct implementing the SlackConfig interface must be set.")
os.Exit(1)
}
sConfig, ok := config.(Config)
if !ok {
log.Println("The bot's config must implement the SlackConfig interface.")
os.Exit(1)
}
return &SlackAdapter{
robot: r,
chSender: make(chan *slack.OutgoingMessage),
chReceiver: make(chan slack.SlackEvent),
token: sConfig.Token(),
}
})
}
func init() {
chat.Register("hipchat", func(r chat.Robot) chat.Adapter {
rooms := os.Getenv("VICTOR_HIPCHAT_ROOMS")
token := os.Getenv("VICTOR_HIPCHAT_TOKEN")
webhookUrl := os.Getenv("VICTOR_HIPCHAT_WEBHOOK")
if rooms == "" || token == "" {
log.Println("The following environment variables are required:")
log.Println("VICTOR_HIPCHAT_ROOMS, VICTOR_HIPCHAT_TOKEN, VICTOR_HIPCHAT_WEBHOOK")
os.Exit(1)
}
// A HipChat API v2 Client
client := hipchat.NewClient(token)
hook, _ := url.Parse(webhookUrl)
hookName := "victor webhook"
hookEvent := "room_message"
hookUrl := fmt.Sprintf("%s://%s%s", hook.Scheme, hook.Host, hook.Path)
// Initialize HipChat Webhooks - your bot must have admin access to perform
// this action. Failure to create webhooks won't stop the bot from
// launching, but you'll have to create them by some other means.
var exists bool
for _, roomId := range strings.Split(rooms, ",") {
hooks, resp, err := client.Room.GetAllWebhooks(roomId, nil)
handleRequestError(resp, err)
if err != nil {
continue
}
exists = false
for _, webhook := range hooks.Webhooks {
if webhook.Event == hookEvent && webhook.URL == hookUrl {
exists = true
break
}
}
if !exists {
_, resp, err := client.Room.CreateWebhook(roomId, &hipchat.CreateWebhookRequest{
Name: hookName,
Event: hookEvent,
URL: hookUrl,
})
handleRequestError(resp, err)
if err != nil {
log.Println("[hipchat adapter init] failed to create webhook")
}
}
}
return &adapter{
robot: r,
client: client,
hook: hook,
}
})
}
func init() {
chat.Register("shell", func(r chat.Robot) chat.Adapter {
return &Adapter{r, make(chan bool)}
})
}
