Go
func HandleRequest(ctx context.Context, event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
	r := InitDI()

	if err := r.CatchEvents(event); err != nil {
		return events.APIGatewayProxyResponse{
			StatusCode: 500,
		}, nil
	}

	return events.APIGatewayProxyResponse{
		StatusCode: 200,
	}, nil
}

func main() {
	lambda.Start(HandleRequest)
}

func InitDI() *infrastructure.Router {
	hotpepperGateway := gateway.NewHotpepperGateway()
	linePresenter := presenter.NewLinePresenter()
	searchInteractor := interactor.NewSearchInteractor(hotpepperGateway, linePresenter)
	setMenuInteractor := interactor.NewSetMenuInteractor(linePresenter)
	linebotController := controllers.NewLinebotController(searchInteractor, setMenuInteractor)
	router := infrastructure.NewRouter(linebotController)
	return router
}

Go
// Router ルーティング
type Router struct {
	lc *controllers.LinebotController
}

// NewRouter コンストラクタ
func NewRouter(lc *controllers.LinebotController) *Router {
	return &Router{lc: lc}
}

// イベントごとにルーティング
func (r *Router) CatchEvents(event events.APIGatewayProxyRequest) error {
	// 署名の検証
	signature := event.Headers["x-line-signature"]
	if signature == "" {
		signature = event.Headers["X-Line-Signature"]
	}
	if !validateSignature(os.Getenv("LINE_SECRET_TOKEN"), signature, []byte(event.Body)) {
		logrus.Error("署名の検証に失敗しました")
		return fmt.Errorf("署名の検証に失敗しました")
	}

	webhook := model.Webhook{}

	// リクエストからイベントを取得
	if err := json.Unmarshal([]byte(event.Body), &webhook); err != nil {
		logrus.Error(err, "router@CatchEvents_json.Unmarshal")
		return err
	}

	for _, we := range webhook.Events {

		// イベントがメッセージの受信だった場合
		if we.Type == linebot.EventTypeMessage {

			switch message := we.Message.(type) {

			// メッセージがテキスト形式の場合
			case *linebot.TextMessage:
				userMessage := message.Text

				if userMessage == model.INTRO_MESSAGE {
					// 最初の導入メッセージ
					if err := r.lc.SetAreaMenu(we); err != nil {
						logrus.Error(err, "router@SetAreaMenu")
						return err
					}
					return nil
				} else if utils.ContainsHyphen(userMessage) {
					// メッセージにハイフンを含む場合（エリア指定）
					if err := r.lc.SetConfirmMenu(we, model.PBD_PREFIX_IDENTIFY_GENRE, "", userMessage); err != nil {
						logrus.Error(err, "router@SetConfirmMenu")
						return err
					}
					return nil
				} else {
					// それ以外の場合（エリア未指定）
					if err := r.lc.SetHelpMenu(we); err != nil {
						logrus.Error(err, "router@SetHelpMenu")
						return err
					}
					return nil
				}

			// メッセージが位置情報の場合
			case *linebot.LocationMessage:
				if err := r.lc.SetConfirmMenu(we, model.PBD_PREFIX_IDENTIFY_GENRE, "", ""); err != nil {
					logrus.Error(err, "router@SetConfirmMenu")
					return err
				}
				return nil
			}
		} else if we.Type == linebot.EventTypePostback {

			// 確認ボタン
			if model.PBD_PREFIX_IDENTIFY_CONFIRM == model.GetPrefix(we.Postback.Data) {
				if err := r.lc.SetConfirmMenu(we, "", we.Postback.Data, ""); err != nil {
					logrus.Error(err, "router@SetConfirmMenu")
					return err
				}
			}

			// ジャンルボタン
			if model.PBD_PREFIX_IDENTIFY_GENRE == model.GetPrefix(we.Postback.Data) {
				if err := r.lc.SetGenreMenu(we, we.Postback.Data); err != nil {
					logrus.Error(err, "router@SetGenreMenu")
					return err
				}
			}

			// 条件ボタン
			if model.PBD_PREFIX_IDENTIFY_CONDITION == model.GetPrefix(we.Postback.Data) {
				if err := r.lc.SetConditionMenu(we, we.Postback.Data); err != nil {
					logrus.Error(err, "router@SetConditionMenu")
					return err
				}
			}

			// お店一覧
			if model.PBD_PREFIX_IDENTIFY_SEARCH == model.GetPrefix(we.Postback.Data) {
				if err := r.lc.GetRestaurantInfos(we, we.Postback.Data); err != nil {
					logrus.Error(err, "router@GetRestaurantInfos")
					return err
				}
			}

			return nil

		} else {
			if err := r.lc.SetHelpMenu(we); err != nil {
				logrus.Error(err, "router@SetHelpMenu")
				return err
			}
			return nil
		}
	}

	return nil

}

