45 | 46 | Do you want to collect points for reports? 47 | On which days do you want to receive menu messages? 48 | 49 | 50 | 52 | Mon 53 | 54 | 55 | 57 | Tue 58 | 59 | 61 | Wed 62 | 63 | 65 | Thu 66 | 67 | 69 | Fri 70 | 71 | 72 | 73 | 91 | 92 | 93 | From... 94 | 96 | To... 97 | 99 | 100 | Change settings 101 | 102 | 188 | 189 | 190 | 191 | -------------------------------------------------------------------------------- /telegram_connector/keyboard_decider.go: -------------------------------------------------------------------------------- 1 | package telegram_connector 2 | 3 | import ( 4 | "encoding/json" 5 | "errors" 6 | "fmt" 7 | "io/ioutil" 8 | "os" 9 | 10 | "github.com/ADimeo/MensaQueueBot/db_connectors" 11 | "go.uber.org/zap" 12 | ) 13 | 14 | type UserRequestType string 15 | 16 | // See more detailed descriptions within switch cases of 17 | // GetIdentifierBasedOnInput() 18 | const ( 19 | LENGTH_REPORT UserRequestType = "LENGTH_REPORT" 20 | PREPARE_REPORT UserRequestType = "PREPARE_REPORT" 21 | INFO_REQUEST UserRequestType = "INFO_REQUEST" 22 | PREPARE_SETTINGS UserRequestType = "PREPARE_SETTINGS" 23 | SETTINGS_INTERACTION UserRequestType = "SETTINGS_INTERACTION" 24 | PUSH_MESSAGE UserRequestType = "PUSH_MESSAGE" 25 | TUTORIAL_MESSAGE UserRequestType = "TUTORIAL_MESSAGE" 26 | PREPARE_MAIN UserRequestType = "PREPARE_MAIN" 27 | ACCOUNT_DELETION UserRequestType = "ACCOUNT_DELETION" 28 | IMAGE_REQUEST UserRequestType = "IMAGE_REQUEST" 29 | ) 30 | 31 | type KeyboardIdentifier int 32 | 33 | const ( 34 | LegacyKeyboard KeyboardIdentifier = -1 35 | NilKeyboard KeyboardIdentifier = 0 36 | ReportKeyboard KeyboardIdentifier = 1 37 | MainKeyboard KeyboardIdentifier = 2 38 | SettingsKeyboard KeyboardIdentifier = 3 39 | NoKeyboard KeyboardIdentifier = 4 40 | ) 41 | 42 | const LEGACY_KEYBOARD_FILEPATH = "./telegram_connector/keyboards/keyboard.json" 43 | const REPORT_KEYBOARD_FILEPATH = "./telegram_connector/keyboards/00_report_keyboard.json" 44 | const MAIN_KEYBOARD_FILEPATH = "./telegram_connector/keyboards/01_main_keyboard.json" 45 | const SETTINGS_KEYBOARD_FILEPATH = "./telegram_connector/keyboards/02_settings_keyboard.json" 46 | 47 | // Needs to be consistent with javascript logic in settings.html 48 | const KEYBOARD_SETTINGS_OPENER_BASE_QUERY_STRING = "?reportAtAll=%t&reportingDays=%d&fromTime=%s&toTime=%s&points=%t" 49 | 50 | func GetCustomizedKeyboardFromIdentifier(chatID int, identifier KeyboardIdentifier) (*ReplyKeyboardMarkupStruct, error) { 51 | baseKeyboard, err := getBaseKeyboardFromIdentifier(identifier) 52 | if err != nil { 53 | return baseKeyboard, err 54 | } 55 | return customizeKeyboardForUser(chatID, identifier, baseKeyboard) 56 | 57 | } 58 | 59 | /* 60 | Takes enum values, as defined in keyboard_decider.go 61 | Reads a JSON file and returns a keyboard struct, depending on the requested identifier. 62 | Raises error on unknown keyboard, or if a nil keyboard was requested - in that case 63 | the caller needs to have special logic. 64 | 65 | This function mostly exists to provide some stability for the NilKeyboard case. 66 | Not having this function would lead to some weird things being encoded in 67 | the compined GetIdentifierViaRequestType and getBaseKeyboardFromIdentifier function 68 | */ 69 | func getBaseKeyboardFromIdentifier(identifier KeyboardIdentifier) (*ReplyKeyboardMarkupStruct, error) { 70 | switch identifier { 71 | case LegacyKeyboard: 72 | { 73 | return getReplyKeyboard(LEGACY_KEYBOARD_FILEPATH), nil 74 | } 75 | case NilKeyboard: 76 | { 77 | var nilKeyboard ReplyKeyboardMarkupStruct 78 | return &nilKeyboard, errors.New("Caller requested nil keyboard, should not send keyboard instead") 79 | } 80 | case NoKeyboard: 81 | { 82 | var noKeyboard ReplyKeyboardMarkupStruct 83 | return &noKeyboard, errors.New("Caller requested no keyboard, should send different message instead") 84 | } 85 | case ReportKeyboard: 86 | { 87 | return getReplyKeyboard(REPORT_KEYBOARD_FILEPATH), nil 88 | } 89 | case MainKeyboard: 90 | { 91 | return getReplyKeyboard(MAIN_KEYBOARD_FILEPATH), nil 92 | } 93 | case SettingsKeyboard: 94 | { 95 | return getReplyKeyboard(SETTINGS_KEYBOARD_FILEPATH), nil 96 | } 97 | } 98 | var nilKeyboard ReplyKeyboardMarkupStruct 99 | return &nilKeyboard, errors.New("Caller requested unknown keyboard type") 100 | } 101 | 102 | /* 103 | "Customizes" the base keyboard for a single user. Right now this means exactly one thing: 104 | The settings keyboard is enriched with the current user settings, so that they can be 105 | displayed without serving an additional request. 106 | */ 107 | func customizeKeyboardForUser(userID int, identifier KeyboardIdentifier, baseKeyboard *ReplyKeyboardMarkupStruct) (*ReplyKeyboardMarkupStruct, error) { 108 | if identifier == SettingsKeyboard { 109 | // This is the only one that needs customization right now 110 | // We need to add the users current settings to the web_app url 111 | // which opens the webview with the settings 112 | settingsQueryString, err := getSettingsQueryStringForUser(userID) 113 | if err != nil { 114 | // Can't customize URL. Go back to defaults, which the html/js define 115 | return baseKeyboard, nil 116 | } 117 | customizedURL := baseKeyboard.Keyboard[1][0].WebApp.URL + settingsQueryString 118 | 119 | baseKeyboard.Keyboard[1][0].WebApp.URL = customizedURL 120 | } 121 | return baseKeyboard, nil 122 | } 123 | 124 | func getSettingsQueryStringForUser(userID int) (string, error) { 125 | preferencesStruct, err := db_connectors.GetUserPreferences(userID) 126 | if err != nil { 127 | zap.S().Error("Can't get user preferences", err) 128 | return "", err 129 | } 130 | userPointPreferences := db_connectors.UserIsCollectingPoints(userID) 131 | queryString := fmt.Sprintf(KEYBOARD_SETTINGS_OPENER_BASE_QUERY_STRING, preferencesStruct.ReportAtAll, preferencesStruct.WeekdayBitmap, preferencesStruct.FromTime, preferencesStruct.ToTime, userPointPreferences) 132 | return queryString, nil 133 | 134 | } 135 | 136 | /* Function that takes a requestType enum and returns a keyboard enum, that is then looked up 137 | when a keyboard should be used. 138 | In theory each messageHandler already has the knowledge to call SendMessage by themselves, 139 | a single response handler will very seldomly (never?) send more than one keyboard to the 140 | user. However, I hope that this centralised switch statement will simplify maintenance, since 141 | there's now a single point where this new functionality can be added, and no one will have 142 | to look up "uuuhhh, which message sent that type again?" 143 | */ 144 | func GetIdentifierViaRequestType(requestType UserRequestType, userID int) KeyboardIdentifier { 145 | zap.S().Debugf("User is sending us a %s request, returning corresponding keyboard identifier", requestType) 146 | switch requestType { 147 | case LENGTH_REPORT: 148 | { 149 | // User sent a length report, or declined to report length. Always comes from the REPORT_KEYBOARD, and always leads to MAIN_KEYBOARD 150 | return MainKeyboard 151 | } 152 | case PREPARE_REPORT: 153 | { 154 | // User wants to send a report/navigate to report keyboard. Always comes fom MAIN_KEYBOARD, always leads to REPORT_KEYBOARD 155 | return ReportKeyboard 156 | } 157 | case INFO_REQUEST: 158 | { 159 | // User requested mensa menu or queue length. Always comes from MAIN_KEYBOARD, always stays at MAIN_KEYBOARD 160 | return NilKeyboard 161 | } 162 | case PREPARE_SETTINGS: 163 | { 164 | // User wants to navigate to settings screen. Always comes from MAIN_KEYBOARD, always leads to SETTINGS_KEYBOARD 165 | return SettingsKeyboard 166 | } 167 | case SETTINGS_INTERACTION: 168 | { 169 | // User did something in settings, either change settings, or request help. Always comes from SETTINGS_KEYBOARD, always stays at SETTINGS_KEYBOARD 170 | return SettingsKeyboard 171 | } 172 | case PUSH_MESSAGE: 173 | { 174 | // A message the user didn't actively request. Always stays at current keyboard 175 | return NilKeyboard 176 | } 177 | case TUTORIAL_MESSAGE: 178 | { 179 | // User requested help or a tutorial. We need to init the main keyboard 180 | return MainKeyboard 181 | } 182 | case IMAGE_REQUEST: 183 | { 184 | // We currently haven't implemented setting keyboards with images yet 185 | return NilKeyboard 186 | } 187 | case PREPARE_MAIN: 188 | { 189 | // User wants to navigate to main. Usually starts at settings, always leads to main 190 | return MainKeyboard 191 | } 192 | case ACCOUNT_DELETION: 193 | // User deleted their account. Remove keyboard to make them feel like the interaction ended 194 | return NoKeyboard 195 | } 196 | zap.S().Error("Caller requested unknown keyboard type, returning nil keyboard") 197 | return NilKeyboard 198 | } 199 | 200 | // Returns the struct that represents the custom keyboard that should be shown to the user 201 | // Reads the json from the given file 202 | func getReplyKeyboard(jsonPath string) *ReplyKeyboardMarkupStruct { 203 | var keyboardArray [][]KeyboardButton 204 | 205 | jsonFile, err := os.Open(jsonPath) 206 | if err != nil { 207 | zap.S().Panicf("Can't access keyboard json file at %s", jsonPath) 208 | } 209 | defer jsonFile.Close() 210 | 211 | jsonAsBytes, err := ioutil.ReadAll(jsonFile) 212 | if err != nil { 213 | zap.S().Panicf("Can't read keyboard json file at %s", jsonPath) 214 | } 215 | err = json.Unmarshal(jsonAsBytes, &keyboardArray) 216 | if err != nil { 217 | zap.S().Panicf("Keyboard json file not formatted correctly: %s", err) 218 | } 219 | 220 | keyboardStruct := ReplyKeyboardMarkupStruct{ 221 | Keyboard: keyboardArray, 222 | ResizeKeyboard: true, 223 | } 224 | return &keyboardStruct 225 | } 226 | 227 | func LoadAllKeyboardsForTest() { 228 | getBaseKeyboardFromIdentifier(LegacyKeyboard) 229 | getBaseKeyboardFromIdentifier(ReportKeyboard) 230 | getBaseKeyboardFromIdentifier(MainKeyboard) 231 | getBaseKeyboardFromIdentifier(SettingsKeyboard) 232 | } 233 | -------------------------------------------------------------------------------- /telegram_connector/keyboards/00_report_keyboard.json: -------------------------------------------------------------------------------- 1 | [ 2 | [{"text":"L0: Virtually empty"}, {"text":"L1: Within kitchen"}, {"text":"L2: Up to food trays"}], 3 | [{"text":"L3: Within first room"}, {"text":"L4: Starting to corner"}, {"text":"L5: Past first desk"}], 4 | [{"text":"L6: Past second desk"}, {"text":"L7: Up to stairs"},{"text":"L8: Even longer"}], 5 | [{"text":"Can't tell"}] 6 | ] 7 | -------------------------------------------------------------------------------- /telegram_connector/keyboards/01_main_keyboard.json: -------------------------------------------------------------------------------- 1 | [ 2 | [{"text":"Report!"}], 3 | [{"text":"Queue?"}, {"text":"Menu?"}] 4 | ] 5 | -------------------------------------------------------------------------------- /telegram_connector/keyboards/02_settings_keyboard.json: -------------------------------------------------------------------------------- 1 | [ 2 | [{"text":"General Help"}, {"text":"Points Help"}], 3 | [{"text":"Change Settings","web_app":{"url":"https://files.telegram.dimeo.de/settings.html"}}, {"text":"Account Deletion"}], 4 | [{"text":"Back"}] 5 | ] 6 | -------------------------------------------------------------------------------- /telegram_connector/keyboards/keyboard.json: -------------------------------------------------------------------------------- 1 | [ 2 | [{"text":"L0: Virtually empty"}, {"text":"L1: Within kitchen"}, {"text":"L2: Up to food trays"}], 3 | [{"text":"L3: Within first room"}, {"text":"L4: Starting to corner"}, {"text":"L5: Past first desk"}], 4 | [{"text":"L6: Past second desk"}, {"text":"L7: Up to stairs"},{"text":"L8: Even longer"}], 5 | [{"text":"/jetze"}] 6 | ] 7 | -------------------------------------------------------------------------------- /telegram_connector/telegram_connector.go: -------------------------------------------------------------------------------- 1 | package telegram_connector 2 | 3 | import ( 4 | "bytes" 5 | "encoding/json" 6 | "fmt" 7 | "io" 8 | "io/ioutil" 9 | "mime/multipart" 10 | "net/http" 11 | "os" 12 | "path/filepath" 13 | "strconv" 14 | 15 | "go.uber.org/zap" 16 | ) 17 | 18 | const KEY_TELEGRAM_TOKEN string = "MENSA_QUEUE_BOT_TELEGRAM_TOKEN" 19 | 20 | type WebhookRequestBodyWebAppData struct { 21 | ButtonText string `json:"button_text"` 22 | Data string `json:"data"` 23 | } 24 | 25 | // Struct definitions taken from https://www.sohamkamani.com/golang/telegram-bot/ 26 | type WebhookRequestBody struct { 27 | Message struct { 28 | Text string `json:"text"` 29 | Chat struct { 30 | ID int `json:"id"` 31 | } `json:"chat"` 32 | Date int `json:"date"` 33 | WebAppData WebhookRequestBodyWebAppData `json:"web_app_data"` 34 | } `json:"message"` 35 | } 36 | 37 | // Also see sendMessageRequestDeleteKeyboardRequestBody 38 | type sendMessageRequestBody struct { // https://core.telegram.org/bots/api#sendmessage 39 | ChatID int `json:"chat_id"` 40 | Text string `json:"text"` 41 | ParseMode string `json:"parse_mode"` 42 | ReplyKeyboardMarkup *ReplyKeyboardMarkupStruct `json:"reply_markup,omitempty"` 43 | } 44 | 45 | // Variation of sendMessageRequestBody. ReplyKeyboardMarkup allows multiple different types 46 | // of values. sendMessageRequestBody is there for setting a keyboard, 47 | // This is for unsetting it 48 | type sendMessageRequestDeleteKeyboardRequestBody struct { 49 | ChatID int `json:"chat_id"` 50 | Text string `json:"text"` 51 | ParseMode string `json:"parse_mode"` 52 | ReplyKeyboardMarkup *ReplyKeyboardRemoveStruct `json:"reply_markup,omitempty"` 53 | } 54 | 55 | // Used for "typing..." indicators, 56 | // https://core.telegram.org/bots/api#sendchataction 57 | type sendChatActionRequestBody struct { 58 | ChatID int `json:"chat_id"` 59 | Action string `json:"action"` 60 | } 61 | 62 | type WebAppInfo struct { 63 | URL string `json:"url"` 64 | } 65 | 66 | // https://core.telegram.org/bots/api#keyboardbutton 67 | type KeyboardButton struct { 68 | Text string `json:"text"` 69 | WebApp *WebAppInfo `json:"web_app,omitempty"` 70 | } 71 | 72 | type ReplyKeyboardMarkupStruct struct { // https://core.telegram.org/bots/api/#replykeyboardmarkup 73 | Keyboard [][]KeyboardButton `json:"keyboard"` 74 | ResizeKeyboard bool `json:"resize_keyboard,omitempty"` 75 | } 76 | 77 | type ReplyKeyboardRemoveStruct struct { // from https://core.telegram.org/bots/api#replykeyboardremove 78 | RemoveKeyboard bool `json:"remove_keyboard"` 79 | } 80 | 81 | // Used for images whose ID or URL we have. 82 | // No specific struct exists for "dynamic" 83 | // image uploads 84 | // https://core.telegram.org/bots/api#inputmediaphoto I think 85 | type sendWebPhotoRequestBody struct { 86 | ChatID int `json:"chat_id"` 87 | Photo string `json:"photo"` 88 | Caption string `json:"caption"` 89 | } 90 | 91 | type telegramResponseBodyPhoto struct { 92 | FileID string `json:"file_id"` // This is the ID we want to use to re-send this image 93 | } 94 | 95 | type telegramResponseBody struct { 96 | Result struct { 97 | Photo []telegramResponseBodyPhoto `json:"photo"` 98 | } `json:"result"` 99 | } 100 | 101 | /* 102 | Reads the telegram token from an environment variable. 103 | The Telegram token is used to identify us to the telegram server when sending messages. 104 | */ 105 | func GetTelegramToken() string { 106 | telegramKey, doesExist := os.LookupEnv(KEY_TELEGRAM_TOKEN) 107 | if !doesExist { 108 | zap.S().Panicf("Error: Environment variable for personal key (%s) not set", KEY_TELEGRAM_TOKEN) 109 | } 110 | return telegramKey 111 | } 112 | 113 | /* 114 | Sends a POST request to the telegram API that contains the link to a photo. This photo is sent to the identified user. Description is set as the text of the message 115 | https://core.telegram.org/bots/api#sendphoto 116 | */ 117 | func SendStaticWebPhoto(chatID int, photoURL string, description string, keyboardIdentifier KeyboardIdentifier) error { 118 | telegramUrl := fmt.Sprintf("https://api.telegram.org/bot%s/sendPhoto", GetTelegramToken()) 119 | 120 | if keyboardIdentifier != NilKeyboard { 121 | zap.S().Error("Tried to set a keyboard with SendDynamicPhoto. Is that even possible?") 122 | // Initial scan of the documentation says it isn't, but I was really tired, and it's quite hot right now. Definitely recheck if needed. 123 | } 124 | 125 | requestBody := &sendWebPhotoRequestBody{ 126 | ChatID: chatID, 127 | Photo: photoURL, 128 | Caption: description, 129 | } 130 | 131 | reqBytes, err := json.Marshal(requestBody) 132 | if err != nil { 133 | return err 134 | } 135 | 136 | _, err = http.Post(telegramUrl, "application/json", bytes.NewBuffer(reqBytes)) 137 | if err != nil { 138 | return err 139 | } 140 | return nil 141 | } 142 | 143 | /* PrepareMultipartForUpload reads the given file, chatID and caption, and writes them 144 | to a buffer in a format corresponding to a multipart request. 145 | Addicionally, it also returns the FormDataContentType for said multipart request. 146 | */ 147 | func prepareMultipartForUpload(pathToFile string, chatID int, caption string) (*bytes.Buffer, string, error) { 148 | // Read file content 149 | file, err := os.Open(pathToFile) 150 | defer file.Close() 151 | requestBody := new(bytes.Buffer) 152 | if err != nil { 153 | zap.S().Errorf("Can't open graph file for detailed /jetze report: %s", pathToFile) 154 | return requestBody, "", err 155 | } 156 | writer := multipart.NewWriter(requestBody) 157 | defer writer.Close() 158 | part, err := writer.CreateFormFile("photo", filepath.Base(pathToFile)) 159 | if err != nil { 160 | zap.S().Errorf("Can't CreateFormFile for /jetze report: %s", pathToFile) 161 | return nil, "", err 162 | } 163 | io.Copy(part, file) 164 | 165 | writer.WriteField("chat_id", strconv.Itoa(chatID)) 166 | writer.WriteField("caption", caption) 167 | 168 | return requestBody, writer.FormDataContentType(), nil 169 | } 170 | 171 | /* SendDynamicPhoto sends an image that is stored locally on this machine 172 | to the user with the given chatID. A description/caption can also be added. 173 | 174 | Returns telegram assigned identifier and error, if the request should fail 175 | */ 176 | func SendDynamicPhoto(chatID int, photoFilePath string, description string, keyboardIdentifier KeyboardIdentifier) (string, error) { 177 | telegramUrl := fmt.Sprintf("https://api.telegram.org/bot%s/sendPhoto", GetTelegramToken()) 178 | 179 | requestBody, contentType, err := prepareMultipartForUpload(photoFilePath, chatID, description) 180 | 181 | if keyboardIdentifier != NilKeyboard { 182 | zap.S().Error("Tried to set a keyboard with SendDynamicPhoto. Is that even possible?") 183 | // Initial scan of the documentation says it isn't, but I was really tired, and it's quite hot right now. Definitely recheck if needed. 184 | } 185 | 186 | if err != nil { 187 | zap.S().Errorf("Couldn't build request to send detailed /jetze report") 188 | return "", err 189 | } 190 | request, _ := http.NewRequest("POST", telegramUrl, requestBody) 191 | request.Header.Add("Content-Type", contentType) 192 | client := &http.Client{} 193 | response, err := client.Do(request) 194 | defer response.Body.Close() 195 | 196 | if err != nil { 197 | zap.S().Errorw("Dynamic photo request failed", "error", err) 198 | return "", err 199 | } 200 | telegramResponse := &telegramResponseBody{} 201 | responseDecoder := json.NewDecoder(response.Body) 202 | err = responseDecoder.Decode(telegramResponse) 203 | 204 | if err != nil { 205 | return "", err 206 | } 207 | 208 | // Telegram returns a list of images, in different resolutions 209 | // All of them share the same file_id 210 | telegramIdentifier := telegramResponse.Result.Photo[0].FileID 211 | 212 | return telegramIdentifier, nil 213 | } 214 | 215 | /* 216 | Sends a POST request to the telegram API that sends the indicated string to the indicated user. 217 | https://core.telegram.org/bots/api#sendmessage 218 | */ 219 | func SendMessage(chatID int, message string, keyboardIdentifier KeyboardIdentifier) error { 220 | telegramUrl := fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage", GetTelegramToken()) 221 | var reqBytes []byte 222 | var err error 223 | if keyboardIdentifier == NilKeyboard { 224 | requestBody := &sendMessageRequestBody{ 225 | ChatID: chatID, 226 | Text: message, 227 | ParseMode: "HTML", 228 | } 229 | reqBytes, err = json.Marshal(requestBody) 230 | } else if keyboardIdentifier == NoKeyboard { 231 | noKeyboard := &ReplyKeyboardRemoveStruct{RemoveKeyboard: true} 232 | requestBodyWithKeyboardRemoval := &sendMessageRequestDeleteKeyboardRequestBody{ 233 | ChatID: chatID, 234 | Text: message, 235 | ParseMode: "HTML", 236 | ReplyKeyboardMarkup: noKeyboard, 237 | } 238 | reqBytes, err = json.Marshal(requestBodyWithKeyboardRemoval) 239 | 240 | } else { 241 | keyboard, err := GetCustomizedKeyboardFromIdentifier(chatID, keyboardIdentifier) 242 | if err != nil { 243 | zap.S().Errorw("Error while sending message, can't get keyboard", 244 | "keyboardIdentifier", keyboardIdentifier, 245 | "error", err) 246 | } 247 | requestBody := &sendMessageRequestBody{ 248 | ChatID: chatID, 249 | Text: message, 250 | ParseMode: "HTML", 251 | ReplyKeyboardMarkup: keyboard, 252 | } 253 | reqBytes, err = json.Marshal(requestBody) 254 | } 255 | 256 | if err != nil { 257 | // err from reqBytes 258 | return err 259 | } 260 | 261 | response, err := http.Post(telegramUrl, "application/json", bytes.NewBuffer(reqBytes)) 262 | defer response.Body.Close() 263 | if err != nil { 264 | return err 265 | } 266 | if response.StatusCode != 200 { 267 | body, _ := ioutil.ReadAll(response.Body) 268 | 269 | zap.S().Errorw("Sending message failed:", "Response", body) 270 | 271 | } 272 | return nil 273 | } 274 | 275 | /* SendTypingIndicator sets the bots status to "sending image" 276 | for this specific user*/ 277 | func SendTypingIndicator(chatID int) error { 278 | telegramUrl := fmt.Sprintf("https://api.telegram.org/bot%s/sendChatAction", GetTelegramToken()) 279 | indicatorString := "upload_photo" 280 | requestBody := &sendChatActionRequestBody{ 281 | ChatID: chatID, 282 | Action: indicatorString, 283 | } 284 | reqBytes, err := json.Marshal(requestBody) 285 | if err != nil { 286 | return err 287 | } 288 | _, err = http.Post(telegramUrl, "application/json", bytes.NewBuffer(reqBytes)) 289 | if err != nil { 290 | zap.S().Error("Failure while sending typing indicator", err) 291 | return err 292 | } 293 | return nil 294 | } 295 | -------------------------------------------------------------------------------- /utils/utils.go: -------------------------------------------------------------------------------- 1 | package utils 2 | 3 | import ( 4 | "os" 5 | "time" 6 | 7 | "go.uber.org/zap" 8 | ) 9 | 10 | const KEY_PERSONAL_TOKEN string = "MENSA_QUEUE_BOT_PERSONAL_TOKEN" 11 | const KEY_DEBUG_MODE string = "MENSA_QUEUE_BOT_DEBUG_MODE" 12 | 13 | func GetLocalLocation() *time.Location { 14 | potsdamLocation, err := time.LoadLocation("Europe/Berlin") 15 | if err != nil { 16 | zap.S().Panic("Can't load location Europe/Berlin!") 17 | } 18 | return potsdamLocation 19 | } 20 | 21 | /* 22 | Reads the personal token from environment variables. 23 | The personal token is part of the url path, and tries to prevent non-authorized users from accessing our webhooks, and therefore spamming our users. 24 | For this purpose it needs to be long, random, and non-public. 25 | */ 26 | func GetPersonalToken() string { 27 | personalKey, doesExist := os.LookupEnv(KEY_PERSONAL_TOKEN) 28 | 29 | if !doesExist { 30 | zap.S().Panicf("Fatal Error: Environment variable for personal key not set: %s", KEY_PERSONAL_TOKEN) 31 | } 32 | return personalKey 33 | } 34 | 35 | func GetMensaOpeningTime() time.Time { 36 | var today = time.Now() 37 | // Mensa opens at 08:00 38 | var openingTime = time.Date(today.Year(), today.Month(), today.Day(), 8, 0, 0, 0, GetLocalLocation()) 39 | return openingTime 40 | } 41 | 42 | func GetMensaClosingTime() time.Time { 43 | var today = time.Now() 44 | // Mensa closes at 18:00 45 | var closingTime = time.Date(today.Year(), today.Month(), today.Day(), 18, 0, 0, 0, GetLocalLocation()) 46 | return closingTime 47 | } 48 | 49 | /*IsInDebugMode can be used to change behaviour 50 | for testing. Currently mostly used to allow 51 | reports at weird times 52 | */ 53 | func IsInDebugMode() bool { 54 | _, doesExist := os.LookupEnv(KEY_DEBUG_MODE) 55 | if !doesExist { 56 | return false 57 | } 58 | return true 59 | } 60 | --------------------------------------------------------------------------------