ASP.NET Core with GraphQL using .NET Boxed

GraphQL is something I have been meaning to look into for awhile, but haven’t found the time. Muhammad Rehan Saeed recent release of .NET Boxed, which is a rebranding of his ASP.NET Core Boilerplate templates, contains a template for GraphQL. This brought GraphQL back to the front of my mind so this post is going to walk through installing and using .NET Boxed to get a GraphQL project up and running.

Template Installation

As with all templates, installation is very easy using the .NET CLI. Open a command prompt and enter the following command.

The * at the end of the command is just making sure the latest version gets installed. After the installation is done you will get a list of all the template you have installed. The two new ones provided by .NET Boxed are highlighted in the screenshot.

Project Creation

For this post, we will be creating a project using the graphql template. Both of the templates provided by .NET Boxed have a lot of optional flags that can be used configure the resulting project. Make sure to run the help command for the template you are using to see if there are any option you want to set. For example, the following command would list all the options for the GraphQL template.

Create and navigate to the directory you want the new project to be created in and then run the following command to create the project with the default setting with the exception of turning off HTTPS. Not something you want to turn off for a production application, but it reduces the complexity of the initial exploration.

With the project created run the following command from the same directory to open it in Visual Studio Code.

Some Project Notes

The project generation creates a ReadMe.html in the root of the project. Make sure and check it out. It has a list of pre-requisites needed for the project as well as a lot of good information on general good practices.

We aren’t going to dig too far into the project itself in this post, but it is helpful to know where the data lives and what it looks like for when we are trying out some GraphQL queries. The backing data is in a static class found in the Repositories/Database.cs file.

The data is Star Wars themed and consists of two lists of characters one for droid and one for humans which get combined into a list of characters. The following is the  Database class for reference.

Try it out

When you run the project in development mode (the default) it will show a GraphQL playground which is made available by GraphQL.NET. It looks like the following.

Box 1 is the area where you enter the query you want to execute against the GraphQL backend. Box 2 is the play button which sends the query to the backend. Finally, box 3 is where the results of the query are displayed.

The following query is asking for ID, Name, and Appears In properties for the human that matches the provided ID.

On our sample data, the query returns the following.

Now let’s try creating a new human. Clear the query area and enter the following query.

If you tried to run the above it would fail. For this query to work we need to define what  $human is. You do this in the Query Variables area which is right below box 1 in the screenshot above. Enter the following and hit the play button.

This will result in the following. Your ID will be different of course.

Wrapping Up

The above information is enough to get started playing with GraphQL with ASP.NET Core. There is a lot more that I want to dig into so look for more posts on these topics. The code can be found here.

Deploying an ASP.NET Core Application to Microsoft Azure

This is the third post in a series on deploying a very simple ASP.NET Core application to the major cloud provides. This post is going to be dealing with setup and deployment to Microsoft Azure.

The following is are the other posts in this series.

Google Cloud Platform
Amazon Web Services
Microsoft Azure (this post)

Sample Application

This is the same as the first post in the series, but am including it in case you missed that post. The sample application that we will be deploying is the basic Razor Pages applications created using the .NET CLI. The following commands are what I used to create the application, create a solution, and add the project to the solution. I ran all these commands in a  CloudSample directory.

Microsoft Azure

The rest of this post is going to be based on the official Create an ASP.NET Core web app in Azure documentation. I already have all the Azure related stuff installed and have used it before, so it will be much easier for me to miss a step. If that happens please leave a comment and I will get the post fixed.

Azure Development for Visual Studio

The additional tools need to use Azure from Visual Studio are part of the Visual Studio installer. I’m assuming that Visual Studio is already installed. To add Azure select the Tools > Get Tools and Features menu.

After the installer launches close all instances of Visual Studio. From the list of features select Azure development and click the Modify button to start the installation.

Sign up for Azure

While the tools are installing is a good time to sign up for Azure if you don’t already have an account. You can sign up here. This is one of the parts that doesn’t work well when you already have an account, but the link above should guide you through the process.

Application Publication

Hope back in Visual Studio and open the solution you want to publish. In the Solution Explorer window right click on the project and select the Publish menu option.

This will show the publish target dialog where you can select what you want to publish to. In this example, we are going to be publishing to an App Service. The details area select Create New option. Then click the Publish button to move to the next screen

