DEV Community: Shreya

Day 2: Unsupervised Learning Examples

Shreya — Wed, 10 Jan 2024 07:58:04 +0000

We know that ChatGPT was trained using a form of unsupervised learning. But where else can we see this ML task in action?

According to “An Introduction to Statistical Learning”: this task can be used to find patterns in cancer research or how people shop online. You can use those patterns to learn about the disease or make decisions to increase how much a customer spends on your website.

For example, let’s say TikTok can classify you into a group of users called Group A because you like watching dance videos and getting book recommendations. If the majority of users in Group A also like Taylor Swift, then TikTok knows to recommend you Taylor Swift content. Without any prior knowledge, the unsupervised learning task would determine what types of content categorizes Group A and which users should be placed in it. If you decide you scroll past the Taylor Swift content, the task would then re-evaluate which group to place you in or which patterns are relevant for that Group.

Now this is a slightly different example, but unsupervised learning is also used in detecting damage in structures like bridges and highrise buildings. There’s a lot more data on normal structures than damaged ones, so unsupervised learning works well in this case, because it can just use the data on normal structures and spot any changes and deviations from it to create those patterns. I’ll link the research paper for this topic if you want to learn more.

Sources:

Day 1: Unsupervised Learning

Shreya — Wed, 10 Jan 2024 06:26:40 +0000

When you ask AI “What is 9+10”, how should it respond?

A calculator app would respond with 19.
A printer app would respond with “What is 9+10?”.
An AI app that’s been trained only using data from social media might respond with 21.

We know that AI apps are different from more conventional apps. If you give a conventional app a certain input, it will follow the code or instructions or algorithm to do what the programmer tells it to do.

Although chatgpt was trained on a seriously large dataset beyond just social media content, it does have the ability to use context from a conversation to make decisions about how to respond to new input. So if you ask chatgpt what is 9+10 based on social media viral content, it will say 21. Obviously that’s not the same as just asking the question by itself, but that’s how our brains work too. If you ask a stranger on the street with no additional context they would probably say 19. But if you ask your friend, they’d probably have enough context to say 21.

ChatGPT is trained using a method called unsupervised learning, which according to itself "is a type of machine learning where the algorithm is given unlabeled data and must find patterns, relationships, or structures within it without explicit guidance.”

So you have an algorithm that has no prior information but it has a task. That task can be to either “cluster” the data into groups or use “dimensional reduction” to simplify it. You give it unlabeled data and it will do one of these tasks. The output is then evaluated for quality and if it’s an iterative process, it can be refined and adjusted and the process repeated until the results are good enough according to people.

Automate Slack and Microsoft Teams Notifications using Python

Shreya — Thu, 16 Mar 2023 16:28:47 +0000

Messaging apps are essential for internal collaboration and critical notifications such as reminders, alerts, and other time-sensitive updates. While integrating with the Slack and Microsoft APIs is fairly straightforward, implementing these tools as a part of a full-featured notification system that embeds with your app experience can be far more daunting.

In this article, we'll show you how to send notifications via Slack and Microsoft Teams, using Courier to make these tools a seamless part of how your app communicates with users.

Prerequisites

Get access to your Courier API Key
Install Python 3.x on your computer
Install trycourier by running the pip install trycourier command

Create a Notification Template for Slack and Teams

Head over to the Notification Designer and create a new notification. Once you have created the notification, you will be able to select your channels. Here you can add Slack, Teams, and/or any other channels you would like to send with.

Click on any of the channels to customize your message. Once you have created your message, you can use the drag-and-drop "Library" on the left side to recreate the message for the remaining channels.

Click on the settings (gear) icon next to the template name (top right) to access the Notification ID, which you will need later to send this message.

Send with Slack

Step 1: Add the Slack integration to Courier

First, head to the Slack channel in Courier https://app.courier.com/channels/slack and click "Install Provider". If you only want to send with Teams, you can skip to the “Send with Microsoft Teams” section.

Step 2: Create a Slack App

Navigate to the Slack Apps page and log into Slack. Click the Create an App button and provide your App Name as depicted below.

Step 3: Add OAuth Permission and Scopes

Define the permissions that your Slack App is authorized to do.

To do so, navigate to the OAuth & Permissions page in the sidebar menu and select the following options from the Scopes section:

chat:write
im:write
users:read
users:read.email

Afterward, click the Install App to Workspace or Reinstall App button at the top of the page. This will generate an output -"Bot User OAuth Token" as depicted below, which will be needed later.

Step 4: Send a Slack DM with Python

Add the code snippet below to your codebase (e.g. index.py ) and update the following properties:

replace with your Courier API key
access_code: replace xoxb-abcd with the Bot User OAuth Token
replace example@gmail.com with your user's email address (this is the email associated with the recipient's Slack Account)
Recommended: use your own email for testing
replace 85S5NWXJVQ4GN8J21JSKV3JVCSV2 with your Notification ID from the first part of this tutorial

from trycourier import Courier
client = Courier(auth_token="<auth-token>")

resp = client.send_message(
  message={
    "to": {
      "slack": {
        "access_token": "xoxb-abcd",
        "email": "example@gmail.com",
      },
    },
    "template": "85S5NWXJVQ4GN8J21JSKV3JVCSV2",
    "data": {
    },
  }
)
print(resp['requestId'])

Execute the Python script to see your notification popup in the user's Slack direct message!

Check your Courier logs for errors if your user did not receive the message.

Slack Resources

Send with Microsoft Teams

We can now try sending the same message via Teams. If you only want to send with Slack, you can skip to the “Routing to multiple channels” section.

Step 1: Sign up for a Microsoft 365 Developer Account

If you do not have a Microsoft 365 developer account, follow the instructions from this guideline to create an account. If you already have an account, you can skip this step.

Step 2: Create a Teams App

Create a new App in Teams. You will need to install the Developer Portal from the Team Apps.

After installing the Developer Portal, navigate to the Apps tab and click the New App button. Then, you will get prompted to enter the application name.

After clicking the Add button, you will be redirected to a new window where you can see the App ID. Make sure to copy the App ID for later use.

Then, click App features from the left menu and click on the tile named Bot. It will open a new window for selecting a bot and bot scopes.

If you do not have a bot created already, follow these steps to create a new one. Also, make sure to save the password generated during the process. Keep the Messaging endpoint blank for the moment.

Step 3: Deploy the bot

Now you need to deploy the App to create the messaging endpoint. For that, open the Microsoft Teams Bot Starter Repo and click the Deploy to Netlify button. There, you will have to connect to your GitHub account and enter your App ID (Bot ID), App Password, Courier Auth Token, and a name for the repo.

Once the site is deployed, copy your site URL since you need it to finish installing the bot.

Step 4: Install the bot

Now, go back to the Tools > Bot Management tab in Developer Portal and select the created bot to finalize the installation process. There, select the Configure option and copy the site URL to the Bot endpoint address field.

Then, select the Channels option from the left menu and tick the Microsoft Teams option.

Step 5: Add the Teams integration to Courier

Now, you need to create a Teams integration in Courier. For that, navigate to the Channels tab and select Microsoft Teams from the options. Then, it will show a window like the one below. Enter the App ID, App Password and click the Install Provider button.

Step 6: Sending a Simple Teams Notification with Python

Add the code snippet below to your codebase (e.g. index.py ) and update the following properties:

