Hi,

One sec...

Enter

Developed mobile application for an Arts Foundation that wanted to offer its highest donors a platform to manage promotions to local restaurant and entertainment areas

Features:

  • Developed using Angular JS front-end and .NET Core 2.0
  • Implemented OData protocol to standardize REST endpoints
  • Utilized Entity Framework Core as ORM with MS SQL Server
  • Built on Apache Cordova (Phone Gap) to allow platform agnostic distribution
  • Designed with material design principles to deliver a sleek and modern user interface to attract a higher user-base
  • Oversaw distribution through Google Play and Apple stores
  

Joys
  • Ramping up quickly on Angular tutorials to be ready for project kick-off
  • Studying the involved life-cycle of push notifications in mobile development
Lessons Learned
  • Recognizing the weaknesses of cross-platform mobile frameworks and knowing when to recommend them over native code
  • Documenting the tedious process of submitting an application to the App store
As featured in the Mind Over Machines company blog

Prior to 70-535: Architecting Microsoft Azure Solutions, I’d never taken a Microsoft Certification exam, nor did I have much experience with Azure. I was definitely out of my wheelhouse. Then I had a senior architect, who works in Azure daily, tell me it took him three tries to pass. Not the most encouraging pep talk.So how did an admitted Azure novice pass on the first go-around? I think it’s because the exam is looking for a wide and general understanding of Azure solutions, rather than a deep knowledge about or ability to implement those solutions.Because this exam can fool the seasoned developer and pass the novice, I’ve outlined my study strategy and flagged some pitfalls to watch out for when attempting to conquer 70-535.

Here is a link to a comprehensive list of items to focus on.

How to study

Since the exam requires breadth over depth, I would get a textbook and start creating flashcards of all the concepts.  If you’re unfamiliar with something, open up the Azure Portal and follow a tutorial online.  Microservices and Azure Service Fabric were particularly new for me hence I built a few Hello World APIs in Visual Studio and deployed them using the given tools until I understood the concepts.

Beyond knowing what the technology does, it’s equally important to know what it does NOT do.  Many Azure tools offer similar services hence it’s key to know which solution is best in a given scenario.  Therefore, knowing Queue Storage is a cost-effective queue tool isn’t enough.  You need to know it doesn’t store data following the first in first out (FIFO) rule and has a 64kb limit.  You don’t need to open the Azure Portal and tinker with it if you understand its purpose.

This exam is trying to pass those who can walk into a client meeting and recommend the proper Azure solution, regardless of if they can actually implement it.

They’ll ask you to demonstrate your understanding by prompting a client scenario where they want a queue tool to store Tweets and it doesn’t matter the message order.  The other option they may give is Azure Service Bus, which does offer FIFO and messages > 64kb, but it would be overkill for storing Tweets especially when order doesn’t matter and even worse if price is a factor.

How they quiz you

Unfortunately, most prep material gives you simple questions like “How many update domains do you get by default in an availability set?” whereas the actual exam gives you verbose real-world scenarios.  Some questions feel like a page long narrative:

Contoso currently has 3 applications  on-premise that listen for triggers based on X while continually sending data to Y, and they would like to migrate them to Azure.  However, their databases need to remain on-premise and their applications need to go to the cloud because of blah blah blah.  The businesses users have this giant list of expectations while the developers want yadda yadda yadda.

After reading a bunch of fluff they ask you an ambiguous question like, “Would Events Hub be an appropriate solution for Contoso?”.  You would have to know the Events Hub is for receiving data and not sending it, therefore the ideal solution is the IoT Hub.  

Thankfully since I used flashcards and knew the purposes and limitations of each technology, it was easy to eliminate certain answer choices.

How NOT to study

I never took the exam’s predecessor 70-534 but some tutorials like ACloud Guru seemed to cut corners on their 535 material by taking their existing 534 material and appending 535 items.  The focus of 534 seemed to be infrastructure related, which I did not see on the exam.  Concepts like setting up VMs, networks, load balancers, gateways, or availability sets had at best one question.  All my efforts into understanding these concepts did not help me.  If you’re pressed for time, I’d focus on studying the purpose and limitation of each Azure service as indicated in the Word doc and not stress the networking concepts.  I hear 70-532 requires implementational understanding of these infrastructure solutions so your efforts will be rewarded eventually.

Go for it!

It took me 3 weeks of daily cramming to feel prepared for an exam in a technology I rarely work in, so you can definitely pass it.  I’d suggest the replay option so if you bomb the first time, you get a second chance. My score was 734 (minimal passing is 700), which I consider a triumph because the closer you get to a perfect score, the more you’ve failed in other ways – such as saving your free time 😉

I couldn’t find many tutorials for creating a simple .NET listener for receiving Webhooks.  The out-of-the-box options in .Net support services for Github, Azure and others but if the API you’re searching for isn’t offered, it’s hard to find documentation that walks you through the process.

Required Skills

This tutorial assumes familiarity with Visual Studio and REST based API calls.  It was originally adapted from this this post and tweaked to incorporate Postman and Emma.  The solution below is only for receiving API calls from JSON requests.

Required Software

Project Setup

Begin by creating a blank Web API project in Visual Studio:

Add the following line to your WebAPI Config class.