func validateSignature(channelSecret string, signature string, body []byte) bool {
	decoded, err := base64.StdEncoding.DecodeString(signature)
	if err != nil {
		logrus.Error(err, "validateSignature_base64.StdEncoding.DecodeString")
		return false
	}

	hash := hmac.New(sha256.New, []byte(channelSecret))
	_, err = hash.Write(body)
	if err != nil {
		logrus.Error(err, "validateSignature_hash.Write")
		return false
	}

	return hmac.Equal(decoded, hash.Sum(nil))
}

Go
// LinebotController LINEBOTコントローラ
type LinebotController struct {
	searchInteractor  usecase.ISearchUsecase
	setMenuInteractor usecase.ISetMenuUsecase
	bot               *linebot.Client
}

// NewLinebotController コンストラクタ
func NewLinebotController(searchInteractor usecase.ISearchUsecase, setMenuInteractor usecase.ISetMenuUsecase) *LinebotController {
	bot, err := linebot.New(
		os.Getenv("LINE_SECRET_TOKEN"),
		os.Getenv("LINE_ACCESS_TOKEN"),
	)
	if err != nil {
		logrus.Fatalf("Error creating LINEBOT client: %v", err)
	}

	return &LinebotController{
		searchInteractor:  searchInteractor,
		setMenuInteractor: setMenuInteractor,
		bot:               bot,
	}
}

func (c *LinebotController) SetHelpMenu(e *linebot.Event) error {
	setHelpMenuInput := menudto.SetHelpMenuInput{
		ReplyToken: e.ReplyToken,
	}

	if _, err := c.setMenuInteractor.SetHelpMenu(setHelpMenuInput); err != nil {
		logrus.Errorf("Error setMenuInteractor.SetHelpMenu(setHelpMenuInput): %v", err)
		return err
	}
	return nil
}

func (c *LinebotController) SetAreaMenu(e *linebot.Event) error {
	setAreaMenuInput := menudto.SetAreaMenuInput{
		ReplyToken: e.ReplyToken,
	}

	if _, err := c.setMenuInteractor.SetAreaMenu(setAreaMenuInput); err != nil {
		logrus.Errorf("Error setMenuInteractor.SetAreaMenu(setAreaMenuInput): %v", err)
		return err
	}
	return nil
}

// 以下省略...

Go
type SetAreaMenuInput struct {
	ReplyToken string
}

Go
// SetMenuInteractor メニューインタラクタ
type SetMenuInteractor struct {
	linePresenter ipresenter.ILinePresenter //依存方向を逆転させるためpresenterの<I>を呼ぶ
}

// NewSetMenuInteractor コンストラクタ
func NewSetMenuInteractor(
	linePresenter ipresenter.ILinePresenter) *SetMenuInteractor {
	return &SetMenuInteractor{
		linePresenter: linePresenter,
	}
}

func (interactor *SetMenuInteractor) SetHelpMenu(in menudto.SetHelpMenuInput) (menudto.SetHelpMenuOutput, error) {
	out := menudto.SetHelpMenuOutput{
		ReplyToken: in.ReplyToken,
		TextMessageData: &model.TextMessageData{
			Content: model.TM_CONTENT_SET_HELP_MENU,
		},
	}

	if err := interactor.linePresenter.SetHelpMenuReplyMessage(out); err != nil {
		logrus.Errorf("Error linePresenter.SetHelpMenuReplyMessage(out): %v", err)
		return out, err
	}
	return out, nil
}

