Zillow Group's investment in the Follow Up Boss platform will further help teams and agents deliver great customer experiences, boost productivity and grow their businesses   SEATTLE, Nov. 1, 2023 /PRNewswire/ -- Zillow Group has entered into an agreement to acquire Follow Up Boss,

Zillow Group to acquire Follow Up Boss, an industry leader in customer relationship management

Fyllo helps companies grow by driving advertising performance in an increasingly privacy-first environment, so we’re proud to be recognized as an Inc. Power Partner,” said Jeff Ragovin, president of Fyllo.

Fyllo Named Inc. Power Partner

Twilio (TWLO) has received quite a bit of attention from Zacks.com users lately. Therefore, it is wise to be aware of the facts that can impact the stock's prospects.

Here is What to Know Beyond Why Twilio Inc. (TWLO) is a Trending Stock

A new study from Juniper Research, the foremost experts in telecommunications markets, has forecast global retail spend via conversational commerce channels will increase to $43 billion by 2028, from $11.

Juniper Research: Infobip, Twilio & Vonage Revealed as Global Leaders in Conversational Commerce in Latest Juniper Research Competitor Leaderboard

Stocks: Real-time U.S. stock quotes reflect trades reported through Nasdaq only; comprehensive quotes and volume reflect trading in all markets and are delayed at least 15 minutes. International stock quotes are delayed as per exchange requirements.

Twilio Inc. Cl A

In terms of liquidity and interest, the mean open interest for Twilio options trades today is 1838.5 with a total volume of 1,013.00. In the following chart, we are able to follow the development of volume and open interest of call and put options for Twilio's big money trades within a strike price range of $35.0 to $75.0 over the last 30 days.

Twilio Unusual Options Activity

The average price predicted for Twilio Inc (TWLO) by analysts is $68.19, which is $14.57 above the current market price. The public float for TWLO is 171.45M, and at present, short sellers hold a 3.60% of that float.

Twilio Inc (TWLO) Stock: What the Analysts are Saying

Learn more about whether Alarm.com Holdings Inc or Twilio Inc is a better investment based on AAII's A+ Investor grades, which compare both companies' key financial metrics.

Which Is a Better Investment, Alarm.com Holdings Inc or Twilio Inc Stock?

Summary Twilio is a concealed value play with a strong margin of safety, offering an attractive option for value-focused investors. Twilio has access to a wealth of unique product usage and user data.

Twilio: An Underappreciated Value Opportunity

Summary After providing you with a brief review of Twilio's Q2 2023 earnings report recently, I wanted to take time to analyze Twilio's competitive positioning. It's a very fascinating business in that,

Twilio: A Micro-Microsoft

TWILIO INC

twilioinc

How I Built A Dagger Pipeline to Send Weekly SMS's With Financial Advice Generated by AI

In the " article, I documented the foundation for a new SaaS solution that I am building (initially for my sister-in-law) — utilizing the Heroku ecosystem. At the end of that article, I had planned to write about the core technologies (Spring Boot, Angular 9, ClearDB, Okta, GitLab and Heroku) in place, as we raced for the 1.0.0 release of the solution. "Using Heroku to Quickly Build a Multi-Tenant SaaS Product However, things have been moving fast around here, and I largely attribute the speed of development and end-user adoption to everything that Heroku brings to the table for this service. As I have noted before, using Heroku as the destination for my service and GitLab's built-in CI/CD pipelines — updates that are merged from a feature branch into the master branch of the client or service are automatically deployed into production (Heroku) without any further intervention. Instead of starting the 1.0.1 release, the project is actually finishing up the 1.0.3 release.  Below is an updated feature map: Progress Via Screenshots Since using Spring JPA to create the initial schema, which it did without any issues, I have been keeping the fitness.sql up to date manually as model updates have been required.  Using IntelliJ IDEA and built in database tooling (including yFiles), I was able to quickly create the following diagram of the current MySQL/ClearDB database structure: As noted in the prior article, everything ties back to the ID of the tenant (or fitness trainer) - which is also enforced in the base JPA Specifications employed at the service level. These changes, along with screens for Client configuration and Workout configuration, allowed the Session screen to be introduced: The Sessions (which is an instance of a workout and at least one client) are presented in an optional calendar view to give the trainer a view which is easy to comprehend at a glance: In the example above, there is only one event scheduled - since the screen shot is from my test account in the production instance of the SaaS solution. There is also a training-mode version of the Session screen, which is mainly a read-only adaptation and consolidates data for quick reference. The icons on this screen are still active, so that that trainer can not only check-in clients, but also provide session information (score and comments) too: Along the Way ... Twilio Was Discovered One of items which was slated for the 1.0.4 release was referred to as Client Check-In.  We soon realized the having a mechanism for the trainer to communicate with the clients was an important aspect, which needed to be handled next. Below are the requirements that were employed for this feature: send reminders to clients ~24 hours before their scheduled session send a workout summary after their workout resend a reminder for a session allow trainer to send a broadcast text message (e,g, "I am going to be on vacation") provide a link to allow client to confirm/cancel their session (planned for a future article) Since the concept of a mobile client is beyond the current feature roadmap, I needed to find a solution that would work with most clients. Knowing that each client was communicating with my sister-in-law via a mobile device, I decided to use SMS (or text messages) to provide a lightweight client for the application. It did not take long to settle on Twilio — especially since two colleagues ( and ) who broadcast on Twitch had been participating in Twilio's " " awesome learning experience. In fact, I would not be surprised if both still have videos on their channels of them playing the "TwilioQuest" game. roberttables blendedsoftware TwilioQuest Twilio provides the functionality I need with a robust API. I was able to quickly set up a trial account (which communicates only with mobile numbers that are added to the system), but that was enough for me to validate the functionality. Preparing for Twilio The first step is to create a new account in Twilio by visiting the following URL: https://www.twilio.com/try-twilio Which should direct first-time users to a screen similar to what is shown below: Once everything is setup, the Twilio dashboard will appear as shown below: The Account SSID and Auth Tokens are accessible via this screen. I wanted to configure Twilio programmatically in mode project, so that using my production instance of Twilio was based upon environment variables passed in from Heroku. Below is a list of the attributes that I am managing in my API: jvc:
sms:
   twilio:
     enabled: ${TWILIO_ENABLED}
     account-sid: ${TWILIO_ACCOUNT_SID}
     auth-token: ${TWILIO_AUTH_TOKEN}
     phone-number: ${TWILIO_PHONE_NUMBER}
     enable-reply: ${TWILIO_ENABLE_REPLY}
     reply-host: ${TWILIO_REPLY_HOST}
     trial: ${TWILIO_IS_TRIAL}
     trial-phone-number: ${TWILIO_TRIAL_PHONE_NUMBER}
     cron-schedule-reminder: cron-schedule-summary: "0 17 * * * ?" "0 27 * * * ?" The README.md for my API repository provides the documentation details for the environment-specific values: ${TWILIO_ENABLED} - Twilio (SMS) enabled [jvc.sms.twilio.enabled] (set to order to disable SMS)