public static class WebApiConfig
{
    public static void Register(HttpConfiguration config)
    {
        // Web API routes
        config.MapHttpAttributeRoutes();
        config.Routes.MapHttpRoute(
            name: "DefaultApi",
            routeTemplate: "api/{controller}/{id}",
            defaults: new { id = RouteParameter.Optional }
        );
 
        // Initialize Generic JSON WebHook receiver
        config.InitializeReceiveGenericJsonWebHooks();
    }
}

Install the following nuget package using the package manager console to obtain the necessary Webhook classes:

Install-Package Microsoft.AspNet.WebHooks.Receivers.Generic

Add the following line of code to aid in routing the requests.  The keys below can be anything you want but must be 32 characters.

<configuration>
<appSettings>
<add key="MS_WebHookReceiverSecret_GenericJson" value="i=1388a6b0d05eca2237f10e4a4641260b0a08f3a5,z=80ad19e357b01a04fe767067df7cd31b96a844e1" />
</appSettings>
<system.web>

The WebHookHandler base class is required to receive Webhook requests.   Paste in this template code:

using Microsoft.AspNet.WebHooks;
using Newtonsoft.Json.Linq;
using System.Threading.Tasks;

namespace MyWebhook
{
      public class GenericJsonWebHookHandler : WebHookHandler
     {
        public GenericJsonWebHookHandler()
        {
           this.Receiver = "genericjson";
        }

        public override Task ExecuteAsync(string generator,                     WebHookHandlerContext context)
        {
          // Get JSON from WebHook
          JObject data = context.GetDataOrDefault<JObject>();

           if (context.Id == "i")
           {
              //You can use the passed in Id to route differently depending on source.
           }
           else if (context.Id == "z")
           {
           }

           return Task.FromResult(true);
         }
   }
}

Let’s test to see if the handler works by building the solution and copying the URL from the output.

(There won’t be a landing page cause the server doesn’t return anything).

localhost (1)

Paste this URL into Postman and append the following:

Localhost:{Your Port}/api/webhooks/incoming/genericjson/z?code=80ad19e357b01a04fe767067df7cd31b96a844e1

URL format for .Net Webhook            URL endpoint from your webconfig

Enter anything you want into the Body.  Note: You need to include something in the Body or the GenericJson config will error out.

bodyinput

Set a breakpoint and  send the request and make sure it comes through.

postman-local

Connecting to Emma

To connect to Emma you need a public facing API.  Right click the solution and select “Publish” to send the solution to Azure for hosting.  Prior to clicking “Create Profile”, click the Advanced link to set the configuration to Debug to be able to debug from the server.

publish

Attach your application to the remote server for debugging:

View ->  Cloud Explorer ->  Find your application ->  “Attach to Debugger”

Replace localhost with your new URL and add HTTPS at the beginning or it won’t work.

https://{The Azure URL youre given}/api/webhooks/incoming/genericjson/z?code=80ad19e357b01a04fe767067df7cd31b96a844e1

You can test the listener again via Postman if you like by pasting in the URL above. 

Log into your Emma account and retrieve your public API key and Account number into Postman and create your first Webhook with your credentials from above.

emma-1

The example below sends a request each time a contact record is updated within Emma.  For a full list of available Webhooks visit the Emma API documentation.

postman-webhook

Authenticate via the Authorization tab and enter your Emma credentials.

authenticate

Send the request via Postman and it should return to you the ID of your Webhook.

Go back to your application in Visual Studio and attach to the debugger.

Test the Webhook by logging into your Emma platform and updating a contact. If you’re connected to the remote server, your breakpoint should be hit within a minute or so.

In order to use the JSON object you received from Emma you need Newtonsoft and a way to deserialize the Emma request.

using Newtonsoft.Json;

public override Task ExecuteAsync(string generator,, WebHookHandlerContext context)
{     

  JObject data = context.GetDataOrDefault<JObject>();

EmmaWebhook request = JsonConvert.DeserializeObject<EmmaWebhook>(data.Root.ToString());

You need a class to map the deserialization

        public class EmmaWebhook

        {

            public string event_name { get; set; }

            public Data data { get; set; }

        }

        public class Data

        {

            public string member_id { get; set; }

            public string account_id { get; set; }
            //The Emma result can also come with a TimeStamp
            //but I didn't want to deal with a DateTime property.

        }

Update a contact in Emma.  If you’ve entered everything correctly, you should see your result in the debugger 😉

debugger

Troubleshooting

If you experience issues where Emma is not sending the request, make sure your webhook is registered.  You can see registered webhooks with the following GET request in Postman:

https://api.e2ma.net/{Your Account Id}/webhooks.

If that doesn’t help connect your Emma account to Zapier and see if Zapier is able to receive the request.  If you’re still unable to receive the request, go back into the article and make sure you did not miss any details such as using the proper key length or HTTPS.

Collaborated on a .NET Core application to assist an investment company in showcasing their members.

Features:

  • Utilized Razor views and JQuery Datatables for user interaction
  • Implemented ‘Repository Pattern’ architecture
  • Utilized Entity Framework Core as ORM
  • Maintained deployment cycle leveraging Visual Studio with Azure deployment tools
  • Maintained ongoing updates and service requests