DEV Community: Nandkishor

Create Protected Routes In NextJS and NextAuth

Nandkishor — Tue, 07 Dec 2021 19:53:10 +0000

Protecting Routes from unauthenticated users is a crucial part of any app.

In this article, I'll show you exactly how to create protected routes in your NextJS application using NextAuth.

I'll use a JWT token as an example, with the accessToken being saved in the session. Check this article for more information.
How to implement NextAuth credentials provider with external API and login page

Because of the way Next.js handles getServerSideProps and getInitialProps, every protected page load must make a server-side request to determine whether the session is valid before generating the requested page (SSR). This increases server load, but there is an option if you are comfortable making requests from the client. You can use **useSession **to ensure that you always have a valid session. If no session is identified after the initial loading state, you can determine the appropriate action to take.

First, let's modify our _app.js file.

import { SessionProvider, useSession, signIn } from 'next-auth/react';
export default function App({
  Component,
  pageProps: { session, ...pageProps },
}) {
  return (
    <SessionProvider session={session}>
      {Component.auth ? (
        <Auth>
          <Component {...pageProps} />
        </Auth>
      ) : (
        <Component {...pageProps} />
      )}
    </SessionProvider>
  )
}

function Auth({ children }) {
  const { data: session, status } = useSession()
  const isUser = !!session?.user
  React.useEffect(() => {
    if (status === "loading") return
    if (!isUser) signIn()
  }, [isUser, status])

  if (isUser) {
    return children
  }

  // Session is being fetched, or no user.
  // If no user, useEffect() will redirect.
  return <div>Loading...</div>
}

Line #23: Do nothing while in the loading state.

Line #24: If the user is not authenticated, force the user to the login page.

Custom Client Session Handling

Because of how Next.js handles getServerSideProps / getInitialProps, every protected page load must make a server-side request to determine whether the session is valid and then build the requested page. This alternate technique enables for the display of a loading status on the initial check, and all subsequent page transitions will be client-side, eliminating the need to check with the server and regenerate pages.

Consider the "/dashboard" page. Only authorized users should be able to view this page.

export default function Dashboard() {
  const { data: session } = useSession()
  return "Some super secret dashboard"
}

Dashboard.auth = true

The session is always non-null inside this page, all the way down the React tree.

Notice that we are using Dashboard.auth = true to check if the user is authenticated, if not redirect to the login page.

We need to add auth = true to every page that we want to protect from the unauthenticated user.

It is simple to extend/modify to support something similar to an options object for role-based authentication on pages. As an example:

Dashboard.auth = {
  role: "admin",
  loading: <LoadingSkeleton />,
  unauthorized: "/login-with-different-user", // redirect to this url
}

I hope this post helps.

Localization with JSON files in .NET 6

Nandkishor — Tue, 30 Nov 2021 15:30:26 +0000

We'll learn how to use JSON-based localization in.NET 6 and how to combine it with caching to make it even more efficient. We'll save the localized strings in JSON files and utilize middleware to swap languages using language keys in the request header.

Source code can be found here

Table of contents

What we'll build?
Getting started with JSON based localization in .NET 6
Testing with Postman
Summary

What we'll Build?

We'll create a .NET 6 Web API that provides messages based on the Accepted Language in the request header. We'll use IDistributedCache to cache the string. The main purpose of this approach is to read language strings from a JSON file instead of a RESX file. We'll do this by adding a new IStringLocalizer implementation. This will be straightforward, but it will be extremely useful. Who doesn't want to work with JSON files?

It'll just need three new classes and a few service registrations. Let's get this started!

Getting started with JSON based localization in .NET 6

Create a new ASP.NET Core Web API project in your favorite IDE (I use Visual Studio 2022 Community). Make sure you're using the .NET 6.0 Framework.

I'm not going to include any other class files in this implementation because I want it to be as basic as possible. To clear up the project, I deleted the weather controllers and related files from the WebAPI solution.

