Alarms: configuring

• Go to https://api.slack.com/apps
• Create an App "midas alarms", select "From scratch"
• Name it "midas alarm" or similar, select your workspace
• Click on "Add features and functionality"
• Select "Incoming Webhooks"
• Activate Incoming Webhooks
• Click on "Add New Webhook to Workspace"
• Select channel where alarms get posted, allow access
• Copy the sample curl request and replace "Hello World" with "$1", such as:

  curl -X POST -H 'Content-type: application/json' --data "{"text":"$1"}' https://hooks.slack.com/services/[xxx]/[yyy]/[zzz]
  

  (leave the keys xxx, yyy, zzz as shown on the web page).

• Create a shell that contains the curl command from step 1.
• Ensure the shell script is executable (e.g., chmod +x script.sh)
• Call the shell script from the alarm system by putting path/to/script.sh '%s' under /Alarms/Classes/xxx/Execute command in the ODB.

• Go to https://web.telegram.org and login by scanning the QR-code with the telegram app on your phone
• Go to https://t.me/botfather
• Click on "open in web"
• A chat window will open.
• Send /newbot into the chat and assign name and username to your bot
• At the end of the bot creation a access token will be displayed. Save that access token.
• Post /mybots into the chat
• Select the bot that was just created
• Click on "Bot settings"
• Click on "Allow Groups"
• Enable groups for the bot
• Click on "back to settings"
• Click on Channel Admin Rights
• Click on "Manage channel" (a checkmark should appear next to the text)
• Close this chat.

• Add the created bot to a telegram group chat via searching for the bot name in "add members" (same as adding new People to the group)
• Now you need the chat_id of the same group chat. When you open the group chat in a webbrowser the URL should look like this https://web.telegram.org/a/#-1700000000 (where 1700000000 will be a different number for you)
• The group chat_id is then -1001700000000 (add -100 in front of the number in your URL)

• With the access token from step 1 and chat_id from step 2, you can post to the telegram group like this: (replace <chat_id> and <accessToken> with your numbers)

  curl -s -X  POST "https://api.telegram.org/bot<accessToken>/sendMessage" -d chat_id=<chat_id> -d text="🚨 Midas alarm triggered with message = $1"
  

• Create a shell script with this command
• Ensure the shell script is executable (e.g., chmod +x script.sh)
• Call the shell script from the alarm system by putting path/to/script.sh '%s' under /Alarms/Classes/xxx/Execute command in the ODB.

First a mattermost bot needs to be created. To do this you need to be an Admin of the Team that the bot should post to.