replace <auth-token> with your Courier API key
conversation_id: get the conversation id from threadId query parameter from the URL after opening Microsoft Teams in the browser
service_url: the service URL associated with that Microsoft Teams tenant (if you are located in the Americas Region, the service url is https://smba.trafficmanager.net/amer)
tenant_id: go to https://teams.microsoft.com/?tenantId and copying the value from the redirected URL tenantId query parameter, or click the three dots next to your Team and click Get link to team to find a link with the tenantId parameter

from trycourier import Courier
client = Courier(auth_token="<auth-token>"

resp = client.send_message(
  message={
      "to": {
      "ms_teams": {
          "conversation_id": "Yl2wJmlmFQkc65UAg0I2kJyCnPJlXvIM4Q3XSrDBZnQ1",
          "tenant_id": "aac0c564-6c5e-4b05-8dc3-408087f77f76",
          "service_url": "https://smba.trafficmanager.net/amer",
      },
      },
      "template": "M79W7S9TRYM04CM634A805T8SYKM",
      "data": {
      },
  } 
)
print(resp['requestId'])

Finally, you can run the python script, and you will see a notification in your Team channel.

Microsoft Teams Resources

Routing to multiple channels

Courier's multi-channel functionality allows you to send notifications across multiple channels, including email, SMS, push notifications, voice, chatbots, and social media platforms, using a single API.

For example, if you want to send an urgent alert to your team, you would use Courier to send this alert as an email, as well as a Slack or Teams notification. As you can see below, Courier supports a large selection of Email, SMS, chat, and push notification providers.

Let’s update the notification template to send across four channels: email, SMS, Slack, and Teams. First, add email and SMS channels to the template and make sure they both also have the same content as the previous two (remember, you can use the Library to drop in pre-built content blocks).

Next, update the Settings of each channel so that “Always send to” is toggled on (away from “Best Of”) for each of the four channels listed.

from trycourier import Courier
client = Courier(auth_token="<auth-token>")

resp = client.send_message(
  message={
    "to": {
      "slack": {
        "access_token": "xoxb-abcd",
        "email": "example@gmail.com",
      },
      "ms_teams": {
          "conversation_id": "85S5NWXJVQ4GN8J21JSKV3JVCSV2",
          "tenant_id": "aac0c564-6c5e-4b05-8dc3-408087f77f76",
          "service_url": "https://smba.trafficmanager.net/amer",
      },
    },
    "template": "Z5N9D2J8DSMBKEHWF27AEEF6J822"
  }
)
print(resp['requestId'])

You can also decide whether you actually want to send to all four channels or only specific ones. “Best of” means that Courier will send to one channel out of all that are listed. E.g. if you list Slack as “Always send to”, but have email and SMS as “Best of”, Courier will send a Slack message and attempt to send an email. If the email fails to deliver for any reason, Courier will then reroute to SMS. This means it will only send an SMS if and when email fails.

Automating Slack and Teams Notifications## Automating Slack notifications

If you prefer a visual workflow, you can create an automation template within Courier.

Create a new Automation, select a schedule Trigger, and add a Send step for your notification. We will update the Type to "Date" and Date to the specific date/time this message should be sent.

In the Send step, select JSON and use the Editor to add the recipient information. In the editor, click "+ Add field" and add slack as an Object. Then click "+Add nested field" and add access_token and email with the appropriate values from the code above.

Automating Teams notifications

The notification template will automatically send to all selected channels.

Head over to the Automation and, in the JSON editor of the Send step, click "+ Add field" and add ms_teams as an Object. Then click "+Add nested field" and add conversation_id, tenant_id, and service_id, with the appropriate values from the code above.

This automation will now have the required user profile data to send to both Slack and MS Teams. If you also want to send to an email or SMS, edit the JSON object to add field for "email" and "phone_number" with the appropriate values.

Conclusion

Automating notifications in team communication platforms such as Slack and Teams can significantly improve team productivity and communication. However, building automated notifications from scratch can be complex and time-consuming. That's where Courier comes in with its easy-to-use Python SDK that allows developers to send notifications to multiple channels with just a few lines of code.

By following the steps outlined in this article, you can set up notification automation with Courier and Python for both Slack and Teams. Additionally, you can leverage Courier's multi-channel functionality to integrate other applications and channels into your notification system.

FAQs

1. What is Courier?

Courier connects communication APIs, data, and development tools that your team already uses to deliver a best-in-class notification system that will trigger messages from your app at just the right time, using just the right channel. It provides powerful API primitives and reusable UI components for building, plus no-code tools for designing templates and communication sequences.

2. What is Slack?

Slack is a cloud-based messaging platform that enables teams to communicate and collaborate in real-time. It is known for its user-friendly interface and extensive third-party integrations, making it a highly customizable platform for teams of all sizes. Slack allows users to easily organize their conversations into channels, share files, and collaborate with other team members. It also offers multiple app integrations, including project management and automation tools.

3. What is Microsoft Teams?

Microsoft Teams is another popular communication and collaboration platform that is part of the Microsoft Office 365 suite. It enables teams to chat, share files, and collaborate in real time, both synchronously and asynchronously. With features such as video conferencing, screen sharing, and group chats, Microsoft Teams is ideal for businesses and organizations that require a comprehensive and centralized collaboration platform.

4. Missing Provider Support error message

If your message did not go through, check your Courier logs. For a "MISSING_PROVIDER_SUPPORT" error message, you will need to double-check if the Slack and/or Teams channels were installed properly in Courier. Try removing the channel(s) (go to the channel and click "Remove Channel" at the bottom of the page) that is causing the error and then adding it again.

New AI-Powered Content and Changelog to Create Great Product Notifications Fast

Shreya — Wed, 08 Feb 2023 16:00:00 +0000

The Designer in Courier’s web UI is an intuitive tool for creating, modifying, and testing notification templates. It allows you to integrate notification design seamlessly into your overall workflow — regardless of your level of technical expertise.

Today, we’re proud to present two new features in the Courier Designer. The AI content generator leverages a GPT model for language generation to optimize messaging in the notification template and make sure it looks right for each channel, or even create new notifications from scratch. It is complemented by the changelog feature, which lets team members view changes to a draft notification in granular detail before they publish it.

Both the AI content generator and the changelog came out of our latest company-internal hackathon. In this article, we’ll explain the new features and demo how you, too, can start using them today. Plus, we’ll briefly talk about the role of hackathons in our product ideation process.

Courier’s Designer

Whether it’s usage-triggered notifications, billing and authentication alerts, or friendly check-in messages: web and mobile apps are now constantly communicating with users to keep them engaged and to improve the overall app experience. A successful notification strategy leverages different channels for different purposes. Courier is all about making this as simple as possible for everyone involved, by bundling channels and providers within one clean interface: the Designer, where teams can draft, adapt, and send out notifications.

The Designer allows you to create content and adjust it to different channels. For instance, someone on your team could use the interface to set up an email template for resetting a password. If you later decide that you want to send it out via a different channel as well, someone else can just go into the Designer and adapt the notification to be sent via SMS, WhatsApp, or a platform like Discord or Slack. For more information, have a look at this overview of all providers supported in Courier.

AI content generator: Use the newest in NLP to create better notifications

You’ve probably heard about — or even interacted with — ChatGPT. OpenAI’s latest language model has had a huge impact on the tech community, likely aided by the fact that they made the model freely available to the general public. Since its introduction in November, people have used ChatGPT to debug their code, write their cover letters, and perform countless other tasks. While some corners of the internet have tended to overstate ChatGPT’s impact, most agree that large language models like GPT are here to stay, and that they are going to change our procedures for text production.

Creating content with GPT-3

ChatGPT is just the newest in a family of models known as GPT-3, the most powerful of which have billions of parameters. With Courier’s new AI content generator, you can now use a GPT-3 model to create notification templates from scratch. All you need to do is provide a prompt and wait a few seconds until the model has produced the desired output.

For our example, we’ll be creating content for an email. Remember, however, that you can use Courier to set up notifications for any channel, from SMS to Slack. And, perhaps the best part, our new AI content generator is free to use with all plans.

How to use the AI content generator

Courier’s new AI content generator can be used to generate content from scratch or to modify existing content to better suit a different channel or use case.

Modifying existing content

While notification content is often initially created and collaborated on separately in a Google Doc or a shared workspace like Notion or Coda, it may not look quite right once you see it in the Courier notification template for that specific channel. This is where AI-driven content gets powerful: you can ask the AI generator to “shorten this by 20%” or “make this language feel more familiar and friendly to suit an SMS notification.”

Here's an example of an email template that needs to be converted into a push notification:

We can quickly achieve this with the AI generator:

Generating content from scratch

Or you may just want to use the AI content generator to draft a template from scratch based on the notification type and use Courier’s Designer as your team collaboration point.This can be done at any point, either during or after initialization.

Content generation during initialization**

Go to the Designer and click on “Create notification.”

There, you will be asked to provide a name for your new notification template. This name can now act as a prompt for the generative language model. If you check the box “Use AI to generate notification content,” your prompt gets routed to the language model, which generates a new notification template from scratch.

Here’s what the model returned about ten seconds after receiving the prompt “Welcome to our newsletter!”:

The curly brackets in our notification template designate variables — have a look at the documentation to learn more. You’ll also notice that the content doesn’t contain any specifics about the product. That’s because our initial prompt (“Welcome to our newsletter!”) was all the model could draw on when it came up with its notification. So let’s now have a look at the second way in which you can leverage the power of generative language modeling in your notifications.

Content generation within the template

Within the template, you can create a new text field by clicking on the “T” icon. Next, choose the AI Generator lightbulb icon within the text field.

You can now prompt the GPT model to generate new content based on more detailed prompts. In our example, we again ask the AI content generator to come up with a newsletter, only this time we provide some more context. The full prompt reads “Welcome a new subscriber to a newsletter by a pet shop. Announce exclusive benefits, like weekly discounts.” And here’s what the model came up with:

You can edit the content before adding it to your template, or add it and adapt it later.

Using AI to drive faster content creation and more frequent iteration raises the issue of how to keep track of changes, which brings us to our next brand-new feature in the Designer: the changelog.

Learn more about the AI-Powered Content Generator in our documentation.

Try creating a new notification yourself.

Changelog: keep track of changes in your Designer

The Designer is often used collaboratively: different people can make changes to a notification’s content, look, or configuration. Before these changes can take effect, someone needs to accept them, using the “Publish Changes” button.

Thanks to the new changelog feature, which is located next to the “Publish Changes” button, users can now view a detailed list of the draft changes made since the last publication.

The changelog details all the recent draft changes, including who made them and when. Not only does this give users a higher sense of control, it’s also in line with best practices in software development, where control over different versions of the code is key to a clean and transparent workflow.

If you want to undo the changes in the changelog, you can remove them via the “Discard Changes” button and get back to the last published state. Note that it is not currently possible to discard or accept changes from the changelog individually.

Having a detailed account of draft changes was a feature often requested by product teams, who would spend too much time messaging back and forth to try and discern when a particular draft change within the template was made, and by whom. All of that can now be seen right from Courier’s web UI.

Build your own notification templates now.

Hacking our way to the top

Both the AI content generator and the changelog are results of our latest hackathon, which we held in December. At Courier, we’re fortunate to have a large pool of extraordinary talent — and our biannual hackathons allow our employees to spend a day unleashing their creative potential. We’ve seen some great features come out of this process — often inspired by conversations with customers, or current events like the release of the latest GPT model.

Using a machine learning language model like GPT-3 for the notifications Designer is just scratching the surface of how AI can make transactional notifications from your web and mobile apps better. Stay tuned as we look for even more ways to improve your notification experience with AI and best practices from software development.

Build a Serverless Lie Detector that uses AI for Facial Recognition

Shreya — Thu, 20 Oct 2022 20:58:47 +0000

GitHub Repository: https://github.com/shreythecray/lie-detector

Follow along with the video tutorial:

We will build a serverless application that uses Artificial Intelligence to conduct facial recognition and uses Courier to send alerts based on the results.
We just launched our first hackathon and are giving away over $1K in prizes! Join us in building a cool project and winning any of the following prizes. 🏆

Courier Hacks 1st Place: Top submission for use for notifications and demonstration of proper app-to-user notifications with the Courier API will receive $1000 via Zelle or PayPal.
Courier Hacks 2nd Place: 2nd Place submission for use for notifications and demonstration of proper app-to-user notifications with the Courier API will receive the Apple AirPods Pro.
Public Favorite: Public favorite winner will receive a Keychron Keyboard.
Runners-Up: Runners-up submissions will receive a Hydro Flask.

Additionally, everyone who submits a project successfully integrating the Courier API will receive a $20 Amazon gift card! Submissions close on September 28th. Register now to submit this project for a chance to win some cool prizes.

Not sure where to start? In this tutorial, we will build a serverless lie detector that uses Artificial Intelligence for Facial Recognition.

What’s going on?

Let’s get started. We are secret agents and headquarters is telling us that one of our spies has betrayed us and has been leaking sensitive, top-secret information to our enemies. Our goal is to build a lie detector that will alert our spy network when we identify the mole. We will use Azure's Cognitive Services to perform facial recognition on everyone on our team. When the Face API recognizes that one of our spies is being deceitful, we will use Courier to broadcast the identity of the mole to our spy network.

Some spies are in an area where they can only guarantee secure messaging through emails, and others prefer quick and secure SMS, so we need to ensure our app can accommodate all spy preferences.

Note: The first three Secret Agents to successfully complete this tutorial and task will receive a top-secret gift from HQ via Courier.

In Part 1, we will create our serverless application using Azure Functions. In Part 2, we will first integrate the Gmail and Twilio APIs, which Courier will use to send emails and text messages. In Part 3, we will demonstrate how to send single messages and set up routing to send multi-channel notifications from the Azure function. And finally, in Part 4, we will explore Azure Cognitive Services and integrate the Face API to analyze emotions and use the Courier API to send alerts when specific deceiving emotions are detected.

Instructions

Part 1: Create a serverless application using Azure Functions

We first need to set up our local development environment to enable using Azure and testing our code.

Install the following VS Code Extensions:
- Azure Tools to create Azure Functions,
- REST Client to test our Azure Function calls (this is an alternative to Postman or Insomnia).

Once the two extensions have been installed successfully, check the left menu for Azure’s A symbol. Completely close and reopen VS Code if the symbol does not automatically appear.

To build an HTTP Trigger Function:

Click on the Azure symbol to open Azure locally. Here we are prompted to sign into our Azure account.
After signing in, we need to open an Azure Subscription or create a new one.
- Note that students can get free credits for Azure.

If the subscription is not showing up locally, follow instructions from the documentation on how to set up our account, which tells us to sign out of Azure on VS Code and sign back in.

Once the subscription appears, click on “Workspace” and create a new project.
Determine where we need to save the files within this project and how we want to name it locally.

Once the location has been selected, we are prompted to make a few decisions about the type of function we want to create.

Select JavaScript for the language
Select HTTP Trigger for template
Rename the function to LieDetector (or any unique name)
Select Function for the Authorization Level.
Open the project to start coding.

You can edit settings later within the function.json file. Let’s open the index.js file and take a moment to understand the boilerplate function.

module.exports = async function (context, req) {
    context.log('JavaScript HTTP trigger function processed a request.');

    const name = (req.query.name || (req.body && req.body.name));
    const responseMessage = name
        ? "Hello, " + name + ". This HTTP triggered function executed successfully."
        : "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.";

    context.res = {
        // status: 200, /* Defaults to 200 */
        body: responseMessage
    };
}

Line #4 demonstrates how we can get data from the function query or request body. Line #5 contains a string assigned to a variable named responseMessage, which uses the data from line #4. On lines #9-12, this variable is then passed into the response object, context.res.

Part 2: Authorize Courier to send messages using Gmail and Twilio APIs

Courier sends messages by consolidating multiple API calls into one. In this second part, we will need to authorize our API to send messages via the Gmail and Twilio APIs.

Log in to your Courier account and create a new secret workspace.
For onboarding, select the email channel and let Courier build with Node.js. Start with the Gmail API since it only takes seconds to set up. All we need to do to authorize is log in via Gmail. Now the API is ready to send messages.
Copy the starter code, a basic API call using cURL, and paste it into a new terminal. It already has saved your API key, knows which email address you want to send to, and has a built-in message.

Once you see Agent Pigeon dancing, we are ready to use Courier to communicate with our spies. Before we build out our application, we need to set up the Twilio provider to enable text messages.

Head over to “Channels" in the left menu and search for Twilio. You will need an Account SID, Auth Token, and a Messaging Service SID to authorize Twilio.
Open twilio.com, login and open the console, and find the first two tokens on that page. Save the Account SID and Auth Token in Courier.

Lastly, you need to locate the Messaging Service SID, which you create in the Messaging tab on the left menu. Checkout Twilio’s docs on how to create a Messaging Service SID, linked in the description.

Once we have all three pieces of information, install the provider. Your Courier account is officially authorized to send any email or SMS within one API call.

Part 3: Send single and multi-channel notifications from the Azure function

We can use Courier to send single messages or set up routing to send multi-channel notifications from within the Azure function. In this third Part, we will start sending messages and will refer to the Courier Node.js quick start, which outlines how to get started with the SDK, and can be found within the Docs page on courier.com.

If you would rather use the Courier API, check out the Secret Message tutorial for instructions or Courier’s API Reference for documentation.

The SDK documentation walks us through getting access to the API key.

Find the API key on https://app.courier.com/settings/api-keys.
Save the API key in the local.settings.json file and bring it into the index.js file as const apiKey = process.env["API_KEY"]. This application can now be authorized to use our Courier account.

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "",
    "FUNCTIONS_WORKER_RUNTIME": "node",
    "API_KEY": "replace-with-your-key"
  }
}

