Mimecast

file="/root/.Mimecast-API.crd"
username="$(grep username "${file}" | sed s/^username=//)"
password="$(grep password "${file}" | sed s/^password=//)"

# Get token.
baseuri="https://api.services.mimecast.com"
response="$(curl \
  --data-urlencode "client_id=${username}" \
  --data-urlencode "client_secret=${password}" \
  --data-urlencode "grant_type=client_credentials" \
  --header "Content-Type: application/x-www-form-urlencoded" \
  --location \
  --request POST \
  --silent \
  "${baseuri}/oauth/token" \
)"
token="$(echo ${response} | sed -e "s/\",.*$//" | sed -e "s/^.*\"//")"

# Send to single recipient.
data="{'data': [ {
  'plainBody':{
    'id':'47',
    'content':'Hello World'
  },
  'subject':'Hello World',
  'to': [ {
    'displayableName':'SMRU-IT',
    'emailAddress':'smru-it@shoklo-unit.com'
  } ]
} ] }"

# Send to multiple recipients.
data="{
  'data': [
    {
      'plainBody': {
        'id': '99',
        'content': 'Testing mail to multiple users using curl with Mimecast API'
      },
      'subject': 'Testing mail to multiple users using curl',
      'to': [
        {
          'displayableName': 'Seeminthu',
          'emailAddress': 'seeminthu@bhf-th.org'
        },
        {
          'displayableName': 'Douwe',
          'emailAddress': 'douwe@shoklo-unit.com'
        }
      ]
    }
  ]
}"




# See https://developer.services.mimecast.com/docs/cloudgateway/1/routes/api/file/file-upload/post
# See https://integrations.mimecast.com/documentation/endpoint-reference/email/file-upload
# See https://stackoverflow.com/questions/64250379/mimecast-api-send-attachment
# See https://developer.services.mimecast.com/api-1-0-to-2-0-migration-guide
response="$(curl \
  --compressed \
  --header "Authorization: Bearer ${token}" \
  --header "Accept: application/json" \
  --request POST \
  --silent \
  "${baseuri}/api/file/file-upload" \
)"
echo "${response}"

# Send with an attachment (text file).
# Send with an attachment (binary file).
# See https://developer.services.mimecast.com/docs/cloudgateway/1/routes/api/file/file-upload/post
# See https://developer.services.mimecast.com/docs/cloudgateway/1/routes/api/email/send-email/post
file="/etc/hosts"
#file="/usr/bin/bdftruncate"
basename="$(basename "${file}")"
size="$(stat --printf="%s" "${file}")"
content="$(cat "${file}")"
content="$(base64 $file)"
data="{'data': [ {
  'attachments': [ {
    'size':${size},
    'filename':'${basename}',
    'content':'${content}',
    'contentDisposition':'attachment; filename=${basename}',
    'contentTransferEncoding':'base64',
    'contentType':'application/octet-stream; name=${basename}',
    'id':'53'
  } ],
  'plainBody':{
    'id':'47',
    'content':'Hello World'
  },
  'subject':'Hello World with attachment',
  'to': [ {
    'displayableName':'Douwe',
    'emailAddress':'douwe@shoklo-unit.com'
  } ]
} ] }"

response="$(curl \
  --compressed \
  --data "${data}" \
  --header "Authorization: Bearer ${token}" \
  --header "Accept: application/json" \
  --header "Content-Type: application/json" \
  --request POST \
  --silent \
  "${baseuri}/api/email/send-email" \
)"
echo "${response}"

$BaseUri = "https://api.services.mimecast.com"
$Credentials = Receive-Credentials "Mimecast-API"
$Username = $Credentials.GetNetworkCredential().Username
$Password = $Credentials.GetNetworkCredential().Password

# Get token.
$Body = "client_id=$Username&client_secret=$Password&grant_type=client_credentials"
$Headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]"
$Headers.Add("Content-Type", "application/x-www-form-urlencoded")
$Method = "POST"
$Uri = "$BaseUri/oauth/token"
$Response = Invoke-RestMethod -Body $Body -Headers $Headers -Method $Method -Uri $Uri
$Token = $Response.access_token