The next step collects the information needed to Create an App Service. The first thing to set is the account in the upper right corner of the screen. This could already be set based on how you are logged in to Visual Studio. Next, click the New link next to the Resource Group and enter the name you want to use. Then click the New link next to the Hosting Plan.

In the Hosting Plan dialog, you get options to give the plan a name, pick your hosting location, and the size. For the Size, I recommend starting with the Free option. After all the options are set click OK.

This will return you to the Create App Service dialog where you can click the Create button to deploy the application. After deployment finishes the site will open in your default browser.

Wrapping Up

For me using Azure from Visual Studio is the simplest experience of all the cloud providers I have tried so far. I don’t guess that is surprising since Microsoft controls both products. Forgetting the integration with Visual Studio it seems that Azure App Services, Google App Engine, and Amazon Elastic Beanstalk are all on par with each other.

As always don’t for get to shutdown/delete the assocated resources for your test project to avoid changes.

Deploying an ASP.NET Core Application to Amazon Web Services

This is the second post in a series on deploying a very simple ASP.NET Core application to the major cloud provides. This post is going to be dealing with setup and deployment to Amazon Web Services (AWS).

The following is are the other posts in this series.

Google Cloud Platform
Amazon Web Services (this post)
Microsoft Azure

Sample Application

This is the same as the first post in the series, but am including it in case you missed that post. The sample application that we will be deploying is the basic Razor Pages applications created using the .NET CLI. The following commands are what I used to create the application, create a solution, and add the project to the solution. I ran all these commands in a  CloudSample directory.

Amazon Web Services

The rest of this post is going to be based on a couple pieces of documentation from Amazon for the Visual Studio Toolkit and Beanstalk with .NET Core. I will be walking through the whole process but wanted to make sure you had access to the same information this post is based on.

AWS Toolkit for Visual Studio

Amazon provides a Visual Studio extension to aid in interactions with their platform from Visual Studio. To install open the Tools > Extensions and Updates menu. Select Online from the left side of the dialog and then search for AWS and select AWS Toolkit for Visual Studio 2017.

Click download, close Visual Studio to trigger installation, and restart Visual Studio after the extension’s installation has completed. When you open Visual Studio back up you should see the AWS Getting Started page with has this link to the IAM Users page in the AWS Console. This will land you on the following page where you have to either sign into your account or sign up for a new account.

After you get through the sign-up/in process you will be at the IAM console where we are going to add a new user by clicking the Add user button.

On the next page fill out the User name you want to use and check the Programmatic access check box and then click the Next: Permissions button.

The next page is all about what permissions the user will have which is handled via groups. Since my account doesn’t have any groups I need to create one using the Create group button.

On the Create group form enter the Group name you want to use. Next, use the search box for Policy type to find the policies related to Elastic Beanstalk. I have selected the full access policy for this sample, but if it is more than just a test this would require more research to see if that is the proper policy to use or not. When done click the Create group button.

This will return you to the group page from above. Click the Next: Review button to continue. The next page is just a review of the options selected on previous pages. Click the Create user button to continue.

The last page has a button to Download .csv, click it and download the file. Back over in Visual Studio on the AWS Getting Started page click the Import from csv file.

Browse and select the csv download above. Then click the Save and Close button on the AWS Getting Started page. After that is complete you should see the AWS Explorer window.

Sign up for AWS Elastic Beanstalk

If you notice in the AWS Explorer screenshot above the Please sign up for this service under AWS Elastic Beanstalk. Double click the Please sign up for this service it will open a new browser window. On this window click the Get started with AWS Elastic Beanstalk button.

The next page will prompt for payment information. After entering your information click the Secure Submit button. The next step is an automated phone call to verify that you who you say you are. The final step in signing up is to select your plan.

Select the Free plan to finish your sign up.

Publishing from Visual Studio

Now that sign up is complete hope back in Visual Studio and open the solution you want to publish. In the Solution Explorer window right-click on the project and click Publish to AWS Elastic Beanstalk.

This will open the Publish to Amazon Web Services dialog. I just took the defaults since this is a new application and I don’t have any existing enviroments. Click the Next button to continue.

On the next screen, an Application Name and Environment Name are needed. Fill them in and click Next.

The next screen is where you can configure the type and size of the EC2 instance that will back your application. I used the defaults. As always click Next when ready.

The next screen allows you to configure permissions. You will never guess, but I used the defaults and clicked Next.