Install the Courier SDK by running the following command in the terminal: npm install @trycourier/courier
Use the require function to import the SDK into the index.js file.

const { CourierClient } = require("@trycourier/courier");

The last step is to walk through the API call within the API docs and integrate it into our codebase.

import { CourierClient } from "@trycourier/courier";
// alternatively:
// const { CourierClient } = require("@trycourier/courier");

const courier = CourierClient({ authorizationToken: "YOUR_AUTH_TOKEN_HERE" });

const { requestId } = await courier.send({
  message: {
    to: {
      email: "email@example.com",
    },
    content: {
      title: "Welcome!",
      body: "Thanks for signing up, {{name}}",
    },
    data: {
      name: "Peter Parker",
    },
    routing: {
      method: "single",
      channels: ["email"],
    },
  },
});

Copy line #5 and paste it above and outside the async function (Azure function).
Everything within lines #7-24 is related to the actual message sending, and needs to be placed inside the async function.

The code on lines #8-23 defines the message object, which provides data to Courier about the messages: the to object about the user receiving the notification, the content object about what the message contains, the data object about any variables that impact the content object or conditions for the outgoing notifications, and the routing object about the types of notifications being sent.

Update the email that this message is being sent to. To protect the identities of our spies, we will use fake contact information here.
Update the message here. For example, we can change the title or email subject to Mule Identified and the body to Beware! The mule is {{name}}. In this case, we can either hardcode the name or get it from the HTTP trigger function body.
Update the responseMessage and log it to the console. This new responseMessage will indicate to us that this HTTP triggered function runs successfully by outputting the requestId response from the Courier API call.
To run this function locally, first run the func start command in the terminal, enabling the trigger for this function (and all functions within this project, if there were others). This command will also return to us the corresponding local endpoint that we can use to trigger this function.

const { requestId } = await courier.send({
  message: {
    to: {
      email: "courier.demos+liedetector@gmail.com",
    },
    content: {
      title: "Mule Identified!",
      body: "Beware! The mule's name is {{name}}.",
    },
    data: {
      name: name,
    },
    routing: {
      method: "single",
      channels: ["email"],
    },
  },
});

We can use Postman or Insomnia to test this function. Here we will use the REST Client VS Code extension, which we installed earlier

Create a request.http file.
To create a new test call, type ### at the top of the request.http file.
Below, define the type of request, in this case POST, and paste the endpoint next to it.
The body of this function call still needs to be defined under the endpoint. Create an object that contains a name parameter and define it as Secret Agent Pigeon.

###
POST http://localhost:7071/api/LieDetector

{
    "name": "Secret Agent Pigeon"
}

Part 4: Analyze emotions with the Face API and send alerts with Courier

Azure Cognitive Services enables us to add cognitive capabilities to apps through APIs and AI services. Check out all of the services provided. In this final part, we will explore Azure Cognitive Services, integrate the Face API to analyze emotions, and use the Courier API to send alerts when specific deceiving emotions are detected.

To access the Face API, navigate to the Azure portal.
“Create a Resource” and locate “AI + Machine Learning” in the list of categories on the left.
Select “Face” from the list of services that appear and update the settings based on our preferences and account.
Hit “Review + Create” and then “Create” to begin the deployment process (this takes a few minutes to complete).
Once deployment is complete, head over to the resource, navigate to “Keys and Endpoints” on the left menu under “Resource Management”, copy one of the keys and the endpoint, and save them within our project in the local.settings.json file.

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "",
    "FUNCTIONS_WORKER_RUNTIME": "node",
    "API_KEY": "replace-with-your-key",
    "FACE_API_KEY": "replace-with-your-azure-key",
    "FACE_ENDPOINT": "replace-with-your-azure-endpoint"
  }
}

These values are treated as secret keys and this file is included in the .gitignore.

Just as we used the Courier SDK, we will use the Face service with Azure’s SDK, which can be found on the Azure Cognitive Services npm page. We will need to use both commands on this page.

Run npm install @azure/cognitiveservices-face in the terminal to install the Face service SDK.
Run npm install @azure/ms-rest-azure-js in the terminal to install the REST Azure Client.
Copy the sample Face API call from the sample code and place it into our codebase.
Move the import statements to the top, above the Azure Function.

const { FaceClient, FaceModels } = require("@azure/cognitiveservices-face");
const { CognitiveServicesCredentials } = require("@azure/ms-rest-azure-js");

async function main() {
  const faceKey = process.env["faceKey"] || "<faceKey>";
  const faceEndPoint = process.env["faceEndPoint"] || "<faceEndPoint>";
  const cognitiveServiceCredentials = new CognitiveServicesCredentials(faceKey);
  const client = new FaceClient(cognitiveServiceCredentials, faceEndPoint);
  const url =
    "https://pbs.twimg.com/profile_images/3354326900/3a5168f2b45c07d0965098be1a4e3007.jpeg";
  const options = {
    returnFaceLandmarks: true
  };
  client.face
    .detectWithUrl(url, options)
    .then(result => {
      console.log("The result is: ");
      console.log(result);
    })
    .catch(err => {
      console.log("An error occurred:");
      console.error(err);
    });
}

main();

Now, we can update the variables within the code snippet.

Update the name of the function on line #43 and the associated function call on line #65 to analyze_face().
Fix the key names on lines #44 and #45 to match the names we created in the local.settings.json file.
Line #49 contains the image this API will analyze. Find a link to an image of our own - to protect the identities of our spies, we will use IU’s image.
Change the options object between lines #50 to #52 to returnFaceAttributes and add an array with emotion as an element.

async function analyze_face() {
  const faceKey = process.env["FACE_API_KEY"];
  const faceEndPoint = process.env["FACE_ENDPOINT"];
  const cognitiveServiceCredentials = new CognitiveServicesCredentials(faceKey);
  const client = new FaceClient(cognitiveServiceCredentials, faceEndPoint);
  const url =
    "https://www.allkpop.com/upload/2021/12/content/231225/web_data/allkpop_1640280755_untitled-1.jpg";
  const options = {
    returnFaceAttributes: ["emotions"]
  };
  client.face
    .detectWithUrl(url, options)
    .then(result => {
      console.log("The result is: ");
      console.log(result);
    })
    .catch(err => {
      console.log("An error occurred:");
      console.error(err);
    });
}

analyze_face();

Finally, we need to be able to manipulate the response from this API call.

Save the response in a variable called result.
Convert the response into a JSON string using the stringify method.

const result = await client.face.detectWithUrl(url, options);
const resultJSON = JSON.stringify(result, null, 2);

We run into an error when we use the REST Client to test our function. The result is not displayed, which means that for some reason, analyze_face() is not returning the correct response. We can check the Face API reference to determine the cause of the error. We can first attempt to resolve the issue by removing a specific emotion from the result object.

const result = await client.face.detectWithUrl(url, options);
const anger = result[0].faceAttributes.emotion.anger;
const angerJSON = JSON.stringify(anger, null, 2);

The actual error stems from a typo on line #51 where the object returned is not plural and should be called emotion. When we test the code, we see that the anger emotion has a value of 0, which matches the selected image.

const options = {
      returnFaceAttributes: ["emotion"]
  };

Finally, instead of returning the value of a single emotion, update the analyze_face() function to return the entire emotion object. This will enable us to compare multiple emotions' values and determine whether the face being analyzed is deceitful.

const result = await client.face.detectWithUrl(url, options);
return result[0].faceAttributes.emotion;

Following instructions from Headquarters, we know that our questions should only invoke specific reactions. If a face shows any hint of anger, neutral, or contempt emotions, we will have to assume that the person being questioned is the mule.

Extract these emotions.

const emotions = await analyze_face();
const anger = emotions.anger;
const angerJSON = JSON.stringify(anger, null, 2);
const neutral = emotions.neutral;
const neutralJSON = JSON.stringify(neutral, null, 2);
const contempt = emotions.contempt;
const contemptJSON = JSON.stringify(contempt, null, 2);

With a simple condition, compare them to 0.

if((angerJSON > 0)||(neutralJSON > 0)||(contemptJSON > 0)) {
        deceptive = true;
    }

Send out alerts to our entire spy network if and when these values are larger than 0.

const { CourierClient } = require("@trycourier/courier");
const { FaceClient, FaceModels } = require("@azure/cognitiveservices-face");
const { CognitiveServicesCredentials } = require("@azure/ms-rest-azure-js");

const apikey = process.env["API_KEY"];
const courier = CourierClient({ authorizationToken: apikey });

module.exports = async function (context, req) {
    context.log('JavaScript HTTP trigger function processed a request.');

    const name = (req.query.name || (req.body && req.body.name));

    const emotions = await analyze_face();
    const anger = emotions.anger;
    const angerJSON = JSON.stringify(anger, null, 2);
    const neutral = emotions.neutral;
    const neutralJSON = JSON.stringify(neutral, null, 2);
    const contempt = emotions.contempt;
    const contemptJSON = JSON.stringify(contempt, null, 2);

    let deceptive = false;

    if((angerJSON > 0)||(neutralJSON > 0)||(contemptJSON > 0)) {
        deceptive = true;
    }

    if(deceptive) {
        const { requestId } = await courier.send({
            message: {
              to: {
                email: "courier.demos+liedetector@gmail.com",
              },
              content: {
                title: "Mule Identified!",
                body: "Beware! The mule's name is {{name}}.",
              },
              data: {
                name: name,
              },
              routing: {
                method: "single",
                channels: ["email"],
              },
            },
          });
    }

    const responseMessage = "The HTTP trigger function ran successfully.";

    context.res = {
        // status: 200, /* Defaults to 200 */
        body: {
            responseMessage,
            "anger": angerJSON,
            "neutral": neutralJSON,
            "contempt": contemptJSON

        }
    };
}

async function analyze_face() {
  const faceKey = process.env["FACE_API_KEY"];
  const faceEndPoint = process.env["FACE_ENDPOINT"];
  const cognitiveServiceCredentials = new CognitiveServicesCredentials(faceKey);
  const client = new FaceClient(cognitiveServiceCredentials, faceEndPoint);
  const url =
    "https://www.allkpop.com/upload/2021/12/content/231225/web_data/allkpop_1640280755_untitled-1.jpg";
  const options = {
      returnFaceAttributes: ["emotion"]
  };
  const result = await client.face.detectWithUrl(url, options)
  return result[0].faceAttributes.emotion;
}

Conclusion

Our lie detector is ready and will alert our spies anytime a captive tries to mess with us. Try building a lie detector of your own and alerting courier.demos+liedetector@gmail.com, and we will send a gift to the first three Secret Agents to complete this task! Head to courier.com/hack-now to get started. Don’t forget to submit your project to our Hackathon for a chance to win over $1000 in cash and prizes!

Quick Links

🔗 GitHub Repository: https://github.com/shreythecray/lie-detector

🔗 Video tutorial: https://youtu.be/0RJ9m-T7sgU

🔗 Courier: app.courier.com

🔗 Register for the Hackathon: https://courier-hacks.devpost.com/

🔗 Courier's Get Started with Node.js: https://www.courier.com/docs/guides/getting-started/nodejs/

🔗 Courier Send API Docs: https://www.courier.com/docs/reference/send/message/

🔗 Twilio Messaging Service SID Docs: https://support.twilio.com/hc/en-us/articles/223181308-Getting-started-with-Messaging-Services

🔗 Courier API Reference: https://www.courier.com/docs/reference/

🔗 Azure for Students: https://azure.microsoft.com/en-us/free/students/

🔗 Troubleshooting Azure Account Setup: https://github.com/microsoft/vscode-azure-account/wiki/Troubleshooting#setup-your-azure-account

🔗 Azure Cognitive Services: https://azure.microsoft.com/en-us/services/cognitive-services/#overview

🔗 Azure Portal: https://portal.azure.com/

🔗 Azure Cognitive Services SDK: https://www.npmjs.com/package/@azure/cognitiveservices-face

Create a Discord Bot that Automates Secret Messages with Node.js