$From = "apc77@shoklo-unit.com"
# Send to single recipient.
$Body = "{'data': [
  {
    'plainBody': {
      'id': '47',
      'content': 'Hello World'
    },
    'subject': 'Hello World',
    'to': [
      {
        'displayableName': 'SMRU-IT',
        'emailAddress': 'smru-it@shoklo-unit.com'
      }
    ]
  }
] }"

# Send to multiple recipients.
$Body = "{'data': [
  {
    'plainBody': {
      'id': '99',
      'content': 'Testing mail to multiple users using PowerShell with Mimecast API'
    },
    'subject': 'Testing mail to multiple users using PowerShell',
    'froom': $From,
    'to': [
      {
        'displayableName': 'Seeminthu',
        'emailAddress': 'seeminthu@bhf-th.org'
      },
      {
        'displayableName': 'Douwe',
        'emailAddress': 'douwe@shoklo-unit.com'
      }
    ]
  }
] }"

$Headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]"
$Headers.Add("Authorization", "Bearer $Token")
$Headers.Add("Accept", "application/json")
$Headers.Add("Content-Type", "application/json")
$Uri = "$BaseUri/api/email/send-email"
$Response = Invoke-RestMethod -Body $Body -Headers $Headers -Method $Method -Uri $Uri
$Response
$Response.fail

# Send with attachment less than 5 MB.
# Note: When the content contains one or more single quotes, it fails with an "Invalid payload" error message.
$Path = "${Env:SystemRoot}\System32\drivers\etc\hosts"
#$Path = "${Env:SystemRoot}\System32\drivers\etc\hosts.tst"
$Name = (Get-Item $Path).Name
$Size = (Get-Item $Path).Length
$Content = Get-Content -Path $Path -Raw
$Content = Get-Content -Encoding "Byte" -Path $Path -Raw        # PowerShell 5.1.
$Content = "aaa bbb 127.0.0.1 ccc"
$Content = "aaa bbb 127.0.0.1 ccc`r`nddd"

#$Text = 'This is a secret and should be hidden'
#$Bytes = [System.Text.Encoding]::Unicode.GetBytes($Text)
$Bytes = Get-Content -Encoding "Byte" -Path $Path -Raw  # PowerShell 5.1.
$Content = [Convert]::ToBase64String($Bytes)
#$Content


$Body = "{'data': [
  {
    'attachments': [
      {
        'content': '$Content',
        'filename': '$Name',
        'size': $Size
      }
    ],
    'plainBody': {
      'id': '53',
      'content': 'Hello World'
    },
    'subject': 'Hello World',
    'to': [
      {
        'displayableName': 'SMRU-IT',
        'emailAddress': 'smru-it@shoklo-unit.com'
      }
    ]
  }
] }"

$Headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]"
$Headers.Add("Authorization", "Bearer $Token")
$Headers.Add("Accept", "application/json")
$Headers.Add("Content-Type", "application/json")
$Uri = "$BaseUri/api/email/send-email"
$Response = Invoke-RestMethod -Body $Body -Headers $Headers -Method $Method -Uri $Uri
$Response
$Response.fail

# Send with attachment greater than 5 MB.
$Path = "${Env:SystemRoot}\System32\drivers\etc\hosts"
$Name = (Get-Item $Path).Name
$Size = (Get-Item $Path).Length
$FileHash = Get-FileHash -Path $Path

<#
#Generate request header values
#$hdrDate = (Get-Date).ToUniversalTime().ToString("ddd, dd MMM yyyy HH:mm:ss UTC")
#$requestId = [guid]::NewGuid().guid
#Create the HMAC SHA1 of the Base64 decoded secret key for the Authorization header
$sha = New-Object System.Security.Cryptography.HMACSHA1
$sha.key = [Convert]::FromBase64String($secretKey)
$sig = $sha.ComputeHash([Text.Encoding]::UTF8.GetBytes($hdrDate + ":" + $requestId + ":" + $uri + ":" + $appKey))
$sig = [Convert]::ToBase64String($sig)
# Generate sha256 of file to upload.
$fileSize = Get-Item $filename
$fileSize = $fileSize.length
#Create Headers
$Headers = @{"Authorization" = "MC " + $accessKey + ":" + $sig;
                "x-mc-date" = $hdrDate;
                "x-mc-app-id" = $appId;
                "x-mc-req-id" = $requestId;
                "Content-Type" = "application/octet-stream";
                "x-mc-arg" = "{'data': [{'sha256': '" + $FileHash.Hash + "', 'fileSize': " + $Size + "}]}";
                }