• In the drop down menu on the top left corner of the mattermost page click on "Integrations" (note: this field will be missing if you are not an Admin of the selected mattermost team)
• Select "Incoming Webhooks"
• Click on "Add Incoming Webhook"
• Give the bot a title and username (e.g. midasalarms) and select the channel to post to, click "save"
• A URL for the incoming webhook should be displayed (https://mattermost.gitlab.rlp.net/hooks/). Copy that URL.

• Copy the webhook URL into the curl command in the following script:

  #!/bin/bash
  alarm_message=$1
  generate_post_data()
  {
  cat <<EOF
  {
    "text": "@all Midas alarm triggered with message = $alarm_message", 
    "icon_emoji":":rotating_light:",
    "username":"Midas"
  }
  EOF
  }
  curl -i -X POST -H 'Content-Type: application/jsoni' --data "$(generate_post_data)" https://mattermost.gitlab.rlp.net/hooks/<token>
  

• Ensure the shell script is executable (e.g., chmod +x script.sh)
• Call the shell script from the alarm system by putting path/to/script.sh '%s' under /Alarms/Classes/xxx/Execute command in the ODB.

1. Make an account: https://app.bird.com/
2. Add some funds to your main wallet: https://app.bird.com/settings/billing/overview/wallets/
3. Buy a number. This number will be the where the call originates from, so you should pick something local to your area.
   • In the left-hand navigation side panel: "Developer" → "Numbers" → "Numbers & Senders"
   • Top-right: "Browse Inventory"
   • Make sure your number is capable of voice calling (it seems like most of them are)
   • Follow the on-screen prompts to finish your purchase and activate the number. You will have to create a UseCase. Either "Mixed" or "Security Alert" should do.
4. Ensure compliance with local regulations
   • Go back to the number summary: "Developer" → "Numbers" → "Numbers & Senders". You should now have your number listed. Click on it.
   • At the top there is a menu, select "Voice"
   • You should see some links to set up brand identification and compliance (what will you be using the number for, the company associated with the number, etc). Follow the on-screen instructions. Once compliance has been requested it may take a few days to be approved.
   • While you wait, you also need to create a Voice Channel. In this same menu, click on "+ Create channel". You can see your channels from the side bar navigation: "Developer" → "Voice" → "Voice Setup".

You need a few pieces of info:

• API Access Key
  • In the side bar navigation: "Developer" → "API Access Keys" (at the bottom)
  • Make a new key. Keep it somewhere safe.
• Workspace ID
  • In the side bar navigation: "Settings" (at the bottom) → "Workspaces" → Click on your workspace
• Channel ID
  • In the side bar navigation: "Developer" → "Voice" → "Voice Setup" → Click on your voice channel → Settings (top right gear)
• Call ID
  • Only available once the call is placed. See the script below.
• Outgoing number
  • In the side bar navigation: "Developer" → "Numbers" → "Numbers & Senders"

Below is an example python script to place a call.

• Tweak it using the information you gathered.
• Call the script from the alarm system by putting python path/to/script.py '%s' under /Alarms/Classes/xxx/Execute command in the ODB.

You can follow the documentation here: https://docs.bird.com/api/voice-api/voice-calls-api.

import json, requests, time, sys

# settings
workspaceId = 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
channelId = 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
APIKEY = 'YourAPIKey'
outgoing = '16042221047' # outgoing number with country code
targetnumber = 'YourPurcahsedPhoneNumber' # who to call
message = "Midas alarm - " + sys.argv[1] # message

# place a call
# https://docs.bird.com/api/voice-api/voice-calls-api/initiate-an-outbound-call
def place_call(number):

    # place the call
    response = requests.post(
        f"https://api.bird.com/workspaces/{workspaceId}/channels/{channelId}/calls",
        headers={"Authorization":f"AccessKey {APIKEY}","Content-Type":"application/json"},
        data=json.dumps({
        "from": outgoing,
        "to": number,
        "ringTimeout": 60,
        "maxDuration": 120,
        "record": False,
        })
    )

    # call id is needed for the next steps
    data = response.json()
    callId = data['id']
    return callId

# get the call status
# https://docs.bird.com/api/voice-api/voice-calls-api/get-a-call-insights
def get_call_status(callId):
    response = requests.get(
        f"https://api.bird.com/workspaces/{workspaceId}/channels/{channelId}/calls/{callId}/insights",
        headers={"Authorization":f"AccessKey {APIKEY}","Accept":"*/*"},
    )
    data = response.json()
    return data['status']

# text-to-voice: play message in the call 
# https://docs.bird.com/api/voice-api/voice-calls-api/say-text-to-speech-tts
def play_message(callId, message):
    response = requests.post(
        f"https://api.bird.com/workspaces/{workspaceId}/channels/{channelId}/calls/{callId}/say",
        headers={"Authorization":f"AccessKey {APIKEY}","Content-Type":"application/json"},
        data=json.dumps({
        "text": message,
        "locale": "en-US",
        "voice": "text",
        "loop": 10, # repeat the message this many times
        "timeout": 30
        })
    )
    return response.json()

# RUN =========================

# place call
callId = place_call(targetnumber)

# wait until call is answered, or until 30s has passed
t0 = time.time()
while time.time() - t0 < 30:
    status = get_call_status(callId)
    print(f'Call status: "{status}"')

    # call was answered
    if status == 'ongoing':
        break

    # check again later
    time.sleep(1)

# play the message
time.sleep(0.5)
play_message(callId, message+',') # comma after message introduces a pause between loops