There are two aspects to this implementation:

A Middleware that can determine the language code passed in at the request header by the client (which will be a postman in our case).
An implementation of the IStringLocalizer to support JSON files. I intend to store the JSON file by the locale name (en-US.json) under a Resources folder. Note that we will also use IDistributedCache to make our system more efficient.

Let’s create a new class and name it JsonStringLocalizer.cs

    public class JsonStringLocalizer : IStringLocalizer
    {
        private readonly IDistributedCache _cache;
        private readonly JsonSerializer _serializer = new();

        public JsonStringLocalizer(IDistributedCache cache)
        {
            _cache = cache;
        }

        public LocalizedString this[string name]
        {
            get
            {
                var value = GetString(name);
                return new LocalizedString(name, value ?? name, value == null);
            }
        }

        public LocalizedString this[string name, params object[] arguments]
        {
            get
            {
                var actualValue = this[name];
                return !actualValue.ResourceNotFound
                    ? new LocalizedString(name, string.Format(actualValue.Value, arguments), false)
                    : actualValue;
            }
        }

        public IEnumerable<LocalizedString> GetAllStrings(bool includeParentCultures)
        {
            var filePath = $"Resources/{Thread.CurrentThread.CurrentCulture.Name}.json";
            using var str = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
            using var sReader = new StreamReader(str);
            using var reader = new JsonTextReader(sReader);
            while (reader.Read())
            {
                if (reader.TokenType != JsonToken.PropertyName)
                    continue;
                string? key = reader.Value as string;
                reader.Read();
                var value = _serializer.Deserialize<string>(reader);
                yield return new LocalizedString(key, value, false);
            }
        }
        private string? GetString(string key)
        {
            string? relativeFilePath = $"Resources/{Thread.CurrentThread.CurrentCulture.Name}.json";
            var fullFilePath = Path.GetFullPath(relativeFilePath);
            if (File.Exists(fullFilePath))
            {
                var cacheKey = $"locale_{Thread.CurrentThread.CurrentCulture.Name}_{key}";
                var cacheValue = _cache.GetString(cacheKey);
                if (!string.IsNullOrEmpty(cacheValue))
                {
                    return cacheValue;
                }

                var result = GetValueFromJSON(key, Path.GetFullPath(relativeFilePath));

                if (!string.IsNullOrEmpty(result))
                {
                    _cache.SetString(cacheKey, result);

                }
                return result;
            }
            return default;
        }
        private string? GetValueFromJSON(string propertyName, string filePath)
        {
            if (propertyName == null) {
                return default;
            }
            if (filePath == null) {
                return default;
            }
            using var str = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
            using var sReader = new StreamReader(str);
            using var reader = new JsonTextReader(sReader);
            while (reader.Read())
            {
                if (reader.TokenType == JsonToken.PropertyName && reader.Value as string == propertyName)
                {
                    reader.Read();
                    return _serializer.Deserialize<string>(reader);
                }
            }
            return default;
        }
    }

Line #3: We use IDistributedCache here.

Line #31 - 46: With GetAllStrings(), we try to read the JSON file name according to CurrentCulture and return a list of LocalizedString objects. The key and values of all the entries in the retrieved JSON file would be included in this list. Deserialization is performed on each of the read JSON values.

Line #47 - 70: String localization is handled by the GetString() method. In this case, the file path is also determined by the request's current culture. If the file exists, a cache key with a unique name is generated. The system would look in cache memory to determine if the matched key contains any value. If a value is discovered in the cache, it is returned. Otherwise, the app opens the JSON file and tries to get and return the string it finds.

Line #11 - 18: _*this[string name] *_This is the entry method in our controller that we will use. It accepts a key and uses the previously described approach to try to find the associated values in the JSON file. It's worth noting that if no value is discovered in the JSON file, the method will return the same key.