#>

$Body = Get-Content -Encoding "Byte" -Path $Path -Raw   # PowerShell 5.1.

$Headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]"
$Headers.Add("Authorization", "Bearer $Token")
#$Headers.Add("Accept", "application/json")
$Headers.Add("Content-Type", "application/octet-stream")
$Headers.Add("x-mc-arg", "{'data': [{'sha256': '" + $FileHash.Hash + "', 'fileSize': " + $Size + "}]}")
# In order to successfully use this endpoint the role assigned to the app must have at least the following level of application permissions granted Account | Dashboard | Read.
$Uri = "$BaseUri/api/file/file-upload"
$Response = Invoke-RestMethod -Body $Body -Headers $Headers -Method $Method -Uri $Uri


$Response
$Response.fail

$Body = "{'data': [
  {
    'attachments': [
      {
        'filename': '$Name',
        'id': '$Id',
        'size': $Size
      }
    ],
    'plainBody': {
      'id': '53',
      'content': 'Hello World'
    },
    'subject': 'Hello World',
    'to': [
      {
        'displayableName': 'SMRU-IT',
        'emailAddress': 'smru-it@shoklo-unit.com'
      }
    ]
  }
] }"

$Headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]"
$Headers.Add("Authorization", "Bearer $Token")
$Headers.Add("Accept", "application/json")
$Headers.Add("Content-Type", "application/json")
$Uri = "$BaseUri/api/email/send-email"
$Response = Invoke-RestMethod -Body $Body -Headers $Headers -Method $Method -Uri $Uri
$Response
$Response.fail

python3
# Do your thing.
exit()
quit()

import hashlib, json, os, requests, uuid

def get_token(file):
  with open(file, "r") as f:
    username = f.readline().strip()
    password = f.readline().strip()
    username = username.replace("username=", "")
    password = password.replace("password=", "")
  url = base + "/oauth/token"
  headers = { 'Content-Type': 'application/x-www-form-urlencoded' }
  payload = "client_id=" + username + "&client_secret=" + password + "&grant_type=client_credentials"
  response = json.loads(requests.request("POST", url, headers=headers, data=payload).text)
  return response['access_token']

def get_hash(file):
  # Incrementally generate a SHA256 hash, to support larger files.
  # More memory efficient than doing it in a single block.
  sha256 = hashlib.sha256()
  with open(file, "rb") as f:
    for block in iter(lambda: f.read(4096), b""):
      sha256.update(block)
  return sha256.hexdigest()

def get_upload_url(token, hash, size):
  url = base + "/api/file/file-upload"
  headers = { "x-request-id": str(uuid.uuid4()), "Authorization": "Bearer " + token, "Accept": "application/json" }
  body = { "data": [ { "sha256": hash, "fileSize": size } ] }
  response = requests.request("POST", url, headers=headers, json=body).json()
  return response['data'][0]['urls'][0]

def upload_file(url, file, token):
  headers = {
    "x-request-id": str(uuid.uuid4()),
    "Content-Type": "application/octet-stream",
    "Accept": "application/json",
    "Authorization": "Bearer " + token
  }
  with open(file, "rb") as f:
    response = requests.request("PUT", url, headers=headers, data=f.read())
    return response.json()["id"]

def send_email(recipient, subject, body, id, size, file, token):
  url = base + "/api/email/send-email"
  body = {
    "data": [
      {
        "attachments": [
          {
            "size": size,
            "id": id,
            "filename": os.path.basename(file)
          }
        ]
        "plainBody": {
          "id": "47",
          "content": body
        },
        "subject": subject,
        "to": [
          {
            "emailAddress": recipient,
          }
        ],
      }
    ]
  }
  headers = {
    "Authorization": f"Bearer {token}",
    "Accept": "application/json",
    "Content-Type": "application/json"
  }
  response = requests.post(url, headers=headers, json=body)
  return response.text

base = "https://api.services.mimecast.com"

# Get token.
token = get_token("/root/.Mimecast-API.crd")