${TWILIO_ACCOUNT_SID} - Twilio (SMS) account SID [jvc.sms.twilio.account-sid] (leave unset to disable SMS, recommended non-Production environments)
${TWILIO_AUTH_TOKEN} - Twilio (SMS) auth token [jvc.sms.twilio.auth-token]  (leave unset to disable SMS, recommended non-Production environments)
${TWILIO_PHONE_NUMBER} - Twilio (SMS) phone number to use sending messages [jvc.sms.twilio.phone-number]
${TWILIO_ENABLE_REPLY} - Twilio (SMS) enablement reply functionality [jvc.sms.twilio.enable-reply]
${TWILIO_REPLY_HOST} - Twilio (SMS) reply host URL ( Angular client) to use when reply functionality is enabled [jvc.sms.twilio.reply-host] (value should not end a /)
${TWILIO_IS_TRIAL} - Twilio (SMS) trial indicator [jvc.sms.twilio.trial] (use non-Production instances)
${TWILIO_TRIAL_PHONE_NUMBER} - Twilio (SMS) trial phone number to send to [jvc.sms.twilio.trial-phone-number] (use non-Production instances) false in for for for of of with for for The cron based items determine the schedule of the session reminder and session summary jobs which are running in each environment (if enabled). Within Spring Boot, a simple TwilioConfigurationProperties class was created: @Data
@Configuration( )
@ConfigurationProperties( )
public {
   private boolean enabled;
   private accountSid;
   private authToken;
   private phoneNumber;
   private boolean enableReply;
   private replyHost;
   private boolean trial;
   private trialPhoneNumber;
   private cronScheduleReminder;
   private cronScheduleSummary;
} "twilioConfigurationProperties" "jvc.sms.twilio" class TwilioConfigurationProperties String String String String String String String With these values set up, I can use the Run/Debug dialog in IntelliJ IDEA to pass in the expected values: In Heroku, these values are set up in the environment: Keep in mind, the Heroku values are different, because that is actually the production instance that I have running. The Sms Service Within the SmsService, the following public methods are available: @RequiredArgsConstructor
@Slf4j
@Service
@Transactional
public {
 @Resource(name = )
 private UserData userData;
 private final AttendeeRepository attendeeRepository;
 private final MotivationalQuoteRepository motivationalQuoteRepository;
 private final SessionRepository sessionRepository;
 private final TwilioConfigurationProperties twilioConfigurationProperties;
 public sendGroupMessage(GroupSmsMessage groupSmsMessage) throws FitnessException { }
 public sendSimpleMessage(SimpleSmsMessage simpleSmsMessage) { }
 public resendSingleReminder(long attendeeId) { }
 @Scheduled(cron = )
 public sendSmsMessages() { }
 @Scheduled(cron = )
 public sendSmsSummaryMessages() { }
} class SmsService "requestScopeUserData" void // allows a trainer to send a SMS message to a select group of customers void // allows the system to send a single SMS message, which is used to send a message to the trainer each time a client confirms or cancels their session void // allows the trainer to render the session reminder. "${jvc.sms.twilio.cron-schedule-reminder}" void // allows the trainer to render the session reminder. "${jvc.sms.twilio.cron-schedule-summary}" void // ran hourly, provides a workout summary (including a random fitness quote) to the customer - which can include: // -  the score from the session // - any comments provided by the trainer // - a random fitness quote These methods are called either by a scheduled task or triggered from a request from the Angular client. The next section presents and example of how the Angular client interacts with the Spring Boot service in order to communicate with the Twilio service. Example - Sending a Group Message Sending a Group Message is initiated by the Angular client.  An example is shown below: The request is passed to the following controller in Spring Boot: @PostMapping(value = )
public ResponseEntity<Void> postSession(@RequestBody GroupSmsMessage groupSmsMessage) { {
       smsService.sendGroupMessage(groupSmsMessage); ResponseEntity<>(HttpStatus.CREATED);
   } (FitnessException e) {
       log.error(e.getMessage()); ResponseEntity<>(HttpStatus.BAD_REQUEST);
   }
} "/sms" try return new catch return new The GroupSmsMessage object has the following properties: @Data
public {
   private messageBody;
   private List<ClientDto> distributionList = ArrayList<>();
} class GroupSmsMessage String new The controller then calls the following method: public sendGroupMessage(GroupSmsMessage groupSmsMessage) throws FitnessException {
   log.info( , groupSmsMessage); (CollectionUtils.isEmpty(groupSmsMessage.getDistributionList())) { FitnessException(FitnessException.ENTITIES_MISSING, );
   } (StringUtils.isEmpty(groupSmsMessage.getMessageBody())) { FitnessException(FitnessException.ENTITIES_MISSING, );
   } (!smsEnabled()) { FitnessException(FitnessException.UNAUTHORIZED, );
   }
   Twilio.init(twilioConfigurationProperties.getAccountSid(), twilioConfigurationProperties.getAuthToken());
   log.info( );
   logSmsInformation();
   int successCount = ;
   int errorCount = ; (ClientDto clientDto : groupSmsMessage.getDistributionList()) {
       Message message = Message.creator( PhoneNumber(twilioConfigurationProperties.isTrial() ? twilioConfigurationProperties.getTrialPhoneNumber() : clientDto.getPersonDto().getPhoneNumber()), PhoneNumber(twilioConfigurationProperties.getPhoneNumber()),
         groupSmsMessage.getMessageBody())
         .create(); (message.getErrorCode() == && StringUtils.isEmpty(message.getErrorMessage())) {
           successCount++;
       } {
           errorCount++;
           log.error( + message.getErrorCode() + +  message.getErrorMessage() + + groupSmsMessage.getMessageBody());
       }
   }
   log.info( , successCount, errorCount);
   log.info( );
} void "sendGroupMessage(groupSmsMessage={})" if throw new "Could not send group SMS message to an empty distribution list." if throw new "Could not send group SMS message with an empty message body." if throw new "sendGroupMessage() SMS is NOT enabled to run on this instance" "sendGroupMessage() started" 0 0 for new new if null else "Error #" "(" ") occurred sending smsMessage=" "Successfully sent {} SMS messages ({} errors)" "sendGroupMessage() completed" In the code above, after checking for elements which can yield a Fitness exception, the Twilio.init() method is called.  Thereafter, a Message is created and the logic has been included to function in production and non-production environments.  This basically ties to using the provided trial phone number when not running in production.  Everything else is straight forward and pass the data received by the Angular client directly to the target distribution list. Conclusion The goal of this article was to outline some client communication needs for the SaaS solution I am building.  Thereafter, I provided an example of how easy it is to create a Twilio instance and integrate the solution into my Spring Boot service and Angular client.  Using Spring Boot and an Angular client, I was able to quickly and easily get SMS communication configured in use within a matter of hours.  In my view, Twilio provides an awesome compliment to the services I am using with Heroku. From a cost perspective, my sister-in-law has been using the SMS functionality for right at two months now and I just added more money into my production Twilio account two days ago.  At this point, the total usage has been right at $10 a month - which is far less than I expected to use. In the next article, I plan to discuss how Twilio was used to send the session reminder, providing a mechanism where clients can confirm or cancel their attendance to this session.  I had initially planned to include everything in one article, but I felt it would be better to create an article dedicated to this functionality.  In another future article, I plan to dive into how an end-user's reply to the original (Twilio) SMS can be redirected to the actual trainer for that customer. Exciting articles planned, for sure! (Published with the kind permission of John Vester from the original at DZone )