The next screen allows you to pick your project build configuration and framework to use. The defaults are set based your project so they should be right. Click the Finish button.

The final screen is to review all the options. If you are happy with everything click the Deploy button.

During deployment, I saw the following error in my output window.

Caught AmazonIdentityManagementServiceException whilst setting up role: User:myUser/CloudSampleBlog is not authorized to perform: iam:GetInstanceProfile on resource: instance profile aws-elasticbeanstalk-ec2-role
Caught Exception whilst setting up service role: User: myUser/CloudSampleBlog is not authorized to perform: iam:PutRolePolicy on resource: role aws-elasticbeanstalk-service-role

This turned out to not really be an issue. I went to my Elastic Beanstalk Dashboard and the application was there and in the process of deploying. The whole process took around 5 minutes. Unlike with Google, I did have to find the URL in the dashboard instead of a browser being opened to the URL automatically.

Wrapping Up

Initial setup with AWS is much more complex than with Google. Redeployment was in the two-minute range which is much faster than what I saw with Google. Overall it seems that Elastic Beanstalk is on par with Google’s App Engine.

Don’t forget to shut down and/or delete your test project when you are finished to make sure you don’t get charged.

Deploying an ASP.NET Core Application to Google Cloud Platform

This is the first post in what is going to be a series on deploying a very simple ASP.NET Core application to the major cloud providers starting with Google’s cloud. This series was inspired by a question from one of my coworkers about the ease-of-use differences for .NET between the cloud providers.

The other posts in the series:
Google Cloud Platform (this post)
Amazon Web Services
Microsoft Azure

Sample Application

The sample application that we will be deploying is the basic Razor Pages applications created using the .NET CLI. The following commands are what I used to create the application, create a solution, and add the project to the solution. I ran all these commands in a  CloudSample directory.

Google Cloud Platform

The rest of this post is going to be based on information from Google which can be found here.

Google Cloud SDK Installation

The first step is to download and install the Google Cloud SDK which can be found here. I’m walking through these steps for Windows, but the previous link has instructions for Linux and Mac as well.

After downloading and run the installer, and be patient it takes awhile to run. When it is done you should see the following screen.

Make sure and leave the bottom two boxes checked as  gcloud init must be complete to get everything working as it should. Click the Finish button and a console will open and walk you through the initialization process.

The first step in the process will open a web browser and ask you to login to your Google account. After logging in you will be asked for a cloud project to use. It should look something like the following.

We want to select  Create a new project which is option 4 in my case. When prompted for a project ID I just hit enter and it let me out of the process so I don’t think a project is actually required at this point so that is a little confusing.

Google Cloud Tools for Visual Studio Installation

Google provides a Visual Studio extension that makes interacting with their platform simpler from within Visual Studio. To install open the  Tools > Extensions and Updates menu. On the left select  Online and then search for  Google. Next, select  Google Cloud Tools for Visual Studio.

Click download, close Visual Studio to trigger installation, and restart Visual Studio. Now that the extension is installed we need to connect it to an account. Using the   Tools > Google Cloud Tools > Manage Accounts menu to launch the Manage Accounts Dialog. Next click  Add Account.

This will launch a web browser where you will need to complete the account add. After the account auth completes Visual Studio should show the  Google Cloud Explorer window logged in the account you selected.

Create an App Engine Project

Open App Engine and click Create.

On the next page, you will need to give the project a name and then click Create.

On the next page select .NET as your language.

And select the location you want your application hosted in and click next.

If you aren’t already signed up then the next step signs you up for a 12 month trial with $300 worth of credit. Click the Signu up for free trial button to continue.

On the next screen, for the trial, you have to select your county as well as agree to the terms.

The next screen is a summary of your account. Review the information and click the Start my free trial button to continue.

Deploy from Visual Studio

In the Google Cloud Explorer window in Visual Studio select the project you just created in the drop-down.

If you don’t see your new project try clicking the refresh button in the upper left-hand side of the window. Now that you have the correct project selected switch over to the  Solution Explorer window and right click on your project and select  Publish to Google Cloud.

On the next screen select  App Engine Flex.

Then on the next screen click publish.

My first deployment took a really long time so don’t worry if you end up waiting a while (5 to 10 minutes). I tried a second deployment and it took just as long so I guess that is just how long it takes. When deployment finished it should open your site in a web browser.

