Use upstream slack-go/slack again (#1018)

vendor/github.com/slack-go/slack/block_object.go

@@ -0,0 +1,216 @@
+package slack
+
+import (
+	"encoding/json"
+)
+
+// Block Objects are also known as Composition Objects
+//
+// For more information: https://api.slack.com/reference/messaging/composition-objects
+
+// BlockObject defines an interface that all block object types should
+// implement.
+// @TODO: Is this interface needed?
+
+// blockObject object types
+const (
+	MarkdownType  = "mrkdwn"
+	PlainTextType = "plain_text"
+	// The following objects don't actually have types and their corresponding
+	// const values are just for internal use
+	motConfirmation = "confirm"
+	motOption       = "option"
+	motOptionGroup  = "option_group"
+)
+
+type MessageObjectType string
+
+type blockObject interface {
+	validateType() MessageObjectType
+}
+
+type BlockObjects struct {
+	TextObjects         []*TextBlockObject
+	ConfirmationObjects []*ConfirmationBlockObject
+	OptionObjects       []*OptionBlockObject
+	OptionGroupObjects  []*OptionGroupBlockObject
+}
+
+// UnmarshalJSON implements the Unmarshaller interface for BlockObjects, so that any JSON
+// unmarshalling is delegated and proper type determination can be made before unmarshal
+func (b *BlockObjects) UnmarshalJSON(data []byte) error {
+	var raw []json.RawMessage
+	err := json.Unmarshal(data, &raw)
+	if err != nil {
+		return err
+	}
+
+	for _, r := range raw {
+		var obj map[string]interface{}
+		err := json.Unmarshal(r, &obj)
+		if err != nil {
+			return err
+		}
+
+		blockObjectType := getBlockObjectType(obj)
+
+		switch blockObjectType {
+		case PlainTextType, MarkdownType:
+			object, err := unmarshalBlockObject(r, &TextBlockObject{})
+			if err != nil {
+				return err
+			}
+			b.TextObjects = append(b.TextObjects, object.(*TextBlockObject))
+		case motConfirmation:
+			object, err := unmarshalBlockObject(r, &ConfirmationBlockObject{})
+			if err != nil {
+				return err
+			}
+			b.ConfirmationObjects = append(b.ConfirmationObjects, object.(*ConfirmationBlockObject))
+		case motOption:
+			object, err := unmarshalBlockObject(r, &OptionBlockObject{})
+			if err != nil {
+				return err
+			}
+			b.OptionObjects = append(b.OptionObjects, object.(*OptionBlockObject))
+		case motOptionGroup:
+			object, err := unmarshalBlockObject(r, &OptionGroupBlockObject{})
+			if err != nil {
+				return err
+			}
+			b.OptionGroupObjects = append(b.OptionGroupObjects, object.(*OptionGroupBlockObject))
+
+		}
+	}
+
+	return nil
+}
+
+// Ideally would have a better way to identify the block objects for
+// type casting at time of unmarshalling, should be adapted if possible
+// to accomplish in a more reliable manner.
+func getBlockObjectType(obj map[string]interface{}) string {
+	if t, ok := obj["type"].(string); ok {
+		return t
+	}
+	if _, ok := obj["confirm"].(string); ok {
+		return "confirm"
+	}
+	if _, ok := obj["options"].(string); ok {
+		return "option_group"
+	}
+	if _, ok := obj["text"].(string); ok {
+		if _, ok := obj["value"].(string); ok {
+			return "option"
+		}
+	}
+	return ""
+}
+
+func unmarshalBlockObject(r json.RawMessage, object blockObject) (blockObject, error) {
+	err := json.Unmarshal(r, object)
+	if err != nil {
+		return nil, err
+	}
+	return object, nil
+}
+
+// TextBlockObject defines a text element object to be used with blocks
+//
+// More Information: https://api.slack.com/reference/messaging/composition-objects#text
+type TextBlockObject struct {
+	Type     string `json:"type"`
+	Text     string `json:"text"`
+	Emoji    bool   `json:"emoji,omitempty"`
+	Verbatim bool   `json:"verbatim,omitempty"`
+}
+
+// validateType enforces block objects for element and block parameters
+func (s TextBlockObject) validateType() MessageObjectType {
+	return MessageObjectType(s.Type)
+}
+
+// validateType enforces block objects for element and block parameters
+func (s TextBlockObject) MixedElementType() MixedElementType {
+	return MixedElementText
+}
+
+// NewTextBlockObject returns an instance of a new Text Block Object
+func NewTextBlockObject(elementType, text string, emoji, verbatim bool) *TextBlockObject {
+	return &TextBlockObject{
+		Type:     elementType,
+		Text:     text,
+		Emoji:    emoji,
+		Verbatim: verbatim,
+	}
+}
+
+// ConfirmationBlockObject defines a dialog that provides a confirmation step to
+// any interactive element. This dialog will ask the user to confirm their action by
+// offering a confirm and deny buttons.
+//
+// More Information: https://api.slack.com/reference/messaging/composition-objects#confirm
+type ConfirmationBlockObject struct {
+	Title   *TextBlockObject `json:"title"`
+	Text    *TextBlockObject `json:"text"`
+	Confirm *TextBlockObject `json:"confirm"`
+	Deny    *TextBlockObject `json:"deny"`
+}
+
+// validateType enforces block objects for element and block parameters
+func (s ConfirmationBlockObject) validateType() MessageObjectType {
+	return motConfirmation
+}
+
+// NewConfirmationBlockObject returns an instance of a new Confirmation Block Object
+func NewConfirmationBlockObject(title, text, confirm, deny *TextBlockObject) *ConfirmationBlockObject {
+	return &ConfirmationBlockObject{
+		Title:   title,
+		Text:    text,
+		Confirm: confirm,
+		Deny:    deny,
+	}
+}
+
+// OptionBlockObject represents a single selectable item in a select menu
+//
+// More Information: https://api.slack.com/reference/messaging/composition-objects#option
+type OptionBlockObject struct {
+	Text  *TextBlockObject `json:"text"`
+	Value string           `json:"value"`
+	URL   string           `json:"url,omitempty"`
+}
+
+// NewOptionBlockObject returns an instance of a new Option Block Element
+func NewOptionBlockObject(value string, text *TextBlockObject) *OptionBlockObject {
+	return &OptionBlockObject{
+		Text:  text,
+		Value: value,
+	}
+}
+
+// validateType enforces block objects for element and block parameters
+func (s OptionBlockObject) validateType() MessageObjectType {
+	return motOption
+}
+
+// OptionGroupBlockObject Provides a way to group options in a select menu.
+//
+// More Information: https://api.slack.com/reference/messaging/composition-objects#option-group
+type OptionGroupBlockObject struct {
+	Label   *TextBlockObject     `json:"label,omitempty"`
+	Options []*OptionBlockObject `json:"options"`
+}
+
+// validateType enforces block objects for element and block parameters
+func (s OptionGroupBlockObject) validateType() MessageObjectType {
+	return motOptionGroup
+}
+
+// NewOptionGroupBlockElement returns an instance of a new option group block element
+func NewOptionGroupBlockElement(label *TextBlockObject, options ...*OptionBlockObject) *OptionGroupBlockObject {
+	return &OptionGroupBlockObject{
+		Label:   label,
+		Options: options,
+	}
+}