How To Easily Integrate Twilio Into Your SaaS Startup [Part 2]

Trivia games provide an engaging and educational experience where you can learn new facts and expand your knowledge across various subjects. Nowadays, Trivia quiz mobile and web applications are the most common go-to areas for such an activity. How about playing a trivia game on WhatsApp? In this tutorial guide, you will learn how to create a trivia quiz application using Twilio for WhatsApp, ASP.NET Core, and ( ). The aim of this tutorial is to create a trivia game application that allows users to play and answer multiple-choice questions using WhatsApp. You will leverage to store and retrieve user progress, track score and maintain game state. The Trivia API licensed under CC BY-NC 4.0 sessions in ASP.NET Core To fetch these questions, you will be using The Trivia API, a REST API, that makes it easy for developers to build quiz apps by providing multiple-choice trivia questions. To learn more about the Trivia API, please visit the__ __. Trivia API documentation Prerequisites To complete this tutorial, you will need: An OS that supports .NET (Windows/macOS/Linux) .NET 7 SDK A code editor or IDE (Recommended: , with the , or ) Visual Studio Visual Studio Code C# plugin JetBrains Rider ngrok CLI A free or paid Twilio Account (If you don't have one, you can ) try Twilio for free Experience with C# and ASP.NET Core . The source code for this tutorial can be found on GitHub Set up a new ASP.NET Core project To get started, using your shell terminal in a preferred working directory, run the following commands to create a new web API project: dotnet new webapi -n TwilioWhatsAppTriviaApp --no-openapi The second command in the snippet above will create a new web API project with the specified name and without OpenAPI (Swagger) support. If you want to use Swagger in the project, just omit in the command above. --no-openapi Change into the project directory by running this command: cd TwilioWhatsAppTriviaApp Install the NuGet package: Twilio Helper library for ASP.NET Core dotnet add package Twilio.AspNet.Core This library simplifies working with Twilio webhooks and APIs in an ASP.NET Core application. Open the project using your preferred IDE. In the folder, remove the boilerplate template controller file, , and also remove the in the project directory. Controllers WeatherForecastController.cs WeatherForcast.cs Build and run your project to ensure everything you have done so far works well using the following commands: dotnet build
dotnet run After successfully running the project, take note of any of the localhost URLs that appear in the debugging console. You can use any of these URLs to set up a publicly accessible local web server using ngrok. Implement Sessions Sessions are one of the several ways of storing a user’s data in an ASP.NET Core application. This is essential when you want to retain user data between requests because by default, the HTTP protocol is stateless - that means data is not preserved. Add the in-memory session provider by modifying , as shown in the following code: Program.cs var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();
builder.Services.AddDistributedMemoryCache();
builder.Services.AddSession(options =>
{
    options.IdleTimeout = TimeSpan.FromSeconds(40);
    options.Cookie.IsEssential = true;
});

var app = builder.Build();

app.UseSession();

app.MapControllers();

app.Run(); registers the distributed memory cache service. This service provides an in-memory cache that can be used to store and retrieve data across multiple requests or sessions. AddDistributedMemoryCache() registers the session services, enabling the application to maintain session state. The parameter allows you to configure various session-related options. is used to set the duration of inactivity after which a session will be considered idle. In this case, it is set to 40 seconds. ensures that the session’s state remains functional and even in scenarios where cookie rejection is enabled. AddSession() options IdleTimeout Cookie.IsEssential Session support is enabled by adding the middleware to the application pipeline, that is, your application gains access to a session object that can be used to store and retrieve data. UseSession Create the Models Create a new folder, in your project directory. Add two model class files, and with properties as shown in the following code samples: Models TriviaApiResponse.cs Question.cs using Newtonsoft.Json;

namespace TwilioWhatsAppTriviaApp.Models;

public class TriviaApiResponse
{
    [JsonProperty("category")]
    public string Category { get; set; }

    [JsonProperty("correctAnswer")]
    public string CorrectAnswer { get; set; }

    [JsonProperty("incorrectAnswers")]
    public List<string> IncorrectAnswers { get; set; }

    [JsonProperty("question")]
    public string Question { get; set; }

    [JsonProperty("type")]
    public string? Type { get; set; }

    [JsonProperty("difficulty")]
    public string Difficulty { get; set; }
} namespace TwilioWhatsAppTriviaApp.Models;

public class Question
{
    public string QuestionText { get; set; }
    public List<(string option, bool isCorrect)> Options { get; set; }
} The model includes properties that represent the fields of The Trivia API response. The attribute ensures that each property is correctly populated with the corresponding JSON data. TriviaApiResponse JsonProperty For a streamlined way to handle trivia questions, the class comes to the rescue. This class encapsulates the necessary information for a trivia question, including the question text and a list of options. Each option is represented by a tuple containing the option text and a boolean value indicating whether it is the correct option. Question Add the Trivia Service Class Create a folder in your project directory and add a new class file named . Modify its contents, as shown in the following code: Services TriviaService.cs using Newtonsoft.Json;
using TwilioWhatsAppTriviaApp.Models;

namespace TwilioWhatsAppTriviaApp.Services;

public class TriviaService
{
    private const string TheTriviaApiUrl = @"https://the-trivia-api.com/api/questions?limit=3";
    private HttpClient httpClient;

    public TriviaService(HttpClient httpClient)
    {
        this.httpClient = httpClient;
    }

    public async Task<IEnumerable<TriviaApiResponse>> GetTrivia()
    {
        var response = await httpClient.GetAsync(TheTriviaApiUrl);
        var triviaJson = await response.Content.ReadAsStringAsync();
        var trivia = JsonConvert.DeserializeObject<IEnumerable<TriviaApiResponse>>(triviaJson);

        return trivia;
    }

