diff --git a/bridge/slack/handlers.go b/bridge/slack/handlers.go
index 1ef2d614..56fd7026 100644
--- a/bridge/slack/handlers.go
+++ b/bridge/slack/handlers.go
@@ -14,7 +14,7 @@ import (
 
 func (b *Bslack) handleSlack() {
 	messages := make(chan *config.Message)
-	if b.GetString("WebhookBindAddress") != "" {
+	if b.GetString(incomingWebhookConfig) != "" {
 		b.Log.Debugf("Choosing webhooks based receiving")
 		go b.handleMatterHook(messages)
 	} else {
@@ -43,7 +43,7 @@ func (b *Bslack) handleSlack() {
 
 func (b *Bslack) handleSlackClient(messages chan *config.Message) {
 	for msg := range b.rtm.IncomingEvents {
-		if msg.Type != "user_typing" && msg.Type != "latency_report" {
+		if msg.Type != sUserTyping && msg.Type != sLatencyReport {
 			b.Log.Debugf("== Receiving event %#v", msg.Data)
 		}
 		switch ev := msg.Data.(type) {
@@ -61,17 +61,25 @@ func (b *Bslack) handleSlackClient(messages chan *config.Message) {
 		case *slack.OutgoingErrorEvent:
 			b.Log.Debugf("%#v", ev.Error())
 		case *slack.ChannelJoinedEvent:
-			b.Users, _ = b.sc.GetUsers()
-			b.Usergroups, _ = b.sc.GetUserGroups()
+			var err error
+			b.users, err = b.sc.GetUsers()
+			if err != nil {
+				b.Log.Errorf("Could not reload users: %#v", err)
+			}
 		case *slack.ConnectedEvent:
 			var err error
-			b.channels, _, err = b.sc.GetConversations(&slack.GetConversationsParameters{Limit: 1000, Types: []string{"public_channel,private_channel,mpim,im"}})
+			b.channels, _, err = b.sc.GetConversations(&slack.GetConversationsParameters{
+				Limit: 1000,
+				Types: []string{"public_channel,private_channel,mpim,im"},
+			})
 			if err != nil {
 				b.Log.Errorf("Channel list failed: %#v", err)
 			}
 			b.si = ev.Info
-			b.Users, _ = b.sc.GetUsers()
-			b.Usergroups, _ = b.sc.GetUserGroups()
+			b.users, err = b.sc.GetUsers()
+			if err != nil {
+				b.Log.Errorf("Could not reload users: %#v", err)
+			}
 		case *slack.InvalidAuthEvent:
 			b.Log.Fatalf("Invalid Token %#v", ev)
 		case *slack.ConnectionErrorEvent:
@@ -88,16 +96,22 @@ func (b *Bslack) handleMatterHook(messages chan *config.Message) {
 		if message.UserName == "slackbot" {
 			continue
 		}
-		messages <- &config.Message{Username: message.UserName, Text: message.Text, Channel: message.ChannelName}
+		messages <- &config.Message{
+			Username: message.UserName,
+			Text:     message.Text,
+			Channel:  message.ChannelName,
+		}
 	}
 }
 
+var commentRE = regexp.MustCompile(`.*?commented: (.*)`)
+
 // handleDownloadFile handles file download
 func (b *Bslack) handleDownloadFile(rmsg *config.Message, file *slack.File) error {
 	// if we have a file attached, download it (in memory) and put a pointer to it in msg.Extra
 	// limit to 1MB for now
 	comment := ""
-	results := regexp.MustCompile(`.*?commented: (.*)`).FindAllStringSubmatch(rmsg.Text, -1)
+	results := commentRE.FindAllStringSubmatch(rmsg.Text, -1)
 	if len(results) > 0 {
 		comment = results[0][1]
 	}
@@ -106,7 +120,7 @@ func (b *Bslack) handleDownloadFile(rmsg *config.Message, file *slack.File) erro
 		return err
 	}
 	// actually download the file
-	data, err := helper.DownloadFileAuth(file.URLPrivateDownload, "Bearer "+b.GetString("Token"))
+	data, err := helper.DownloadFileAuth(file.URLPrivateDownload, "Bearer "+b.GetString(tokenConfig))
 	if err != nil {
 		return fmt.Errorf("download %s failed %#v", file.URLPrivateDownload, err)
 	}
@@ -116,7 +130,7 @@ func (b *Bslack) handleDownloadFile(rmsg *config.Message, file *slack.File) erro
 }
 
 // handleUploadFile handles native upload of files
-func (b *Bslack) handleUploadFile(msg *config.Message, channelID string) (string, error) {
+func (b *Bslack) handleUploadFile(msg *config.Message, channelID string) {
 	for _, f := range msg.Extra["file"] {
 		fi := f.(config.FileInfo)
 		if msg.Text == fi.Comment {
@@ -141,37 +155,46 @@ func (b *Bslack) handleUploadFile(msg *config.Message, channelID string) (string
 			b.Log.Errorf("uploadfile %#v", err)
 		}
 	}
-	return "", nil
 }
 
 // handleMessageEvent handles the message events
 func (b *Bslack) handleMessageEvent(ev *slack.MessageEvent) (*config.Message, error) {
+	var err error
+
 	// update the userlist on a channel_join
-	if ev.SubType == "channel_join" {
-		b.Users, _ = b.sc.GetUsers()
+	if ev.SubType == sChannelJoin {
+		if b.users, err = b.sc.GetUsers(); err != nil {
+			return nil, err
+		}
 	}
 
 	// Edit message
-	if !b.GetBool("EditDisable") && ev.SubMessage != nil && ev.SubMessage.ThreadTimestamp != ev.SubMessage.Timestamp {
+	if !b.GetBool(editDisableConfig) && ev.SubMessage != nil && ev.SubMessage.ThreadTimestamp != ev.SubMessage.Timestamp {
 		b.Log.Debugf("SubMessage %#v", ev.SubMessage)
 		ev.User = ev.SubMessage.User
-		ev.Text = ev.SubMessage.Text + b.GetString("EditSuffix")
+		ev.Text = ev.SubMessage.Text + b.GetString(editSuffixConfig)
 	}
 
 	// use our own func because rtm.GetChannelInfo doesn't work for private channels
-	channel, err := b.getChannelByID(ev.Channel)
+	channelInfo, err := b.getChannelByID(ev.Channel)
 	if err != nil {
 		return nil, err
 	}
 
-	rmsg := config.Message{Text: ev.Text, Channel: channel.Name, Account: b.Account, ID: "slack " + ev.Timestamp, Extra: make(map[string][]interface{})}
+	rmsg := config.Message{
+		Text:    ev.Text,
+		Channel: channelInfo.Name,
+		Account: b.Account,
+		ID:      "slack " + ev.Timestamp,
+		Extra:   map[string][]interface{}{},
+	}
 
-	if b.UseChannelID {
-		rmsg.Channel = "ID:" + channel.ID
+	if b.useChannelID {
+		rmsg.Channel = "ID:" + channelInfo.ID
 	}
 
 	// find the user id and name
-	if ev.User != "" && ev.SubType != messageDeleted && ev.SubType != "file_comment" {
+	if ev.User != "" && ev.SubType != sMessageDeleted && ev.SubType != sFileComment {
 		user, err := b.rtm.GetUserInfo(ev.User)
 		if err != nil {
 			return nil, err
@@ -198,7 +221,7 @@ func (b *Bslack) handleMessageEvent(ev *slack.MessageEvent) (*config.Message, er
 	}
 
 	// when using webhookURL we can't check if it's our webhook or not for now
-	if rmsg.Username == "" && ev.BotID != "" && b.GetString("WebhookURL") == "" {
+	if rmsg.Username == "" && ev.BotID != "" && b.GetString(outgoingWebhookConfig) == "" {
 		bot, err := b.rtm.GetBotInfo(ev.BotID)
 		if err != nil {
 			return nil, err
@@ -226,18 +249,18 @@ func (b *Bslack) handleMessageEvent(ev *slack.MessageEvent) (*config.Message, er
 	}
 
 	// file comments are set by the system (because there is no username given)
-	if ev.SubType == "file_comment" {
-		rmsg.Username = "system"
+	if ev.SubType == sFileComment {
+		rmsg.Username = sSystemUser
 	}
 
 	// do we have a /me action
-	if ev.SubType == "me_message" {
+	if ev.SubType == sMeMessage {
 		rmsg.Event = config.EVENT_USER_ACTION
 	}
 
 	// Handle join/leave
-	if ev.SubType == "channel_leave" || ev.SubType == "channel_join" {
-		rmsg.Username = "system"
+	if ev.SubType == sChannelLeave || ev.SubType == sChannelJoin {
+		rmsg.Username = sSystemUser
 		rmsg.Event = config.EVENT_JOIN_LEAVE
 	}
 
@@ -247,19 +270,19 @@ func (b *Bslack) handleMessageEvent(ev *slack.MessageEvent) (*config.Message, er
 	}
 
 	// deleted message event
-	if ev.SubType == messageDeleted {
+	if ev.SubType == sMessageDeleted {
 		rmsg.Text = config.EVENT_MSG_DELETE
 		rmsg.Event = config.EVENT_MSG_DELETE
 		rmsg.ID = "slack " + ev.DeletedTimestamp
 	}
 
 	// topic change event
-	if ev.SubType == "channel_topic" || ev.SubType == "channel_purpose" {
+	if ev.SubType == sChannelTopic || ev.SubType == sChannelPurpose {
 		rmsg.Event = config.EVENT_TOPIC_CHANGE
 	}
 
 	// Only deleted messages can have a empty username and text
-	if (rmsg.Text == "" || rmsg.Username == "") && ev.SubType != messageDeleted && len(ev.Files) == 0 {
+	if (rmsg.Text == "" || rmsg.Username == "") && ev.SubType != sMessageDeleted && len(ev.Files) == 0 {
 		// this is probably a webhook we couldn't resolve
 		if ev.BotID != "" {
 			return nil, fmt.Errorf("probably an incoming webhook we couldn't resolve (maybe ourselves)")
@@ -269,16 +292,14 @@ func (b *Bslack) handleMessageEvent(ev *slack.MessageEvent) (*config.Message, er
 
 	// save the attachments, so that we can send them to other slack (compatible) bridges
 	if len(ev.Attachments) > 0 {
-		rmsg.Extra["slack_attachment"] = append(rmsg.Extra["slack_attachment"], ev.Attachments)
+		rmsg.Extra[sSlackAttachment] = append(rmsg.Extra[sSlackAttachment], ev.Attachments)
 	}
 
 	// if we have a file attached, download it (in memory) and put a pointer to it in msg.Extra
-	if len(ev.Files) > 0 {
-		for _, f := range ev.Files {
-			err := b.handleDownloadFile(&rmsg, &f)
-			if err != nil {
-				b.Log.Errorf("download failed: %s", err)
-			}
+	for _, f := range ev.Files {
+		err := b.handleDownloadFile(&rmsg, &f)
+		if err != nil {
+			b.Log.Errorf("download failed: %s", err)
 		}
 	}
 
@@ -287,17 +308,17 @@ func (b *Bslack) handleMessageEvent(ev *slack.MessageEvent) (*config.Message, er
 
 // skipMessageEvent skips event that need to be skipped :-)
 func (b *Bslack) skipMessageEvent(ev *slack.MessageEvent) bool {
-	if ev.SubType == "channel_leave" || ev.SubType == "channel_join" {
-		return b.GetBool("nosendjoinpart")
+	if ev.SubType == sChannelLeave || ev.SubType == sChannelJoin {
+		return b.GetBool(noSendJoinConfig)
 	}
 
 	// ignore pinned items
-	if ev.SubType == "pinned_item" || ev.SubType == "unpinned_item" {
+	if ev.SubType == sPinnedItem || ev.SubType == sUnpinnedItem {
 		return true
 	}
 
 	// do not send messages from ourself
-	if b.GetString("WebhookURL") == "" && b.GetString("WebhookBindAddress") == "" && ev.Username == b.si.User.Name {
+	if b.GetString(outgoingWebhookConfig) == "" && b.GetString(incomingWebhookConfig) == "" && ev.Username == b.si.User.Name {
 		return true
 	}
 
@@ -308,7 +329,7 @@ func (b *Bslack) skipMessageEvent(ev *slack.MessageEvent) bool {
 		}
 	}
 
-	if !b.GetBool("EditDisable") && ev.SubMessage != nil && ev.SubMessage.ThreadTimestamp != ev.SubMessage.Timestamp {
+	if !b.GetBool(editDisableConfig) && ev.SubMessage != nil && ev.SubMessage.ThreadTimestamp != ev.SubMessage.Timestamp {
 		// it seems ev.SubMessage.Edited == nil when slack unfurls
 		// do not forward these messages #266
 		if ev.SubMessage.Edited == nil {
@@ -316,21 +337,16 @@ func (b *Bslack) skipMessageEvent(ev *slack.MessageEvent) bool {
 		}
 	}
 
-	if len(ev.Files) > 0 {
-		for _, f := range ev.Files {
-			// if the file is in the cache and isn't older then a minute, skip it
-			if ts, ok := b.cache.Get("file" + f.ID); ok && time.Since(ts.(time.Time)) < time.Minute {
-				b.Log.Debugf("Not downloading file id %s which we uploaded", f.ID)
-				return true
-			} else {
-				if ts, ok := b.cache.Get("filename" + f.Name); ok && time.Since(ts.(time.Time)) < time.Second*10 {
-					b.Log.Debugf("Not downloading file name %s which we uploaded", f.Name)
-					return true
-				} else {
-					b.Log.Debugf("Not skipping %s %s", f.Name, time.Now().String())
-				}
-			}
+	for _, f := range ev.Files {
+		// if the file is in the cache and isn't older then a minute, skip it
+		if ts, ok := b.cache.Get("file" + f.ID); ok && time.Since(ts.(time.Time)) < time.Minute {
+			b.Log.Debugf("Not downloading file id %s which we uploaded", f.ID)
+			return true
+		} else if ts, ok := b.cache.Get("filename" + f.Name); ok && time.Since(ts.(time.Time)) < 10*time.Second {
+			b.Log.Debugf("Not downloading file name %s which we uploaded", f.Name)
+			return true
 		}
+		b.Log.Debugf("Not skipping %s %s", f.Name, time.Now().String())
 	}
 
 	return false
diff --git a/bridge/slack/helpers.go b/bridge/slack/helpers.go
index 273cf7c6..9af5dfac 100644
--- a/bridge/slack/helpers.go
+++ b/bridge/slack/helpers.go
@@ -8,8 +8,8 @@ import (
 	"github.com/nlopes/slack"
 )
 
-func (b *Bslack) userName(id string) string {
-	for _, u := range b.Users {
+func (b *Bslack) getUsername(id string) string {
+	for _, u := range b.users {
 		if u.ID == id {
 			if u.Profile.DisplayName != "" {
 				return u.Profile.DisplayName
@@ -17,22 +17,26 @@ func (b *Bslack) userName(id string) string {
 			return u.Name
 		}
 	}
+	b.Log.Warnf("Could not find user with ID '%s'", id)
 	return ""
 }
 
 func (b *Bslack) getAvatar(userid string) string {
-	var avatar string
-	if b.Users != nil {
-		for _, u := range b.Users {
-			if userid == u.ID {
-				return u.Profile.Image48
-			}
+	for _, u := range b.users {
+		if userid == u.ID {
+			return u.Profile.Image48
 		}
 	}
-	return avatar
+	return ""
+}
+
+func (b *Bslack) getChannel(channel string) (*slack.Channel, error) {
+	if strings.HasPrefix(channel, "ID:") {
+		return b.getChannelByID(strings.TrimPrefix(channel, "ID:"))
+	}
+	return b.getChannelByName(channel)
 }
 
-/*
 func (b *Bslack) getChannelByName(name string) (*slack.Channel, error) {
 	if b.channels == nil {
 		return nil, fmt.Errorf("%s: channel %s not found (no channels found)", b.Account, name)
@@ -44,7 +48,6 @@ func (b *Bslack) getChannelByName(name string) (*slack.Channel, error) {
 	}
 	return nil, fmt.Errorf("%s: channel %s not found", b.Account, name)
 }
-*/
 
 func (b *Bslack) getChannelByID(ID string) (*slack.Channel, error) {
 	if b.channels == nil {
@@ -58,45 +61,40 @@ func (b *Bslack) getChannelByID(ID string) (*slack.Channel, error) {
 	return nil, fmt.Errorf("%s: channel %s not found", b.Account, ID)
 }
 
-func (b *Bslack) getChannelID(name string) string {
-	idcheck := strings.Split(name, "ID:")
-	if len(idcheck) > 1 {
-		return idcheck[1]
-	}
-	for _, channel := range b.channels {
-		if channel.Name == name {
-			return channel.ID
-		}
-	}
-	return ""
-}
+var (
+	mentionRE  = regexp.MustCompile(`<@([a-zA-Z0-9]+)>`)
+	channelRE  = regexp.MustCompile(`<#[a-zA-Z0-9]+\|(.+?)>`)
+	variableRE = regexp.MustCompile(`<!((?:subteam\^)?[a-zA-Z0-9]+)(?:\|@?(.+?))?>`)
+	urlRE      = regexp.MustCompile(`<(.*?)(\|.*?)?>`)
+)
 
 // @see https://api.slack.com/docs/message-formatting#linking_to_channels_and_users
 func (b *Bslack) replaceMention(text string) string {
-	results := regexp.MustCompile(`<@([a-zA-Z0-9]+)>`).FindAllStringSubmatch(text, -1)
-	for _, r := range results {
-		text = strings.Replace(text, "<@"+r[1]+">", "@"+b.userName(r[1]), -1)
+	replaceFunc := func(match string) string {
+		userID := strings.Trim(match, "@<>")
+		if username := b.getUsername(userID); userID != "" {
+			return "@" + username
+		}
+		return match
 	}
-	return text
+	return mentionRE.ReplaceAllStringFunc(text, replaceFunc)
 }
 
 // @see https://api.slack.com/docs/message-formatting#linking_to_channels_and_users
 func (b *Bslack) replaceChannel(text string) string {
-	results := regexp.MustCompile(`<#[a-zA-Z0-9]+\|(.+?)>`).FindAllStringSubmatch(text, -1)
-	for _, r := range results {
-		text = strings.Replace(text, r[0], "#"+r[1], -1)
+	for _, r := range channelRE.FindAllStringSubmatch(text, -1) {
+		text = strings.Replace(text, r[0], "#"+r[1], 1)
 	}
 	return text
 }
 
 // @see https://api.slack.com/docs/message-formatting#variables
 func (b *Bslack) replaceVariable(text string) string {
-	results := regexp.MustCompile(`<!((?:subteam\^)?[a-zA-Z0-9]+)(?:\|@?(.+?))?>`).FindAllStringSubmatch(text, -1)
-	for _, r := range results {
+	for _, r := range variableRE.FindAllStringSubmatch(text, -1) {
 		if r[2] != "" {
-			text = strings.Replace(text, r[0], "@"+r[2], -1)
+			text = strings.Replace(text, r[0], "@"+r[2], 1)
 		} else {
-			text = strings.Replace(text, r[0], "@"+r[1], -1)
+			text = strings.Replace(text, r[0], "@"+r[1], 1)
 		}
 	}
 	return text
@@ -104,12 +102,11 @@ func (b *Bslack) replaceVariable(text string) string {
 
 // @see https://api.slack.com/docs/message-formatting#linking_to_urls
 func (b *Bslack) replaceURL(text string) string {
-	results := regexp.MustCompile(`<(.*?)(\|.*?)?>`).FindAllStringSubmatch(text, -1)
-	for _, r := range results {
+	for _, r := range urlRE.FindAllStringSubmatch(text, -1) {
 		if len(strings.TrimSpace(r[2])) == 1 { // A display text separator was found, but the text was blank
-			text = strings.Replace(text, r[0], "", -1)
+			text = strings.Replace(text, r[0], "", 1)
 		} else {
-			text = strings.Replace(text, r[0], r[1], -1)
+			text = strings.Replace(text, r[0], r[1], 1)
 		}
 	}
 	return text
diff --git a/bridge/slack/slack.go b/bridge/slack/slack.go
index 6aa89375..6524f974 100644
--- a/bridge/slack/slack.go
+++ b/bridge/slack/slack.go
@@ -2,6 +2,7 @@ package bslack
 
 import (
 	"errors"
+	"fmt"
 	"strings"
 	"sync"
 
@@ -18,22 +19,52 @@ type Bslack struct {
 	mh           *matterhook.Client
 	sc           *slack.Client
 	rtm          *slack.RTM
-	Users        []slack.User
-	Usergroups   []slack.UserGroup
+	users        []slack.User
 	si           *slack.Info
 	channels     []slack.Channel
 	cache        *lru.Cache
-	UseChannelID bool
+	useChannelID bool
 	uuid         string
 	*bridge.Config
 	sync.RWMutex
 }
 
-const messageDeleted = "message_deleted"
+const (
+	sChannelJoin     = "channel_join"
+	sChannelLeave    = "channel_leave"
+	sMessageDeleted  = "message_deleted"
+	sSlackAttachment = "slack_attachment"
+	sPinnedItem      = "pinned_item"
+	sUnpinnedItem    = "unpinned_item"
+	sChannelTopic    = "channel_topic"
+	sChannelPurpose  = "channel_purpose"
+	sFileComment     = "file_comment"
+	sMeMessage       = "me_message"
+	sUserTyping      = "user_typing"
+	sLatencyReport   = "latency_report"
+	sSystemUser      = "system"
+
+	tokenConfig           = "Token"
+	incomingWebhookConfig = "WebhookBindAddress"
+	outgoingWebhookConfig = "WebhookURL"
+	skipTLSConfig         = "SkipTLSVerify"
+	useNickPrefixConfig   = "PrefixMessagesWithNick"
+	editDisableConfig     = "EditDisable"
+	editSuffixConfig      = "EditSuffix"
+	iconURLConfig         = "iconurl"
+	noSendJoinConfig      = "nosendjoinpart"
+)
 
 func New(cfg *bridge.Config) bridge.Bridger {
-	b := &Bslack{Config: cfg, uuid: xid.New().String()}
-	b.cache, _ = lru.New(5000)
+	newCache, err := lru.New(5000)
+	if err != nil {
+		cfg.Log.Fatalf("Could not create LRU cache for Slack bridge: %v", err)
+	}
+	b := &Bslack{
+		Config: cfg,
+		uuid:   xid.New().String(),
+		cache:  newCache,
+	}
 	return b
 }
 
@@ -44,50 +75,54 @@ func (b *Bslack) Command(cmd string) string {
 func (b *Bslack) Connect() error {
 	b.RLock()
 	defer b.RUnlock()
-	if b.GetString("WebhookBindAddress") != "" {
-		if b.GetString("WebhookURL") != "" {
+	if b.GetString(incomingWebhookConfig) != "" {
+		if b.GetString(outgoingWebhookConfig) != "" {
 			b.Log.Info("Connecting using webhookurl (sending) and webhookbindaddress (receiving)")
-			b.mh = matterhook.New(b.GetString("WebhookURL"),
-				matterhook.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
-					BindAddress: b.GetString("WebhookBindAddress")})
-		} else if b.GetString("Token") != "" {
+			b.mh = matterhook.New(b.GetString(outgoingWebhookConfig), matterhook.Config{
+				InsecureSkipVerify: b.GetBool(skipTLSConfig),
+				BindAddress:        b.GetString(incomingWebhookConfig),
+			})
+		} else if b.GetString(tokenConfig) != "" {
 			b.Log.Info("Connecting using token (sending)")
-			b.sc = slack.New(b.GetString("Token"))
+			b.sc = slack.New(b.GetString(tokenConfig))
 			b.rtm = b.sc.NewRTM()
 			go b.rtm.ManageConnection()
 			b.Log.Info("Connecting using webhookbindaddress (receiving)")
-			b.mh = matterhook.New(b.GetString("WebhookURL"),
-				matterhook.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
-					BindAddress: b.GetString("WebhookBindAddress")})
+			b.mh = matterhook.New(b.GetString(outgoingWebhookConfig), matterhook.Config{
+				InsecureSkipVerify: b.GetBool(skipTLSConfig),
+				BindAddress:        b.GetString(incomingWebhookConfig),
+			})
 		} else {
 			b.Log.Info("Connecting using webhookbindaddress (receiving)")
-			b.mh = matterhook.New(b.GetString("WebhookURL"),
-				matterhook.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
-					BindAddress: b.GetString("WebhookBindAddress")})
+			b.mh = matterhook.New(b.GetString(outgoingWebhookConfig), matterhook.Config{
+				InsecureSkipVerify: b.GetBool(skipTLSConfig),
+				BindAddress:        b.GetString(incomingWebhookConfig),
+			})
 		}
 		go b.handleSlack()
 		return nil
 	}
-	if b.GetString("WebhookURL") != "" {
+	if b.GetString(outgoingWebhookConfig) != "" {
 		b.Log.Info("Connecting using webhookurl (sending)")
-		b.mh = matterhook.New(b.GetString("WebhookURL"),
-			matterhook.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
-				DisableServer: true})
-		if b.GetString("Token") != "" {
+		b.mh = matterhook.New(b.GetString(outgoingWebhookConfig), matterhook.Config{
+			InsecureSkipVerify: b.GetBool(skipTLSConfig),
+			DisableServer:      true,
+		})
+		if b.GetString(tokenConfig) != "" {
 			b.Log.Info("Connecting using token (receiving)")
-			b.sc = slack.New(b.GetString("Token"))
+			b.sc = slack.New(b.GetString(tokenConfig))
 			b.rtm = b.sc.NewRTM()
 			go b.rtm.ManageConnection()
 			go b.handleSlack()
 		}
-	} else if b.GetString("Token") != "" {
+	} else if b.GetString(tokenConfig) != "" {
 		b.Log.Info("Connecting using token (sending and receiving)")
-		b.sc = slack.New(b.GetString("Token"))
+		b.sc = slack.New(b.GetString(tokenConfig))
 		b.rtm = b.sc.NewRTM()
 		go b.rtm.ManageConnection()
 		go b.handleSlack()
 	}
-	if b.GetString("WebhookBindAddress") == "" && b.GetString("WebhookURL") == "" && b.GetString("Token") == "" {
+	if b.GetString(incomingWebhookConfig) == "" && b.GetString(outgoingWebhookConfig) == "" && b.GetString(tokenConfig) == "" {
 		return errors.New("no connection method found. See that you have WebhookBindAddress, WebhookURL or Token configured")
 	}
 	return nil
@@ -101,7 +136,7 @@ func (b *Bslack) JoinChannel(channel config.ChannelInfo) error {
 	// use ID:channelid and resolve it to the actual name
 	idcheck := strings.Split(channel.Name, "ID:")
 	if len(idcheck) > 1 {
-		b.UseChannelID = true
+		b.useChannelID = true
 		ch, err := b.sc.GetChannelInfo(idcheck[1])
 		if err != nil {
 			return err
@@ -114,7 +149,7 @@ func (b *Bslack) JoinChannel(channel config.ChannelInfo) error {
 
 	// we can only join channels using the API
 	if b.sc != nil {
-		if strings.HasPrefix(b.GetString("Token"), "xoxb") {
+		if strings.HasPrefix(b.GetString(tokenConfig), "xoxb") {
 			// TODO check if bot has already joined channel
 			return nil
 		}
@@ -141,11 +176,14 @@ func (b *Bslack) Send(msg config.Message) (string, error) {
 	}
 
 	// Use webhook to send the message
-	if b.GetString("WebhookURL") != "" {
+	if b.GetString(outgoingWebhookConfig) != "" {
 		return b.sendWebhook(msg)
 	}
 
-	channelID := b.getChannelID(msg.Channel)
+	channelInfo, err := b.getChannel(msg.Channel)
+	if err != nil {
+		return "", fmt.Errorf("could not send message: %v", err)
+	}
 
 	// Delete message
 	if msg.Event == config.EVENT_MSG_DELETE {
@@ -155,7 +193,7 @@ func (b *Bslack) Send(msg config.Message) (string, error) {
 		}
 		// we get a "slack <ID>", split it
 		ts := strings.Fields(msg.ID)
-		_, _, err := b.sc.DeleteMessage(channelID, ts[1])
+		_, _, err = b.sc.DeleteMessage(channelInfo.ID, ts[1])
 		if err != nil {
 			return msg.ID, err
 		}
@@ -163,14 +201,14 @@ func (b *Bslack) Send(msg config.Message) (string, error) {
 	}
 
 	// Prepend nick if configured
-	if b.GetBool("PrefixMessagesWithNick") {
+	if b.GetBool(useNickPrefixConfig) {
 		msg.Text = msg.Username + msg.Text
 	}
 
 	// Edit message if we have an ID
 	if msg.ID != "" {
 		ts := strings.Fields(msg.ID)
-		_, _, _, err := b.sc.UpdateMessage(channelID, ts[1], msg.Text)
+		_, _, _, err = b.sc.UpdateMessage(channelInfo.ID, ts[1], msg.Text)
 		if err != nil {
 			return msg.ID, err
 		}
@@ -179,12 +217,12 @@ func (b *Bslack) Send(msg config.Message) (string, error) {
 
 	// create slack new post parameters
 	np := slack.NewPostMessageParameters()
-	if b.GetBool("PrefixMessagesWithNick") {
+	if b.GetBool(useNickPrefixConfig) {
 		np.AsUser = true
 	}
 	np.Username = msg.Username
 	np.LinkNames = 1 // replace mentions
-	np.IconURL = config.GetIconURL(&msg, b.GetString("iconurl"))
+	np.IconURL = config.GetIconURL(&msg, b.GetString(iconURLConfig))
 	if msg.Avatar != "" {
 		np.IconURL = msg.Avatar
 	}
@@ -193,8 +231,8 @@ func (b *Bslack) Send(msg config.Message) (string, error) {
 	// add file attachments
 	np.Attachments = append(np.Attachments, b.createAttach(msg.Extra)...)
 	// add slack attachments (from another slack bridge)
-	if len(msg.Extra["slack_attachment"]) > 0 {
-		for _, attach := range msg.Extra["slack_attachment"] {
+	if msg.Extra != nil {
+		for _, attach := range msg.Extra[sSlackAttachment] {
 			np.Attachments = append(np.Attachments, attach.([]slack.Attachment)...)
 		}
 	}
@@ -202,16 +240,17 @@ func (b *Bslack) Send(msg config.Message) (string, error) {
 	// Upload a file if it exists
 	if msg.Extra != nil {
 		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
-			b.sc.PostMessage(channelID, rmsg.Username+rmsg.Text, np)
-		}
-		// check if we have files to upload (from slack, telegram or mattermost)
-		if len(msg.Extra["file"]) > 0 {
-			b.handleUploadFile(&msg, channelID)
+			_, _, err = b.sc.PostMessage(channelInfo.ID, rmsg.Username+rmsg.Text, np)
+			if err != nil {
+				b.Log.Error(err)
+			}
 		}
+		// Upload files if necessary (from Slack, Telegram or Mattermost).
+		b.handleUploadFile(&msg, channelInfo.ID)
 	}
 
 	// Post normal message
-	_, id, err := b.sc.PostMessage(channelID, msg.Text, np)
+	_, id, err := b.sc.PostMessage(channelInfo.ID, msg.Text, np)
 	if err != nil {
 		return "", err
 	}
@@ -223,26 +262,36 @@ func (b *Bslack) Reload(cfg *bridge.Config) (string, error) {
 }
 
 func (b *Bslack) createAttach(extra map[string][]interface{}) []slack.Attachment {
-	var attachs []slack.Attachment
+	var attachements []slack.Attachment
 	for _, v := range extra["attachments"] {
 		entry := v.(map[string]interface{})
-		s := slack.Attachment{}
-		s.Fallback = entry["fallback"].(string)
-		s.Color = entry["color"].(string)
-		s.Pretext = entry["pretext"].(string)
-		s.AuthorName = entry["author_name"].(string)
-		s.AuthorLink = entry["author_link"].(string)
-		s.AuthorIcon = entry["author_icon"].(string)
-		s.Title = entry["title"].(string)
-		s.TitleLink = entry["title_link"].(string)
-		s.Text = entry["text"].(string)
-		s.ImageURL = entry["image_url"].(string)
-		s.ThumbURL = entry["thumb_url"].(string)
-		s.Footer = entry["footer"].(string)
-		s.FooterIcon = entry["footer_icon"].(string)
-		attachs = append(attachs, s)
+		s := slack.Attachment{
+			Fallback:   extractStringField(entry, "fallback"),
+			Color:      extractStringField(entry, "color"),
+			Pretext:    extractStringField(entry, "pretext"),
+			AuthorName: extractStringField(entry, "author_name"),
+			AuthorLink: extractStringField(entry, "author_link"),
+			AuthorIcon: extractStringField(entry, "author_icon"),
+			Title:      extractStringField(entry, "title"),
+			TitleLink:  extractStringField(entry, "title_link"),
+			Text:       extractStringField(entry, "text"),
+			ImageURL:   extractStringField(entry, "image_url"),
+			ThumbURL:   extractStringField(entry, "thumb_url"),
+			Footer:     extractStringField(entry, "footer"),
+			FooterIcon: extractStringField(entry, "footer_icon"),
+		}
+		attachements = append(attachements, s)
 	}
-	return attachs
+	return attachements
+}
+
+func extractStringField(data map[string]interface{}, field string) string {
+	if rawValue, found := data[field]; found {
+		if value, ok := rawValue.(string); ok {
+			return value
+		}
+	}
+	return ""
 }
 
 // sendWebhook uses the configured WebhookURL to send the message
@@ -252,39 +301,48 @@ func (b *Bslack) sendWebhook(msg config.Message) (string, error) {
 		return "", nil
 	}
 
-	if b.GetBool("PrefixMessagesWithNick") {
+	if b.GetBool(useNickPrefixConfig) {
 		msg.Text = msg.Username + msg.Text
 	}
 
 	if msg.Extra != nil {
 		// this sends a message only if we received a config.EVENT_FILE_FAILURE_SIZE
 		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
-			iconURL := config.GetIconURL(&rmsg, b.GetString("iconurl"))
-			matterMessage := matterhook.OMessage{IconURL: iconURL, Channel: msg.Channel, UserName: rmsg.Username, Text: rmsg.Text}
-			b.mh.Send(matterMessage)
+			iconURL := config.GetIconURL(&rmsg, b.GetString(iconURLConfig))
+			matterMessage := matterhook.OMessage{
+				IconURL:  iconURL,
+				Channel:  msg.Channel,
+				UserName: rmsg.Username,
+				Text:     rmsg.Text,
+			}
+			if err := b.mh.Send(matterMessage); err != nil {
+				b.Log.Errorf("Failed to send message: %v", err)
+			}
 		}
 
 		// webhook doesn't support file uploads, so we add the url manually
-		if len(msg.Extra["file"]) > 0 {
-			for _, f := range msg.Extra["file"] {
-				fi := f.(config.FileInfo)
-				if fi.URL != "" {
-					msg.Text += " " + fi.URL
-				}
+		for _, f := range msg.Extra["file"] {
+			fi := f.(config.FileInfo)
+			if fi.URL != "" {
+				msg.Text += " " + fi.URL
 			}
 		}
 	}
 
 	// if we have native slack_attachments add them
 	var attachs []slack.Attachment
-	if len(msg.Extra["slack_attachment"]) > 0 {
-		for _, attach := range msg.Extra["slack_attachment"] {
-			attachs = append(attachs, attach.([]slack.Attachment)...)
-		}
+	for _, attach := range msg.Extra[sSlackAttachment] {
+		attachs = append(attachs, attach.([]slack.Attachment)...)
 	}
 
-	iconURL := config.GetIconURL(&msg, b.GetString("iconurl"))
-	matterMessage := matterhook.OMessage{IconURL: iconURL, Attachments: attachs, Channel: msg.Channel, UserName: msg.Username, Text: msg.Text}
+	iconURL := config.GetIconURL(&msg, b.GetString(iconURLConfig))
+	matterMessage := matterhook.OMessage{
+		IconURL:     iconURL,
+		Attachments: attachs,
+		Channel:     msg.Channel,
+		UserName:    msg.Username,
+		Text:        msg.Text,
+	}
 	if msg.Avatar != "" {
 		matterMessage.IconURL = msg.Avatar
 	}