Wrapping Up

After the initial set of installs and setup, Google Cloud with ASP.NET Core is pretty straightforward. The deployment time seems way too long, but that is really the only complaint I have.

Don’t forget to shut down and/or delete your test project when you are finished to make sure it doesn’t use up your credits.

Migration from ASP.NET Core 2.0 to 2.1

On May 30th .NET Core 2.1 was released including the corresponding version of ASP.NET Core 2.1 and Entity Framework Core 2.1. In this post, I will be taking one of the projects used in my ASP.NET Basics series and converting it from its current 2.0.x version into the newly released 2.1 version. The starting point for the code can be found here. This is all based on the official migration guide.

If you are looking at the sample solution it is the Contacts project that this post is going to be dealing with.

Installation

Thankfully the download page is much improved over the last time there was a release. Head here and to download and install the .NET Core 2.1 SDK. It is available for Windows, Linux, and Mac. The link should drop you on the appropriate page for your OS.

After installation, open a command prompt and run the following command. If all worked well you should see version 2.1.300 listed.

If you are on Windows make sure and install at least Visual Studio 2017 15.7.

Project File Changes

Right-click on the project and select Edit {projectName}.csproj from the menu.

First, change the TargetFramework to netcoreappp2.1.

The other required changes it to move away from the Microsoft.AspNetCore.All package to the version-less Microsoft.AspNetCore.App package.

I did a bit more digging and it turns out that the project file can be greatly simplified from the version I had for this application. The following is the full project file will all the bits that were not required removed and the two changes above already made.

Main Changes

There have been changes to how what the  Main function looks like to better allow for integration tests. This is the original code in the Program.cs file.

And the following is the new version.

Startup Changes

Startup.cs has one change that is required which is the removal of the following line from the  Configure function.

In the  ConfigureServices function if you want to use the new features in 2.1 change the  services.AddMvc() to set the compatibility version. This allows you to upgrade the version of the SDK without having to change your whole application since you have to opt into the version you want to target.

If you check out the official migration guide they also point out how to enable a couple more features such as HTTPS and some things to help with GDPR. Neither of these is needed in this application so I’m skipping them in this guide.

Identity Changes

I had to make one change in ManageLogins.cshtml to get my project to build because of a rename/removal AuthenticationScheme to DisplayName.

If you haven’t made many changes to the identity code in your project you might consider using the new identity razor class library. You can find the details here.

Wrapping Up

Migrations between versions of ASP.NET Core have gotten easier over time as you can tell by the smaller length of these posts. One thing to note is while this will get you targeting 2.1 with all the performance benefits and access to a lot of the new features there will still be work needed if you want to do everything the new 2.1 style. I highly recommend creating a new 2.1 application to get a feel for the other changes you might want to make to your existing applications.

The code with all the changes can be found here. Remeber that the only project that was upgraded was the Contacts project.

Electron.NET: Save Dialog & File Writing

This post is another expansion of my Electron.NET sample to show how to prompt the user with a save dialog and write a file to disk. The sample code before any changes can be found here. As with all the posts I have done on Electron.NET the API Demos repo helped out a lot.

For this example, we will be adding an export button to the contact detail page that will export the contact as JSON.

Dialog Controller

Following how the API Demo is setup I added a  DialogController with the following code.

The setup above tells Electron when it receives a  save-dialog request to show the operating system’s save dialog with the options specified. When the user completes the dialog interaction then it is set up so Electron will send out a  save-dialog-reply message so anything listing can act on the user’s selection.

The bits with  saveAdded is to work around an issue I was having with the dialog being shown multiple times. There is something off about my setup that I haven’t had time to track down, but I felt like even with this one querk this post is still valuable.

Next, I added the following import to the  _Layout.cshtml file.

As I am writing this I am wondering if this could be the cause of my multiple dialog issues? Maybe this should just be on the contact detail page?

Contact Detail Page Changes

The rest of the changes are in the  Views/Contacts/Details.cshtml. The first thing I did was add a new div and button at the bottom of the page. Based on the look of the existing page it isn’t the prettiest looking thing, but the look of the UI isn’t really the point of this post. Here is the code for the new div. Make note that the button has a specific ID.

Finally, the following script section was added.

On the server side, the model is converted to JSON and stored which will be used when writing the file. If anyone has a better way of doing this part I would love to hear about it in the comments. I’m referring to this bit of code.