    public List<Question> ConvertTriviaToQuestions(IEnumerable<TriviaApiResponse> questions)
    {
        List<Question> newQuestions = new();

        foreach (var question in questions)
        {
            var options = new List<(string option, bool isCorrect)>()
            {
                (question.CorrectAnswer, true),
                (question.IncorrectAnswers[0], false),
                (question.IncorrectAnswers[1], false),
                (question.IncorrectAnswers[2], false)
            };

            // Shuffle the options randomly
            Random random = new();
            options = options.OrderBy(_ => random.Next()).ToList();

            newQuestions.Add(new Question { QuestionText = question.Question, Options = options });
        }

        return newQuestions;
    }
} The class contains two methods: and . The method sends the HTTP GET request to The Trivia API with a query parameter, , that specifies that only 3 questions should be returned. Without the limit parameter, the API returns 10 questions by default. TriviaService GetTrivia ConvertTriviaToQuestions GetTrivia limit=3 The method converts the response from the API into an organized manner. The method also shuffles all question options randomly, so that a single option won’t be the answer to all questions. ConvertTriviaToQuestions To register and the HTTP client in your application's Dependency Injection (DI) container, modify as shown in the following code: TriviaService Program.cs using TwilioWhatsAppTriviaApp.Services;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();
builder.Services.AddDistributedMemoryCache();
builder.Services.AddSession(options =>
{
    options.IdleTimeout = TimeSpan.FromSeconds(40);
    options.Cookie.IsEssential = true;
});
builder.Services.AddHttpClient();
builder.Services.AddScoped<TriviaService>();

var app = builder.Build();

app.UseSession();

app.MapControllers();

app.Run(); Create the Trivia Controller Add an empty API controller class in a file named to the folder and modify its content as shown in the following code: TriviaController.cs Controllers using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using Twilio.AspNet.Core;
using Twilio.TwiML;
using Twilio.TwiML.Messaging;
using TwilioWhatsAppTriviaApp.Models;
using TwilioWhatsAppTriviaApp.Services;

namespace WhatsappTrivia.Controllers;

[Route("[controller]")]
[ApiController]
public class TriviaController : TwilioController
{
    private const string SessionKeyIsGameOn = "IsGameOn";
    private const string SessionKeyScore = "Score";
    private const string SessionKeyCurrentQuestionIndex = "CurrentQuestionIndex";
    private const string SessionKeyTotalQuestions = "TotalQuestions";
    private const string SessionKeyQuestions = "Questions";

    private static readonly string[] StartCommands = { "START", "S" };
    private static readonly string[] OptionValues = { "A", "B", "C", "D" };

    private readonly TriviaService triviaService;

    public TriviaController(TriviaService triviaService)
    {
        this.triviaService = triviaService;
    }

    [HttpPost]
    public async Task<IActionResult> Index()
    {
        var response = new MessagingResponse();
        var form = await Request.ReadFormAsync();
        var body = form["Body"].ToString().ToUpper().Trim();

        await HttpContext.Session.LoadAsync();
        var isGameOn = Convert.ToBoolean(HttpContext.Session.GetString(SessionKeyIsGameOn));
        int currentQuestionIndex = HttpContext.Session.GetInt32(SessionKeyCurrentQuestionIndex) ?? 0;
        int totalQuestions = HttpContext.Session.GetInt32(SessionKeyTotalQuestions) ?? 0;

        if (StartCommands.Contains(body) && !isGameOn)
        {
            await StartGame();
            HttpContext.Session.SetString(SessionKeyIsGameOn, "true");
            response.Message(PresentQuestionWithOptions(currentQuestionIndex));
            return TwiML(response);
        }

        if (OptionValues.Contains(body) && isGameOn)
        {
            var result = ProcessUserAnswer(body, currentQuestionIndex);
            response.Message(result);

            currentQuestionIndex++;

            if (currentQuestionIndex <= totalQuestions - 1)
            {
                HttpContext.Session.SetInt32(SessionKeyCurrentQuestionIndex, currentQuestionIndex);
                response.Append(new Message(PresentQuestionWithOptions(currentQuestionIndex)));
            }
            else
            {
                response.Append(new Message(EndTrivia()));
            }

            return TwiML(response);
        }

        response.Message(!isGameOn ? "*Hello! Send 'Start' or 'S' to play game*" : "*Invalid Input! Send a correct option 'A', 'B', 'C' or 'D'*");

        return TwiML(response);
    }

    private async Task StartGame()
    {
        if (HttpContext.Session.GetString(SessionKeyQuestions) != null)
        {
            HttpContext.Session.Remove(SessionKeyQuestions);
        }

        var trivia = await this.triviaService.GetTrivia();
        var questions = this.triviaService.ConvertTriviaToQuestions(trivia);

        AddNewQuestionsToSession(questions);
        HttpContext.Session.SetInt32(SessionKeyTotalQuestions, questions.Count);
    }

    private string ProcessUserAnswer(string userAnswer, int questionIndex)
    {
        bool optionIsCorrect = false;
        int score = HttpContext.Session.GetInt32(SessionKeyScore) ?? 0;
        var question = RetrieveQuestionFromSession(questionIndex);

        switch (userAnswer)
        {
            case "A":
                optionIsCorrect = question.Options[0].isCorrect;
                break;
            case "B":
                optionIsCorrect = question.Options[1].isCorrect;
                break;
            case "C":
                optionIsCorrect = question.Options[2].isCorrect;
                break;
            case "D":
                optionIsCorrect = question.Options[3].isCorrect;
                break;
        }

        if (optionIsCorrect)
        {
            score++;
            HttpContext.Session.SetInt32(SessionKeyScore, score);
        }

        return optionIsCorrect 
            ? "_Correct ✅_" 
            : $"_Incorrect ❌ Correct answer is {question.Options.Find(o => o.isCorrect).option.TrimEnd()}_";
    }

    private string PresentQuestionWithOptions(int questionIndex)
    {
        var question = RetrieveQuestionFromSession(questionIndex);
        return $"""
                {questionIndex + 1}. {question.QuestionText}
                {OptionValues[0]}. {question.Options[0].option}
                {OptionValues[1]}. {question.Options[1].option}
                {OptionValues[2]}. {question.Options[2].option}
                {OptionValues[3]}. {question.Options[3].option}
                """;
    }

    private void AddNewQuestionsToSession(List<Question> questions) =>
        HttpContext.Session.SetString(SessionKeyQuestions, JsonConvert.SerializeObject(questions));

    private Question RetrieveQuestionFromSession(int questionIndex)
    {
        var questionsFromSession = HttpContext.Session.GetString(SessionKeyQuestions);
        return JsonConvert.DeserializeObject<List<Question>>(questionsFromSession)[questionIndex];
    }

