Create Address Alteration Definition

POST {base_url}/api/policy/address-alteration/create-definition
    Authorization: MC {accesskKey}:{Base64 encoded signed Data To Sign}
    x-mc-date: {dateTime}
    x-mc-req-id: {unique id}
    x-mc-app-id: {applicationId}
    Content-Type: application/json
    Accept: application/json
    
    
    {
      "data":[
        {
            "folderId": "String",
            "addressAlterations": [
                {
                    "routing": "String",
                    "originalAddress": "String",
                    "addressType": "String",
                    "newAddress": "String"
                }
            ]
        }
      ]
    }
    

import base64
    import hashlib
    import hmac
    import uuid
    import datetime
    import requests
    
    # Setup required variables
    base_url = "https://xx-api.mimecast.com"
    uri = "/api/policy/address-alteration/create-definition"
    url = base_url + uri
    access_key = "YOUR ACCESS KEY"
    secret_key = "YOUR SECRET KEY"
    app_id = "YOUR APPLICATION ID"
    app_key = "YOUR APPLICATION KEY"
    
    # Generate request header values
    request_id = str(uuid.uuid4())
    hdr_date = datetime.datetime.utcnow().strftime("%a, %d %b %Y %H:%M:%S") + " UTC"
    
    # DataToSign is used in hmac_sha1
    dataToSign = ':'.join([hdr_date, request_id, uri, app_key])
    
    # Create the HMAC SHA1 of the Base64 decoded secret key for the Authorization header
    hmac_sha1 = hmac.new(base64.b64decode(secret_key), dataToSign.encode(), digestmod=hashlib.sha1).digest()
    
    # Use the HMAC SHA1 value to sign the hdrDate + ":" requestId + ":" + URI + ":" + appkey
    sig = base64.b64encode(hmac_sha1).rstrip()
    
    # Create request headers
    headers = {
        'Authorization': 'MC ' + access_key + ':' + sig.decode(),
        'x-mc-app-id': app_id,
        'x-mc-date': hdr_date,
        'x-mc-req-id': request_id,
        'Content-Type': 'application/json'
    }
    
    payload = {
            'data': [
                {
                    "folderId": "String",
                    "addressAlterations": [
                        {
                            "routing": "String",
                            "originalAddress": "String",
                            "addressType": "String",
                            "newAddress": "String"
                        }
                    ]
                }
            ]
        }
    
    r = requests.post(url=url, headers=headers, data=str(payload))
    
    print(r.text)

static void Main(string[] args)
            {
                //Setup required variables
                string baseUrl = "https://xx-api.mimecast.com";
                string uri = "/api/policy/address-alteration/create-definition";
                string accessKey = "YOUR ACCESS KEY";
                string secretKey = "YOUR SECRET KEY";
                string appId = "YOUR APPLICATION ID";
                string appKey = "YOUR APPLICATION KEY";
    
                //Generate request header values
                string hdrDate = System.DateTime.Now.ToUniversalTime().ToString("R");
                string requestId = System.Guid.NewGuid().ToString();
    
                //Create the HMAC SHA1 of the Base64 decoded secret key for the Authorization header
                System.Security.Cryptography.HMAC h = new System.Security.Cryptography.HMACSHA1(System.Convert.FromBase64String(secretKey));
    
                //Use the HMAC SHA1 value to sign the hdrDate + ":" requestId + ":" + URI + ":" + appkey
                byte[] hash = h.ComputeHash(System.Text.Encoding.Default.GetBytes(hdrDate + ":" + requestId + ":" + uri + ":" + appKey));
    
                //Build the signature to be included in the Authorization header in your request
                string signature = "MC " + accessKey + ":" + System.Convert.ToBase64String(hash);
    
                //Build Request
                System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(baseUrl + uri);
                request.Method = "POST";
                request.ContentType = "application/json";
    
                //Add Headers
                request.Headers[System.Net.HttpRequestHeader.Authorization] = signature;
                request.Headers.Add("x-mc-date", hdrDate);
                request.Headers.Add("x-mc-req-id", requestId);
                request.Headers.Add("x-mc-app-id", appId);
    
                //Add request body
                //Create and write data to stream
                string postData = @"{
                        ""data"": [
                            {
                                ""folderId"": ""String"",
                                ""addressAlterations"": [
                                    {
                                        ""routing"": ""String"",
                                        ""originalAddress"": ""String"",
                                        ""addressType"": ""String"",
                                        ""newAddress"": ""String""
                                    }
                                ]
                            }
                        ]
                    }";
    
                byte[] payload = System.Text.Encoding.UTF8.GetBytes(postData);
    
                System.IO.Stream stream = request.GetRequestStream();
                stream.Write(payload, 0, payload.Length);
                stream.Close();
    
                //Send Request
                System.Net.HttpWebResponse response = (System.Net.HttpWebResponse)request.GetResponse();
    
                //Output response to console
                System.IO.StreamReader reader = new System.IO.StreamReader(response.GetResponseStream());
                string responseBody = "";
                string temp = null;
                while ((temp = reader.ReadLine()) != null)
                {
                    responseBody += temp;
                };
                System.Console.WriteLine(responseBody);
                System.Console.ReadLine();
            }

