IBM Cloud Event Notifications Node.js SDK

Node.js client library to interact with various Event Notifications APIs.

Table of Contents

• Overview
• Prerequisites
• Installation
• Using the SDK
• Set Environment
• Questions
• Issues
• Open source @ IBM
• Contributing
• License

Overview

The IBM Cloud Event Notifications Node.js SDK allows developers to programmatically interact with the Event Notifications service in IBM cloud.

Service Name | Import Path --- | --- Event-Notifications | @ibm-cloud/event-notifications-node-admin-sdk/event-notifications/v1

Prerequisites

• You need an IBM Cloud account.
• Node.js >=14: This SDK is tested with Node.js versions 14 and up. It may work on previous versions but this is not officially supported.

Installation

npm install @ibm-cloud/event-notifications-node-admin-sdk

Using the SDK

For general SDK usage information, please see this link

Initialize SDK

Initialize the sdk to connect with your Event Notifications service instance.

import { EventNotificationsV1 } from '@ibm-cloud/event-notifications-node-admin-sdk/event-notifications/v1';
import { IamAuthenticator } from '@ibm-cloud/event-notifications-node-admin-sdk/auth';

const authenticator = new IamAuthenticator({
  apikey: <apikey>,  // Event notifications service instance APIKey
});

const initParameters = {
   authenticator,
  serviceUrl: "https://" + region + ".event-notifications.cloud.ibm.com/event-notifications"
}
const eventNotificationsService = EventNotificationsV1.newInstance(initParameters);

To configure service URL for Private Endpoint

If you enabled service endpoints in your account, you can send API requests over the IBM Cloud private network. In the initialisation, the base endpoint URLs of the IAM(authenticator) & Event Notification(service) should be modified to point to private endpoints.

1. Setting client options programmatically

const authenticator = new IamAuthenticator({
    apikey: <apikey>,  // Event notifications service instance APIKey
    url: "https://private.iam.cloud.ibm.com",
})

const initParameters = {
   authenticator,
  serviceUrl: "https://private." + region + ".event-notifications.cloud.ibm.com/event-notifications"
}

2. Using external configuration properties

   EVENT_NOTIFICATIONS_AUTH_URL = https://private.iam.cloud.ibm.com/identity/token

• region : Region of the Event Notifications Instance

Using the SDK

SDK Methods to consume

• Source
  • Create Source
  • List Sources
  • Get Source
  • Update Source
  • Delete Source
• Topics
  • Create Topics
  • List Topics
  • Get Topic
  • Update Topics
  • Delete Topics
• Destinations
  • Create Destination
  • List Destinations
  • Get Destination
  • Update Destination
  • Delete Destination
  • Custom Domain_Name_verification
  • Test Destination
• Templates
  • Create Template
  • List Templates
  • Get Template
  • Update Template
  • Delete Template
• Push Destination APIs
  • Create Destination tag subscription
  • List Destination tag subscription
  • Delete Destination device tag subscription
• Subscriptions
  • Create Subscription
  • List Subscriptions
  • Get Subscription
  • Update Subscription
  • Delete Subscription
• Integration
  • Create Integration
  • List Integrations
  • Get Integrations
  • Update Integration
• SMTP Configurations
  • Create SMTP Configuration
  • Create SMTP User
  • Get SMTP Configuration
  • Get SMTP User
  • Get SMTP Allowed Ips
  • List SMTP Configurations
  • List SMTP Users
  • Update SMTP Configuration
  • Update SMTP User
  • Delete SMTP User
  • Delete SMTP Configuration
  • Verify SMTP
• Metrics
  • Get Metrics
• Send Notifications

Source

Create Source

 const params = {
    instanceId: <instance-id>, // Event notifications service instance GUID
    name: '<source-name>',
    description: '<source-description>',
    enabled: false,
  };

  let res;
  try {
    res = await eventNotificationsService.createSources(params);
    console.log(JSON.stringify(res.result, null, 2));
    sourceId = res.result.id;
  } catch (err) {
    console.warn(err);
  }

List Sources

const params = {
  instanceId: <instance-id>, // Event notifications service instance GUID
};

eventNotificationsService
  .listSources(params)
  .then((res) => {
    console.log(JSON.stringify(res.result, null, 2));
  })
  .catch((err) => {
    console.warn(err);
  });

Get Source

const params = {
  instanceId: <instance-id>, // Event notifications service instance GUID
  id: <source-id>, // Event notifications service instance Source ID
};