Shreya — Tue, 11 Oct 2022 17:59:20 +0000

Before Starting

GitHub Repository: https://github.com/shreythecray/infiltration

The open source hackathon just started, and we are giving away over $1K in prizes! Join us in building a cool project and winning any of the following prizes. 🏆

Courier Hacks: Open Source Winner: Top submission for use for notifications and demonstration of proper app-to-user notifications with the Courier API will receive $1000 via Zelle or PayPal.
Security Experience: Best project to integrate OAuth and require users to login will receive a $200 (USD) Amazon gift card.
Frontend Experience: Project with the best frontend design and accessibility experience will receive a $200 (USD) Amazon gift card.
Automated Experience: Best demonstration of how apps can help users automate their day-to-day processes. Can but does not need to use Automations API will receive a $200 (USD) Amazon gift card.

Additionally, everyone who submits a project successfully integrating the Courier API will receive a $20 Amazon gift card (limitations apply)! Submissions close on October 26th. Register now to submit this project for a chance to win some cool prizes.

Not sure where to start? In this tutorial, we will create a Discord bot that sends daily automated messages encrypted in Morse code with Node.js and the Courier API.

What is Going On?

Recap

We are secret agents, and we previously built an application to send secret messages encrypted in Morse code to communicate with our spy network. Learn more >

Last time, headquarters told us that one of our spies had leaked sensitive, top-secret information to our enemies, so we built a lie detector that alerted our spy network when we identified the mole. We used Azure's Cognitive Services to perform facial recognition on everyone on our team and Courier to broadcast the identity of the mole to our spy network. Learn more >

What’s Next:

We have successfully identified the mule and have alerted our spy network! In an unfortunate turn of events, the mule happens to be our partner, Agent X, and now we are being suspected as a traitor as well. Since we are highly skilled, Headquarters knows that the Lie Detector won’t work on us, but we have been placed off-duty until we can prove that we are innocent.

Before we were removed from duty, we were able to use the Lie Detector to find out that the enemy had thousands of civilians under control in a secret Discord server. The civilians are being brainwashed with enemy propaganda every day. To prove our innocence, we decide to go undercover and infiltrate the enemy’s Discord server. With the help of Agent X, we have been added to the server as an administrator. Our plan is to create and install a Discord bot that automates encrypted messages to the civilians and alerts them about the situation so that they can escape.

Let’s Build

Pre-reqs:

Admin access to a Discord server
A cool undercover Agent name for our Discord bot
Optional: a cool undercover Agent profile picture for our Discord bot

Part 1: Set Up Node.js Project

Today, we will be building this with Node.js. If you’re curious about how to build this project using Ruby, cURL, Powershell, Go, PHP, Python, or Java, let us know: https://discord.com/invite/courier. You can also access code for these within our API reference. Let’s get started:

Create a new project folder.
Create three new files: “index.js”, “.env”, and “.gitignore”.
Install dotenv npm package to store variables: npm install dotenv --save

Import and configure dotenv by adding to top of index.js: require("dotenv").config();
Similarly, install node-fetch npm package to make API calls: npm install node-fetch@2

Import and configure node-fetch by adding to top of index.js: const fetch = require("node-fetch");

Part 2: Create a Discord Bot

Sign up for (or log into) Courier >
Open Discord provider in Channels. Here we will need our Discord bot token to continue.
In order to access a Discord bot token, we’ll create a Discord application and add a Discord bot.
- Click on “New Application” within the Discord Developer Dashboard.
- Type the app’s name and click “Create”.
- In the left menu, open the “Bot” page and click “Add Bot”. We can update the icon and username (bot icon file can be found in the GitHub linked above).
Once the bot has been created, copy the bot token provided and paste it in Courier (make sure to keep this token private).
We will need to give this application permission to post as the bot within our server. Check out the Bot permissions documentation.
- Within the application, head over to OAuth2 and click on URL generator
- Select the bot scope
- Select the following permissions: View Channels, Send Messages, and Read Message History
- Go to the generated URL below. This URL will invite the bot to the server and authorize it with the permissions chosen.
On Discord, click on User Settings (next to username on the bottom left). Access the Advanced settings page and enable Developer Mode ✅.
Back in the Discord server, right click on the channel and copy the channel ID (bottom of list). Add this as the value of channelID in the .env file within the project and save it as a variable within the index.js file:
```
const channelID = process.env.channelID
```

Now, Courier has access to sending messages to this server as the bot.

Part 3: Send Messages

Create a new notification within the Notification Designer
Add the Chat notification channel with Discord as the provider
Select on the Chat channel on the right to edit the message
Write and publish the message. We need to create a clear message that will indicate to our civilians how to escape. Our message will be: Run while you can. You can find shelter here: https://discord.com/invite/courier.
Copy the notification template ID from the notification’s settings and add it as the value of templateID in the .env file within the project and save it as a variable within the index.js file:
```
const templateID = process.env.templateID
```

Create a test event and replace the channel_id in the JSON with the channel_id we received from Discord earlier.

{
  "courier": {},
  "data": {},
  "profile": {
    "discord": {
      "channel_id": "768866348853383208"
    }
  },
  "override": {}
}

Test a test message to ensure that the Discord provider integration is working correctly.
Replace the message with a variable {secretMessage} so that, later, we can edit the message from our code directly.

Part 4: Encrypt Message with the Morse API

Create an asynchronous function called encryptMessage(), which takes originalMessage as a parameter. This function will call the Morse API, which will allow us to translate any message from English to Morse code. The enemy will have to spend more time and resources into decrypting our messages, which will give our civilians time to escape from the server.
```
async function encryptMessage(originalMessage) {
}
```

Let’s define the GET API call options:

const morseOptions = {
    method: 'GET',
    headers: {
        Accept: 'application/json',
        'Content-Type': 'application/json'
    }
};

We need to attach the originalMessage function parameter to the Morse API endpoint:

const morseEndpoint = "https://api.funtranslations.com/translate/morse.json?text="+originalMessage

We need to be able to access the translation from this API call in the body of the Courier API call. To call the API, we can use node-fetch as we did before.
- Create a variable called morseResponse, which will hold the entire response from this call.
- Convert the JSON object into a JavaScript object morseResponseJSON so that we can read it within our code.
- Get the translated message out of that object and save it in a new variable called encryptedMessage.
- Return encryptedMessage so that we can call this function to access it elsewhere.
```
const morseResponse = await fetch(morseEndpoint, morseOptions);
const morseResponseJSON = await morseResponse.json();
const encryptedMessage = morseResponseJSON.contents.translated;
console.log(encryptedMessage);
return encryptedMessage;
```

NOTE: The Morse API has a rate limit, which may give you an error if you run it too many times within the hour. In this case, you will have to wait for some time before continuing.

Part 5: Automate Messages

Learn about Automations >

Check out the Automations API reference >

Create a new asynchronous function called runDiscordAutomation(), which will call the encryptMessage() function to translate a message and use the Courier API to automatically send messages to the enemy Discord server everyday.
```
async function runDiscordAutomation() {
}
```
Before we can run our message through the Morse translation API, we need to ensure that it is in the correct format, with all spaces converted into their URL encoding, %20 as shown below. We can call encryptMessage() with originalMessage as a parameter to translate it. encryptedMessage will evaluate as the translated message.
```
const originalMessage = "run%20while%20you%20can%20you%20can%20find%20shelter%20here";
const encryptedMessage = await encryptMessage(originalMessage);
```
Add the link to the safe server in the notification template within the designer: “https://discord.com/invite/courier”

Let’s define the Courier Automation endpoint and options. Here we will need access to our Courier API Key, which can be found within the Courier Settings page. Save the first value in the .env file as apiKey and access it in this file as process.env.apiKey.

const automationsEndpoint = "https://api.courier.com/automations/invoke"

const courierOptions = {
    method: "POST",
    headers: {
        Accept: "application/json",
        "Content-Type": "application/json",
        Authorization: 'Bearer ' + process.env.apiKey
    },
    body: JSON.stringify({
        //next steps
    }),
};

The body object within the options will encompass two objects: automation and data
```
body: JSON.stringify({
    "automation": {
    },
    "data": {
    } 
}),
```
- The automation object will include a steps array, which will consist of all steps required for the automation. Our automation consists of reminders that are sent once a day - in this case we will be adding three steps: a send step, a delay, and another send step (so on).
```
"automation": {
    "steps": [],
},
```
- Each step will need to be defined with two objects: the type of action (send, delay, cancel, etc.) and message. The message consists of the notification template ID (we saved this in the .env file earlier) and information about where this message is being sent. A Discord message requires either a user_id or a channel_id. In order to reach as many innocent civilians as possible, as quickly as possible, we will directly send messages in a channel.
- This is what the send and delay steps would look like:
```
{
    "action": "send",
    "message": {
        "template": templateID,
        "to": {
            "discord": {
                "channel_id": process.env.channelID
            }
        }
    }
},
```

    ```json
    {
        "action": "send",
        "duration":"1 day"
    },
    ```

- The data object would need to contain the `encryptedMessage`:

    ```jsx
    "data": {
        "secretMessage": encryptedMessage
    }
    ```

- [Learn more about sending to a channel via Courier >](https://www.courier.com/docs/guides/providers/direct-message/discord/#sending-a-message-to-a-channel)

For testing purposes, it’s easier to either remove 1 delay step or keep it at a short period like 1 minute

Finally, we can use node-fetch again to call the Automations API and trigger this automation

fetch(automationsEndpoint, courierOptions)
    .then((response) => response.json())
    .then((response) => console.log(response))
    .catch((err) => console.error(err));

Conclusion

Our Discord bot is ready to save some civilians. Try building a Discord bot of your own and tweet a screenshot of your Courier automated messages in action, and we will send a gift to the first three Secret Agents to complete this task! Head to courier.com/hack-now to get started. Don’t forget to submit your project to our Hackathon for a chance to win over $1000 in cash and prizes!

Quick Links

🔗 GitHub Repository: https://github.com/shreythecray/infiltration

🔗 Courier: app.courier.com

🔗 Register for the Hackathon: https://courier.com/hackathon

🔗 Discord Application and Bot Guide: https://discord.com/developers/docs/getting-started

🔗 Courier Discord Provider Docs: https://www.courier.com/docs/guides/providers/direct-message/discord/

🔗 Courier Automations Docs: https://www.courier.com/docs/automations/

🔗 Courier Automations API Reference: https://www.courier.com/docs/reference/

Build a Serverless Lie Detector that uses AI for Facial Recognition

Shreya — Wed, 14 Sep 2022 15:51:21 +0000

GitHub Repository: https://github.com/shreythecray/lie-detector

Follow along with the video tutorial:

Courier Hacks 1st Place: Top submission for use for notifications and demonstration of proper app-to-user notifications with the Courier API will receive $1000 via Zelle or PayPal.
Courier Hacks 2nd Place: 2nd Place submission for use for notifications and demonstration of proper app-to-user notifications with the Courier API will receive the Apple AirPods Pro.
Public Favorite: Public favorite winner will receive a Keychron Keyboard.
Runners-Up: Runners-up submissions will receive a Hydro Flask.

Not sure where to start? In this tutorial, we will build a serverless lie detector that uses Artificial Intelligence for Facial Recognition.

What’s going on?

Some spies are in an area where they can only guarantee secure messaging through emails, and others prefer quick and secure SMS, so we need to ensure our app can accommodate all spy preferences.

Note: The first three Secret Agents to successfully complete this tutorial and task will receive a top-secret gift from HQ via Courier.

Instructions

Part 1: Create a serverless application using Azure Functions

We first need to set up our local development environment to enable using Azure and testing our code.

Install the following VS Code Extensions:
- Azure Tools to create Azure Functions,
- REST Client to test our Azure Function calls (this is an alternative to Postman or Insomnia).

Once the two extensions have been installed successfully, check the left menu for Azure’s A symbol. Completely close and reopen VS Code if the symbol does not automatically appear.

To build an HTTP Trigger Function:

Click on the Azure symbol to open Azure locally. Here we are prompted to sign into our Azure account.
After signing in, we need to open an Azure Subscription or create a new one.
- Note that students can get free credits for Azure.

If the subscription is not showing up locally, follow instructions from the documentation on how to set up our account, which tells us to sign out of Azure on VS Code and sign back in.

Once the subscription appears, click on “Workspace” and create a new project.
Determine where we need to save the files within this project and how we want to name it locally.

Once the location has been selected, we are prompted to make a few decisions about the type of function we want to create.

Select JavaScript for the language
Select HTTP Trigger for template
Rename the function to LieDetector (or any unique name)
Select Function for the Authorization Level.
Open the project to start coding.

You can edit settings later within the function.json file. Let’s open the index.js file and take a moment to understand the boilerplate function.

module.exports = async function (context, req) {
    context.log('JavaScript HTTP trigger function processed a request.');

    const name = (req.query.name || (req.body && req.body.name));
    const responseMessage = name
        ? "Hello, " + name + ". This HTTP triggered function executed successfully."
        : "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.";

    context.res = {
        // status: 200, /* Defaults to 200 */
        body: responseMessage
    };
}

Part 2: Authorize Courier to send messages using Gmail and Twilio APIs

Courier sends messages by consolidating multiple API calls into one. In this second part, we will need to authorize our API to send messages via the Gmail and Twilio APIs.

Log in to your Courier account and create a new secret workspace.
For onboarding, select the email channel and let Courier build with Node.js. Start with the Gmail API since it only takes seconds to set up. All we need to do to authorize is log in via Gmail. Now the API is ready to send messages.
Copy the starter code, a basic API call using cURL, and paste it into a new terminal. It already has saved your API key, knows which email address you want to send to, and has a built-in message.

Once you see Agent Pigeon dancing, we are ready to use Courier to communicate with our spies. Before we build out our application, we need to set up the Twilio provider to enable text messages.

Head over to “Channels" in the left menu and search for Twilio. You will need an Account SID, Auth Token, and a Messaging Service SID to authorize Twilio.
Open twilio.com, login and open the console, and find the first two tokens on that page. Save the Account SID and Auth Token in Courier.

Once we have all three pieces of information, install the provider. Your Courier account is officially authorized to send any email or SMS within one API call.

Part 3: Send single and multi-channel notifications from the Azure function

If you would rather use the Courier API, check out the Secret Message tutorial for instructions or Courier’s API Reference for documentation.

The SDK documentation walks us through getting access to the API key.

Find the API key on https://app.courier.com/settings/api-keys.
Save the API key in the local.settings.json file and bring it into the index.js file as const apiKey = process.env["API_KEY"]. This application can now be authorized to use our Courier account.

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "",
    "FUNCTIONS_WORKER_RUNTIME": "node",
    "API_KEY": "replace-with-your-key"
  }
}