#Setup required variables
    $baseUrl = "https://xx-api.mimecast.com"
    $uri = "/api/policy/address-alteration/create-definition"
    $url = $baseUrl + $uri
    $accessKey = "YOUR ACCESS KEY"
    $secretKey = "YOUR SECRET KEY"
    $appId = "YOUR APPLICATION ID"
    $appKey = "YOUR APPLICATION KEY"
    
    #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)
    
    #Create Headers
    $headers = @{"Authorization" = "MC " + $accessKey + ":" + $sig;
                    "x-mc-date" = $hdrDate;
                    "x-mc-app-id" = $appId;
                    "x-mc-req-id" = $requestId;
                    "Content-Type" = "application/json"}
    
    #Create post body
    $postBody = "{
                        ""data"": [
                            {
                                ""folderId"": ""String"",
                                ""addressAlterations"": [
                                    {
                                        ""routing"": ""String"",
                                        ""originalAddress"": ""String"",
                                        ""addressType"": ""String"",
                                        ""newAddress"": ""String""
                                    }
                                ]
                            }
                        ]
                    }"
    
    #Send Request
    $response = Invoke-RestMethod -Method Post -Headers $headers -Body $postBody -Uri $url
    
    #Print the response
    $response

public static void main(String[] args) throws java.io.IOException, java.security.NoSuchAlgorithmException, java.security.InvalidKeyException {
    
            //set up variables for request
            String baseUrl = "https://xx-api.mimecast.com";
            String uri = "/api/policy/address-alteration/create-definition";
            String url = "https://" + baseUrl + uri;
            String accessKey = "YOUR ACCESS KEY";
            String secretKey = "YOUR SECRET KEY";
            String appId = "YOUR APPLICATION ID";
            String appKey = "YOUR APPLICATION KEY";
    
            //create URL object
            java.net.URL obj = new java.net.URL(url);
    
            // set guid for x-mc-req-id header
            String guid = java.util.UUID.randomUUID().toString();
    
            // set date for x-mc-date header
            java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("EEE, d MMM yyyy HH:mm:ss z");
            sdf.setTimeZone(java.util.TimeZone.getTimeZone("UTC"));
            String date = sdf.format(new java.util.Date());
    
            //create signature for the Authorization header
            String dataToSign = date + ":" + guid + ":" + uri + ":" + appKey;
            String hmacSHA1 = "HmacSHA1";
            javax.crypto.spec.SecretKeySpec signingKey = new javax.crypto.spec.SecretKeySpec(org.apache.commons.codec.binary.Base64.decodeBase64(secretKey.getBytes()), hmacSHA1);
            javax.crypto.Mac mac = javax.crypto.Mac.getInstance(hmacSHA1);
            mac.init(signingKey);
            String sig = new String(org.apache.commons.codec.binary.Base64.encodeBase64(mac.doFinal(dataToSign.getBytes())));
    
            // create request object
            javax.net.ssl.HttpsURLConnection con = (javax.net.ssl.HttpsURLConnection) obj.openConnection();
    
            //set request type to POST
            con.setRequestMethod("POST");
            con.setDoOutput(true);
    
            //add reuqest headers
            con.setRequestProperty("Authorization", "MC " + accessKey + ":" + sig);
            con.setRequestProperty("x-mc-req-id", guid);
            con.setRequestProperty("x-mc-app-id", appId);
            con.setRequestProperty("x-mc-date", date);
            con.setRequestProperty("Content-Type", "application/json");
            con.setRequestProperty("Accept", "application/json");
    
            //Add post body to the request
            String postBody = "{\n" +
            " \"data\": [\n" +
            "     {\n" +
            "         \"folderId\": \"String\",\n" +
            "         \"addressAlterations\": [\n" +
            "              \"routing\": \"String\",\n" +
            "              \"originalAddress\": \"String\",\n" +
            "              \"addressType\": \"String\",\n" +
            "              \"newAddress\": \"String\"\n" +
            "         ]\n" +
            "     }\n" +
            " ]\n" +
            "}";
            java.io.OutputStream os = con.getOutputStream();
            os.write(postBody.getBytes("UTF-8"));
            os.close();
    
            //process response
            java.io.BufferedReader in = new java.io.BufferedReader(
                    new java.io.InputStreamReader(con.getInputStream()));
            String inputLine;
            StringBuffer response = new StringBuffer();
    
            while ((inputLine = in.readLine()) != null) {
                response.append(inputLine);
            }
            in.close();
    
            //return result
            java.lang.System.out.println(response.toString());
        }