eventNotificationsService
  .getSource(params)
  .then((res) => {
    console.log(JSON.stringify(res.result, null, 2));
  })
  .catch((err) => {
    console.warn(err);
  });

Update Source

const params = {
    instanceId: <instance-id>, // Event notifications service instance GUID
    id: <sourceId>,
    name: '<source-updated-name>',
    description: '<source-updated-description>',
    enabled: true,
  };

    let res;
    try {
      res = await eventNotificationsService.updateSource(params);
      console.log(JSON.stringify(res.result, null, 2));
    } catch (err) {
      console.warn(err);
    }

Delete Source

 const params = {
    instanceId: <instance-id>, // Event notifications service instance GUID
    id: <sourceId>,
  };

  try {
    await eventNotificationsService.deleteSource(params);
  } catch (err) {
    console.warn(err);
  }

Topics

Create Topic

// Rules
const rulesModel = {
  enabled: false,
  event_type_filter: "$.notification_event_info.event_type == 'cert_manager'", // Add your event type filter here.
  notification_filter: "$.notification.findings[0].severity == 'MODERATE'", // Add your notification filter here.
};

// TopicUpdateSourcesItem
const topicUpdateSourcesItemModel = {
  id: <source-id>,  // Event notifications service instance Source ID
  rules: [rulesModel],
};

const params = {
  instanceId: <instance-id>, // Event notifications service instance GUID
  name: <topic-name>,
  description: <topic-description>,
  sources: [topicUpdateSourcesItemModel],
};

eventNotificationsService
  .createTopic(params)
  .then((res) => {
    console.log(JSON.stringify(res.result, null, 2));
  })
  .catch((err) => {
    console.warn(err);
  });

List Topics

const params = {
  instanceId: <instance-id>,
};

eventNotificationsService
  .listTopics(params)
  .then((res) => {
    console.log(JSON.stringify(res.result, null, 2));
  })
  .catch((err) => {
    console.warn(err);
  });

Get Topic

const params = {
  instanceId: <instance-id>,
  id: <topic-id>,
};

eventNotificationsService
  .getTopic(params)
  .then((res) => {
    console.log(JSON.stringify(res.result, null, 2));
  })
  .catch((err) => {
    console.warn(err);
  });

Update Topic

// Rules
const rulesModel = {
  enabled: true,
  event_type_filter: "$.notification_event_info.event_type == 'cert_manager'", // Add your event type filter here.
  notification_filter: "$.notification.findings[0].severity == 'MODERATE'",  // Add your notification filter here.
};

// TopicUpdateSourcesItem
const topicUpdateSourcesItemModel = {
  id: <source-id>,
  rules: [rulesModel],
};

const params = {
  instanceId: <instance-id>,
  id: <topic-id>,
  name: <topic-update-name>,
  sources: [topicUpdateSourcesItemModel],
};

eventNotificationsService
  .replaceTopic(params)
  .then((res) => {
    console.log(JSON.stringify(res.result, null, 2));
  })
  .catch((err) => {
    console.warn(err);
  });

Delete Topic

const params = {
  instanceId : <instance-id>,
  id : <topic-id>,
}  

eventNotificationsService
.deleteTopic(params)
.then(res => {
  console.log(JSON.stringify(res.result, null, 2));
})
  .catch(err => {
    console.warn(err);
  });

Destinations

Create Destination

 // DestinationConfigParamsWebhookDestinationConfig
   const destinationConfigParamsModel = {
    url: <destination-config-url>,
    verb: <destination-config-verb>,
    custom_headers: {  <header-key>: <header-value> },
    sensitive_headers: [<header-key>],
  };

  // DestinationConfig
  const destinationConfigModel = {
    params: destinationConfigParamsModel,
  };

  const params = {
    instanceId: <instance-id>,
    name: <destination-name>,
    type: <destination-type>,
    description: <destination-description>,
    config: destinationConfigModel,
  };

 eventNotificationsService.createDestination(params)
 .then(res => {
  console.log(JSON.stringify(res.result, null, 2));
})
  .catch(err => {
    console.warn(err);
  });

Among the supported destinations, if you need to create Push Notification destinations, you have the additional option of choosing a destination of production type or pre-production type. Set pre_prod boolean parameter to true to configure destination as pre-production destination else set the value as false. Supported destinations are Android, iOS, Chrome, Firefox and Safari.

List Destinations

const params = {
  instanceId : <instance-id>,
}

eventNotificationsService.listDestinations(params)
 .then(res => {
  console.log(JSON.stringify(res.result, null, 2));
})
.catch(err => {
    console.warn(err);
});