Install the Courier SDK by running the following command in the terminal: npm install @trycourier/courier
Use the require function to import the SDK into the index.js file.

const { CourierClient } = require("@trycourier/courier");

The last step is to walk through the API call within the API docs and integrate it into our codebase.

import { CourierClient } from "@trycourier/courier";
// alternatively:
// const { CourierClient } = require("@trycourier/courier");

const courier = CourierClient({ authorizationToken: "YOUR_AUTH_TOKEN_HERE" });

const { requestId } = await courier.send({
  message: {
    to: {
      email: "email@example.com",
    },
    content: {
      title: "Welcome!",
      body: "Thanks for signing up, {{name}}",
    },
    data: {
      name: "Peter Parker",
    },
    routing: {
      method: "single",
      channels: ["email"],
    },
  },
});

Copy line #5 and paste it above and outside the async function (Azure function).
Everything within lines #7-24 is related to the actual message sending, and needs to be placed inside the async function.

Update the email that this message is being sent to. To protect the identities of our spies, we will use fake contact information here.
Update the message here. For example, we can change the title or email subject to Mule Identified and the body to Beware! The mule is {{name}}. In this case, we can either hardcode the name or get it from the HTTP trigger function body.
Update the responseMessage and log it to the console. This new responseMessage will indicate to us that this HTTP triggered function runs successfully by outputting the requestId response from the Courier API call.
To run this function locally, first run the func start command in the terminal, enabling the trigger for this function (and all functions within this project, if there were others). This command will also return to us the corresponding local endpoint that we can use to trigger this function.

const { requestId } = await courier.send({
  message: {
    to: {
      email: "courier.demos+liedetector@gmail.com",
    },
    content: {
      title: "Mule Identified!",
      body: "Beware! The mule's name is {{name}}.",
    },
    data: {
      name: name,
    },
    routing: {
      method: "single",
      channels: ["email"],
    },
  },
});

We can use Postman or Insomnia to test this function. Here we will use the REST Client VS Code extension, which we installed earlier

Create a request.http file.
To create a new test call, type ### at the top of the request.http file.
Below, define the type of request, in this case POST, and paste the endpoint next to it.
The body of this function call still needs to be defined under the endpoint. Create an object that contains a name parameter and define it as Secret Agent Pigeon.

###
POST http://localhost:7071/api/LieDetector

{
    "name": "Secret Agent Pigeon"
}

Part 4: Analyze emotions with the Face API and send alerts with Courier

To access the Face API, navigate to the Azure portal.
“Create a Resource” and locate “AI + Machine Learning” in the list of categories on the left.
Select “Face” from the list of services that appear and update the settings based on our preferences and account.
Hit “Review + Create” and then “Create” to begin the deployment process (this takes a few minutes to complete).
Once deployment is complete, head over to the resource, navigate to “Keys and Endpoints” on the left menu under “Resource Management”, copy one of the keys and the endpoint, and save them within our project in the local.settings.json file.

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "",
    "FUNCTIONS_WORKER_RUNTIME": "node",
    "API_KEY": "replace-with-your-key",
    "FACE_API_KEY": "replace-with-your-azure-key",
    "FACE_ENDPOINT": "replace-with-your-azure-endpoint"
  }
}

These values are treated as secret keys and this file is included in the .gitignore.

Just as we used the Courier SDK, we will use the Face service with Azure’s SDK, which can be found on the Azure Cognitive Services npm page. We will need to use both commands on this page.

Run npm install @azure/cognitiveservices-face in the terminal to install the Face service SDK.
Run npm install @azure/ms-rest-azure-js in the terminal to install the REST Azure Client.
Copy the sample Face API call from the sample code and place it into our codebase.
Move the import statements to the top, above the Azure Function.

const { FaceClient, FaceModels } = require("@azure/cognitiveservices-face");
const { CognitiveServicesCredentials } = require("@azure/ms-rest-azure-js");

async function main() {
  const faceKey = process.env["faceKey"] || "<faceKey>";
  const faceEndPoint = process.env["faceEndPoint"] || "<faceEndPoint>";
  const cognitiveServiceCredentials = new CognitiveServicesCredentials(faceKey);
  const client = new FaceClient(cognitiveServiceCredentials, faceEndPoint);
  const url =
    "https://pbs.twimg.com/profile_images/3354326900/3a5168f2b45c07d0965098be1a4e3007.jpeg";
  const options = {
    returnFaceLandmarks: true
  };
  client.face
    .detectWithUrl(url, options)
    .then(result => {
      console.log("The result is: ");
      console.log(result);
    })
    .catch(err => {
      console.log("An error occurred:");
      console.error(err);
    });
}

main();

Now, we can update the variables within the code snippet.

Update the name of the function on line #43 and the associated function call on line #65 to analyze_face().
Fix the key names on lines #44 and #45 to match the names we created in the local.settings.json file.
Line #49 contains the image this API will analyze. Find a link to an image of our own - to protect the identities of our spies, we will use IU’s image.
Change the options object between lines #50 to #52 to returnFaceAttributes and add an array with emotion as an element.

async function analyze_face() {
  const faceKey = process.env["FACE_API_KEY"];
  const faceEndPoint = process.env["FACE_ENDPOINT"];
  const cognitiveServiceCredentials = new CognitiveServicesCredentials(faceKey);
  const client = new FaceClient(cognitiveServiceCredentials, faceEndPoint);
  const url =
    "https://www.allkpop.com/upload/2021/12/content/231225/web_data/allkpop_1640280755_untitled-1.jpg";
  const options = {
    returnFaceAttributes: ["emotions"]
  };
  client.face
    .detectWithUrl(url, options)
    .then(result => {
      console.log("The result is: ");
      console.log(result);
    })
    .catch(err => {
      console.log("An error occurred:");
      console.error(err);
    });
}

analyze_face();

Finally, we need to be able to manipulate the response from this API call.

Save the response in a variable called result.
Convert the response into a JSON string using the stringify method.

const result = await client.face.detectWithUrl(url, options);
const resultJSON = JSON.stringify(result, null, 2);

const result = await client.face.detectWithUrl(url, options);
const anger = result[0].faceAttributes.emotion.anger;
const angerJSON = JSON.stringify(anger, null, 2);

const options = {
      returnFaceAttributes: ["emotion"]
  };

Finally, instead of returning the value of a single emotion, update the analyze_face() function to return the entire emotion object. This will enable us to compare multiple emotions' values and determine whether the face being analyzed is deceitful.

const result = await client.face.detectWithUrl(url, options);
return result[0].faceAttributes.emotion;

Extract these emotions.

const emotions = await analyze_face();
const anger = emotions.anger;
const angerJSON = JSON.stringify(anger, null, 2);
const neutral = emotions.neutral;
const neutralJSON = JSON.stringify(neutral, null, 2);
const contempt = emotions.contempt;
const contemptJSON = JSON.stringify(contempt, null, 2);

With a simple condition, compare them to 0.

if((angerJSON > 0)||(neutralJSON > 0)||(contemptJSON > 0)) {
        deceptive = true;
    }

Send out alerts to our entire spy network if and when these values are larger than 0.

const { CourierClient } = require("@trycourier/courier");
const { FaceClient, FaceModels } = require("@azure/cognitiveservices-face");
const { CognitiveServicesCredentials } = require("@azure/ms-rest-azure-js");

const apikey = process.env["API_KEY"];
const courier = CourierClient({ authorizationToken: apikey });

module.exports = async function (context, req) {
    context.log('JavaScript HTTP trigger function processed a request.');

    const name = (req.query.name || (req.body && req.body.name));

    const emotions = await analyze_face();
    const anger = emotions.anger;
    const angerJSON = JSON.stringify(anger, null, 2);
    const neutral = emotions.neutral;
    const neutralJSON = JSON.stringify(neutral, null, 2);
    const contempt = emotions.contempt;
    const contemptJSON = JSON.stringify(contempt, null, 2);

    let deceptive = false;

    if((angerJSON > 0)||(neutralJSON > 0)||(contemptJSON > 0)) {
        deceptive = true;
    }

    if(deceptive) {
        const { requestId } = await courier.send({
            message: {
              to: {
                email: "courier.demos+liedetector@gmail.com",
              },
              content: {
                title: "Mule Identified!",
                body: "Beware! The mule's name is {{name}}.",
              },
              data: {
                name: name,
              },
              routing: {
                method: "single",
                channels: ["email"],
              },
            },
          });
    }

    const responseMessage = "The HTTP trigger function ran successfully.";

    context.res = {
        // status: 200, /* Defaults to 200 */
        body: {
            responseMessage,
            "anger": angerJSON,
            "neutral": neutralJSON,
            "contempt": contemptJSON

        }
    };
}

async function analyze_face() {
  const faceKey = process.env["FACE_API_KEY"];
  const faceEndPoint = process.env["FACE_ENDPOINT"];
  const cognitiveServiceCredentials = new CognitiveServicesCredentials(faceKey);
  const client = new FaceClient(cognitiveServiceCredentials, faceEndPoint);
  const url =
    "https://www.allkpop.com/upload/2021/12/content/231225/web_data/allkpop_1640280755_untitled-1.jpg";
  const options = {
      returnFaceAttributes: ["emotion"]
  };
  const result = await client.face.detectWithUrl(url, options)
  return result[0].faceAttributes.emotion;
}

Conclusion

Quick Links

🔗 GitHub Repository: https://github.com/shreythecray/lie-detector

🔗 Video tutorial: https://youtu.be/0RJ9m-T7sgU

🔗 Courier: app.courier.com

🔗 Register for the Hackathon: https://courier-hacks.devpost.com/

🔗 Courier's Get Started with Node.js: https://www.courier.com/docs/guides/getting-started/nodejs/

🔗 Courier Send API Docs: https://www.courier.com/docs/reference/send/message/

🔗 Twilio Messaging Service SID Docs: https://support.twilio.com/hc/en-us/articles/223181308-Getting-started-with-Messaging-Services

🔗 Courier API Reference: https://www.courier.com/docs/reference/