Next, a click event is added to the export button which when fired sends a message to show the save dialog defined in the controller.

Finally, a callback is added for the message that the user has finished with the dialog that was shown.

In the callback, if the user entered a path then the JSON for the model is written to the selected path.

Wrapping Up

While writing a contact to JSON might not be the most useful thing in the world the same idea could be used to with the information to a vCard file.

After working on this example I finally feel like I am getting a better hold on how Electron is working. Hopefully, this series is helping you feel the same. The completed code can be found here.

Pass ASP.NET Core Appsettings Values to Angular via an API Call

There have been a few issues opened on the repo I have showing usage of Angular, Identity Server 4, and ASP.NET Core together that related to incompatibilities with the newer versions of Angular. In an effort to fix this issue the plan was to recreate the client application using the new Angular template from Microsoft which from what I read should address the issue.

The code before any changes can be found here, but in this case, the whole client application has been recreated so the starting point may not be super helpful.

The Problem

For the most part, this worked well, but the problem can when I needed to use some configuration values from ASP.NET Core in my new Angular application. The previous versions of the template used server-side rendering which I utilized to pass the configuration values. The new template doesn’t use server-side rendering by default and I wanted to find a way to solve the issue without requiring server-side rendering.

The other issue is that I want to be able to run this application in Azure and set the configuration values as environment variables. While Angular seems to have support for environment files finding a solution that used a systems environment variables turned out too not be simple.

Configuration API Endpoint

Since the configuration values I need to get to the client application are secret I decided to go the route of pulling them via an API call back to the same ASP.NET Core application that is hosting the Angular Application, which is the Client App project in the sample solution.

I added a  ConfigurationController.cs class to the  Controller directory with the following contents.

This controller gets constructed with a reference to the application’s configuration which is then used to populate a dictionary with the values my Angular application needs. For completeness, the following is the contents of the application’s  appsettings.json file.

Angular Changes

This is the part that I really struggled to get right. I needed the configuration values from the API above to be available as soon as possible. Thankfully I came across this blog post by Juri Strumpflohner which covers using Angular’s  APP_INITIALIZER.

The first thing I need was to create a class in Angular to get the configuration values from the API and serve to them the rest of the Angular application. To do this I added a  configuration.service.ts into a new  ClientApp/src/app/configuration directory. The full class follows.

This class hits the API to get the configuration values in the loadConfig function and maps it to a class level field. It also provides properties to get the individual configuration values.

As I mentioned above, getting the application to get these configuration values in a timely matter was something I really struggled to do. The first step to using Angular’s  APP_INITIALIZER to solve this issue is to change the import from  @angular/core to include  APP_INITIALIZER and to import the  ConfigurationService.  All these changes are being made in the  app.module.ts file.

Next, we need to define a function that will call the  ConfigurationService.loadConfig function.

Finally, in the  providers array add an element for the  APP_INITIALIZER and the  ConfigurationService.

 Wrapping Up

This is one of those things that turned out to be way more complicated than I expected. Thankfully with the above changes, I was able to get it working. I hope this saves you all some time. The code with all the changes can be found here.

Electron.NET: Tray Icon

This post is a continuation of my exploration of Electron.NET which started with this post. Today I’m going to take the existing sample project and expand it to include a tray icon. As with the post on customizing the application level menus, this post relied heavily on the Electon.NET API Demos repo.

Add an Icon

The first step I took was to find an icon I wanted to show in the tray area. Since this is just a sample application I didn’t spend a lot of time on this. Once you have your icon it needs to be added to your project. Following the example, in the API Demo, I add an  Assets directory to the top level of the project and copied in my  Stock-Person.png file. This directory and file need to end up in the output of the builds which can be done by adding the following to the  csproj file.

In Visual Studio this can be done via the UI, but since I am sticking to VS Code for this project I did the edit manually.

Tray Controller

Add a  TrayController to the  Controllers directory which will be used to hold all the code needed to add the tray icon. The following is the full class.

Most of the code above is dealing with building an array of  MenuItem which will be options when right-clicking the tray icon. In this case of this sample, there will be two menu items one for creating a contact and the other to remove the tray icon.

Electron.Tray.Show is the bit that actually shows the tray icon and it takes a path for the icon to display and the menu items to show. The last bit is a call to  Electron.Tray.SetToolTip which, not surprisingly, sets the tooltip on the tray icon.