Next, we'll create a Factory class that will be responsible for generating the JsonStringLocalizer instance internally. Name the new class as JsonStringLocalizerFactory.

    public class JsonStringLocalizerFactory : IStringLocalizerFactory
    {
        private readonly IDistributedCache _cache;

        public JsonStringLocalizerFactory(IDistributedCache cache)
        {
            _cache = cache;
        }

        public IStringLocalizer Create(Type resourceSource) =>
            new JsonStringLocalizer(_cache);

        public IStringLocalizer Create(string baseName, string location) =>
            new JsonStringLocalizer(_cache);
    }

Then comes the fun part: writing a Middleware that can read the Accept-Language key from the request header and set the current thread's language if the culture is valid.

Create a new class and name it LocalizationMiddleware.

    public class LocalizationMiddleware : IMiddleware
    {
        public async Task InvokeAsync(HttpContext context, RequestDelegate next)
        {
            var cultureKey = context.Request.Headers["Accept-Language"];
            if (!string.IsNullOrEmpty(cultureKey))
            {
                if (DoesCultureExist(cultureKey))
                {
                    var culture = new CultureInfo(cultureKey);
                    Thread.CurrentThread.CurrentCulture = culture;
                    Thread.CurrentThread.CurrentUICulture = culture;
                }
            }
            await next(context);
        }
        private static bool DoesCultureExist(string cultureName)
        {
            return CultureInfo.GetCultures(CultureTypes.AllCultures)
                .Any(culture => string.Equals(culture.Name, cultureName,
              StringComparison.CurrentCultureIgnoreCase));
        }
    }

Line #5: The Accept-Language of the current HTTP context is read here from the request header.

Line #8-13: The current thread culture is set if a valid culture is found.

Let's start by adding some language files. Create a new Resources folder and add two new JSON files to it. The JSON files will be named en-US.json and de-DE.json

Sample of en-US.json

{
  "hi": "Hello",
  "welcome": "Welcome {0}, How are you?"
}

Next,de-DE.json. PS, the following was translated via Google Translate.

{
  "hi": "Hallo",
  "welcome": "Willkommen {0}, wie geht es dir?"
}

As you can see, we have two keys, hello and welcome, that the program is supposed to translate based on the request header.

Now comes the crucial phase, where we register our middleware and the JSONLocalizer as services. Add the following to the ConfigureServices function in Startup.cs.

services.AddLocalization();
services.AddSingleton<LocalizationMiddleware>();
services.AddDistributedMemoryCache();
services.AddSingleton<IStringLocalizerFactory, JsonStringLocalizerFactory>();

Add the following to the Configure method. It's worth noting that we've set en-US as our application's default culture. This can also be made configurable by moving it to the appsettings.

var options = new RequestLocalizationOptions
{
    DefaultRequestCulture = new RequestCulture(new CultureInfo("en-US"))
};
app.UseRequestLocalization(options);
app.UseStaticFiles();
app.UseMiddleware<LocalizationMiddleware>();

Finally, let's create a new API Controller to show how our JSON localizer works. Create a new Controller with the name HomeController.

    public class HomeController : ControllerBase
    {
        private readonly IStringLocalizer<HomeController> _stringLocalizer;

        public HomeController(IStringLocalizer<HomeController> stringLocalizer)
        {
            _stringLocalizer = stringLocalizer;
        }
        [HttpGet]
        public IActionResult Get()
        {
            var message = _stringLocalizer["hi"].ToString();
            return Ok(message);
        }
        [HttpGet("{name}")]
        public IActionResult Get(string name)
        {
            var message = string.Format(_stringLocalizer["welcome"], name);
            return Ok(message);
        }
        [HttpGet("all")]
        public IActionResult GetAll()
        {
            var message = _stringLocalizer.GetAllStrings();
            return Ok(message);
        }
    }

Line #3: Constructor Injection of IStringLocalizer instance.

Line #10 - 14: Here's a test to see whether we can output the localized version of the key 'hi' to the console and then return it as a response.