Get Destination

const params = {
  instanceId : <instance-id>,
  id : <destination-id>,
}

eventNotificationsService
.getDestination(params)
.then(res => {
  console.log(JSON.stringify(res.result, null, 2));
})
.catch(err => {
  console.warn(err);
});

Update Destination

// DestinationConfigParamsWebhookDestinationConfig
const destinationConfigParamsModel = {
  url:  <destination-config-update-url>,
  verb: <destination-config-update-verb>,
  custom_headers: { <header-key>: <header-value> },
  sensitive_headers: [<header-key>],
};

// DestinationConfig
const destinationConfigModel = {
  params: destinationConfigParamsModel,
};
const params = {
  instanceId: <instance-id>,
  id: <destination-id>,
  name: <destination-update-name>,
  description: <destination-update-description>,
  config: destinationConfigModel,
};

eventNotificationsService.updateDestination(params)
.then(res => {
  console.log(JSON.stringify(res.result, null, 2));
})
  .catch(err => {
    console.warn(err);
  });

Delete Destination

const params = {
  instanceId : <instance-id>,
  id : <destination-id>,
}
eventNotificationsService
.deleteDestination(params)
.then(res => {
  console.log(JSON.stringify(res.result, null, 2));
})
  .catch(err => {
    console.warn(err);
  });

Test Destination

This functionality allows you to test a destination. The feature simplifies the process of verifying whether a destination is functioning correctly. Currently, this functionality supports following destinations:

1. Slack
2. PagerDuty
3. ServiceNow
4. Microsoft® Teams
5. IBM Cloud Code Engine
6. IBM Cloud Object Storage

const testDestinationParams = {
  instanceId : <instance-id>, // Event notifications service instance GUID
  id : <destination-id>,     	// Event notifications service instance Destination ID
};
try {
  const testDestinationResult = await eventNotificationsService.testDestination(testDestinationParams);
  console.log(JSON.stringify(testDestinationResult.result, null, 2));
} catch (err) {
  console.warn(err);
}

Once the test is completed, you will be presented with the results. These results will typically include:

• Status: Whether the test is successful or failed
• Response Code: If test fails, then the response code sent from the end destination client is returned
• Response Message: If test fails, then the response message sent from the end destination client is returned

Custom Domain Name Verification

After creation of the custom email destination with your domain name, make sure its validated for the right ownership. This can be done with SPF and DKIM verification.

• Sender Policy Framework (SPF), which is used to authenticate the sender of an email. SPF specifies the mail servers that are allowed to send email for your domain.
• DomainKeys Identified Mail (DKIM), which allows an organization to take responsibility for transmitting a message by signing it. DKIM allows the receiver to check the email that claimed to have come from a specific domain, is authorized by the owner of that domain.

const updateSpfVerifyDestinationParams = {
    instanceId : <instance-id>,
    id : <destination-id>,
    type: <verification-type>,
  };

  let res;
  try {
    res = await eventNotificationsService.updateVerifyDestination(
      updateSpfVerifyDestinationParams
    );
    console.log(JSON.stringify(res.result, null, 2));
  } catch (err) {
    console.warn(err);
  }

Templates

Template is a pre-defined layout, that may include content like images, text and dynamic content based on event. Rather than creating a new content from scratch each time, you can use a template as a base and configure them in subscription. supports the following templates:

• Custom Email notification
• Custom Email invitation

Create Template

Custom Email Template

const templateConfigModel = {
  params: {
    body: 'base 64 encoded html contents',
    subject: 'Hi this is invitation for invitation message',
},
};
let createTemplateParams = {
  instanceId: <instance-id>,
  name: <template-name>,
  type: <template-type>,
  templateConfigModel,
  description: <template-description>,
};
let createTemplateResult;
try {
  createTemplateResult = await eventNotificationsService.createTemplate(createTemplateParams);
  console.log(JSON.stringify(createTemplateResult.result, null, 2));
} catch (err) {
  console.warn(err);
}

For custom email supported template type values: smtp_custom.invitation, smtp_custom.notification

Slack Template

const templateConfigModel = {
  params: {
    body: 'base 64 encoded json body',
},
};
let createTemplateParams = {
  instanceId: <instance-id>,
  name: <template-name>,
  type: <template-type>,
  templateConfigModel,
  description: <template-description>,
};
let createTemplateResult;
try {
  createTemplateResult = await eventNotificationsService.createTemplate(createTemplateParams);
  console.log(JSON.stringify(createTemplateResult.result, null, 2));
} catch (err) {
  console.warn(err);
}