Include the tray icon

The final change is to make sure the code to show the tray icon gets run when the application starts. Open the  _Layout.cshtml file in the  Views/Shared directory. In the  head tag add the following which will cause the application to call the  Index action on the  TrayController.

Wrapping Up

As with everything I have tried so far, Electon.NET makes it easy to add a tray icon to your applications. If you are a .NET developer so far I haven’t found any downsides to using Electron.NET. If you have hit any walls with this tool leave a comment. The finished code for this post can be found here.

Electron.NET: Custom Application Menus

This post will take the existing sample Electron.NET application used in Create a Desktop Application using ASP.NET Core and Electron.NET and Electron.NET with a Web API and expand it to customize the application menu. I leaned heavily on the Electron.NET API Demos repo to guide how this should be done. The code before any changes can be found here.

Menu Controller

While not a requirement I follow the API Demo example of putting the application level menus in its own controller. Add a  MenusController to the  Controllers directory. The following is the full class.

What the above comes down to is building an array of  MenuItem types and then using   Electron.Menu.SetApplicationMenu(menu) to pass the array to Electron which handles replacing the default set of menus with the ones defined in the array.

For most of the items that were on the default set of menus all that is needed to add back the default functionality is to set the  Role to the function you want. For example in the above for a Copy menu item, we can assign  Role to  MenuRole.copy and Electron will handle the implementation of a copy without us having to write any additional code.

Navigate to a page from the application menu

One thing I wanted to be able to do was from a menu create a new contact. It was easy enough to add a top-level menu for Contacts and a sub-item for Create. It took me awhile, but I finally figured out how to build a URL that would work. The following code is the menu items for the Contacts menu.

The ASP.NET Core backend is running on localhost, the key that took me awhile to locate was the port. In the end, I found that the port being used can be found using  BridgeSettings.WebPort.

Include the menu

The final change that is needed is to make sure the new set of menus get rendered. For the sample application open the  _Layout.cshtml file in the  Views/Shared directory. Inside the  head tag add the following line which will force a call to the  MenusController when the application loads.

Wrapping Up

Customizing the application menu ended up being pretty easy. If I hadn’t wanted to navigate to a specific page I would have been done in no time, but hitting the issue with navigation helped me learn more about how Electron.NET is working. You can check out the finished code here.

.NET CLI Errors Due to VSTS Package Source

At work, we use Visual Studio Team Services for source control, internal NuGet package management, and continuous integration. It has been a great tool that has really helped streamline our processes.

.NET CLI Issue

The problem with the setup is if the .NET CLI calls anything that uses NuGet (restore, installing new templates) with the VSTS package source enable it results in the following unauthorized error.

C:\Program Files\dotnet\sdk\2.1.103\NuGet.targets(104,5): error : Unable to load the service index for source https://company.pkgs.visualstudio.com/_packaging/feedname/nuget/v3/index.json. [project.csproj]
C:\Program Files\dotnet\sdk\2.1.103\NuGet.targets(104,5): error : Response status code does not indicate success: 401 (Unauthorized). [project.csproj]

I have been working around this by disabling the VSTS package source when working with the .NET CLI. It is a bit of a pain, but it works since I’m not using any of the packages from our private feed.

A Fix

I had the opportunity to talk to one of the VSTS product managers (PM) for the package management area and they are aware that this issue. While not the ultimate fix the PM pointed out that I could use a personal access token to get around the error.

Create a Personal Access Token

Log in to VSTS and hover over your profile picture and select security.

Next, click the add button on the Personal access tokens screen.

The next page you will need to enter a description for the token and select how long the token should be good for. It is also very important to change the Authorized Scopes off of all and only select the ones you want the token to be valid for. In my case, I selected everything package related, but Packaging (read) would be enough if you aren’t going adding packages to the feed.

At the bottom of the above screen click the Create Token button. This will take you back to the token list page with a new item for your new token and this will be your only opportunity to get a copy of the token.

Add NuGet Source with Token

Now that you have a token open up a command prompt and use the following command to add the NuGet source that will use your new personal access token.

Wrapping Up

It turned out to be pretty easy fix this issue. Don’t be like me and just deal with it by disabling the package sources causing the problem. Just make sure that you don’t check-in your NuGet config file that contains your personal access token.