Line #16 - 20: The application should return a localized version of "Welcome xxxx, how are you?" when we give this endpoint a random name. That's all there is to it.

Line #22 - 26: This method would ideally return all the keys and values found in the corresponding JSON file.

Testing with Postman

Let's fire up Postman and perform some basic tests.

Here is what you get as a response when you send a GET request to the /api/home endpoint with the Accept-Language as de-DE

Accept-Language is set to en-US.

Now, I try to send a GET request to the /api/home endpoint along with the name. Accept-Language set to en-US

Accept-Language set to de-DE.

Finally, when you send a GET request to the /api/home/all endpoint, you get to see all the key/value pairs of our strings in the JSON file related to the relevant accept-language.

Isn't it great to have in your projects?

Summary

We learned a quick and easy technique to implement JSON-based localization in .NET 6 applications in this article. The source code can be found here.

DateOnly and TimeOnly in .NET 6

Nandkishor — Fri, 04 Jun 2021 20:05:15 +0000

Two long-awaited types have been added to the core library in.NET 6 (preview 4). Developers can use DateOnly and TimeOnly to express either the date or time element of a DateTime. These two new types are structs (value types) and can be used when your code has to deal with date or time notions separately. The System namespace contains both types. Using these new types may be consistent with how databases allow for the representation of similar data. These types, in particular, are compatible with the SQL Server date and time data types.

USING DATEONLY IN .NET 6

In terms of what they represent, the types are very self-explanatory. We may use DateOnly to express a date without a time component. For example, we may represent someone’s date of birth in our application. In such instances, we seldom need to use the time component of a DateTime, and a conventional approach would be to set the time to 00:00:00.000. We may be more specific about our intentions when using DateOnly.
We may create an instance of DateOnly by supplying the year, month, and day as arguments:

var date = new DateOnly(2021, 06, 04);

This creates a DateOnly that represents 4th June 2021.
If we want to create a DateOnly instance from the existing DateTime, it can be achieved by calling the FromDateTime method.

var currentDate = DateOnly.FromDateTime(DateTime.Now);

We may parse a string expressing a date into a DateOnly form using either Parse, which may cause an exception or TryParse, which returns a bool indicating success or failure, much like we can with the existing DateTime type.

if (DateOnly.TryParse("04/06/2021", new CultureInfo("en-US"), DateTimeStyles.None, out var result))
{
    Console.WriteLine(result);
}

We can also add days, months, or years to a DateOnly instance, which will result in a new instance with the updated date.

var newDate = date.AddDays(1).AddMonths(1).AddYears(1);

USING TIMEONLY IN .NET 6

The TimeOnly struct is used to represent a time that is not related to a date. Consider developing a reminder app that will remind the users about the specific task every day. In this case, the date part is not important as we want to remember the time of the day when the reminder should pop up.
There are various constructor overloads for the TimeOnly type. The more popular ones, which I expect most developers to use, allow us to create a date that accepts either the hour and minute, the hour, minute, and second, or the hour, minute, second, and millisecond for the time.

public TimeOnly(int hour, int minute)

public TimeOnly(int hour, int minute)
public TimeOnly(int hour, int minute, int second)
public TimeOnly(int hour, int minute, int second, int millisecond)

we can represent 08:30 am by creating the following TimeOnly instance.

var startTime = new TimeOnly(08, 30);

The hour portion is expected to be provided using the 24-hour clock format, where 1 pm is 13 hours.
TimeOnly internally holds a long that represents the number of ticks (100 nanosecond intervals) that have passed since midnight by the specified time. For example, 1 a.m. is one hour into the day, which is 36,000,000,000 ticks since midnight (00:00:00.0000000). we can construct a TimeOnly by providing the ticks as an input.

public TimeOnly(long ticks);

var endTime = new TimeOnly(14, 00, 00);

We can also perform mathematical operations on these TimeOnly instances, such as calculating the difference.

var diff = endTime - startTime;

I hope you learned something new from this article.