For slack template supported template type value: slack.notification

Webhook Template

const templateConfigModel = {
  params: {
    body: 'base 64 encoded json body',
},
};
let createTemplateParams = {
  instanceId: <instance-id>,
  name: <template-name>,
  type: <template-type>,
  templateConfigModel,
  description: <template-description>,
};
let createTemplateResult;
try {
  createTemplateResult = await eventNotificationsService.createTemplate(createTemplateParams);
  console.log(JSON.stringify(createTemplateResult.result, null, 2));
} catch (err) {
  console.warn(err);
}

For webhook template supported template type value: webhook.notification

List Templates

const params = {
  instanceId: <instance-id>,
};

let res;
try {
  res = await eventNotificationsService.listTemplates(params);
  console.log(JSON.stringify(res.result, null, 2));
} catch (err) {
  console.warn(err);
}

Get Template

const params = {
  instanceId: <instance-id>,
  id: <template-id>,
};

let res;
try {
  res = await eventNotificationsService.getTemplate(params);
  console.log(JSON.stringify(res.result, null, 2));
} catch (err) {
  console.warn(err);
}

Update Template

Update Email Template

const templateConfigModel = {
  params: {
    body: 'base 64 encoded html content',
    subject: 'Hi this is invitation for invitation message',
  },
}; 
let replaceTemplateParams = {
  instanceId: <instance-id>,
  name: <template-name>,
  type: <template-type>,
  templateConfigModel,
  description: <template-description>,s
};
let replaceTemplateResult;
try {
  replaceTemplateResult = await eventNotificationsService.replaceTemplate(replaceTemplateParams);
} catch (err) {
  console.warn(err);
}

For custom email supported template type values: smtp_custom.invitation, smtp_custom.notification

Update Slack Template

const templateConfigModel = {
  params: {
    body: 'base 64 encoded json body',
  },
}; 
let replaceTemplateParams = {
  instanceId: <instance-id>,
  name: <template-name>,
  type: <template-type>,
  templateConfigModel,
  description: <template-description>,s
};
let replaceTemplateResult;
try {
  replaceTemplateResult = await eventNotificationsService.replaceTemplate(replaceTemplateParams);
} catch (err) {
  console.warn(err);
}

For slack template supported template type value: slack.notification

Update Webhook Template

const templateConfigModel = {
  params: {
    body: 'base 64 encoded json body',
  },
}; 
let replaceTemplateParams = {
  instanceId: <instance-id>,
  name: <template-name>,
  type: <template-type>,
  templateConfigModel,
  description: <template-description>,s
};
let replaceTemplateResult;
try {
  replaceTemplateResult = await eventNotificationsService.replaceTemplate(replaceTemplateParams);
} catch (err) {
  console.warn(err);
}

For webhook template supported template type value: webhook.notification

Delete Template

const params = {
  instanceId: <instance-id>,
  id: <template-id>,
};

try {
  await eventNotificationsService.deleteTemplate(params);
} catch (err) {
  console.warn(err);
}

Push Destination APIs

Create Destination tag subscription

const params = {
  instanceId: <instance-id>,
  id: <destination-id>,
  deviceId: <device-id>,
  tagName: <tag-name>,
};

let res;
try {
  res = await eventNotificationsService.createTagsSubscription(params);
  console.log(JSON.stringify(res.result, null, 2));
} catch (err) {
  console.warn(err);
}

List Destination tag subscription

const params = {
  instanceId: <instance-id>,
  id: <destination-id>,
};

let res;
try {
  res = await eventNotificationsService.listTagsSubscription(params);
  console.log(JSON.stringify(res.result, null, 2));
} catch (err) {
  console.warn(err);
}

Delete Destination device tag subscription

const params = {
  instanceId: <instance-id>,
  id: <destination-id>,
  deviceId: <device-id>,
  tagName: <tag-name>
};

try {
  await eventNotificationsService.deleteTagsSubscription(params);
} catch (err) {
  console.warn(err);
}

Subscriptions

Create Subscription

While Creating Subscription use any of one option from webhook or email

// SubscriptionCreateAttributesWebhookAttributes
const subscriptionCreateAttributesModel = {
  signing_enabled: false,
  template_id_notification: <webhook-template-id>,
};

const params = {
  instanceId: <instance-id>,
  name: <subscription-name>,
  destinationId: <destination-id>,
  topicId: <topic-id>,
  attributes: subscriptionCreateAttributesModel,
  description: <subscription-description>,
};
eventNotificationsService
.createSubscription(params)
.then(res => {
  console.log(JSON.stringify(res.result, null, 2));
})
  .catch(err => {
    console.warn(err);
  });