# Get file hash and size.
file = "/etc/hosts"
hash = get_hash(file)
size = str(os.path.getsize(file))

# Generate new upload URL.
url = get_upload_url(token, hash, size)

# Put file to given url and return id.
id = upload_file(url, file, token)

# Send email.
recipient = "douwe@shoklo-unit.com"
subject = "Test 01"
body = "Hello world"
send_email(recipient, subject, body, id, size, file, token)

# See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition
# See https://en.wikipedia.org/wiki/MIME
# See https://pro2col.com/blog/automate-file-transfers-like-an-expert-with-powershell-google-cloud

def execute(file, recipient, sender, subject, token, url):
  size = str(os.path.getsize(file))
  with open(file, "rb") as f:
    data=f.read()
  code = base64.b64encode(data)
  content = code.decode("ascii")
  body = {
    "data": [
      {
        "subject": subject,
        #"from": { "emailAddress": sender, "displayableName": "Python" },
        "from": { "emailAddress": sender, "displayableName": "Relay" },
        #"from": { "emailAddress": sender },
        "to": [ { "emailAddress": recipient, } ],
        "attachments": [
          {
            "size": size,
            "content": content,
            "contentDisposition": "attachment",
            "contentId": "",
            "contentTransferEncoding": "base64",
            "contentType": "image/jpeg",
            "extraHeaders": [
              {
                "name": "",
                "value": ""
              }
            ],
            "filename": os.path.basename(file)
          }
        ]
      }
    ]
  }
  headers = {
    "Authorization": "Bearer " + token,
    "Accept": "application/json",
    "Content-Type": "application/json"
  }
  response = requests.post(url, headers=headers, json=body)
  return response.text

# See https://www.example-code.com/powershell/mime_content_transfer_encoding.asp

content = '/9j/4AAQSkZJRgABAQEASABIAAD//gAmRmlsZSB3cml0dGVuIGJ5IEFkb2JlIFBob3Rvc2hvcD8g\
NC4w/9sAQwAQCwwODAoQDg0OEhEQExgoGhgWFhgxIyUdKDozPTw5Mzg3QEhcTkBEV0U3OFBtUVdf\
YmdoZz5NcXlwZHhcZWdj/9sAQwEREhIYFRgvGhovY0I4QmNjY2NjY2NjY2NjY2NjY2NjY2NjY2Nj\
Y2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2Nj/8IAEQgAFAAUAwERAAIRAQMRAf/EABcAAAMBAAAA\
AAAAAAAAAAAAAAIDBAX/xAAYAQADAQEAAAAAAAAAAAAAAAABAgMEAP/aAAwDAQACEAMQAAAB2kZY\
NNEijWKddfTmLgALWH//xAAbEAACAgMBAAAAAAAAAAAAAAABAgMRAAQSE//aAAgBAQABBQL0XqN+\
pM2aqJGMiqFFCyg7z//EABwRAAICAgMAAAAAAAAAAAAAAAERAAIQIQMSUf/aAAgBAwEBPwHqU5aq\
Axx+y1tMQl4elj//xAAcEQEAAQUBAQAAAAAAAAAAAAABEQACEBIhA1H/2gAIAQIBAT8B3Bhqy7Zc\
enyiwmGgDhiOzj//xAAdEAABAwUBAAAAAAAAAAAAAAABAAIREBIhIkFR/9oACAEBAAY/ArZyn+Cg\
xtxWuJaoCnqDuin/xAAcEAABBAMBAAAAAAAAAAAAAAABABEhYRAxQVH/2gAIAQEAAT8hkEwPUUR9\
DYfE4nxtRpIkBTsayuALIiuY/9oADAMBAAIAAwAAABDWPTsf/8QAGhEAAwADAQAAAAAAAAAAAAAA\
AAEREDFBIf/aAAgBAwEBPxC0DVPcWm+Ce4OesrkE6bjH/8QAGBEBAQEBAQAAAAAAAAAAAAAAAREA\
QRD/2gAIAQIBAT8QahMiOc8YgSrnTY3ELclHXn//xAAcEAEBAAIDAQEAAAAAAAAAAAABEQAhMUFx\
EFH/2gAIAQEAAT8Qn3igmSZSj+c4N4zapMy9IjFV98wncN2iuLFsCEbDGxQkI6RO/n//2Q=='