    private string EndTrivia()
    {
        var score = HttpContext.Session.GetInt32(SessionKeyScore) ?? 0;
        var totalQuestions = HttpContext.Session.GetInt32(SessionKeyTotalQuestions) ?? 0;

        var userResult = $"""
                Thanks for playing! 😊
                You answered {score} out of {totalQuestions} questions correctly.
                
                To play again, send 'Start' or 'S'
                """;

        HttpContext.Session.Clear();
        return userResult;
    }
} This controller class is responsible for handling incoming messages, managing session state, and generating responses. It inherits from the class provided by the Twilio.AspNet.Core library, which gives you access to the method. You can use this method to respond with . The class uses methods to interact with the session. The valid inputs are elements in the and read-only arrays. The body of the incoming message is compared with these elements to ensure that the user sent a proper input, if not, a message will be sent to the user prompting them to make the right input based on the game's current state. Other fields with the “SessionKey” prefix are used to define private constant strings for session keys in the program. TwilioController TwiML TwiML, which is the Twilio Markup Language TriviaController HttpContext.Session StartCommands OptionValues The method is the main action method that handles incoming HTTP POST requests from WhatsApp via the route. It loads the session data using and retrieves data regarding the game state from the session using the and methods. Index /Trivia HttpContext.Session.LoadAsync() HttpContext.Session.GetString() HttpContext.Session.GetInt32() The use of underscores (_) and asterisks (*) at the beginning and end of certain strings is to achieve italic and bold text formatting respectively in rendered WhatsApp messages. Each helper method in the performs a specific task that supports the main functionality of the class. TriviaController method initializes the game by retrieving trivia questions, converting them into a format suitable for the game, and storing them in the session. StartGame method processes the user's answer to a question and determines if it is correct or not. ProcessUserAnswer method is responsible for formatting and presenting a question along with its options. PresentQuestionWithOptions method stores a list of questions in the session. It converts the questions to JSON format and saves the JSON string in the session. AddNewQuestionsToSession method retrieves a question from the session using the question index. RetrieveQuestionFromSession method generates a message to end the trivia game. This method also removes session data related to the game. Based on the configuration of session service in , this happens automatically when the session is idle for 40 seconds. EndTrivia Program.cs Test the Application To test the application, you need to set up Twilio Sandbox for WhatsApp, make your application endpoint publicly accessible and add the endpoint URL in the Sandbox configuration as a webhook. Setup Twilio Sandbox for WhatsApp Go to the , navigate to . Twilio Console Message > Try it out > Send a WhatsApp Message Follow the instructions on the page to connect to the sandbox, by sending a WhatsApp message from your device to the Twilio number provided in order to create a successful connection with the WhatsApp sandbox. Similarly, other individuals who wish to test your app with their respective numbers will need to follow the same procedure. Expose your webhook using ngrok for testing Now, open a shell terminal and run the following command to start ngrok and expose your local ASP.NET Core app by replacing with the full URL of your localhost you copied initially: <localhost-url> ngrok http <localhost-url> ngrok will generate a public URL that forwards requests to your local ASP.NET app. Look for the forwarding URL labelled in the ngrok terminal window and copy it. Forwarding Go back to the Twilio Try WhatsApp page, click on , and change the endpoint url with the URL generated by ngrok plus the route and ensure the method is set to POST. Then click Save to save the new sandbox configuration. Sandbox Settings When a message comes in forwarding /Trivia Project Demo Run your ASP.NET Core project using the following command: dotnet run Now, test your application by sending a message in the initial conversation with the Twilio Sandbox number. Conclusion By leveraging the power of the Twilio platform and WhatsApp, you have created an immersive trivia game experience for users to enjoy. You have also learned how to save and retrieve data from sessions. There are several ways this project can be improved upon. You can further improve this project by adding timer, handling exceptions, allowing users to choose difficulty and applying the chosen difficulty as a query parameter via The Trivia API URL (e.g ). Additionally, you can explore the possibility of creating a solution that allows users to fill out surveys via WhatsApp. https://the-trivia-api.com/api/questions?difficulty=hard

Build a Trivia Quiz WhatsApp Bot With Twilio and ASP.NET Core

Twilio এবং ASP.NET কোর দিয়ে একটি ট্রিভিয়া কুইজ WhatsApp বট তৈরি করুন

Erstellen Sie mit Twilio und ASP.NET Core einen Quiz-WhatsApp-Bot

Cree un bot de WhatsApp de prueba de trivia con Twilio y ASP.NET Core

Créez un bot WhatsApp Trivia Quiz avec Twilio et ASP.NET Core

ट्विलियो और ASP.NET कोर के साथ एक ट्रिविया क्विज़ व्हाट्सएप बॉट बनाएं

Twilio と ASP.NET Core を使用してトリビア クイズ WhatsApp ボットを構築する

Twilio 및 ASP.NET Core를 사용하여 상식 퀴즈 WhatsApp Bot 구축

Crie um bot de perguntas e respostas para WhatsApp com Twilio e ASP.NET Core

Создайте бота WhatsApp для викторины с помощью Twilio и ASP.NET Core

Twilio ve ASP.NET Core ile Trivia Quiz WhatsApp Botu Oluşturun

Xây dựng Bot WhatsApp Quiz Trivia với Twilio và ASP.NET Core

使用 Twilio 和 ASP.NET Core 构建问答测验 WhatsApp 机器人

A significant number of web applications depend on external APIs when integrating third-party services. Due to maintenance or ongoing development, they may occasionally be unavailable during development. In situations like these, mock APIs are helpful in testing, because they allow developers to continue integrating against the service. Alternatively, there may be a price per API request, so simulating API responses during development might be crucial to minimizing cost. In this short tutorial, you will learn how to Twilio's Lookup API. mock Prerequisites PHP 8.2 or newer globally installed Composer Your preferred text editor or IDE An HTTP client such as or curl Postman Understanding Twilio's Lookup API Among other things, the enables customers to access phone number data, carrier details, and caller names attached to phone numbers. It also supports phone number validation and formatting. You can see a sample response from the API is available below. Twilio Lookup API {
  "calling_country_code": "1",
  "country_code": "US",
  "phone_number": "+14159929960",
  "national_format": "(415) 992-9960",
  "valid": true,
  "validation_errors": null,
  "caller_name": null,
  "sim_swap": null,
  "call_forwarding": null,
  "live_activity": null,
  "line_type_intelligence": null,
  "identity_match": null,
  "reassigned_number": null,
  "sms_pumping_risk": null,
  "url": "https://lookups.twilio.com/v2/PhoneNumbers/+14159929960"
} Create the project directory The first thing to do is to create the project directory, where you store your PHP projects, and to switch into it. To do that, run the commands below. mkdir lookup
cd lookup The structure of the application is simplistic, consisting of two directories: and . The controller class named , which manages the backend logic before passing it to the front end, is located in the directory. The front end is located in the directory. app public Lookup.php app public To create the core directory structure, run the command below. mkdir -p \
    app/Twilio \
    public/ Use the following commands if you're using Microsoft Windows: mkdir app/Twilio
mkdir public Create the application The next thing to do is to add all of the dependencies that the project needs. The application will run on the and PHP’s version of . Run the command below to install these dependencies. Slim framework Google’s phone number library composer require --with-all-dependencies \
    giggsey/libphonenumber-for-php \
    selective/basepath \
    slim/psr7 \
    slim/slim You will need to add configuration so that the classes created in this tutorial will be available throughout the application. To do this, in add the JSON snippet below after the already existing code. a PSR-4 Autoloader composer.json "autoload": {
    "psr-4": {
        "App\\": "app"
    }
} Then, run the following command to update Composer's autoloader file ( ). vendor/autoload.php composer dump-autoload Creating the mock class Now that all the dependencies are installed, the next step is to create the class that will return the mock data. To do that, create a new file named in the directory. Then, paste the code below into the new file. Lookup.php app/Twilio <?php