🔗 Azure for Students: https://azure.microsoft.com/en-us/free/students/

🔗 Troubleshooting Azure Account Setup: https://github.com/microsoft/vscode-azure-account/wiki/Troubleshooting#setup-your-azure-account

🔗 Azure Cognitive Services: https://azure.microsoft.com/en-us/services/cognitive-services/#overview

🔗 Azure Portal: https://portal.azure.com/

🔗 Azure Cognitive Services SDK: https://www.npmjs.com/package/@azure/cognitiveservices-face

Sending Secret Messages with the Courier API and Node.js

Shreya — Tue, 06 Sep 2022 20:57:07 +0000

Follow along with the video tutorial:

We are launching our first hackathon next week, and giving away over $1K in prizes! Join us in building a cool project and winning any of the following prizes 🏆

Courier Hacks 1st Place: Top submission for use for notifications and demonstration of proper app-to-user notifications with the Courier API will receive $1000 via Zelle or PayPal.
Courier Hacks 2nd Place: 2nd Place submission for use for notifications and demonstration of proper app-to-user notifications with the Courier API will receive the Apple AirPods Pro.
Public Favorite: Public favorite winner will receive a Keychron Keyboard.
Runners-Up: Runners-up submissions will receive a Hydro Flask.

Additionally, everyone who submits a project successfully integrating the Courier API will receive a $20 Amazon gift card!

Not sure where to start? In this tutorial, we will be building a Node.js app that sends multi-channel notifications in morse code.

What’s going on?

We are secret agents today, and our goal is to send encoded messages to our spy network. Some spies prefer reading emails, and others prefer reading texts, so we need to ensure that our app can accommodate all spy preferences.

Note: The first five secret agents to successfully complete this tutorial and this task will receive a gift from Courier.

In Chapter 1, we will first integrate the Gmail and Twilio APIs, which Courier will use to send emails and text messages. In Chapter 2, we will demonstrate how to send single messages and setup routing to send multi-channel notifications. In Chapter 3, we will integrate a translation API to convert our messages into Morse code.

We are hosting our first hackathon next month, starting September 5th until September 30th. Register now to submit this project for a chance to win some cool prizes.

Instructions

Chapter 1: Authorize Courier to send messages using Gmail and Twilio APIs

In this first Chapter, we will need to authorize our API to send the secret messages. Let’s get started by integrating the Gmail and Twilio APIs, enabling Courier to send emails and messages from a single API call.

Log in to your Courier account and create a new secret workspace.
For onboarding, select the email channel and let Courier build with Node.js. Start with the Gmail API since it only takes seconds to set up. All we need to do to authorize is log in via Gmail. Now the API is ready to send messages.
Copy the starter code, a basic API call using cURL, and paste it in a new terminal. It already has saved your API key and knows which email address you want to send to, and has a message already built in.

Once you can see the dancing pigeon, you are ready to use Courier to send more notifications. Before we build out our application, we need to set up the Twilio provider to enable text messages.

Head over to “Channels" in the left menu and search for Twilio. You will need an Account SID, Auth Token, and a Messaging Service SID to authorize Twilio.
Open twilio.com, login and open the Console, and find the first two tokens on that page. Save the Account SID and Auth Token in Courier.

Lasty, you need to locate the Messaging Service SID, which you create in the Messaging tab on the left menu. Checkout Twilio’s docs on how to create a Messaging Service SID, linked in the description.

Once we have all three pieces of information, install the provider. Now your Courier account is authorized to send any email or SMS within one API call.

Chapter 2: Send single and multi-channel notifications

In this next Chapter, you will start sending messages. To send the secret messages, head to the Send API documentation. Here you can find everything related to sending messages.

On the right, you will see some starter code and can select a language of your choice from cURL, Node.js, Ruby, Python, Go, or PHP.

Select Node.js to get started.

// Dependencies to install:
// $ npm install node-fetch --save

const fetch = require('node-fetch');

const options = {
  method: 'POST',
  headers: {
    Accept: 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "message": {
      "template": "NOTIFICATION_TEMPLATE"
    }
  })
};

fetch('https://api.courier.com/send', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));

This ]basic POST request can be edited to include the spies’ data such as how to contact them and the message you need to send. The “Notification Template” can be replaced with your own template.

Add an email address in the email field on the left, which you will notice automatically appears in the code snippet on the right.

// Dependencies to install:
// $ npm install node-fetch --save

const fetch = require('node-fetch');

const options = {
  method: 'POST',
  headers: {
    Accept: 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "message": {
      "template": "NOTIFICATION_TEMPLATE",
      "to": {
        "email": "courier.demos+secretmessage@gmail.com"
      }
    }
  })
};

fetch('https://api.courier.com/send', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));

Next, you need to add the actual message you are sending. These messages are pretty simple, so you can write them directly into the API call instead of creating a template.

Write in a subject in the title object (this can be changed anytime).
In the email body, write your message.

// Dependencies to install:
// $ npm install node-fetch --save

const fetch = require('node-fetch');

const options = {
  method: 'POST',
  headers: {
    Accept: 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "message": {
      "to": {
        "email": "courier.demos+secretmessage@gmail.com"
      },
      "content": {
        "title": "new subject",
        "body": "message"
      }
    }
  })
};

fetch('https://api.courier.com/send', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));

As before, the data on the left automatically appears in the code snippet on the right. There is a content object that encompasses the title and body parameters.

Now you just need to make sure that this API call has access to your Courier account, which links to the Gmail and Twilio APIs.

Replace the Auth Token with the Courier API Key (stored in Courier account settings under API Keys)[https://www.courier.com/docs/guides/getting-started/nodejs/#getting-your-api-keys].

// Dependencies to install:
// $ npm install node-fetch --save

const fetch = require('node-fetch');

const options = {
  method: 'POST',
  headers: {
    Accept: 'application/json',
    'Content-Type': 'application/json',
    Authorization: 'Bearer apikey'
  },
  body: JSON.stringify({
    "message": {
      "to": {
        "email": "courier.demos+secretmessage@gmail.com"
      },
      "content": {
        "title": "new subject",
        "body": "message"
      }
    }
  })
};

fetch('https://api.courier.com/send', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));

Send this code out from here to test that the API call works (click "Try it" above the code snippet).
Go to your Courier logs and click on the latest log for more information. You should be able to view how it is rendered for the user receiving the message. If there was an error, you should also be able to access an error code there.

Now you can integrate this code into our own Node.js application.

Open VS Code and open a new project with a file called index.js.
Past the code into the index.js file.
Install the node-fetch npm package, enabling you to make API calls.
Open a terminal and paste the command to install the package.

$ npm install node-fetch --save

Run the program in the terminal.

$ node index.js

Here, you may run into a node-fetch error, which is caused by the require statement on line 4. To fix this, install a different version of the package found on the node-fetch documentation: https://www.npmjs.com/package/node-fetch#class-response.

npm install node-fetch@2

Now when you run this program, you should get a response from Courier that includes the requestID in the VS Code console. This indicates that the API call was made successfully, and you can head over to the Courier datalog to determine if the message was also sent successfully.

Since you are a Secret Agent, you should probably protect the API key in case our code gets into the wrong hands.

Create a new file called .env.
Store the API Key as a variable in the .env file.

APIKEY="fksdjfgjsdkfgndfsmn"

Install the dotenv npm package, allowing you to access the variable in the index.js file.
Once the package is installed, access the key by referring to it as process.env.APIKEY.
Add require('dotenv').config() to the top of the index.js file.
Run this program to confirm that it still works the same.

At this point, you can send a single message to the spies via email. However, you know that some spies prefer to use text messages, so you will need to enable multi-channel notifications. Let’s head back to the Courier docs and scroll down to the routing object, which contains the method and channels. Two types of methods are available - all and single. ‘All’ means that Courier will attempt to send the message to every channel listed. “Single” means that Courier will attempt to send it to the first channel that works. Let’s integrate this into our program.

Add the routing object anywhere within the message object, at the same level as to and content.
Define the channels within the same routing object - you can choose SMS or email, in this case, since you already have an email address defined.

"message": {
    "to": {
      "email": process.env.EMAIL
    },
    "content": {
      "title": "new subject",
      "body": "message"
    },
    "routing": {
      "method": "single",
      "channels": "email"
    },
}

Convert the channels property into an array to define multiple channels and list both email and SMS.

"channels": ["email", "sms"]

You now have two different channels that this message can be sent to. All methods would send this message to both email and SMS. Single method would try to send this to the first that works. Since you have the user’s email address but not their phone number, this program can only send it via email.

If the two channels were reversed, Courier would try to send an SMS, fail to do so, and then default to sending an email.

"channels": ["sms", "email"]

Add the user’s phone number to make the SMS channel work. Now this program should be able to send text messages via Twilio.

"message": {
    "to": {
      "email": process.env.EMAIL,
      "phone_number": process.env.PHONENUMBER
    },
    "content": {
      "title": "new subject",
      "body": "message"
    },
    "routing": {
      "method": "single",
      "channels": ["sms", "email"]
    },
}

Change the single method to all and run the program again.

"message": {
    "to": {
      "email": process.env.EMAIL,
      "phone_number": process.env.PHONENUMBER
    },
    "content": {
      "title": "new subject",
      "body": "message"
    },
    "routing": {
      "method": "all",
      "channels": ["sms", "email"]
    },
}

Courier can now send via Twilio and Gmail within the same API call.

Chapter 3: Integrate a translation API to convert messages to Morse code

NOTE: The Morse API has a rate limit, which may give you an error if you run it too many times within the hour. In this case, you will have to wait for some time before continuing.

In this last Chapter, you will integrate the Fun Translations Morse API to encode the secret messages and send them over to the spies. You can search for documentation on the Morse API on the Fun Translations website.. Here you have access to all the information you need to make the call - you have an endpoint and an example demonstrating that the original message is a parameter for the endpoint.

🔗 Fun Translations: https://funtranslations.com/api/#morse

🔗 Fun Translations API: https://api.funtranslations.com/

Start by encasing the Courier API call in a function.
Add a call to that function below the async function definition.
Refactor options to courier_options.

// Dependencies to install:
// $ npm install node-fetch --save

const fetch = require('node-fetch');
require('dotenv').config()

async function send_secret_message() {

    const courier_options = {
        method: 'POST',
        headers: {
          Accept: 'application/json',
          'Content-Type': 'application/json',
          Authorization: 'Bearer ' + process.env.APIKEY
        },
        body: JSON.stringify({
          "message": {
            "to": {
              "email": process.env.EMAIL,
              "phone_number": process.env.PHONENUMBER
            },
            "content": {
              "title": "new subject",
              "body": "message"
            },
            "routing": {
              "method": "all",
              "channels": ["sms", "email"]
            },
          }
        })
      };

      fetch('https://api.courier.com/send', courier_options)
        .then(response => response.json())
        .then(response => console.log(response))
        .catch(err => console.error(err));

}

send_secret_message()

Before sending the message, you first need to make a call to the Morse API to translate the message. You can use node-fetch in the same way as you did for Courier to make this call.

Copy the code within the async function to make the new API call.
Paste the code above the Courier API call.
Update the endpoint to the Morse API endpoint.
Refactor options to morse_options for the first call.
Remove the authorization token in the Morse API call since it does not require an API Key.
Remove the body object.
Add the message - “hey secret agent x this is your message” - as a parameter within the endpoint and replace all spaces in the message with its url-encode (%20).

// Dependencies to install:
// $ npm install node-fetch --save

const fetch = require('node-fetch');
require('dotenv').config()

async function send_secret_message() {

    const morse_options = {
        method: 'GET',
        headers: {
          Accept: 'application/json',
          'Content-Type': 'application/json'
        }
      };

      const original_message = "hey%20secret%20agent%20x%20this%20is%20your%20message"
      const morse_endpoint = "https://api.funtranslations.com/translate/morse.json?text="+original_message

      fetch(morse_endpoint, morse_options)
        .then(response => response.json())
        .then(response => console.log(response))
        .catch(err => console.error(err));

    const courier_options = {
        method: 'POST',
        headers: {
          Accept: 'application/json',
          'Content-Type': 'application/json',
          Authorization: 'Bearer ' + process.env.APIKEY
        },
        body: JSON.stringify({
          "message": {
            "to": {
              "email": process.env.EMAIL,
              "phone_number": process.env.PHONENUMBER
            },
            "content": {
              "title": "new subject",
              "body": "message"
            },
            "routing": {
              "method": "all",
              "channels": ["sms", "email"]
            },
          }
        })
      };

      fetch('https://api.courier.com/send', courier_options)
        .then(response => response.json())
        .then(response => console.log(response))
        .catch(err => console.error(err));

}