// SetAreaMenu エリアメニュー設定
func (interactor *SetMenuInteractor) SetAreaMenu(in menudto.SetAreaMenuInput) (menudto.SetAreaMenuOutput, error) {
	postbackData := "area_menu"

	out := menudto.SetAreaMenuOutput{
		ReplyToken: in.ReplyToken,
		ButtonsTemplateData: model.ButtonsTemplateData{
			ThumbnailImageURL: model.BT_THUMBNAIL_SET_AREA_MENU,
			Title:             model.BT_TITLE_SET_AREA_MENU,
			Text:              model.BT_MESSAGE_SET_AREA_MENU,
		},
		PostbackActionData: model.PostbackActionData{
			Label:       model.PBA_LABEL_SET_AREA_MENU,
			Data:        postbackData,
			Text:        model.PBA_TEXT_SET_AREA_MENU,
			DisplayText: model.PBA_DISPLAY_TEXT_SET_AREA_MENU,
			InputOption: model.PBA_INPUT_OPTION_SET_AREA_MENU,
			FillInText:  model.PBA_FILL_IN_TEXT_SET_AREA_MENU,
		},
		URIActionData: model.URIActionData{
			Label: model.UA_LABEL_SET_AREA_MENU,
			URI:   model.UA_URI_SET_AREA_MENU,
		},
		TemplateMessageData: model.TemplateMessageData{
			AltText: model.TM_LABEL_SET_AREA_MENU,
		},
	}
	if err := interactor.linePresenter.SetAreaMenuReplyMessage(out); err != nil {
		return out, err
	}
	return out, nil
}

// 省略...

Go
// LinePresenter LINEプレゼンタ
type LinePresenter struct {
	bot *linebot.Client
}

// NewLinePresenter コンストラクタ
func NewLinePresenter() ipresenter.ILinePresenter {
	bot, err := linebot.New(
		os.Getenv("LINE_SECRET_TOKEN"),
		os.Getenv("LINE_ACCESS_TOKEN"),
	)
	if err != nil {
		logrus.Fatalf("Error creating LINEBOT client: %v", err)
	}

	return &LinePresenter{bot: bot}
}

// SetHelpMenuReplyMessage リプライメッセージ
func (p *LinePresenter) SetHelpMenuReplyMessage(out menudto.SetHelpMenuOutput) error {
	if _, err := p.bot.ReplyMessage(out.ReplyToken, linebot.NewTextMessage(out.TextMessageData.Content)).Do(); err != nil {
		logrus.Errorf("Error LINEBOT replying message: %v", err)
		return err
	}
	return nil
}

// SetAreaMenu リプライメッセージ
func (p *LinePresenter) SetAreaMenuReplyMessage(out menudto.SetAreaMenuOutput) error {
	bt := linebot.NewButtonsTemplate(
		out.ButtonsTemplateData.ThumbnailImageURL,
		out.ButtonsTemplateData.Title,
		out.ButtonsTemplateData.Text,
		linebot.NewPostbackAction(
			out.PostbackActionData.Label,
			out.PostbackActionData.Data,
			out.PostbackActionData.Text,
			out.PostbackActionData.DisplayText,
			out.PostbackActionData.InputOption,
			out.PostbackActionData.FillInText,
		),
		linebot.NewURIAction(
			out.URIActionData.Label,
			out.URIActionData.URI,
		),
	)
	tm := linebot.NewTemplateMessage(out.TemplateMessageData.AltText, bt)

	if _, err := p.bot.ReplyMessage(out.ReplyToken, tm).Do(); err != nil {
		logrus.Errorf("Error LINEBOT replying message: %v", err)
		return err
	}
	return nil
}

// 省略...

上画像の場合、「条件に追加する」ボタンにポストバックアクションを「ペット同伴可」みたいなテキスト情報のポストバックデータと共に仕込む。そうすることで、ボタンが押すされたときに、「ペット同伴可」というポストバックデータをWebhookを介してリクエストが飛んでくる。