import base64
code = base64.b64decode(content)
newFile = open("/tmp/filename.jpg", "wb")
newFile.write(code)
newFile.close()

file = "/tmp/Fryslan.jpg"
size = str(os.path.getsize(file))
with open(file, "rb") as f:
  data=f.read()
content = base64.b64encode(data)

#content = "Somewhere"
file = "/tmp/Fryslan.jpg"
recipient = "douwe@shoklo-unit.com"
sender = "douwe@shoklo-unit.com"
sender = "powershell@shoklo-unit.com"
sender = "relay@shoklo-unit.com"
sender = "api-77fdda1b-2c30-46b2-818a-a807c92cb49a@shoklo-unit.com"
subject= "Test 1 on 2025-01-09"
token = get_token("/root/.Mimecast-API.crd")
url = "https://api.services.mimecast.com/api/email/send-email"
execute(file, recipient, sender, subject, token, url)
#execute(code, recipient, sender, subject, token, url)

# From is not in the permitted addresses (primary, alias and alternates)

def send_email0(recipient, subject, body, content, size, file, token):
  url = base + "/api/email/send-email"
  body = {
    "data": [
      {
        "attachments": [
          {
            "size": size,
            "content": content,
            "filename": os.path.basename(file)
          }
        ]
        "plainBody": {
          "id": "47",
          "content": body
        },
        "subject": subject,
        "to": [
          {
            "emailAddress": recipient,
          }
        ],
      }
    ]
  }
  headers = {
    "Authorization": f"Bearer {token}",
    "Accept": "application/json",
    "Content-Type": "application/json"
    #"Content-Type": "application/octet-stream",
  }
  response = requests.post(url, headers=headers, json=body)
  return response.text

base = "https://api.services.mimecast.com"

# Get token.
token = get_token("/root/.Mimecast-API.crd")

# Get file hash and size.
file = "/etc/hosts"
hash = get_hash(file)
size = str(os.path.getsize(file))

content = "Hello Douwe"
with open(file, "rb") as f:
  content=f.read()

# Send email.
recipient = "douwe@shoklo-unit.com"
subject = "Test 01"
body = "Hello world"
send_email0(recipient, subject, body, content, size, file, token)

import base64, json, os, requests

def get_token(file):
  with open(file, "r") as f:
    username = f.readline().strip()
    password = f.readline().strip()
    username = username.replace("username=", "")
    password = password.replace("password=", "")
  url = "https://api.services.mimecast.com/oauth/token"
  headers = { 'Content-Type': 'application/x-www-form-urlencoded' }
  payload = "client_id=" + username + "&client_secret=" + password + "&grant_type=client_credentials"
  response = json.loads(requests.request("POST", url, headers=headers, data=payload).text)
  return response['access_token']

def send_email(file, recipient, sender, subject, token, url):
  size = str(os.path.getsize(file))
  with open(file, "rb") as f:
    data=f.read()
  code = base64.b64encode(data)
  content = code.decode("ascii")
  body = {
    "data": [
      {
        "subject": subject,
        "to": [ { "emailAddress": recipient, } ],
        "attachments": [
          {
            "size": size,
            "content": content,
            #"contentDisposition": "attachment",
            "contentDisposition": form-data; name="encoded_image"; filename="$FileName"
            "contentId": "",
            "contentTransferEncoding": "base64",
            "contentType": "image/jpeg",
            "extraHeaders": [
              {
                "name": "",
                "value": ""
              }
            ],
            "filename": os.path.basename(file)
          }
        ]
      }
    ]
  }
  headers = {
    "Authorization": "Bearer " + token,
    "Accept": "application/json",
    "Content-Type": "application/json"
  }
  response = requests.post(url, headers=headers, json=body)
  return response.text

file = "/tmp/Fryslan.jpg"
recipient = "douwe@shoklo-unit.com"
recipient = "customerreply@mimecast.com"
recipient = "aturcotte@mimecast.com"
sender = "relay@shoklo-unit.com"
subject= "Test 3 on 2025-01-09"
subject= "RE: Case #01356424 Created: Send email with attachment using Mimecast API"
token = get_token("/root/.Mimecast-API.crd")
url = "https://api.services.mimecast.com/api/email/send-email"
send_email(file, recipient, sender, subject, token, url)