List Subscriptions

const params = {
  instanceId : <instance-id>,
}
eventNotificationsService
.listSubscriptions(params)
.then(res => {
  console.log(JSON.stringify(res.result, null, 2));
})
  .catch(err => {
    console.warn(err);
  });

Get Subscription

const params = {
  instanceId : <instance-id>,
  id : <subscription-id>,
}
eventNotificationsService.
getSubscription(params)
.then(res => {
  console.log(JSON.stringify(res.result, null, 2));
})
  .catch(err => {
    console.warn(err);
  });

Update Subscription

const subscriptionUpdateAttributesModel = {
  signing_enabled: true,
  template_id_notification: <webhook-template-id>,
};

const params = {
  instanceId: <instance-id>,
  id: <subscription-id>,
  name: <subscription-update-name>,
  description: <subscription-update-description>,
  attributes: subscriptionUpdateAttributesModel,
};
 
eventNotificationsService
.updateSubscription(params)
  .then(res => {
  console.log(JSON.stringify(res.result, null, 2));
})
.catch(err => {
  console.warn(err);
});

Delete Subscription

const params = {
  instanceId : <instance-id>,
  id : <subscription-id>,
}
eventNotificationsService
.deleteSubscription(params)
.then(res => {
  console.log(JSON.stringify(res.result, null, 2));
})
  .catch(err => {
    console.warn(err);
  });

Integration

Create Integration

const metadata = {
  endpoint: <end-point>,
  crn: <crn>,
  bucket_name: <cos-bucket-name>,
};

const params = {
  instanceId : <instance-id>,
  id: <integration-id>,
  type: 'collect_failed_events',
  metadata,
};

const res = await eventNotificationsService.createIntegration(params);

List Integrations

const params = {
      instanceId : <instance-id>,
      offset : <offset>,
      limit : <limit>,
      search : <search>,
    };

const res = await eventNotificationsService.listIntegrations(params);

Get Integration

const params = {
  instanceId : <instance-id>,
  id: <integration-id>,
};

const res = await eventNotificationsService.getIntegration(params);

Update Integration

For kms/hs-crypto-

const metadata = {
  endpoint: <end-point>,
  crn: <crn>,
  root_key_id: <root-key-id>,
};

const params = {
  instanceId : <instance-id>,
  id: <integration-id>,
  type: <integration-type>,
  metadata,
};

const res = await eventNotificationsService.replaceIntegration(params);

For Cloud Object Storage-

const metadata = {
  endpoint: <end-point>,
  crn: <crn>,
  bucket_name: <cos_bucket_name>,
};

const params = {
  instanceId : <instance-id>,
  id: <integration-id>,
  type: 'collect_failed_events',
  metadata,
};

const res = await eventNotificationsService.replaceIntegration(params);

SMTPConfigurations

Create SMTP Configuration

const createSmtpConfigurationParams = {
  instanceId : <instance-id>,
  name : <smtp-name>,
  domain : <smtp-domain>,
  description : <smtp-description>,
};