namespace App\Twilio;

use libphonenumber\PhoneNumberFormat;
use libphonenumber\PhoneNumberUtil;

class Lookup
{
    public array $data = [];

    public function fetch(string $number)
    {
        $phoneUtil = PhoneNumberUtil::getInstance();
        $phone_number = $phoneUtil->parse($number);

        $this->data = [
            'calling_country_code' => $phone_number->getCountryCode(),
            'country_code' => $phoneUtil->getRegionCodeForNumber($phone_number),
            'phone_number' => $phoneUtil->format($phone_number, PhoneNumberFormat::E164),
            'national_format' => $phoneUtil->format($phone_number, PhoneNumberFormat::NATIONAL),
            'valid' => $phoneUtil->isValidNumber($phone_number),
            'validation_errors' => $this->validationResult($phoneUtil->isPossibleNumberWithReason($phone_number)),
            'caller_name' => null,
            'sim_swap' => null,
            'call_forwarding' => null,
            'live_activity' => null,
            'line_type_intelligence' => null,
            'identity_match' => null,
            'url' => $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI']
        ];

        return json_encode($this->data, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
    }

    private function validationResult($reason): string
    {
        return match ($reason) {
            0 => 'NULL',
            1 => 'INVALID_COUNTRY_CODE',
            2 => 'TOO_SHORT',
            3 => 'TOO_LONG',
        };
    }
} The class has a single property, named , which is an array used to hold any data returned from the request. It has two methods: and . The method returns the data to the user once the method is invoked. The method of the phone library is a method that validates the given number and returns integers from 0-3. The method replaces these integer codes with their corresponding human-readable codes since the package returns the validation result as an integer. $data fetch() validationResult() fetch() isPossibleNumberWithReason() validationResult() libphonenumber Check out to find out more. the phone library documentation The most crucial part of the application has now been created. All that is left is bootstrapping the Slim application and testing it. To do so, create a new file named in the directory. Then, paste the code below into the file. index.php public <?php

use App\Twilio\Lookup;
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Selective\BasePath\BasePathMiddleware;
use Slim\Factory\AppFactory;

require_once __DIR__ . '/../vendor/autoload.php';

$app = AppFactory::create();

$app->get('/phonenumbers/{number}', 
function (Request $request, Response $response, array $param) {
    $data = new Lookup();

    $response
        ->getBody()
        ->write($data->fetch($param['number']));

    return $response
        ->withHeader('content-type', 'application/json')
        ->withStatus(200);
});

$app->run(); The code imports the required classes and initializes the Slim application with a single route. The route is restricted to handling GET requests. It receives a number which is passed to 's method, then the result is returned. Finally, the application is launched, by calling its method. Lookup fetch() run() Test the application With the application complete it's time to run it with PHP’s built-in web server and test it. php -S localhost:8000 -t public For testing, run the curl command line below after replacing with a valid . <<PHONE NUMBER>> E.164 formatted phone number curl -i -H "Accept: application/json" \
    -H "Content-Type: application/json" \
    -X GET http://localhost:8000/phonenumbers/<<PHONE NUMBER>> Feel free to use another tool, such as Postman, instead of curl to test the code. This should return a response similar to the following. HTTP/1.1 200 OK
Host: localhost:8000
Date: Tue, 04 Jul 2023 12:54:08 GMT
Connection: close
X-Powered-By: PHP/8.2.0
content-type: application/json

{
    "calling_country_code": 234,
    "country_code": "NG",
    "phone_number": "+2349000080000",
    "national_format": "0900 008 0000",
    "valid": false,
    "validation_errors": "NULL",
    "caller_name": null,
    "sim_swap": null,
    "call_forwarding": null,
    "live_activity": null,
    "line_type_intelligence": null,
    "identity_match": null,
    "url": "localhost:8000/phonenumbers/+2349000080000"
} Since the phone number used in this sample is invalid, you can swap it out with your own in the URL. That’s how to mock the Twilio Lookup API plays an essential part in development, and in this tutorial we went through how to mock Twilio's Lookup API. However, given the mockup's numerous limitations, it is important to note that this should only be used in lieu of the actual Lookup API during development, rather than as a replacement. Mocking Happy building! Prosper is a freelance Laravel web developer and technical writer that enjoys working on innovative projects that use open-source software. When he's not coding, he searches for the ideal startup opportunity to pursue. Find him on Twitter and . Linkedin " " by is licensed under the . Look Up Klosterhof Leipzig Tenzin Peljor CC BY-SA 2.0 Also published . here

Creating a Mock Twilio Lookup API

279 Stories To Learn About Programming

143 Stories To Learn About Javascript

Let's learn about via these 43 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Es6 /Learn Repo A newer version of javascript introduced in 2015. Also known as ECMAScript 2015 or ECMAScript 6 1. A common misconception about async/await in JavaScript (© https://www.twilio.com/blog/2015/10/asyncawait-the-hero-javascript-deserved.html) 2. Singleton Pattern in ES6: The Good, The Bad, The Ugly Singletons are fairly controversial as far as I can tell, especially in Javascript programming. Let's take a look at what they are, when to (maybe) use them, and when not to. 3. 6 Reasons Why JavaScript Async/Await Blows Promises Away (Tutorial) 👉 This article has been updated and republished, read the latest version here 4. Copying text to clipboard with JavaScript In this article, I will be explaining in depth how the copyToClipboard snippet from 30 seconds of code works. You can find the source code for it and a ton of other useful methods in the project’s repository. 5. Polyfills: everything you ever wanted to know, or maybe a bit less The browser world we live in today is pretty great. You can use promises and fetch and arrow functions and const and let — all the hip new gear — and it will work in every major browser. No polyfills, no transpiling, it will Just Work. 6.  JavaScript Spread and Rest Operators: A Guide Understand Javascript Spread and rest operators 7. 5 Exciting New JavaScript Features You Can Use Today 5 Must-Know Features in JavaScript ES2022: Enhance Your Code and Boost Your Productivity 8. A Guide for Using Native ECMAScript (ES) Modules This article will present examples of ECMAScript (ES) modules—what you can achieve with them and where you will hit some limitations. 9. Oleksandr Demian Have Changed His Work as Understood How Bad It Was During Pandemic “In these unprecedented times…” People build unprecedented products, and contribute to the internet in unprecedented ways. Go on, make a fellow human’s day and nominate the best YOUR best of 2020’s tech industry for a 2020 #Noonie, the tech industry’s most independent
and community-driven awards: NOONIES.TECH. One such impressive human is Oleksandr Demian from Italy: 2020 Noonie nominee in Future Heroes and Technology categories. 10. Understanding the Power of Proxy in JavaScript A Proxy object is an object that wraps another object and intercepts fundamental operations on it, such as property access, assignment, and deletion 11. 5 Great JavaScript Projects to Code During Quarantine We’re only three months into the new decade and we’ve already had the threat of WW3, Australia being on fire, and an outbreak of a new Coronavirus. Surprisingly, it’s the latter that has forced many people to isolate themselves at home. 12. Introducing the at() Method for JavaScript Arrays This article is about latest ecma script or ES22 update of at() method of array. at() method of array is used for getting the value based on index 13. How to Use ES6 with Webpack This article is for those who use ES6 syntax along with Webpack. After I started using Javascript with Webpack I met a lot of unexpected errors. All of them were because of ES6 syntax usage. Those of you who decided to start javascript using "Classes" or you need to use ESlint I'll try to explain how to save some time. In short, it's all about loaders. 14. Getting Out Of ReferenceError Because of Scope in Javascript Everything happens within spaces and Environments. Basic knowledge of javascript is highly recommended, before proceeding with this content. 15. JS Arrow Functions for Newbies Introduction to new ES6 javascript feature - Arrow Functions. 16. 3 Must-learn JavaScript Concepts to Master Before Learning React Jumping on learning React is easy, but you'll hit your head hardly later on if you are not yet familiar with these 4 key concepts detailed in this article. 17. What I Wish Every Developer Knew About let In Javascript. One of the greatest things introduced in ES6 was the variable initialization. Why is it better then ? Let's see. let var 18. Once Upon a Time in Javascript: Classes and Inheritance Classes in javascript were first introduced as part of ECMAScript 6 standard back in 2015. Today, they feel like something natural, but how was javascript before them? 19. How To Use The Spread Operator on a Function You can’t officially do it, but you can write a function that does virtually the same thing. Let’s see how and maybe why you should. 20. Once Upon a Time in Javascript: The const Keyword const keyword was first introduced in javascript as part of ECMAScript 6 standard back in 2015. It probably the most popular way of declaring a variable in javascript, but how was javascript before them? 21. Working With Iterators and Generators in Javascript ES6 Here are the use cases for iterators and generators that are closer to the real-world scenario than a simple "Hello World" type code. 22. React — The State Bait and This Dot Problems One of the things that make React quite intimidating for new users is that there are some concepts that need to be grasped before jumping in. 23. Coffee… what? How Developers Quit To Use CoffeeScript It’s been over 10 years since the release of CoffeeScript and after a
decade, it seems we can state that this innovative idea became
completely forgotten by the front-end developers community. 24. Reduce JS Bundle Size by Dynamically Importing es6 Modules How to reduce javascript bundle size of web application by dynamically importing es6/javascript modules 25. Top 3 Coding Challenges for Mid-level JavaScript developers If you have a considerable amount of experience with JavaScript, you are expected to solve complex coding challenges. 26. Javascript: From Objects to Factory Functions And Modules Objects 27. Understanding Symbol: Javascript's Newest Primitive Type Symbol, the brand new primitive type for JavaScript is worth to know more for each single front-end hacker. 28. Destructuring in Javascript Destructuring is a very simple concept in javascript, it allows you to pull out some variables from object/array, but it has a lot of features. Here are some cool things you can do with it! 29. Understanding JavaScript Generators And Basic Use-Cases In one of my many deep-dives about JavaScript, I came across generators. They looked interesting. 30. Javascript: The Most Complex Language For me this is one of the strangest things I did in my life, talk to you about what is it for me one of the most complex languages that I have worked with. Javascript is something really strange when you compare it with other languages. 31. What Is Tagged Template Literal In Javascript Before ES6(ECMAScript 2015), we have used single quotes('...') and double quotes("...") to wrap string literals. A simple example is, 32. Write Cleaner Code with My Top 5 JavaScript Hacks 33. Building TicTacToe Using Vanilla JavaScript I am sure you have played tictactoe as a child. In this article, we will build tictactoe using plain JavaScript step by step. Let's go! 34. Front-End Development Without Node_modules Using Skypack and Snowpack Once upon a time, we could simply put an HTML and a script file into an FTP server, quickly have a working website and call it a day. 35. How to Write a Simple NPM Package Imagine that you don't need any compiler or bundler to prepare your NPM package written in ES2020 standard. Yes, you can. 36. 10 Things Every Beginner Should Know When Learning Javascript And React React is build on top of pure Javascript for the most part.  Here you will learn about 10 Javascript concepts that will help you write better React code. 37. JavaScript Typed Arrays: Beginners Guide JavaScript typed arrays are array-like objects that provide a mechanism for reading and writing raw binary data in memory buffers. As you may already know, Array objects grow and shrink dynamically and can have any JavaScript value. JavaScript engines perform optimizations so that these arrays are fast. 38. Revealing Module Pattern in JS [A How-To Guide] Let’s understand a bit of the theory behind the module pattern and the purpose it serves on implementing this pattern. The Module pattern was originally defined as a way to provide both private and public encapsulation for classes. 39. 12 JavaScript Concepts That Will Level Up Your Development Skills JavaScript is a complex language. If you’re a JavaScript developer at any level, it’s important to understand its foundational concepts. This article tackles 12 concepts that are critical for any JS developer to understand, but in no way represents the full breadth of what a JS developer should know. I will be continuously updating this list in a Github repository called JS Tips & Tidbits. Please star ⭐ and share if you want to follow along! 40. Why I’m Excited for JavaScript Class Private Fields: A Case Study (JavaScript Class Privacy — Or Lack Thereof) 41. How To Set Up tsconfig [Part 1] Guide to TypeScript tsconfig.json. Settings explanation. Tips and tricks. Each new project I prefer to write on TS rather than native JavaScript. 42. Learn JavaScript Array Methods in just 8 Minutes!! 43. Top 24 ES6 Code Snippets for JavaScript Problems Here I have hand-picked some of the most useful code snippets from 30 seconds of code. It’s an awesome resource, go ahead and show it some love. Thank you for checking out the 43 most read stories about Es6 on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

43 Stories To Learn About Es6

Let's learn about via these 25 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Asynchronous /Learn Repo 1. Analyzing Asynchronous Binary Byzantine Agreement (ABBA) Consensus on SKALE Blockchain Every blockchain follows a consensus protocol to assign blocks but some consensus like ABBA is created to give security, scalability, and stability. 2. Building Efficient Crypto Trading Software With Python Learn about building efficient trading software principles, such as event-driven approach, microservices, and asynchronous programming. 3. The Event Loop Concept and Asynchronous Development in JavaScript Responsiveness is usually achieved through the use of asynchronous functions. This means that you can let your code do several things at the same time. 4. Unity 2023.1 Introduces Awaitable Class New Awaitable class in Unity 2023.1, methods, properties, usage. Emphasizes understanding async-await & experimenting for best results. 5. Introduction to Mocha Testing Framework Mocha is a feature-rich JavaScript test framework running on Node.js and in the browser. 6. How to Improve Django 3.1 View Performance with Async Support Django 3.1 provides support for asynchronous views, allowing developers to make significant performance improvements. 7. Why Do You Need a Cancellation Token in C# for Tasks? The algorithm how and when you should use cancellation tokens for tasks in c# to use cooperative cancellation when working on parallel computing projects. 8. Going Serverless? Here’s 5 Use Cases Since 2014 when AWS launched AWS Lambda and kickstarted the serverless movement, going serverless has grown exponentially for organizations of all sizes from one-man start-ups to huge listed global enterprises. While there are some challenges to this new architecture, the ways moving to serverless can transform a business often far outweigh these. 9. An Intro to Rio: A Lightweight Job Scheduler in Go Rio is a lightweight job scheduler and job chaining library. Its mainly build for Golang web apps, but it can be very easily mold to serve any applications. 10. A common misconception about async/await in JavaScript (© https://www.twilio.com/blog/2015/10/asyncawait-the-hero-javascript-deserved.html) 11. How to Fetch Data From an API in React.js Without any doubt, the use of React is increasing day by day. And also API(Application Programming Interface) is gaining more popularity in the modern era of technology. This article will guide a beginner to play with React to API. 12. When You Shouldn't Use Async in Python What comes to a Python developer’s mind when he needs to write an I/O bound application? Of course async. Why? Usually, because it’s a trend. And I’ve seen this 13. Asynchronous Programming in Python using Async IO In this article, we’ll be learning what is Async IO, its components, and a basic implementation in Python to get you started. 14. First Steps With Kotlin Coroutines The guide to start using coroutines for asynchronous programming to prevent blocking threads and efficiently utilize CPU resources. 15. Unit Testing Functionality: Testing setTimeout and setInterval Recently at a client, a question came up about unit testing functionality that used setTimeout and setInterval. 16. Handling Node.JS as an Asynchronous Application with Error Handling In this article, you will learn how to implement the following coding practices to differentiate between Synchronous and Asynchronous Calls. 17. Worrying About The New Normal? Let's Focus On Making Remote Work Exceptional Instead. There are many contenders for the Oxford Word of the Year in 2020. The award - which can also be a phrase - is awarded as a reflection of the ethos, mood, or preoccupations of that particular year. 18. 10 Most Sought-After Programming Languages You Should Learn In 2021 If you are working on any technology and want to know which programming language is best for you then you can follow this article. 19. Testing Asynchronous JS Code: 2020 Edition The text you are about to read describes an imaginary dialog between two programmers on their way to discover the orgastic pleasures of a library called asyncFn. 20. Asynchronous Programming Techniques with Kotlin An introduction to Kotlin coroutines compared to Futures/Promises such as Reactor’s Mono or Java’s CompletableFuture 21. Is JavaScript a Single Threaded Language? If you have been using Javascript for a while then you may come across the phrase that it’s a single threaded language. 22. Reactive Programming with Java Spring, R2DBC and MariaDB Whether or not you've been actively developing within one of the JVM languages or not, you've likely at least heard of the concept of reactive programming by now. If not, I certainly encourage you to do a little research into the whole idea of declarative programming using data streams. 23. 6 Reasons Why JavaScript Async/Await Blows Promises Away (Tutorial) 👉 This article has been updated and republished, read the latest version here 24. What it's Like to Migrate a Backend Service From Spring Boot to Vert.X A practical example of the gains and pitfalls in migrating existing Sprint Boot logic to Vert.x with considerations to the experience and process involved. 25. Implementing JavaScript Promise in 70 lines of code! Ever wondered how JavaScript Promise works internally? Obviously there is some native browser support involved, right? Nope! We can implement the Promise interface using pure JavaScript, examples are libraries like Bluebird or Q. And it’s much simpler than you may think, we can do so in only 70 lines of code! This will help with gaining a deeper insight into Promises by demystifying the underlying formation. Can also serve as a good interview question, if you are an evil employer (don’t be!). Let’s dig into it! Thank you for checking out the 25 most read stories about Asynchronous on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

25 Stories To Learn About Asynchronous

Build a Serverless Lie Detector that uses AI for Facial Recognition

Follow along with the video tutorial: https://youtu.be/6W2rIyUdmas?embedable=true 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 🏆 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 1st 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. Courier Hacks 2nd Place: Public favorite winner will receive a Keychron Keyboard. Public Favorite: Runners-up submissions will receive a Hydro Flask. Runners-Up: 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. The first five secret agents to successfully complete this tutorial and this task will receive a gift from Courier. Note: 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. Register for the Hackathon: https://courier-hacks.devpost.com/ 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 accountLog in to your Courier account and create a new secret workspace. Log in to your Courier account 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 , login and open the Console, and find the first two tokens on that page. Save the Account SID and Auth Token in Courier. twilio.com 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 , linked in the description. how to create a Messaging Service SID 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 . Here you can find everything related to sending messages. Send API documentation 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. Selection 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 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. Courier logs 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 file. index.js 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 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. requestID 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 file. index.js Once the package is installed, access the key by referring to it as . process.env.APIKEY Add to the top of the file. require('dotenv').config() index.js 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 object, which contains the and . Two types of methods are available - and . ‘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. routing method channels all single Add the object anywhere within the object, at the same level as and . routing message to content Define the channels within the same object - you can choose SMS or email, in this case, since you already have an email address defined. routing "message": {
    "to": {
      "email": process.env.EMAIL
    },
    "content": {
      "title": "new subject",
      "body": "message"
    },
    "routing": {
      "method": "single",
      "channels": "email"
    },
} Convert the property into an array to define multiple channels and list both email and SMS. channels "channels": ["email", "sms"] You now have two different channels that this message can be sent to. methods would send this message to both email and SMS. 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. All Single 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 and run the program again. all "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 to . options 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 to for the first call. options morse_options Remove the authorization token in the Morse API call since it does not require an API Key. Remove the object. body 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 request. However, on a separate API documentation, it is written as a request. Update the call type to and you should see the translated message within the response. POST GET GET, 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 , which will hold the entire response from this call. morse_response 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 variable. message "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 ,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 for a chance to win over $1000 in cash and prizes!XYZ. courier.demos+secretmessage@gmail.com Hackathon Quick Links 🔗 GitHub Repository: https://github.com/shreythecray/secret-messages 🔗 Video tutorial: https://www.youtu.be/6W2rIyUdmas Log in to your Courier accountLog in to your Courier account 🔗 Courier: https://app.courier.com/signup?utm_campaign=Developer Relations&utm_source=secret-message app.courier.com 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/ Also published . here

Stories, News & Mentions about TWILIOINC

Twilioinc’s Stories on HackerNoon

Twilioinc's News & Mentions