send_secret_message()

Comment out the Courier API call, since you only need to test the code you just added.

When you run this program, we may receive an error that states that there is an error parsing the JSON. This issue is caused by an error in the documentation, which here states that it should be a POST request. However, on a separate API documentation, it is written as a GET request. Update the call type to GET, and you should see the translated message within the response.

ObviouslyClearly, you don’t want to send all of this information to the spies, y. You only need the secret message.

Isolate the message by logging response.contents.translated.

fetch(morse_endpoint, morse_options)
    .then(response => response.json())
    .then(response => console.log(response.contents.translated))
    .catch(err => console.error(err));

You need to be able to access the translation from this API call in the body of the Courier API call.

Create a variable called morse_response, which will hold the entire response from this call.
Convert the JSON object into a JavaScript object so that you can read it within your code.
Get the translated message out of that object and save it in a new variable called message.
Log this variable to confirm that it works.

const morse_response = await fetch(morse_endpoint, morse_options)
    // .then(response => response.json())
    // .then(response => console.log(response.contents.translated))
    // .catch(err => console.error(err));
const translation = await morse_response.json();
const message = translation.contents.translated
console.log(message)

Replace the message within the body of the Courier API call with the encoded message you just saved in the message variable.

"message": {
    "to": {
      "email": process.env.EMAIL,
      "phone_number": process.env.PHONENUMBER
    },
    "content": {
      "title": "new secret message",
      "body": message
    },
    "routing": {
      "method": "all",
      "channels": ["sms", "email"]
    },
}

The Courier datalog should show that the messages were successfully encoded and sent via both SMS and email. Here’s what the email looks like:

Conclusion

Our spies are now ready to receive their secret encoded messages. Try changing the body of the content to your own secret message and send it over to courier.demos+secretmessage@gmail.com ,and we will send a gift to the first five Secret Agents who complete this task! Don’t forget to submit your project to our Hackathon for a chance to win over $1000 in cash and prizes!XYZ.

Quick Links

🔗 GitHub Repository: https://github.com/shreythecray/secret-messages

🔗 Video tutorial: https://youtu.be/6W2rIyUdmas

🔗 Courier: app.courier.com

🔗 Register for the Hackathon: https://courier-hacks.devpost.com/

🔗 Courier's Get Started with Node.js: https://www.courier.com/docs/guides/getting-started/nodejs/

🔗 Courier Send API Docs: https://www.courier.com/docs/reference/send/message/

🔗 Twilio Messaging Service SID Docs: https://support.twilio.com/hc/en-us/articles/223181308-Getting-started-with-Messaging-Services

🔗 Node-fetch: https://www.npmjs.com/package/node-fetch

🔗 Dotenv: https://www.npmjs.com/package/dotenv

🔗 Fun Translations: https://funtranslations.com/api/#morse

🔗 Fun Translations API: https://api.funtranslations.com/

Sending Secret Messages with the Courier API and Node.js

Shreya — Thu, 25 Aug 2022 03:12:00 +0000

GitHub Repository: https://github.com/shreythecray/secret-messages

Follow along the video tutorial:

We are launching our first Hackathon next week and we are giving our over $1K in prizes! Join to build a cool project and win any of the following prizes 🏆

Courier Hacks 1st Place: Top submission for use for notifications and demonstration of proper app-to-user notifications with the Courier API will receive $1000 via Zelle or PayPal.
Courier Hacks 2nd Place: 2nd Place submission for use for notifications and demonstration of proper app-to-user notifications with the Courier API will receive the Apple AirPods Pro.
Public Favorite: Public favorite winner will receive a Keychron Keyboard.
Runner Up: Runner up submission will receive a Hydroflask.

Additionally, everyone who submits a project successfully integrating the Courier API will receive a $20 Amazon gift card!

Not sure where to start? In this tutorial, we will be building a Node.js app that sends multi-channel notifications in morse code.

What’s going on?

We are secret agents today and our goal is to send encoded messages to our spy network. Some spies prefer reading emails and others prefer reading texts, so we need to make sure that our app can accommodate all spy preferences.

Note: The first 5 Secret Agents to complete this tutorial and this task successfully will receive a gift from Courier.

We are hosting our first hackathon next month, starting September 5th until September 30th. Register now to submit this project for a chance to win some cool prizes.

Instructions

Chapter 1: Authorize Courier to send messages using Gmail and Twilio APIs

In this first Chapter, we will need to authorize our API to send the secret messages. Let’s get started by integrating the Gmail and Twilio APIs, which will enable Courier to send emails and messages from a single API call.

Log into your Courier account and create a new secret workspace.
For the onboarding process, select the email channel and let Courier and build with Node.js. Start with the Gmail API since it only takes seconds to set up. All we need to do to authorization is login via Gmail. Now the API is ready to send messages.
Copy the starter code, which is a basic API call using cURL, and paste it in a new terminal. It has your API key saved already, knows which email address you want to send to, and has a message already built in.

Once you can see the dancing pigeon, you are ready to use Courier to send more notifications. Before we build out our application, we just need to set up the Twilio provider to enable text messages.

Head over to “Channels" in the left menu and search for Twilio. You will need an Account SID, Auth Token, and a Messaging Service SID to authorize Twilio.
Open twilio.com, login and open the Console, and find the first two tokens on that page. Save the Account SID and Auth Token in Courier.

You lastly just need to locate the Messaging Service SID, which can be created in the Messaging tab on the left menu. Checkout Twilio’s docs on how to create a Messaging Service SID, linked in the description.

Once we have all three pieces of information, install the provider and now your Courier account is authorized to send any email or SMS within one API call.

Chapter 2: Send single and multi-channel notifications

In this next Chapter, you will start sending messages. To actually send the secret messages, head over to the Send API documentation. Here you can find everything related to sending messages.

On the right, you will see some starter code and can select a language of your choice from cURL, Node.js, Ruby, Python, Go, or PHP.

Select Node.js to get started.

// Dependencies to install:
// $ npm install node-fetch --save

const fetch = require('node-fetch');

const options = {
  method: 'POST',
  headers: {
    Accept: 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "message": {
      "template": "NOTIFICATION_TEMPLATE"
    }
  })
};

fetch('https://api.courier.com/send', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));

This is a basic POST request that can be edited to include the spies’ data such as how to contact them and the message you need to send. The “Notification Template” can be replaced with your own template.

Add an email address in the email field on the left, which you will notice automatically appears in the code snippet on the right.

// Dependencies to install:
// $ npm install node-fetch --save

const fetch = require('node-fetch');

const options = {
  method: 'POST',
  headers: {
    Accept: 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "message": {
      "template": "NOTIFICATION_TEMPLATE",
      "to": {
        "email": "courier.demos+secretmessage@gmail.com"
      }
    }
  })
};

fetch('https://api.courier.com/send', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));

Next you need to add the actual message you are sending. These messages are pretty simple, so you can directly write them into the API call instead of creating a template.

Write in a subject in the title object (this can be changed anytime).
In the email body, write your message.

// Dependencies to install:
// $ npm install node-fetch --save

const fetch = require('node-fetch');

const options = {
  method: 'POST',
  headers: {
    Accept: 'application/json',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "message": {
      "to": {
        "email": "courier.demos+secretmessage@gmail.com"
      },
      "content": {
        "title": "new subject",
        "body": "message"
      }
    }
  })
};

fetch('https://api.courier.com/send', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));

Just as before, the data on the left automatically appears in the code snippet on the right. There is a content object that encompasses the title and body parameters.

Now you just need to make sure that this API call has access to your Courier account, which is linked to the Gmail and Twilio APIs

Replace the Auth Token with the Courier API Key (stored in Courier account settings under API Keys)[https://www.courier.com/docs/guides/getting-started/nodejs/#getting-your-api-keys].

// Dependencies to install:
// $ npm install node-fetch --save

const fetch = require('node-fetch');

const options = {
  method: 'POST',
  headers: {
    Accept: 'application/json',
    'Content-Type': 'application/json',
    Authorization: 'Bearer apikey'
  },
  body: JSON.stringify({
    "message": {
      "to": {
        "email": "courier.demos+secretmessage@gmail.com"
      },
      "content": {
        "title": "new subject",
        "body": "message"
      }
    }
  })
};

fetch('https://api.courier.com/send', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));

Send this code out from here to test that the API call works (click "Try it" above the code snippet).
Go to your Courier logs and click on the latest log for more information. You should be able to view how it rendered for the user receiving the message. If there was an error, you should be able to access an error code there as well.

Now you can integrate this code into our own Node.js application.

Open VS Code and open a new project with a file called index.js.
Past the code into the index.js file.
Install the node-fetch npm package, which will enable you to make API calls.
Open a terminal and paste the command to install the package.

$ npm install node-fetch --save

Run the program in the terminal.

$ node index.js

Here you may run into an error with node-fetch, which is caused by the require statement on line 4. To fix this, install a different version of the package found on the node-fetch documentation: https://www.npmjs.com/package/node-fetch#class-response.

npm install node-fetch@2

Now when you run this program, you should get a response from Courier that includes the requestID in the VS Code console. This indicates that the API call was made successfully and you can head over to the Courier datalog to determine if the message was sent successfully as well.

Since you a are Secret Agent, you should probably protect the API key in case our code gets in the wrong hands.

Create a new file called .env.
Store the API Key as a variable in the .env file.

APIKEY="fksdjfgjsdkfgndfsmn"

Install the dotenv npm package, which will allow you to access the variable in the index.js file.
Once the package is installed, access the key by referring to it as process.env.APIKEY.
Add require('dotenv').config() to the top of the index.js file.
Run this program to confirm that it still works the same.

At this point, you can send a single message to the spies via email. However, you know that some spies prefer to use text messages, so you will need to enable multi-channel notifications. Let’s head back to the Courier docs and scroll down to the routing object, which contains the method and channels. There are two types of methods available - all and single. All means is that Courier will attempt to send the message to every channel listed. Single means that Courier will attempt to send it to the first channel that works. Let’s integrate this into our program.

Add the routing object anywhere within the message object, at the same level as to and content.
Define the channels within the same routing object - you can choose SMS or email, in this case, since you already have an email address defined.

"message": {
    "to": {
      "email": process.env.EMAIL
    },
    "content": {
      "title": "new subject",
      "body": "message"
    },
    "routing": {
      "method": "single",
      "channels": "email"
    },
}

Convert the channels property into an array to define multiple channels and list both email and SMS.

"channels": ["email", "sms"]

You now have 2 different channels that this message can be sent to. all methods would send this message to both email and SMS. single method would try to send this to the first that works. Since you have the user’s email address but not their phone number, this program can only send it via email.

If the two channels were reversed, Courier would try to send an SMS, fail to do so, and then default to sending an email.

"channels": ["sms", "email"]

Add the user’s phone number in order to make the SMS channel work. Now this program should be able to send text messages via Twilio.

"message": {
    "to": {
      "email": process.env.EMAIL,
      "phone_number": process.env.PHONENUMBER
    },
    "content": {
      "title": "new subject",
      "body": "message"
    },
    "routing": {
      "method": "single",
      "channels": ["sms", "email"]
    },
}

Change the single method to all and run the program again.

"message": {
    "to": {
      "email": process.env.EMAIL,
      "phone_number": process.env.PHONENUMBER
    },
    "content": {
      "title": "new subject",
      "body": "message"
    },
    "routing": {
      "method": "all",
      "channels": ["sms", "email"]
    },
}

Courier is now able to send via Twilio and Gmail within the same API call.

Chapter 3: Integrate a translation API to convert messages to Morse code

NOTE: The Morse API has a rate limit, which may give you an error if you run it too many times within the hour. In this case, you will have to wait for some time before continuing.

In this last Chapter, you will integrate the Fun Translations Morse API to encode the secret messages and send them over to the spies. On the Fun Translations website, you can search for documentation on the Morse API. Here you have access to all of the information you need to make the call - you have an endpoint and an example that demonstrates that the original message is a parameter for the endpoint.

🔗 Fun Translations: https://funtranslations.com/api/#morse