$BaseUri = "https://api.services.mimecast.com"
$Credentials = Receive-Credentials "Mimecast-API"
$Username = $Credentials.GetNetworkCredential().Username
$Password = $Credentials.GetNetworkCredential().Password

# Get token.
$Body = "client_id=$Username&client_secret=$Password&grant_type=client_credentials"
$Headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]"
$Headers.Add("Content-Type", "application/x-www-form-urlencoded")
$Method = "POST"
$Uri = "$BaseUri/oauth/token"
$Response = Invoke-RestMethod -Body $Body -Headers $Headers -Method $Method -Uri $Uri
$Token = $Response.access_token

$Body = "{'data': [
 {
   'htmlBody': {
     'id': '99',
     'content': 'Hello World <html'
   },
   'subject': 'Test A htmlBody: FAIL',
   'to': [
           {
       'displayableName': 'Douwe Kiestra',
       'emailAddress': 'douwe@shoklo-unit.com'
     }
   ]
 }
] }"

$Body = "{'data': [
 {
   'plainBody': {
     'id': '99',
     'content': 'Hello World <html'
   },
   'subject': 'Test B plainBody: FAIL',
   'to': [
           {
       'displayableName': 'Douwe Kiestra',
       'emailAddress': 'douwe@shoklo-unit.com'
     }
   ]
 }
] }"

$Body = "{'data': [
 {
   'plainBody': {
     'id': '99',
     'content': 'Hello World <htm'
   },
   'subject': 'Test C plainBody: PASS',
   'to': [
           {
       'displayableName': 'Douwe Kiestra',
       'emailAddress': 'douwe@shoklo-unit.com'
     }
   ]
 }
] }"

$Headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]"
$Headers.Add("Authorization", "Bearer $Token")
$Headers.Add("Accept", "application/json")
$Headers.Add("Content-Type", "application/json")
$Uri = "$BaseUri/api/email/send-email"
$Response = Invoke-RestMethod -Body $Body -Headers $Headers -Method $Method -Uri $Uri
$Response
$Response.fail

python3
# Do your thing.
exit()
quit()

import hashlib, json, os, requests, uuid

def get_token(file):
  with open(file, "r") as f:
    username = f.readline().strip()
    password = f.readline().strip()
    username = username.replace("username=", "")
    password = password.replace("password=", "")
  url = base + "/oauth/token"
  headers = { 'Content-Type': 'application/x-www-form-urlencoded' }
  payload = "client_id=" + username + "&client_secret=" + password + "&grant_type=client_credentials"
  response = json.loads(requests.request("POST", url, headers=headers, data=payload).text)
  return response['access_token']

def send_email(recipient, subject, body, id, token):
  url = base + "/api/email/send-email"
  body = {
    "data": [
      {
        "htmlBody": {
          "id": "47",
          "content": body
        },
        "subject": subject,
        "to": [
          {
            "emailAddress": recipient,
          }
        ],
      }
    ]
  }
  headers = {
    "Authorization": f"Bearer {token}",
    "Accept": "application/json",
    "Content-Type": "application/json"
  }
  response = requests.post(url, headers=headers, json=body)
  return response.text

def send_email2(recipient, subject, body, id, token):
  url = base + "/api/email/send-email"
  body = {
    "data": [
      {
        "plainBody": {
          "id": "47",
          "content": body
        },
        "subject": subject,
        "to": [
          {
            "emailAddress": recipient,
          }
        ],
      }
    ]
  }
  headers = {
    "Authorization": f"Bearer {token}",
    "Accept": "application/json",
    "Content-Type": "application/json"
  }
  response = requests.post(url, headers=headers, json=body)
  return response.text

base = "https://api.services.mimecast.com"

# Get token.
token = get_token("/root/.Mimecast-API.crd")

# Send email.
recipient = "douwe@shoklo-unit.com"
subject = "Test 01"
body = "Hello world <htm"
send_email(recipient, subject, body, id, token)
send_email2(recipient, subject, body, id, token)

# Send email.
recipient = "douwe@shoklo-unit.com"
subject = "Test 01"
body = "Hello world <html"
send_email(recipient, subject, body, id, token)
send_email2(recipient, subject, body, id, token)