const res = await eventNotificationsService.createSmtpConfiguration(
  createSmtpConfigurationParams

Create SMTP User

const createSmtpUserParams = {
  instanceId : <instance-id>,
  id: <smtp-Config-id>,
  description: <user-description>,
};

const res = await eventNotificationsService.createSmtpUser(createSmtpUserParams);

Get SMTP Configuration

const getSmtpConfigurationParams = {
  instanceId : <instance-id>,
  id: <smtp-Config-id>,
};
      
const res = await eventNotificationsService.getSmtpConfiguration(getSmtpConfigurationParams);

Get SMTP User

const getSmtpUserParams = {
  instanceId : <instance-id>,
  id: <smtp-Config-id>,
  userId: <smtp-user-id>,
};

const res = await eventNotificationsService.getSmtpUser(getSmtpUserParams);

Get SMTP Allowed Ips

const getSmtpAllowedIpsParams = {
  instanceId : <instance-id>,
  id: <smtp-Config-id>,
};

const res = await eventNotificationsService.getSmtpAllowedIps(getSmtpAllowedIpsParams);

List SMTP Configurations

const listSmtpConfigurationsParams = {
  instanceId : <instance-id>,
  offset : <offset>,
  limit : <limit>,
  search : <search>,
};
const res = await eventNotificationsService.listSmtpConfigurations(
  listSmtpConfigurationsParams
);

List SMTP Users

const listSmtpUsersParams = {
  instanceId : <instance-id>,
  id: <smtp-Config-id>,
  offset : <offset>,
  limit : <limit>,
  search : <search>,
};

const res = await eventNotificationsService.listSmtpUsers(listSmtpUsersParams);

Update SMTP Configuration

const updateSmtpConfigurationParams = {
  instanceId : <instance-id>,
  id: <smtp-Config-id>,
  name: <smtp-name>,
  description: <smtp-description>,
};

const res = await eventNotificationsService.updateSmtpConfiguration(
  updateSmtpConfigurationParams
);

Update SMTP User

const updateSmtpUserParams = {
  instanceId : <instance-id>,
  id: <smtp-Config-id>,
  userId: <smtp-user-id>,
  description <smtp-user-description>,
};

const res = await eventNotificationsService.updateSmtpUser(updateSmtpUserParams);

Delete SMTP User

const deleteSmtpUserParams = {
  instanceId : <instance-id>,
  id: <smtp-Config-id>,
  userId: <smtp-user-id>,
};

const res = await eventNotificationsService.deleteSmtpUser(deleteSmtpUserParams);

Delete SMTP Configuration

const deleteSmtpConfigurationParams = {
  instanceId : <instance-id>,
  id: <smtp-Config-id>,
};

const res = await eventNotificationsService.deleteSmtpConfiguration(
  deleteSmtpConfigurationParams
);

Verify SMTP

const type = 'dkim,spf,en_authorization';
const updateVerifySmtpParams = {
  instanceId : <instance-id>,
  id: <smtp-Config-id>,
  type,
};

const res = await eventNotificationsService.updateVerifySmtp(updateVerifySmtpParams);

supported verification types are dkim,spf and en_authorization.

Metrics

Get Metrics

const getMetricsParams = {
  instanceId: <instance-id>,
  destinationType: 'smtp_custom',
  gte: <gte-timestamp>,
  lte: <lte-timestamp>,
  destinationId: <destination-id>,
  emailTo: <email-to>,
  notificationId: <notification-id>,
  subject: <subject>,
};

try {
  const res = await eventNotificationsService.getMetrics(getMetricsParams);
  console.log(JSON.stringify(res.result, null, 2));
} catch (err) {
  console.warn(err);
}

Send Notifications

// NotificationFCMDevices
    const notificationDevicesModel = {
      user_ids: ['<user-ids>'],
      fcm_devices: ['<fcm-device-ids>'],
      apns_devices: ['<apns-device-ids>'],
      huawei_devices: ['<huawei-device-ids>']
      tags: ['<tag-names>'],
      platforms: ['<device-platforms>'],
    };
    
    const notificationApnsBodyModel = {
      aps: {
        alert: '<notification-message>',
        badge: 5,
      },
    };

    const notificationFcmBodyModel = {
      message: {
        'android': {
          'notification': {
              'title': '<notification-title>',
              'body': '<notification-message>'
          },
          'data': {
              'name': 'Robert',
              'description': 'notification for the Poker'
          },
        },
      }
    };

   const notificationApnsHeaders = {
     "apns-collapse-id": "<apns-apns-collapse-id-value>"
    }

   const notificationSafariBodymodel = {
      saf: {
          alert: 'Game Request',
          badge: 5,
      },
    }

    const notificationHuaweiBodymodel = {
      'android': {
          'notification': {
              'title': '<notification-title>',
              'body': '<notification-message>'
          },
          'data': {
              'name': 'Robert',
              'description': 'notification for the Poker'
          },
        },
      }

     const htmlBody =
      '"Hi  ,<br/>Certificate expiring in 90 days.<br/><br/>Please login to <a href="https: //cloud.ibm.com/security-compliance/dashboard">Security and Complaince dashboard</a> to find more information<br/>"'; 

    let notificationID = "<notification-id>"
    let notificationSubject = "<notification-subject>"
    let notificationSeverity = "<notification-severity>"
    let typeValue = "<notification-type>"
    let notificationsSouce = "<notification-source>"
    let mms = '{"content": "akajdklahl", "content_type": "image/png"}'

const notificationCreateModel = {
      instanceId,
      ibmenseverity: notificationSeverity,
      id: notificationID,
      source: notificationsSouce,
      ibmensourceid: sourceId,
      type: typeValue,
      time: '<notification-time>',
      ibmenpushto: JSON.stringify(notificationFcmDevicesModel),
      ibmenfcmbody: JSON.stringify(notificationFcmBodyModel),
      ibmenapnsbody: JSON.stringify(notificationApnsBodyModel),
      ibmensafaribody: JSON.stringify(notificationSafariBodymodel),
      ibmenhuaweibody: JSON.stringify(notificationHuaweiBodymodel),
      ibmenmailto: JSON.stringify(['[email protected]', '[email protected]']),
      ibmensmsto: JSON.stringify(['+911234567890', '+911224567890']),
      ibmenslackto: JSON.stringify(['C07FALXBH4G','C07FALXBU4G']),
      ibmentemplates: JSON.stringify(['149b0e11-8a7c-4fda-a847-5d79e01b71dc']),
      ibmensubject: 'certificate expire',
      ibmenmms: JSON.stringify(mms),
      ibmenhtmlbody: htmlBody,
      ibmendefaultshort: 'short info',
      ibmendefaultlong: 'long info',
      specversion: '1.0',
    };

    let body = notificationCreateModel;
    const sendNotificationsParams = {
      instanceId,
      body,
    };

    let res;
    try {
      res = await eventNotificationsService.sendNotifications(sendNotificationsParams);
      console.log(JSON.stringify(res.result, null, 2));
    } catch (err) {
      console.warn(err);
    }

• ibmenpushto - Set up the push notifications targets.
  • user_ids (Array of String) - Send notification to the specified userIds.
  • fcm_devices (Array of String) - Send notification to the list of specified Android devices.
  • apns_devices (Array of String) - Send notification to the list of specified iOS devices.
  • chrome_devices (Array of String) - Send notification to the list of specified Chrome devices.
  • firefox_devices (Array of string) - Send notification to the list of specified Firefox devices.
  • tags (Array of string) - Send notification to the devices that have subscribed to any of these tags.
  • platforms (Array of string) - Send notification to the devices of the specified platforms.
    • Pass 'G' for google (Android) devices.
    • Pass 'A' for iOS devices.
    • Pass 'WEB_FIREFOX' for Firefox browser.
    • Pass 'WEB_CHROME' for Chrome browser.
• Event Notifications SendNotificationsOptions - Event Notifications Send Notifications method.
  • instance_id (string) - Unique identifier for IBM Cloud Event Notifications instance.
  • ibmenseverity (string) - Severity for the notifications. Some sources can have the concept of an Event severity. Hence a handy way is provided to specify a severity of the event. example: LOW, HIGH, MEDIUM
  • id* (string) - A unique identifier that identifies each event. source+id must be unique. The backend should be able to uniquely track this id in logs and other records. Send unique ID for each send notification. Same ID can be sent in case of failure of send notification. source+id will be logged in IBM Cloud Logging service. Using this combination we will be able to trace the event movement from one system to another and will aid in debugging and tracing.
  • source* (string) - Source of the notifications. This is the identifier of the event producer. A way to uniquely identify the source of the event. For IBM Cloud services this is the crn of the service instance producing the events. For API sources this can be something the event producer backend can uniquely identify itself with.
  • ibmensourceid* (string) - This is the ID of the source created in EN. This is available in the EN UI in the "Sources" section.
  • type (string) - This describes the type of event. It is of the form : This type is defined by the producer. The event type name has to be prefixed with the reverse DNS names so the event type is uniquely identified. The same event type can be produced by 2 different sources. It is highly recommended to use hyphen - as a separator instead of _.
  • data (string) - The payload for webhook notification. If data is added as part of payload then its mandatory to add datacontenttype.
  • datacontenttype - The notification content type. example: application/json
  • time (string) - Time of the notifications. UTC time stamp when the event occurred. Must be in the RFC 3339 format.
  • ibmenpushto (string) - Targets for the FCM notifications. This contains details about the destination where you want to send push notification. This attribute is mandatory for successful delivery from an Android FCM or APNS destination.
  • ibmenfcmbody (string) - Set payload string specific to Android platform [Refer this FCM official link].
  • ibmenhuaweibody (string) - Set payload string specific to Android platform [Refer this FCM official link].
  • ibmenapnsbody (string) - Set payload string specific to iOS platform [Refer this APNs official doc link].
  • ibmensafaribody (string) - Set payload string specific to safari platform [Refer this Safari official doc link].
  • ibmenapnsheaders (string) - Set headers required for the APNs message [Refer this APNs official link(Table 1 Header fields for a POST request)]
  • ibmenchromebody (string) - Message body for the Chrome notifications. Refer this official documentation for more.
  • ibmenfirefoxbody (string) - Message body for the Firefox notifications. Refer this official documentation for more.
  • ibmenchromeheaders (string) - Headers for the Chrome notifications. Refer this official documentation for more.
  • ibmenfirefoxheaders (string) - Headers for the Firefox notifications. Refer this official documentation for more.
  • ibmendefaultshort* (string) - Default short text for the message.
  • ibmendefaultlong* (string) - Default long text for the message.
  • specversion* (string) - Spec version of the Event Notifications. Default value is 1.0.
  • ibmenhtmlbody* (string) - The html body of notification for email.
  • ibmenmailto* (Array of string) - Array of email ids to which the notification to be sent.
  • ibmensmsto* (Array of string) - Array of SMS numbers to which the notification to be sent.
  • ibmenslackto* (Array of string) - Array of Slack channel/member ids to which the notification to be sent.
  • ibmentemplates* (Array of string) - Array of template IDs that needs to be applied while sending notification for custom domain email and slack destination.

Note: variable with * represents the mandatory attribute.

Set Environment

Find event_notifications_v1.env.hide in the repo and rename it to event_notifications_v1.env. After that add the values for,

• EVENT_NOTIFICATIONS_URL - Add the Event Notifications service instance Url.
• EVENT_NOTIFICATIONS_APIKEY - Add the Event Notifications service instance apikey.
• EVENT_NOTIFICATIONS_GUID - Add the Event Notifications service instance GUID.

Optional

• EVENT_NOTIFICATIONS_AUTH_URL - Add the IAM url if you are using IBM test cloud.

• EVENT_NOTIFICATIONS_FCM_KEY - Add firebase server key for Android FCM destination.

• EVENT_NOTIFICATIONS_FCM_ID - Add firebase sender Id for Android FCM destination.

• EVENT_NOTIFICATIONS_FCM_PROJECT_ID - fcm project id

• EVENT_NOTIFICATIONS_FCM_CLIENT_EMAIL - fcm client email

• EVENT_NOTIFICATIONS_FCM_PRIVATE_KEY - fcm private key

• EVENT_NOTIFICATIONS_SAFARI_CERTIFICATE - safari certificate path

• EVENT_NOTIFICATIONS_SNOW_CLIENT_ID - service now client id

• EVENT_NOTIFICATIONS_SNOW_CLIENT_SECRET - service now client secret

• EVENT_NOTIFICATIONS_SNOW_USER_NAME - service now user name

• EVENT_NOTIFICATIONS_SNOW_PASSWORD - service now password

• EVENT_NOTIFICATIONS_SNOW_INSTANCE_NAME - service now instance name

• EVENT_NOTIFICATIONS_COS_BUCKET_NAME - cloud object storage bucket name

• EVENT_NOTIFICATIONS_COS_INSTANCE - cloud object storage instance id

• EVENT_NOTIFICATIONS_COS_INSTANCE_CRN - cloud object storage instance crn

• EVENT_NOTIFICATIONS_COS_ENDPOINT - cloud object storage end point

• EVENT_NOTIFICATIONS_CODE_ENGINE_URL - code engine app url

• EVENT_NOTIFICATIONS_CODE_ENGINE_PROJECT_CRN - code engine project crn

• EVENT_NOTIFICATIONS_HUAWEI_CLIENT_SECRET - huawei client secret

• EVENT_NOTIFICATIONS_HUAWEI_CLIENT_ID - huawei client id

• EVENT_NOTIFICATIONS_SLACK_URL - slack webhook url

• EVENT_NOTIFICATIONS_MS_TEAMS_URL - msteams webhook url

• EVENT_NOTIFICATIONS_PD_ROUTING_KEY - pagerduty routing key

• EVENT_NOTIFICATIONS_PD_API_KEY - pagerduty api key

• EVENT_NOTIFICATIONS_TEMPLATE_BODY - base 64 encoded html content

• EVENT_NOTIFICATIONS_SLACK_TEMPLATE_BODY - base 64 encoded json body

• EVENT_NOTIFICATIONS_WEBHOOK_TEMPLATE_BODY - base 64 encoded json body

Questions

If you are having difficulties using this SDK or have a question about the IBM Cloud services, please ask a question at Stack Overflow.

Issues

If you encounter an issue with the SDK, you are welcome to submit a bug report. Before that, please search for similar issues. It's possible someone has already encountered this issue.

Open source @ IBM

Find more open source projects on the IBM Github Page

Contributing

See CONTRIBUTING.

License

This project is released under the Apache 2.0 license. The license's full text can be found in LICENSE.