andrea-chiarelli

I have over 20 years of experience as a software engineer and technical author. Throughout my career, I've used several programming languages and technologies for the projects I was involved in, ranging from C# to JavaScript, ASP.NET to Node.js, Angular to React, SOAP to REST APIs, etc.

In the last few years, I've been focusing on simplifying the developer experience with Identity and related topics, especially in the .NET ecosystem.

Principal Developer Advocate

Andrea Chiarelli

A new release of the package Auth0 Templates for .NET is out with new project templates and other improvements.

A new awesome version of the [Auth0 Templates for .NET package](https://www.nuget.org/packages/Auth0.Templates/) has been released! It brings you new templates and other improvements, which we will discover in a moment. Install now the latest release of the templates by running the following command in a terminal window:

```bash
dotnet new install Auth0.Templates
```

> ⚠️ Make sure you have uninstalled any previous version of the package from your machine before installing the new one.

Ready to learn what's new in the latest release? Let's go!

## New Project Templates

The first big news is that two new templates are now available: the Blazor Web App and the MAUI templates.

### The Blazor Web App template

The Blazor Web App template allows you to create a web application using the .NET 8 Blazor application model. As you may know, this new type of Blazor application has some complexities in properly supporting authentication. Take a look at [this article](https://auth0.com/blog/auth0-authentication-blazor-web-apps/) to learn more about it. Now you can have a starting point for your new Blazor application with Auth0 embedded in a snap by simply running the following command:

```bash
dotnet new auth0blazor -o MyNewBlazorApp
```

As usual, if you also have the [Auth0 CLI](https://github.com/auth0/auth0-cli) installed on your machine and logged in, you can automatically register your app with Auth0. Of course, you can still use the templates with Visual Studio:

![Auth0 Blazor Web App template in Visual Studio](https://images.ctfassets.net/23aumh6u8s0i/1fmXTCgaPVzvKGGiW0QPon/edd5f2a979472be788c9c6d448dc1ed0/auth0-blazor-web-app-vs.png)

Read [more about the Blazor Web App template here](https://github.com/auth0/auth0-dotnet-templates/blob/main/docs/auth0blazor.md).

### The MAUI template

With the MAUI template, you can build desktop and mobile applications with Auth0 authentication for Windows, macOS, iOS, and Android using a single code base. In this case, the command to use is as follows:

```bash
dotnet new auth0maui -o MyNewMauiApp
```

Building your new MAUI app using this template will save you a lot of time, as you can see from reading [this article](https://auth0.com/blog/add-authentication-to-dotnet-maui-apps-with-auth0/).

Check out [this document to learn more about the MAUI template](https://github.com/auth0/auth0-dotnet-templates/blob/main/docs/auth0maui.md).

## Other Improvements

In addition to the new templates, the new package brings you other internal and external improvements. To mention just a few of them:

- The Blazor WebAssembly template now supports .NET 8.
- The program that registers your application with Auth0 is no longer tied to .NET 7.0.
- A few issues with the auto-registration script have been fixed.

These improvements help provide a better experience when scaffolding and registering your application with Auth0.

<include src="ebook-ads/dotnetIdentity" />

## JetBrains Rider Support

Now you can use the Auth0 Templates with JetBrains Rider! Starting with [version 2024.1](https://www.jetbrains.com/rider/whatsnew/), Rider fully supports custom templates, so now you can choose your preferred IDE to build your .NET applications with Auth0 integrated, regardless of your operating system. This is especially important now that [Visual Studio for Mac is close to its retirement](https://learn.microsoft.com/en-us/visualstudio/mac/what-happened-to-vs-for-mac?view=vsmac-2022).

Previously, Rider [didn't support parameters for custom templates](https://youtrack.jetbrains.com/issue/RIDER-16759), which was a clear barrier to using the Auth0 Templates. Now you can use them just like in Visual Studio!

![Auth0 Blazor Web App Template in JetBrains Rider](https://images.ctfassets.net/23aumh6u8s0i/2wWfc13e4He4h6Ob3H7Eyu/d4fcd35aab3ae5a1ed41f6ec25fc486b/auth0-blazor-web-app-rider.png)

## A Look Back and a Glimpse Forward

The first version of the package was released one year ago. Since then, the project has grown with new templates and integration with the Auth0 CLI for automatic registration of your applications. During this year, the package has been downloaded over 8,000 times, and we have received suggestions and contributions.

We want to continue improving the current templates by adding features and improving the developer experience. Your feedback is very important. Share your thoughts by leaving a message below, or by opening a [new issue](https://github.com/auth0/auth0-dotnet-templates/issues/new/choose) to report problems and request new features.
If you like the project, don't forget [to star it on GitHub](https://github.com/auth0/auth0-dotnet-templates).

New Templates for Building .NET Apps with Auth0 Authentication

Emily Ann Clemons

Emily Ann Clemons is the Product Marketing Manager for Workflows, Okta’s automation and orchestration platform that allows anyone to build Identity-based experiences using out-of-the-box integrations and templates. Prior to Okta, Emily Ann worked at Salesforce on other no-code tooling. Emily Ann is a proud graduate of Auburn University and lives in New York City.

Product Marketing Manager, Workflows

What you need to build —and where you need to take your customers — depends on a multitude of factors, including what stack you decide to rest your engineering laurels on.

Going from an anonymous user to a personalized loyalty member journey can take a thousand steps.

With minimal tech investment but a big impact on security and user experience (UX), Okta Customer Identity Cloud has the necessary tools to take the guesswork out of building for common and unique use cases alike.

## What is an Action?

Actions let you customize authentication and extend Auth0's capabilities with custom logic. The Actions platform allows you to visually build custom workflows with drag-and-drop Action blocks for complete control.

Actions don't require any downloads or updates on your end. They’re written in Javascript and have 2,000,000 npm modules available to start building. You can test an Action before making it live and even roll back with versioning, which saves the headache of remediation and debugging. 

End users also benefit from Actions — with our extensibility platform, you can customize experiences designed to lower friction, making it seamless for customers to convert from anonymous to known users.

## Learn by Example: Actions Templates

To support engineers in understanding the power of Actions, we’ve created templates that teach you how to kickstart your understanding of this powerful extensibility layer and address the most common use cases you’ll probably want to solve. 

There are many templates to choose from, intended to bolster your security posture, increase conversions, and improve customer retention.

### Use cases

Actions templates are organized into different use case categories:

* **MFA**: create table stakes for your MFA implementation, and harness Machine Learning confidence scoring to implement your own adaptive MFA program
* **Enrich profile:** connect your upstream and downstream services with Auth0 as your unified source of truth for the user profile
* **Access control**: limit access to a select group of users and check important account and session information

We designed these use cases to help you get the most out of your Identity solution with Okta Customer Identity Cloud.

### Triggers

Templates provide you with sample code to get you started with different use cases that can be associated with the following triggers:

* Login
* Machine to Machine
* Pre-User Registration
* Post User Registration
* Post Change Password
* Send Phone Message
* Password Reset / Post Challenge

Multiple Actions can be associated with a single trigger, and you can customize templates to work for your own use cases and flows. 

## Migrate from Rules and Hooks or DIY Code

With Rules and Hooks being [deprecated by late 2024](https://auth0.com/blog/preparing-for-rules-and-hooks-end-of-life/), you can trust Actions templates to guide you through best practices that we’ve baked into the platform. Most Rules and Hooks properties have been moved or reshaped into Actions, so semantics are now clearer and more well-organized with new, consolidated ways of expressing the same or similar information.  

Actions streamlines your coding efforts with programming models closely aligned with the Auth0 management API and Auth0 platform.

The way the data is accessed in Actions promotes safe and efficient code, potentially saving you on costly calls to different APIs and running into rate limiting.

Actions templates teach you how to write your own custom code to save you time to ship.

We’ve covered our favorite Actions templates in the following implementation guides that only scratch the surface when it comes to Actions:

* [Adaptive MFA](https://www.okta.com/resources/whitepaper-make-your-mfa-adaptive-with-actions-templates/)
* [Flag sensitive transactions for step-up authentication](https://www.okta.com/resources/whitepaper-flag-sensitive-transactions-for-step-up-authentication/)
* [Collect FPD post-reg and post-login](https://www.okta.com/resources/whitepaper-connect-your-application-to-salesforce-with-first-party-data/)

Actions Template Implementation Guides: Introduction

A new version of the Auth0 Templates for .NET package has been released: discover the new powerful features.

In May, we [announced the release of Auth0 Templates for .NET](https://auth0.com/blog/introducing-auth0-templates-for-dotnet/), a NuGet package that allows .NET developers to scaffold a new project with Auth0 embedded. Today, we are announcing the release of a new powerful version of the package: [Auth0 Templates for .NET 2.1](https://www.nuget.org/packages/Auth0.Templates). 🎉

Go to your terminal window and install the new package by running the following command:

```bash
dotnet new install Auth0.Templates
```

> ⚠️ If you already have a previous version of the package installed on your machine, please uninstall it using the following command before installing the new package:
>
> ```bash
> dotnet new uninstall Auth0.Templates
> ```
>
> 

Let's explore what's new and how you can now create **a working application with Auth0 authentication in less than a minute!**

## Auth0 CLI integration

The most prominent feature introduced in this new release is the integration with the [Auth0 CLI](https://github.com/auth0/auth0-cli), the command line tool that allows you to manage your Auth0 tenants and your application registration from your terminal window.

> 📖 If you are new to the Auth0 CLI, take a look at [the Auth0 CLI Basics Lab](https://developer.auth0.com/resources/labs/tools/auth0-cli-basics) to learn how to use it.

If you have the Auth0 CLI installed on your machine and are already logged in to your Auth0 tenant, you can have your new application automatically registered. Let's do an example to better explain.

### Self-Registration in .NET CLI

Suppose you want to create a Blazor Server application with Auth0 authentication embedded. You can start by running the following command in a terminal window:

```bash
dotnet new auth0blazorserver -o MyBlazorServerApp
```

This command uses the `auth0blazorserver` template to create a Blazor Server application in the `MyBlazorServerApp` folder.

After launching the command, you will see a message similar to the following:

```bash
The template "Auth0 Blazor Server App" was created successfully.

Processing post-creation actions...

Template is configured to run the following action:
Actual command: register-with-auth0.cmd 
Do you want to run this action [Y(yes)|N(no)]?
```

With this message, the template engine asks if you want to register the newly created application with Auth0.

Once you confirm, the new Blazor application will be registered on your current Auth0 tenant. You will see the registration data onscreen for documentation purposes only, as you don't need to configure it manually. In fact, your new application will be automatically configured. All you need to do is run your Blazor application with `dotnet run`!

As you can see, using the integration with the Auth0 CLI allows you to have **an application up and running in less than a minute!**

Of course, you can still pass the configuration options on the command line in case you don't have the Auth0 CLI installed or if you have already registered the application with Auth0. See the [specific options for each template](https://github.com/auth0/auth0-dotnet-templates#usage) for more details.

### Auth0 registration in Visual Studio

If you are using the templates with Visual Studio, you can't leverage the self-registering feature. This is not a limitation of the template, but a restriction imposed by Visual Studio (see [this issue](https://github.com/dotnet/templating/issues/4575) for context).

However, you can run the registration action manually. So, assuming you want to create your Blazor Server application with Visual Studio, select the Auth0 Blazor Server App template as shown in the following picture:

![Auth0 Blazor Server template in Visual Studio](https://images.ctfassets.net/23aumh6u8s0i/4vIKOhrrozhmSDMkYPsEUr/5bd66766af25db726fb3aca5c4d731ab/auth0-blazorserver-app-vs.png)

Then, accept the default values proposed by the template configuration window and create the project.

After the project is created, go to the newly created application and run the following command:

```bash
./register-with-auth0.cmd
```

This command will automatically register your Blazor Server application with Auth0 and configure your application.

> Note: On MacOS you must enable the script to execute. Run the following command before launching the automatic registration:
>
> ```bash
> chmod +x register-with-auth0.cmd
> ```

## .NET 8 Support

The new release of Auth0 Templates for .NET supports .NET 8 by default for most templates. When you use the `dotnet new` command without specifying a framework version, you will get a .NET project with .NET 8 as the target framework. This is also the default .NET version when you are using Visual Studio, as shown below:

![Auth0 Template for ASP.NET Core MVC targeting .NET 8](https://images.ctfassets.net/23aumh6u8s0i/1mnYGKi2t006MED0sC2raQ/902bd9cb7b94be9e4b0d4c6c14b9d3ea/auth0-mvc-app-vs-options.png)

Blazor templates do not currently support .NET 8, but they still target .NET 7. The reason for this choice depends on the new .NET 8 Blazor model, which provides a more fluid approach between the Server and the WebAssembly hosting models. Currently, there are no official guidelines on how to integrate OpenID Connect with the new Blazor model. If you are interested in this topic, you can follow [this thread in the Auth0 Community forum](https://community.auth0.com/t/net-8-0-blazor/119691) to stay updated.

<include src="ebook-ads/dotnetIdentity" />

## Minimal API Template

The [Auth0 Templates for .NET package](https://www.nuget.org/packages/Auth0.Templates/) contains four templates since its first release:

- ASP.NET Core MVC
- ASP.NET Core Web API
- Blazor Server
- Blazor WebAssembly (ASP.NET Core hosted)

This new release adds a new template for [ASP.NET Core minimal API](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/minimal-apis). To use this template, add the `--minimal` option to the `dotnet new auth0webapi` command, as shown in the following example:

```bash
dotnet new auth0webapi -o MyWebAPI --minimal
```

This command creates a minimal API project in the `MyWebAPI` folder, and if you have the .NET CLI installed on your machine, it also registers it with Auth0.

In Visual Studio, you can simply select the *Use minimal API* checkbox as shown in the following picture:

![Options for the Auth0 ASP.NET Core Web API template in Visual Studio](https://images.ctfassets.net/23aumh6u8s0i/30Wl7yaOdnuWBhmdbRZa3v/259aa7ca9bb215da9fba8e62bfee8d87/auth0-webapi-app-vs-options.png)

## Looking Ahead

We hope that these new features will help .NET developers set up their new applications with Auth0 more easily than before. Our goal for the next release is to include a template for the missing Blazor model and add templates for other .NET application types.

Your feedback is valuable. If you experience a problem or have a request, please [open an issue](https://github.com/auth0/auth0-dotnet-templates/issues/new/choose) on the project's GitHub repository.

Remember that [Auth0 Templates for .NET](https://github.com/auth0/auth0-dotnet-templates) is an open source project, so your contribution is welcome! If you think you can help, check out [our contribution policy](https://github.com/auth0/auth0-dotnet-templates/tree/main#contributing) and get involved.



Auth0 Templates for .NET: A New Powerful Version Released

Sam Yapkowitz

I began my career in enterprise software development and got exposure to lots of different frameworks and methodologies. I quickly realized my passion was in the architecture and design of solutions to unique problems. I now get to use these skills to help my customers build high-quality experiences using Okta. When not at work you can find me on the golf course, playing Rocket League or watching football with my friends.

Senior Solutions Engineer

Learn how to perform A/B testing on the Universal Login page using Liquid templates and custom parameters.

There is no way to natively A/B test the Universal Login as of today. But, it can be achieved with the use of the [Liquid](https://shopify.github.io/liquid/basics/introduction/) templates that power the Universal Login, custom parameters passed from the client side, and an A/B testing platform such as [Split.io](http://split.io/), [Google Optimize](https://marketingplatform.google.com/about/optimize/), or [LaunchDarkly](https://launchdarkly.com/).  A/B testing, also known as split testing, refers to a randomized experimentation process wherein two or more versions of a variable (web page, page element, etc.) are shown to different segments of website visitors at the same time to determine which version leaves the maximum impact and drives business metrics.

## What Is the Universal Login?

Auth0 Universal Login (UL) defines your login flow, which is the key feature of an authorization server. Whenever a user needs to prove their identity, your applications redirect to Universal Login, and then Auth0 will do what is needed to guarantee the user's identity.

When using Universal Login, you don't have to do any integration work to handle different methods of authentication. You can start off using a simple username and password, and then add other features, such as social login and multi-factor authentication (MFA).

Configuring Universal Login is dynamic (and does not require application-level changes) because all functionality is driven by the web pages served by the centralized Authentication Server. Your applications benefit from any improvements Auth0 makes in the login flow without the need for you to change your code.

You can create a consistent, branded login experience by customizing the login page appearance and behavior from the Auth0 Dashboard. For advanced use cases, you can even change the code of each page.

To learn more about the differences between Universal Login and embedded login, read [Centralized Universal Login vs. Embedded Login](https://auth0.com/docs/authenticate/login/universal-vs-embedded-login).

## Universal Login Liquid Templates

The UL can be modified through the use of Liquid [templates](https://auth0.com/docs/customize/universal-login-pages/universal-login-page-templates).  To work with these Liquid templates, you will need to configure a [Custom Domain](https://auth0.com/docs/customize/custom-domains). These templates allow you to define the HTML, CSS, and JS that are shipped to the client when making an `authorize` request. These Liquid templates allow you to run conditional logic based on the Liquid syntax. This functionality allows you to provide a unique UX based on things such as application, organization, tenant, locale, and specific screen. There is the ability to pass specific query parameters during an `authorize` request that can be accessed inside the Liquid template syntax for even further customization options. These parameters must be prefixed with `ext-` to be honored by the UL. These can be accessed through `transaction.params.ext-{param}`. With these parameters, we can now specify different versions of the UL to render for a user. Here is a Liquid template example of conditionally branding the UL based on one of the custom query parameters. This example leverages the param `ext-alt-brand`:

```html
<!DOCTYPE html>
<html lang="{{locale}}">

  <head>
    <title>Welcome to {{ application.name }} </title>
    {%- auth0:head -%}
    <style>
      {% if transaction.params.ext-alt-brand == "portal_0" %}
      body {
        background-image: radial-gradient(blue, rgb(200, 200, 200));
      }
      #custom-prompt-logo {
        background-image: url('https://banner2.cleanpng.com/20180328/roq/kisspng-circle-logo-symbol-font-templates-5abbf957bfda53.1977074015222685037859.jpg');
      }
      {% elsif transaction.params.ext-alt-brand == "portal_1" %}
      body {
        background-image: url("https://images.unsplash.com/photo-1592450865877-e3a318ec3522?ixlib=rb-1.2.1&auto=format&fit=crop&w=2255&q=80");
        background-size: cover;
        background-position: center;
        background-repeat: no-repeat;
      }
      #custom-prompt-logo {
      background-image: url('https://bootstraplogos.com/wp-content/uploads/edd/2017/11/logo-51.png');
      }
      .prompt-wrapper {
        position: relative;
        display: flex;
        align-items: center;
        width: 480px;
        height: 100%;
        justify-content: center;
        background-color: rgb(247, 198, 233);
      }
      {% else %}
      body {
        background: linear-gradient(-45deg, #ff44dd, #3885ff, #3ec6eb, #1bc99f);
        background-size: 100% 100%;
      }
      #custom-prompt-logo {
        background-image: url('https://cdn.auth0.com/blog/auth0rta/theme/logos/auth0-logo-black.png');
      }
      {% endif %}
      {% if organization != null && organization != undefined %}
        #custom-prompt-logo {
            background-image: url({{ organization.metadata.logo_url }});
        }
        body {
            background: linear-gradient({{ organization.metadata.linear_gradient }})
        }
      {% endif %}

  </style>
  </head>
  <body class="_widget-auto-layout _use-custom-prompt-logo">
      <div class="prompt-wrapper">
        {%- auth0:widget -%}
      </div>
  </body>
</html>
```

When the value of the param `ext-alt-brand` is `portal_0`, the following version of the login page (say, version A) will be shown:

![Universal Login test page version A](https://images.ctfassets.net/23aumh6u8s0i/HaEPIJiEdF8m9l9XI96i2/a2b427c463052ef25e8e1395d83497ab/universal-login-test-a.png)

When the value of the param `ext-alt-brand` is `portal_1`, version B of the login page is shown:

![Universal Login test page version B](https://images.ctfassets.net/23aumh6u8s0i/5hWtq9COZWNfSAXgvzwB4r/ad29b45a10bd7d3f3843f87c8c93eeba/universal-login-test-b.png)

> Note: You can see the domain and application are the same, yet we have a unique UX for an A/B test.

## Client-Side Implementation

There are many ways to accomplish an A/B test with the Universal Login now that we understand how to render separate versions of the UX. A traditional A/B test will have equal weights between all of the options, and upon a user entering one of these flows, the first step would be to check the browser for a cookie indicating whether a particular user has entered into the experiment already.

If the user is new, they will be assigned one of the pathways for the experiment and then be delivered the content for the item. If a user has previously entered the experiment, we can examine their cookie to determine which pathway they belong to and continue delivering them that same content to provide a consistent UX for the lifetime of the experiment.

This can be implemented manually, but many providers offer this service OOTB, such as Split and LaunchDarkly, to help you make this piece more flexible as you run more experiments or implement feature flagging from a deployment perspective. For this writeup, I have built out examples leveraging both Split and Google Optimize.

To put the final piece in place, my application is built with Next.JS and deployed on Vercel to take advantage of their [Edge Middleware](https://vercel.com/docs/concepts/functions/edge-middleware) capability. This piece is purely preference, and is very dependent on your current implementation of CIC. The Edge Middleware functionality on Vercel allows you to intercept requests on the edge and rewrite URLs extremely quickly. This allows you to decouple the A/B test from your client-side authentication logic. For instance, any place in my application can continue to leverage the same login route without needing more logic to be added. The Edge Middleware then interfaces with my A/B provider to read/write cookies as well as modify the login route to supply the proper parameter during the `authorize` request. You can view the source code for the [Google Optimize](https://github.com/samyap4/auth0-ab-testing-optimize) example and the [Split](https://github.com/samyap4/auth0-ab-testing-split) example on my GitHub.

## Live Examples

Here are snippets of the live examples in action on [Split](https://auth0-ab-testing-split.vercel.app/). The cookie being set here is called `flag-universal_login`. This is version A in action:

<AmpContent>
<amp-youtube
    data-videoid="dnjnnIVDp-Q"
    layout="responsive"
    width="480" height="270">
</amp-youtube>
</AmpContent>

<NonAmpContent>
<div
  class='embed-container'
  style="position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%;margin-bottom:40px;">
    <iframe
      style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;"
      src='https://www.youtube.com/embed/dnjnnIVDp-Q'
      frameborder='0' allowfullscreen>
    </iframe>
</div>
</NonAmpContent>

Here is version B in action:

<AmpContent>
<amp-youtube
    data-videoid="zgj5SpiRuVo"
    layout="responsive"
    width="480" height="270">
</amp-youtube>
</AmpContent>

<NonAmpContent>
<div
  class='embed-container'
  style="position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%;margin-bottom:40px;">
    <iframe
      style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;"
      src='https://www.youtube.com/embed/zgj5SpiRuVo'
      frameborder='0' allowfullscreen>
    </iframe>
</div>
</NonAmpContent>

You can see the application is the same, and I can generate a different UX based on the cookie being set by my [Split.io](http://split.io/) configuration.

## Implementing Analytics

Now that we have demonstrated how to deliver different experiences to different users, the final step of the A/B testing journey will be to start gathering metrics about how users are interacting with your content. We already discussed that we can leverage the templates to bring in custom scripts to your Universal Login screens. You can use whatever service you like for tag management, such as [Google Tag Manager](https://marketingplatform.google.com/about/tag-manager/).

## Conclusion

At Auth0, we aim to provide a high-quality service and developer experience for our customers. The first interaction with your customers is often times a login screen, so we understand how important it is for the user experience to be top-notch. With our hosted Universal Login, we take away the burden of deploying and maintaining these highly secure workflows. With the capabilities of our templates outlined in this post, we are able to help your teams iterate more quickly and customize the experience to be sticky for your brand and ultimately help your business grow.


Universal Login A/B Testing

Create your .NET applications secured with Auth0 in less than a minute with Auth0 Templates for .NET.

<div class="alert alert-info alert-icon">
   <i class="icon-budicon-500"></i>
   <strong>A new version of Auth0 Templates for .NET is available!<br/>
Check out <a href="/blog/auth0-templates-for-dotnet-powerful-version/">Auth0 Templates for .NET: A New Powerful Version Released</a> to learn what new features it brings to you.
   </strong>
 </div>

Project templates are a handy way to scaffold an application in minutes, if not seconds. .NET developers are used to templates since Microsoft provides several built-in project templates for .NET through the [.NET SDK](https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-new-sdk-templates) or [Visual Studio](https://learn.microsoft.com/en-us/visualstudio/ide/creating-project-and-item-templates).

Now you have .NET templates with Auth0 embedded, including the right Auth0 SDK and best practices for a given type of application! You can build your .NET projects integrated with Auth0 in seconds using the .NET CLI or the IDE you prefer: Visual Studio or Visual Studio Code.

## What Is Auth0 Templates for .NET?

[Auth0 Templates for .NET](https://github.com/auth0/auth0-dotnet-templates) is a project that provides you with a set of project templates to help you scaffold your application with Auth0 support for authentication and authorization. Currently, the project offers templates for the following application types:

- ASP.NET Core MVC
- ASP.NET Core Web API
- Blazor Server
- Blazor WebAssembly (ASP.NET Core hosted)

More templates will be added in the near future. The templates target .NET 7 and allow you to create your applications by using the typical approach you are accustomed to using the built-in templates.

## Install the Package

The Auth0 Templates for .NET project uses the [modern template approach](https://learn.microsoft.com/en-us/dotnet/core/tools/custom-templates), which guarantees high compatibility across different development environments and operating systems. This means that you can use the templates with your preferred development environment: .NET CLI, Visual Studio for Windows and Mac, or Visual Studio Code.

Even JetBrains Rider is supported, but at the time of writing, there is still an [issue with parameter support](https://youtrack.jetbrains.com/issue/RIDER-16759) that prevents the full power of the templates from being used.

To install the [Auth0 Templates for .NET NuGet package](https://www.nuget.org/packages/Auth0.Templates/), run the following command in a terminal window:

```bash
dotnet new install Auth0.Templates::2.0.1
```

Once the package is installed, use your preferred IDE to create your application.

## Create Your .NET Project

Let's see how you can use the templates to create a new .NET application. First, there are some preliminary steps to take. The templates assume that you have already registered your application with Auth0 and have all the necessary configuration settings at hand.

To integrate your application with Auth0, you need an Auth0 account. You can <a href="https://a0.to/blog_signup" data-amp-replace="CLIENT_ID" data-amp-addparams="anonId=CLIENT_ID(cid-scope-cookie-fallback-name)">sign up for a free one now</a>. Then you need to [register your application](https://auth0.com/docs/get-started/auth0-overview/create-applications) or [your API](https://auth0.com/docs/get-started/auth0-overview/set-up-apis) in the Auth0 dashboard. The registration step will return some data that you will use to set up your app through the templates. Basically, this data is a subset of the following:

- the Auth0 domain, 
- the client ID, 
- the client secret, 
- the API identifier or audience.

Once you have this data from the Auth0 dashboard, you are ready to use the Auth0 templates for building your app.

### Use the templates in .NET CLI

You can leverage the `dotnet new` command to list the available templates. For example, you can run the following command to get the list of available Auth0 templates:

```bash
dotnet new list auth0
```

As a result of this command, you should see the following list:

```bash
Template Name                 Short Name         Language  Tags                        
----------------------------  -----------------  --------  ----------------------------
Auth0 ASP.NET Core Web API    auth0webapi        [C#]      Web/WebAPI/Auth0            
Auth0 ASP.NET Core Web App    auth0webapp        [C#]      Web/MVC/Razor Pages/Auth0   
Auth0 Blazor Server App       auth0blazorserver  [C#]      Web/Blazor/Auth0            
Auth0 Blazor WebAssembly App  auth0blazorwasm    [C#]      Web/Blazor/WebAssembly/Auth0
```

Suppose you want to learn the CLI syntax for using the Blazor Server template. You run the following command in your terminal:

```bash
dotnet new auth0blazorserver --help
```

This command will show you all the options you can provide to build an already configured Blazor Server application.

To create a new Blazor Server app through the Auth0 template, use the following command:

```bash
dotnet new auth0blazorserver \
    --domain <YOUR_AUTH0_DOMAIN> \
    --client-id <YOUR_CLIENT_ID> \
    -o MyBrandNewApp
```

> The line continuation character (`\`) shown above is just for presentation purposes. Use the appropriate character for your command line shell if you want to use it in your operating system.

Replace the placeholders `<YOUR_AUTH0_DOMAIN>` and `<YOUR_CLIENT_ID>` with the actual values you got when registering your app in the Auth0 dashboard. This command will create your Blazor Server application in the `MyBrandNewApp` folder.

After creating the app, you can run it and test authentication support in a minute!

> Read [this document to learn how to use the available Auth0 templates](https://github.com/auth0/auth0-dotnet-templates/tree/main#usage).

### Use the templates in Visual Studio

The templates installed with the above command are also available in Visual Studio. Select the Auth0 template for the app you want to create, as shown in the following picture for Visual Studio for Windows:

![Auth0 templates in Visual Studio for Windows](https://images.ctfassets.net/23aumh6u8s0i/5A53ehX7663L0HxkB65Aos/2cbbbb09f3ad4c4979e052f4f02b2ac2/auth0-blazorserver-app-vs.png)

The following picture comes from Visual Studio for Mac:

![Auth0 templates in Visual Studio for Mac](https://images.ctfassets.net/23aumh6u8s0i/7nyet9ozGX1bk4Kf4AFipb/00d4a3fbb394bde20e132526244161ce/auth0-blazorserver-app-vs-mac.png)

You will then be prompted for the registration information, as shown in the following picture (Visual Studio for Windows):

![Auth0 template options in Visual Studio for Windows](https://images.ctfassets.net/23aumh6u8s0i/3YMXIB1UY58WD2iFCeydyX/8e03f036e38cc6a6a5136328c3077947/auth0-blazorserver-app-vs-options.png)

This is the corresponding screen on Visual Studio for Mac:

![Auth0 template options in Visual Studio for Mac](https://images.ctfassets.net/23aumh6u8s0i/2rctCGwBn68ACigGj6wf2L/98b0805b10d53e76d49014f53c9123f9/auth0-blazorserver-app-vs-mac-options.png)

Next, you specify the project's name and where you want to save it, as you would with standard templates. That's it! Once the application is created, you can run it and test authentication.

> Read [this document to learn how to use the available Auth0 templates](https://github.com/auth0/auth0-dotnet-templates/tree/main#usage).

<include src="ebook-ads/dotnetIdentity" />

## Looking Forward

This is the first release of the [Auth0 Templates for .NET](https://www.nuget.org/packages/Auth0.Templates/) package, but we want to add new templates and improve the developer experience as well. Your feedback is highly appreciated, so please leave your comments below and let us know what you think about this project.

The [Auth0 Templates for .NET project](https://github.com/auth0/auth0-dotnet-templates) is open source, so your contribution is also welcome! If you think you can help with this project, check out [our contribution policy](https://github.com/auth0/auth0-dotnet-templates/tree/main#contributing) and get involved.


Introducing Auth0 Templates for .NET

How to create your .NET project template to use with .NET CLI and Visual Studio.

How to Create Your .NET Project Template

john-papa

John Papa is a dedicated father and husband, a professional Web Developer, and avid OSS and community advocate. He currently is a Developer Advocate for Microsoft and has formerly worked for Disney on several web and mobile applications that you may have used. His passions are coding and teaching modern web technologies and enjoying everything Disney with his family. John is a co-host of the Real Talk JavaScript podcast, author of the Angular Style Guide, and many popular Pluralsight courses. You can reach John on Twitter at @john_papa.

Principal Developer Advocate Lead

John Papa

Find and report more errors than ever with Angular 9's Ivy compiler, strict template checking.



We have likely read about some of the benefits of the Ivy compiler and runtime. It's faster. It makes smaller bundle sizes. And it has [many other great new features that are introduced in Angular 9](https://auth0.com/blog/angular-9-whats-new/). Yet one of the most compelling and useful features is one we don't hear as often.

What if Angular could find bugs in our existing code? Hidden bugs that we may not notice. Subtle bugs that could cause problems? [Angular 9](https://angular.io) and the [Ivy](https://angular.io/guide/ivy) compiler do just that.

The new feature is known as strict template checking. Angular has been checking expressions and bindings within the templates of our applications for years. But with Angular 9, it finds and reports more errors than ever. It is pretty cool that we could have bugs in our templates right now, and this new feature reports them to us so we can fix them.

Seeing is believing, so let's see some examples. We'll kick things off using Angular 8, and we'll progress to Angular 9. We'll also adjust some compilation settings. These differences help us see where Angular 9 can detect additional errors that Angular 8 could not.

<include src="TweetQuote" quoteText="With Angular 9's new feature, strict template checking, we can find and report more errors than ever!"/>

## Compiling with Angular 8

Let's start with an example that we can all relate to, using Angular 8. 

We use a lot of `*ngFor` directives in our templates to iterate over arrays of objects. We reference an array and display the details of each object in the array in a template. The following component displays a list of heroes in the template.

``` html  

// app.component.ts

import { Component } from "@angular/core";
interface Hero {
  id: number;
  name: string;
}

@Component({
  selector: "app-root",
  template: `
      <div>{{ title }}</div>
      <ul>
        <li *ngFor="let hero of heroes; trackBy: trackByHero">
          <div>{{ hero.Id }} {{ hero.name }}</div>
        </li>
      </ul>
  `
})

export class AppComponent {
  heroes: Hero[] = [
    { id: 10, name: "Landon" },
    { id: 20, name: "Ella" },
    { id: 30, name: "Madelyn" },
    { id: 40, name: "Haley" }
  ];
  trackByHero(hero: Hero) { return hero.id; }
}

```

We're going to explore the `fullTemplateTypeCheck` setting in our `tsconfig.json` file, which, by default for our Angular 8 app, is set to `true`.

```json
{
  "compileOnSave": false,
  "compilerOptions": {
  …
  },
  "angularCompilerOptions": {
    "fullTemplateTypeCheck": true,
    "strictInjectionParameters": true
  }
}
```

When we build this application with Angular 8 using `ng build` it compiles successfully. It even serves the application in the browser when we run `ng serve --open`. 

Now we can build the app with Angular 8 using AOT by running the command `ng build --prod`. Now we see Angular is reporting an error that the `title` does not exist in our component. When both AOT and the `fullTemplateTypeCheck` setting set to true, Angular can detect when we refer to a model that is missing from our component.

```text
ERROR in src/app/app.component.ts.AppComponent.html(3,12): Property' title' does not exist on type 'AppComponent'.
```

This error message is clear, but what is that filename `app.component.ts.AppComponent.html`? We can guess, correctly, that it means the `app.component.ts` file. But it would be nice if the filename was clear. We could fix this error now, but let's see what happens when we compile with Angular 9.

## Angular 9’s No Strict Templates

After upgrading to Angular 9 and its Ivy compiler, we can use a new setting in `tsconfig.json` for strict template checks. We'll open the file `tsconfig.json` and locate the `angularCompilerOptions` section. Let’s remove the `fullTemplateTypeCheck` entry and replace it with `strictTemplates: false`. Our `tsconfig.json` file should now have the following settings for the `angularCompilerOptions` with the strict templates checked disabled.

```json
{
  "compileOnSave": false,
  "compilerOptions": {
  …
  },
  "angularCompilerOptions": {
    "strictTemplates": false,
    "strictInjectionParameters": true
  }
}
```

When we build this application with Angular 9 using `ng build`, we immediately see an error for the missing `title` model. Also, the error is a little easier to read, as the Ivy compiler reports the file where the bug occurs.

```text
ERROR in src/app/app.component.ts:12:15 - error TS2339: Property 'title' does not exist on type 'AppComponent'.
```

We only had to run `ng build` to see this error with Angular 9, while in Angular 8 we did not see this error message when we ran `ng build`. This is because the AOT (Ahead of Time) compilation does not run in Angular 8 unless we explicitly tell it to run or we run `ng build --prod`. AOT compilation occurs with Angular 9 in `ng build` and `ng build --prod`. Having the AOT compilation in `ng build` is convenient because in Angular 8 we could have errors while we develop our application until we run a production build. Angular 9 tells us right away if we have this type of error.

Let's fix our error by adding a title model to our component. We'll add the following code inside of the `AppComponent`:

```javascript
  title = 'Heroes';
```

Now we can build successfully with `ng build` with Angular 9. So to recap what just happened, we upgraded to Angular 9 and disabled strict template checks, and the Ivy compiler tells us errors that were missed in a standard `ng build` in Angular 8.

Now let's ramp up the stakes a bit and see if we can get Angular 9 to show us any more hidden errors.

## Strict Templates

Let's change the setting in `tsconfig.json` to enable strict template checks. We'll open the file `tsconfig.json` and locate the `angularCompilerOptions` section. Let’s remove the `fullTemplateTypeCheck` entry and replace it with `strictTemplates: true`. Our `tsconfig.json` file should now have the following settings for the `angularCompilerOptions` with the strict templates checked enabled.

```json
{
  "compileOnSave": false,
  "compilerOptions": {
  …
  },
  "angularCompilerOptions": {
    "strictTemplates": true,
    "strictInjectionParameters": true
  }
}
```

Now when we build and serve the application with `ng build` we are presented with a series of errors, as shown in the following image:

![Strict Template Check Find Several Errors in Angular 9](https://images.ctfassets.net/23aumh6u8s0i/6J00gz6V5dgxHbzkvhw1xf/e8836f9bfb60c45229ceffa729bda64f/strict-template-checking-errors)

If we tackle these one-by-one, we can see that the first error is complaining that something is wrong with the `*ngFor` statement. The real hint is how it references `TrackByFunction<Hero>`. Our function `trackByHero` only accepts a `hero` parameter. However, the implementation of a `TrackByFunction<T>` states that it should accept an index and a type T. This is why it is saying that `hero` and `index` are incompatible because we did not pass the `index`.

We can fix this error by refactoring our function to look like the following code:

```javascript
  // Old code
  // trackByHero(hero: Hero) {
  // return hero.id;
  // }
  // Refactored code
  trackByHero(index: number, hero: Hero): number {
    return hero.id;
  }
```

When we run `ng build` after refactoring the `trackByHero` function, we see fewer error messages.

![Strict Template Check Error for missing property on a model](https://images.ctfassets.net/23aumh6u8s0i/6wNVWwlV25Mm8nrKnE8UgM/40160e9f303349b737879a92592b9ce7/strict-template-check-model)

This last error reports that the property `Id` does not exist on the `hero` model. After closer examination in our component's code, we can see this is indeed an error. The code should be binding to `hero.id`. This minor typo was not detected in Angular 8 and can only be detected in Angular 9 with strict templates!

Now when we refactor the template to bind to `hero.id` and run `ng build` once again, we have success! 

Angular 9's Ivy compiler and the strict template check found these errors that Angular 8 could not detect.

## What Happened?

Angular 8 does check the templates for errors, but it had gaps in what it could not detect. For example, when using AOT and the `fullTemplateTypeCheck` setting, Angular 8 could detect missing models from a component. But it could not detect the properties of those models. This is why the properties of the `hero` could not be verified by Angular 8.

We explored a few different scenarios, so let's break this down a bit:

* When `fullTemplateTypeCheck` was false, Angular didn't check the bindings inside the `*ngFor` template. So the `<li>`'s bindings did not get checked.

* When `fullTemplateTypeCheck` was true, Angular checked that the `hero` is a valid model on the component, but it assumes the model is of type `any`.

* When `strictTemplates` is true, Angular 9 and the Ivy compiler verify that `hero` is a valid model of type `Hero`, and that the properties on that model (`hero.id` and `hero.name`) are also valid.

<include src="TweetQuote" quoteText="Angular 9's Ivy compiler and the strict template check finds errors that Angular 8 could not detect."/>

## Should We Use Strict Templates Now?

If we upgrade from Angular 8 to Angular 9 using [this excellent upgrade guide](https://update.angular.io/), the `strictTemplates` setting isn't applied to our app. Wait, if this helps our app detect bugs, why wouldn't we want it? Imagine how we might react if our app, which seems to work fine right now, produced compilation errors after an upgrade?  

By making this a manual change that we must opt into for Angular 9, we control the experience, and we control when we decide to ask Angular to look for template bugs that may exist. 

> Note: The Angular team intends to set `strictTemplates` to true in the next version, Angular 10. 

If we want to get to a point where we have strict templates slowly, there is a way we can do this more gradually. There are several additional checks that Angular 9's Ivy compiler can check for us. We can use [this guide in the Angular docs to gradually get to `strictTemplates`](https://angular.io/guide/template-typecheck#troubleshooting-template-errors) by turning on individual strict flags and fix newly revealed errors until none are remaining.

Whatever is decided, it is nice that Angular 9 and its Ivy compiler detect more errors than ever before, and we can gradually fix them at our own pace without disrupting our workflow.

## Other Angular Resources

If you want to learn more about these features, check out these great resources:

* [Angular 9 Template Type Checking](https://angular.io/guide/template-typecheck)
* [TypeScript configuration](https://angular.io/guide/typescript-configuration)
* [Angular Language Service for Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=Angular.ng-template&wt.mc_id=auth0-blog-jopapa)

<include src="asides/AboutAuth0" />

---


Angular 9's Best Hidden Feature: Strict Template Checking

1097492785caf9ffeebffeb624202d8f?s=200 avatar

1097492785caf9ffeebffeb624202d8f?s=200

Prosper is a great speaker, community leader, open source hacker, technical consultant, and a fervent Developer Advocate. He is a full-stack software engineer who has worked on biometric, health and developer tools. Prosper recently co-founded a startup called Eden that’s focused on improving the quality of lives in Nigeria and currently leads the engineering team. He also co-founded forloop, the largest developer community in Africa.

Former Auth0 Employee

Prosper Otemuyiwa

Create React App (CRA) is a very good tool for creating React apps from the CLI without build configuration.



---

**TL;DR:** There are several tools available for developers to aid the building of various types of websites and applications. One such tool is [**Create React App(CRA)**](https://github.com/facebookincubator/create-react-app), the CLI tool that helps JavaScript developers create react apps with no build configuration. As awesome as **CRA** is, developers still need a way of tweaking, adding special scripts and modules that doesn't come bundled with **CRA**. Today, I'll teach you how to create custom `create-react-app` scripts for you and your team!

---

Many developers already use [create-react-app](https://github.com/facebookincubator/create-react-app) to build their React applications, but like I mentioned earlier, developers are still screaming for more configuration options! Some are interested in having support for:

* PostCSS
* CSS Modules
* LESS
* SASS
* ES7
* MobX
* Server Rendering

..and a lot more out of the box!

A lot of developers, including JavaScript newbies create *React* apps from scratch daily, so the *CRA* team at Facebook built the *create-react-app* tool to make the process of creating such apps less tedious and error-prone.

As a developer that needs support for some of the technologies I highighted earlier, one way of going about it is running `npm run eject`. This command copies all the config files and dependencies right into your project, then you can manually configure your app with all sorts of tools to satisfaction.

One major challenge developers might face with *eject* is not been able to enjoy the future features of *CRA* . Another challenge with *eject* would be ineffecient synchronised setup across React developers working in team. One great way of solving this later challenge is publishing a fork of `react-scripts` for your team, then all your developers can just run `create-react-app my-app --scripts-version mycompany-react-scripts` and have the same setup across board. Let's learn how to accomplish that!


## Create a Fork

Open up your GitHub repo and fork the [create-react-app repo](https://github.com/facebookincubator/create-react-app)

![Creating a fork of create-react-app](https://images.ctfassets.net/23aumh6u8s0i/7u1YvLkXhzbeQjnaSCxJbQ/bf83b03caae7460819dfbbe663984852/fork)
_Creating a fork of create-react-app_

**Note:** It is recommended that you fork from the latest stable branch. Master is unstable.

Inside the `packages` directory, there is a folder called `react-scripts`. The `react-scripts` folder contains scripts for building, testing and starting your app. In fact, this is where we can tweak, configure and add new scripts and templates.


## Tweak the Configuration

Clone the directory and open up the `react-scripts/scripts/init.js` in your code editor. Let's add some few console messages like so:


```js

......
......
console.log(chalk.red('VERY IMPORTANT:'));
console.log('Create a .env file at the root of your project with REACT_APP_EMPLOYEE_ID and REACT_APP_POSITION_ID');
console.log('  You can find these values in the company dashboard under application settings.');
console.log('  https://company.bamboohr.com/settings');
console.log();
.......

```

![Block to add important message](https://images.ctfassets.net/23aumh6u8s0i/n7LhzGHKp5tEMU4OmKrXa/7eb55ae3947e1d7a909d20f92f2dfe9e/important-messages)
_Add the important message during installation here_

![Important Message added to Installation process](https://images.ctfassets.net/23aumh6u8s0i/4qwNthcuPvylJrOW2Xx2K9/60668429708f5804833da8a4af85e066/added_message)
_Added important message to show during installation_


**Now, Let's change templates**

Open up `react-scripts/template/src/App.js` and replace it with this:

```js

import React, { Component } from 'react';
import logo from './logo.svg';
import './App.css';

class App extends Component {

  getEnvValues() {
    if (!process.env.REACT_APP_EMPLOYEE_ID || !process.env.REACT_APP_POSITION_ID) {
      throw new Error('Please define `REACT_APP_EMPLOYEE_ID` and `REACT_APP_POSITION_ID` in your .env file');
    }

    const employeeID = process.env.REACT_APP_EMPLOYEE_ID
    const position = process.env.REACT_APP_POSITION_ID;

    return { employeeID, position };
  }

  render() {

    const { employeeID, position } = this.getEnvValues();

    return (
      <div className="App">
        <div className="App-header">
          <img src={logo} className="App-logo" alt="logo" />
          <h2>Welcome to Unicode Labs</h2>
        </div>
        <p className="App-intro">
           <b> Employee ID: { employeeID } </b><br/><br/>
           <b> Position: { position } </b>
        </p>
      </div>
    );
  }
}

export default App;

```

Now, go to `react-scripts/template/public` directory. Open the `index.html` file and change the value of the `<title>` tag to `Unicode Labs`.

You can also change the favicon to your company's favicon. You can change as many things as you want and add custom components that your team uses frequently.

Create an `.env.example` in the `react-scripts/template` directory that contains the following:

```bash

REACT_APP_EMPLOYEE_ID='44566'
REACT_APP_POSITION_ID='ENGR'

```

A user will have to rename it to `.env` once the `create-react-app` tool is done installing the `react-scripts`. You should add this instruction to the `README` file.

**Note:** *CRA* already includes support for custom env variables if you're open to prefixing their names with **REACT_APP**.

That's all we need!

## Publish react-scripts to NPM

Before publishing to npm, we need to change the value of the `name` key of the `package.json` file in `react-scripts` directory to `unicodelabs-react-scripts`.

Change the value of the `description` key to `Unicodelabs Configuration and scripts for Create React App.` Also, point the value of the `repository` key to the right location. In my case, it is `unicodelabs/create-react-app`.

Now, `cd` to the `react-scripts` directory from your terminal like so:

![react-scripts directory](https://images.ctfassets.net/23aumh6u8s0i/bb1nEBWI7mEn8AhvlhHHr/866debaed0d8a87efd4b265581b6a8df/react-scripts-directory)
_Change into this directory on your terminal_

You need to login to npm like so:

![Npm Login](https://images.ctfassets.net/23aumh6u8s0i/4ICjtFsI8ZCZ0HDmZcC5FJ/2a26a2a62b862577aa9e4fd5695eff66/npmlogin)
_Log into Npm_

Go ahead and publish

![Publish](https://images.ctfassets.net/23aumh6u8s0i/4EQQcIx1ZYGYIrTBSmkrs7/790ea1dd69fddd70e8764820c8c70160/publish)
_Published unicodelabs-react-scripts to npm_

## Test Your Custom Script

Head over to your terminal and run:

```bash

create-react-app test-app --scripts-version unicodelabs-react-scripts

```

In your own case it would be `yourname-react-scripts`, where `yourname` is your company name or whatever name you choose to give it.

*CRA* would install it and then you will see a notice like so:

![Important Warning](https://images.ctfassets.net/23aumh6u8s0i/2pxfM1TOJAmcSV8cq6rDgx/d4962cf535c3e81cdb0fefd4e671492e/important-warning)
_Important Warning_

Remember, when we put this message in the code earlier? Awesome!

Now, `cd` into the `test-app` directory, rename the `.env.example` to `.env` and run `npm start` command.

Your app will spin up with the new template like so:

![New template showing up](https://images.ctfassets.net/23aumh6u8s0i/4ERTl04dXoEUUmTecZl8MR/2e48651dc4684d4bd3dae2f2f812693c/result)

**Note**: If you have yarn installed, then create-react-app would install your app using Yarn.

<include src="asides/React" />

## Conclusion

Great programmers constantly sharpen their tools daily to increase productivity. *CRA* is a great tool for quickly building React Applications. In addition, having your own customized fork of `react-scripts` helps you and your team easily add all the configurations you need. You'll need to maintain your fork, and [make sure it is synced](https://help.github.com/articles/fork-a-repo/#keep-your-fork-synced) with the upstream to have all updates. [Backstroke](https://github.com/1egoman/backstroke) is a bot that can help you with this.

Have a very productive time hacking away!


"template"