🔗 Fun Translations API: https://api.funtranslations.com/

Start by encasing the Courier API call in a function.
Add a call to that function below the async function definition.
Refactor options to courier_options.

// Dependencies to install:
// $ npm install node-fetch --save

const fetch = require('node-fetch');
require('dotenv').config()

async function send_secret_message() {

    const courier_options = {
        method: 'POST',
        headers: {
          Accept: 'application/json',
          'Content-Type': 'application/json',
          Authorization: 'Bearer ' + process.env.APIKEY
        },
        body: JSON.stringify({
          "message": {
            "to": {
              "email": process.env.EMAIL,
              "phone_number": process.env.PHONENUMBER
            },
            "content": {
              "title": "new subject",
              "body": "message"
            },
            "routing": {
              "method": "all",
              "channels": ["sms", "email"]
            },
          }
        })
      };

      fetch('https://api.courier.com/send', courier_options)
        .then(response => response.json())
        .then(response => console.log(response))
        .catch(err => console.error(err));

}

send_secret_message()

Before sending the message, you first need to make a call to the Morse API to translate the message. You can use node-fetch in the same way as you did for Courier to make this call.

Copy the code within the async function to make the new API call.
Paste the code above the Courier API call.
Update the endpoint to the Morse API endpoint.
Refactor options to morse_options for the first call.
Remove the authorization token in the Morse API call since it does not require an API Key.
Remove the body object.
Add the message - “hey secret agent x this is your message” - as a parameter within the endpoint and replace all spaces in the message with its url-encode (%20).

// Dependencies to install:
// $ npm install node-fetch --save

const fetch = require('node-fetch');
require('dotenv').config()

async function send_secret_message() {

    const morse_options = {
        method: 'GET',
        headers: {
          Accept: 'application/json',
          'Content-Type': 'application/json'
        }
      };

      const original_message = "hey%20secret%20agent%20x%20this%20is%20your%20message"
      const morse_endpoint = "https://api.funtranslations.com/translate/morse.json?text="+original_message

      fetch(morse_endpoint, morse_options)
        .then(response => response.json())
        .then(response => console.log(response))
        .catch(err => console.error(err));

    const courier_options = {
        method: 'POST',
        headers: {
          Accept: 'application/json',
          'Content-Type': 'application/json',
          Authorization: 'Bearer ' + process.env.APIKEY
        },
        body: JSON.stringify({
          "message": {
            "to": {
              "email": process.env.EMAIL,
              "phone_number": process.env.PHONENUMBER
            },
            "content": {
              "title": "new subject",
              "body": "message"
            },
            "routing": {
              "method": "all",
              "channels": ["sms", "email"]
            },
          }
        })
      };

      fetch('https://api.courier.com/send', courier_options)
        .then(response => response.json())
        .then(response => console.log(response))
        .catch(err => console.error(err));

}

send_secret_message()

Comment out the Courier API call, since you only need to test the code you just added.

When you run this program, we may receive an error that states that there is an error parsing the JSON. This issue is caused by an error in the documentation, which here states that it should be a POST request. However, on a separate API documentation it is written as a GET request. Update the call type to GET and you should see the translated message within the response.

Clearly, you don’t want to send all of this information to the spies. You only need the secret message.

Isolate the message by logging response.contents.translated.

fetch(morse_endpoint, morse_options)
    .then(response => response.json())
    .then(response => console.log(response.contents.translated))
    .catch(err => console.error(err));

You need to be able to access the translation from this API call in the body of the Courier API call.

Create a variable called morse_response, which will hold the entire response from this call.
Convert the JSON object into a JavaScript object so that you can read it within your code.
Get the translated message out of that object and save it in a new variable called message.
Log this variable to confirm that it works.

const morse_response = await fetch(morse_endpoint, morse_options)
    // .then(response => response.json())
    // .then(response => console.log(response.contents.translated))
    // .catch(err => console.error(err));
const translation = await morse_response.json();
const message = translation.contents.translated
console.log(message)

Replace the message within the body of the Courier API call with the encoded message you just saved in the message variable.

"message": {
    "to": {
      "email": process.env.EMAIL,
      "phone_number": process.env.PHONENUMBER
    },
    "content": {
      "title": "new secret message",
      "body": message
    },
    "routing": {
      "method": "all",
      "channels": ["sms", "email"]
    },
}

The Courier datalog should show that the messages were successfully encoded and sent via both SMS and email. Here’s what the email looks like:

Conclusion

Our spies are now ready to receive their secret encoded messages. Try changing the body of the content to your own secret message and send it over to courier.demos+secretmessage@gmail.com and we will send a gift to the first 5 Secret Agents who complete this task! Don’t forget to submit your project to our Hackathon for a chance to win XYZ.

Quick Links

🔗 GitHub Repository: https://github.com/shreythecray/secret-messages
🔗 Video tutorial: https://youtu.be/6W2rIyUdmas

🔗 Courier: app.courier.com
🔗 Register for the Hackathon: https://courier-hacks.devpost.com/
🔗 Courier's Get Started with Node.js: https://www.courier.com/docs/guides/getting-started/nodejs/
🔗 Courier Send API Docs: https://www.courier.com/docs/reference/send/message/
🔗 Twilio Messaging Service SID Docs: https://support.twilio.com/hc/en-us/articles/223181308-Getting-started-with-Messaging-Services
🔗 Node-fetch: https://www.npmjs.com/package/node-fetch
🔗 Dotenv: https://www.npmjs.com/package/dotenv
🔗 Fun Translations: https://funtranslations.com/api/#morse
🔗 Fun Translations API: https://api.funtranslations.com/

Tutorial: Install New Fonts on Macs

Shreya — Tue, 21 Jun 2022 04:51:25 +0000

No one asked for this, but since it's easier than I thought it would be, I figured I'd write it share it and hope it helps someone.

Find your font (found mine on https://fonts.google.com/)
Install the fonts and open the folder
Double click on each font file (*.ttf files) individually to open them
Click "Install File"

If it doesn't show up automatically, quit and reopen the program you want to use it in.

Note: not sure why mine is in Hindi, but it does indeed work with English text.

Reference: https://support.apple.com/en-us/HT201749

Know any mobile development communities?

Shreya — Wed, 25 May 2022 20:57:17 +0000

I want to join some virtual mobile development communities but I'm not sure where to start.

When To Build Engineering Tools And When To Buy Them

Shreya — Thu, 05 May 2022 00:45:43 +0000

Hacking the Engineering Process is a San Francisco-based meetup, which opens discussion for software engineers and tech enthusiasts to share their thoughts on leading topics, pose thought-provoking questions for each other, and learn more about how various engineering teams measure developer productivity amongst themselves.

In March, the guest speaker was the VP of Engineering at Apartment List, Sue Nallapeta. Nallapeta is a leader in tech and is passionate about building highly performant and vastly scalable engineering systems. One of the questions that many engineering leaders often contemplate is whether or when to build or buy software in the process of building a product. Companies invest a lot of time and resources into building software, while buying software can also be expensive in other ways. In her talk, Nallapeta described the “7 C’s” she considers when making this decision between build vs buy and shared her experience in implementing this process while developing Apartment List.

Capability

The first C is Capability, which is determined by the problem that you are solving for, including any features you need or want to build. This is a product and a business’s core, and often what makes it stand out amongst others. These capabilities are what you want to go to market with and what your customers will use. The question then becomes whether these capabilities already exist. If so, developers need to decide whether it is worth building them from scratch or using the tools that are already available, which is a decision that depends on how quickly the product needs to go to market and which path would help achieve the goal most effectively and efficiently.

Cost

There are two common dimensions to cost that most people will look at when building. The first is resources, including how many engineers a team may need to develop the product. The second being time, on how long it will take for those engineers to build the product given the resources they have available. Most teams will consider the two and choose the cheaper option. There are, however, other pertinent costs that can and possibly should impact your decision: build time, maintenance costs (to monitor the product, support it, build test cases, etc.), infrastructure costs, and hosting costs (which are hidden but can add up to a lot).

There are other costs if you choose to buy. Transferring a solution you already have or integrating a new tool can be time consuming and have major migration costs. Buying software also involves onboarding costs (how long it takes for engineers to learn the new system and become comfortable with it) with offboarding costs (typically there is an overlap between old and new systems) and maintenance costs for successful long-term integration. It is crucial for teams to think beyond these two dimensions before making a decision based on cost.

Complexity

In order to build systems that are easy to understand and explain to others including the sales team, growth team, and all business stakeholders. Teams often build products that are very complex, and complexity also grows as the product scales. For example, Netflix’s scale was so large that they needed to invest in their own Content Distribution Network (CDN) and built Open Connect, which they can ship to all ISPs to cache videos on the client side to deliver content quickly.

Competence

A product’s build speed heavily depends on the team’s competence. Do we have the right engineers on the team who understand what needs to be built? Do they have the experience and domain knowledge to understand what we are solving from the business and customer perspective? Do they work well together? If not, how long will it take to hire and build this team? Building a competent team can take upwards of 3-6 months just to hire.
At a previous company, Nallapeta’s team acquired over 10 companies, each acquisition immediately adding value in the span of a couple of months. If they built, it would have taken several months or more to add those capabilities.

Cohesion

Cohesion, or connectedness, is tricky in the case of buying - whether the feature you are buying integrates with the other systems that you already have. For example, Apartment List uses Salesforce for Customer Relationship Management (CRM), and any other software they build that ingests data should support sending data to Salesforce. You can create value through an ecosystem of softwares, where systems coexist with each other and are dependent on each other.

Competitive Advantage

Any product needs to be able to compete once it enters the market. Competitive advantage is a key factor decided by whether the product or its features are core to its functionality and to the business. The product’s capability determines if it can be competitive and can ship features faster to win the industry.

Continuity

Continuity goes hand-in-hand with maintenance. It determines how you ensure scalability of the product as your user base grows and as new feature requests rise. This is important to track so you can guarantee that your system is sustainable and you don’t need to replace the system every few years, which can be a major setback.

Apartment List’s Experience

Build: A/B testing

In building a product that satisfied all of the capability needs, Out of the Box (OOTB) solutions were insufficient for the business need at the time. Apartment List is a subscription based business. The team had to quickly ship many experiments, and try various subscription based models and paywalls, each with changes in prices and features, which would not have been possible without fast iteration.

They also wanted to maintain control over customization to build a great user experience. The product was highly customized for various customers and customers sub-groups. It also provided a great competitive advantage with insights and quicker feature launches with a lower experimentation and test setup, leading to an increase in customers globally.

Build: Billing System

In a high risk industry, the chargeback rates are extremely high. With a subscription based business model, Apartment List needed to maintain fall back use cases such that if a payment does not go through for a customer, the system automatically redirects to a different payment processor, a feature unavailable in other billing system tools. This allowed them to also lower the renewal rates and offer more discounts to their customers. Most importantly, Apartment List’s margin was low, meaning using a tool like Stripe would lead to them cutting into their margins.

Buy: Email Software

Apartment List had initially built their own email software, which was relevant for the stage of the business. At the startup stage, it made more sense to build the software and have access to customized complex features. However, engineering teams did not have the bandwidth or documentation to support the system and over time, as the team who built the software left the company, there was not enough in-house knowledge about the software to maintain it. Eventually using the in-house software also meant that something as simple as a brand update with new logos and colors would require weeks or months of engineering effort.

Apartment List chose Courier to support transactional emails and another provider for marketing emails. This also helped the company achieve cohesion, with the new systems integrating well with the existing system and each other.

Buy: Testing Software

Every company requires some form of Quality Assurance (QA), which, as the product scales, can become an expensive and tedious process that forces engineers to divide their attention away from the product. Using an external tool offers better control and ease of use of the testing software and increases the efficiency of the testing process.

Build & Buy: Analytics

Data is the backbone of any company, requiring high data accuracy and coverage. Every decision made needs to be built on a strong foundation. With evolving business needs, ApartmentList chose to both buy analytics software and build on top of it to close the gaps.

Learn More & Join

If you would like to learn more about Sue Nallapeta’s decision making process and experience with Build vs Buy, check out the talk recording on YouTube: https://youtu.be/dTSFDkWM1oM

Hacking the Engineering Process hosts monthly meetups.

Become a member: https://www.meetup.com/hacking-the-engineering-process/
Submit a CFP: https://jkfr7wbzytt.typeform.com/submit-cfp