I'm making good progress on the Azure B2C User Management App that I'm building. I've been really thinking about how to roll out the app for the initial release and think that the best way to do it is to provide a published .Net Core MVC website. Users will be able to download the compiled website with instructions on how to set up the site and get it working right away.

The completely published website feels like the simplest way to get the first version of the app out the door. I'm not sure if this is going to be the most useful for people, there is a little configuration that needs to be done on the server side to enable the app to interact with the end user's Azure B2C tenant. But once the keys are configure, the app itself doesn't require any more configuration as there is no backing database with it. It uses the client id and client secret of a registered app in the Azure B2C tenant for each request to authenticated and authorize itself into the client's tenant.

The initial release of the app will be very simple and will solve the one the problem that lead me to develop the app: You can view and edit custom user attributes and custom extension attributes from a UI instead of having to spin up a new MS Graph API instance every time you want to view or update your B2C users. The interface will be very simple and consist of three screens initially. Here are the screen shots of the three different screens that a user will initially encounter.

1. View a list of all users in the B2C tenant

2. View the details of a user

3. Edit the details of a user - including the custom attributes and external properties that are not either viewable or editable in the Azure Portal.

Alongside the out of the box user properties provided by Microsoft.Graph.Models.User I created a section called Custom Attributes. Each custom attribute of the tenant is listed here and is editable. When the user clicks Save Changes all these values are posted back to the Azure Portal.

Here you can see the Is Admin and Role custom user attribute/extension property. Speaking of, I can't figure out the difference between user attribute/extension property. They both seem to refer to the same underlying object but in the documentation I've read seem to be used interchangeably.

The MVP is ready to start testing with beta testers but I'm not sure how I want to roll this out just yet. Does it make sense to publish the compiled website to my e-commerce store with a set of instructions on how to install and set up the IIS instance? I'm not sure, it makes sense to me and I'm eager to get the first version out to test how people respond to this feature. Over the next couple of days I'm going to think about a rollout strategy that makes sense and will get the app into the hands of people who can give me some real feedback.

Last weekend we took a long weekend trip to Palm Springs for some sunshine and warm weather. We split up Saturday to be part pool time and the other part we drove out to Joshua Tree National Park. The drive to the west entrance from Palm Springs is a little over an hour. We left late afternoon in order to catch the sunset and do a little bit of star gazing after the sun went down.

Joshua Tree is a great national park. Seeing this park at sunset and then again at night made us really excited to camp out there some day.

Here's a few of my favorite pictures from the few hours we spent running around in the park.

This winter has been really warm in Minneapolis. December and the beginning of January started out extremely above average with hardly any snow. In the past two weeks it's cooled down quite a bit. We've been hit with some serious cold weather with daily high temperatures not getting above 10°F. Even with these cold days we're still in the running for the warmest meteorological winter on record.

Top ten warmest winters in Minneapolis/St. Paul

I pulled the top ten warmest December, January and February months based on the average temperature for each of the months from the ACIS tool. The meteorological winter is defined by December, January and February. You can see that we are barely holding holding onto the #2 spot. This week is suppose to get above average again, so with 43 days to go there is a good chance that we end up with the warmest winter in MPLS / STP history.

I started writing an Azure B2C user admin app from scratch. This app has been rolling around my head for the past year. I found in the past couple of years that there isn't a good way for a business end users who are not part of an Azure admin group to update user information. And if those users are part of the Azure admin group the non-tech people need to learn the Azure portal dashboard. This is path is easy for a developer or devops person familiar with the Azure portal interface. But for a regular user who hasn't spent much time in Azure this can become a pain and can be confusing.

On top of the user needing to be a granted appropriate rights in Azure, there isn't a graphical interface that supports updating user custom properties and extension properties. Anytime I want to update or view a custom property for Azure B2C user I need to get the keys, create an access token and view/update the users via Postman requests. This takes time and knowledge of the MS Graph API, not to mention having to have the correct permissions to be able to get the client secret for the particular Graph API application making the request.

Because of these reasons I've decided to create a new product that will allow users to manage their Azure B2C users from a easy to use management dashboard. The same type of user dashboards that .net developers have been building with ASP Membership providers and lately the Identity provider for years. Instead of having to spin one up and code it yourself, this product will be turn key and ready to go.

These are the two biggest questions I'm rolling around in my head while I build the code base for this app:

1. On-prem or SaaS? Should the application be an on-prem installable IIS instance in the client environment or will users trust this application and allow a SaaS app to store their client credentials for authentication?
2. Build the full application or create a client library that is accessible from Nuget and allow the purchaser to build the HTML and user interface. Or can this application be built as an API to allow the backend functionality but keep the interface open to the client?

To start I'm I've been writing the app as an on-prem IIS instance using .Net Core MVC. This will allow me to build out the entire functionality in a separate C# service while I try to answer the questions above.

Yesterday I went to work from a coffee shop that I've never been but meaning to visit for a while. I met the owners ten years ago selling coffee at the Linden Hills Farmer's Market. Since then they've opened multiple locations and are the best coffee roaster in the Twin Cities.

While I was working a man came into the coffee shop and asked one of the barista's to use their land line. The barista was helpful and gave the man the phone to make his call. He made the phone call, gave the phone back to the workers and went to sit down. A little while later a person called the coffee shop asking to speak to someone who had just called them from that number. The barista happily obliged and walked the phone over to the man who made the initial phone call patiently waiting. He took the phone call, talked for a bit then hung up and headed out the door.

That was it, end of transaction. I'm not sure that man even ordered a coffee, but it was a great to watch this interaction in a time of where everyone has a phone and everyone always seems to know where everyone is.

Later on a person called the coffee shop to ask what the barista's favorite Chinese food was. I didn't hear the other end of the phone, but the barista relayed that someone called to find out her favorite Chinese food and was going to bring them lunch.

This coffee shop also has a heater above the door that is wired to turn on when the door opens and close when the door closes. So each time a person walks into the shop a blast of heat comes down from the ceiling. This is great for people sitting by the door, however I feel that it makes the inside of the coffee shop really really warm.

I'm writing this post to kick start my blogging habit. Hopefully it sticks this time. Lately I've been writing about how to fix bugs or set up environments, but the more I read about writing the more intrigued I am to make writing in public a habit. I subscribe to the People & Blogs newsletter and find it fascination how people are still using normal blogging the same way they did in the early 2000s.

Back in the 2000s I had a local blog with two friends that was semi-popular. We'd write about our things in Minneapolis and I'd post some life updates. This was before Twitter took over and people who wanted to post something in public did it on the Internet.

Winter Break

Today technically marks the end of the work year for me and the start of winter break until January 2nd. I plan on working a little bit here and there, enough to manage projects and clients but I'm really going to try and take a break this year. There are some side projects that I have been itching to get done or make progress on, too. This next week feels like the right time to make some head-way on those.

Some of the projects I want to focus on:

• Today's Record High
  • Talking to some other developers at my co-working space has renewed my interest in this project. Which isn't too hard, but when I know someone else feels the same way I do about a project it gets me excited to work on it some more.
• Armchair Media Explorer
  • This data set of all the books/movies/shows that are mentioned on Armchair Expert is a little over a year old at this point. Given this good size dataset we should be able to create some pretty graphs and charts.
• JetTip Data
  • This is a project that my software company is partners with JetTip. We've developed a consumer to feed the JetTip mobile app/website with real-time FAA flight updates. There are some error handling and service configurations that I need to put in place to make sure that the hosting is as rock solid as it needs to be.

T is off school this entire week so we have some time together. I think some nice warm winter walks, a snowboard lesson and general overall just hanging out enjoy time off from work and school.

I hope to work on my latte art as well. I'm getting better at it since I started drinking a cortado every morning instead of making a pour over. I still make pour overs for K. She prefers straight up coffee to espresso drinks.

Record Highs for Christmas

It's been the warmest December that I can remember in Minneapolis this year. It's an el nino year so the weather will naturally be warmer, however with the impact of climate change it appears that this year is kind of crazy. With Christmas around the corner I looked up our record highs on Christmas Eve and Christmas where in Minneapolis. It looks like we are going to be close if not breaking these records this year.

Looking at the temperatures as a record is kind of wild, we have been close, if not above those temperatures for the past couple of weeks it seems. The temperature might not have broken any records over the last couple of weeks but it's been freakishly abnormally warm here all December and November.

Here is a look at the record temps for Christmas Eve and Christmas in the Minneapolis area.

Christmas Eve

Christmas Day

Here's a look at the recent temperatures for December here as well. I took this screen grab from my side project, Today's Record High.

That's about it for today. I seem to have written a good amount of information here which is pretty awesome considering this is the first blog post that I've just let my stream of conscious go. It feels good to let your brain run and get those thoughts out onto digital paper.

The comments on this Hacker News post generated a bunch of opinions on the ability for developers to solve a FizzBuzz problem. Specifically in a coding interview. I’ve never actually seen what the FizzBuzz problem was, so I had to look it up. In this blog post I solve FizzBuzz in C#.

The FizzBuzz problem is a challenge for a developer to write a method, in any language, to return different parts of the word FizzBuzz.

It goes like this:

• If a number is divisible by 3 or 5 => return FizzBuzz
• If a number is only divisible by 3 => return Fizz
• If a number is divisible by 5 => return Buzz
• If a number is not divisible by 3 or 5 => return the number

Over twenty years of programming experience and I’ve never come across question in an interview so I thought it would be fun to jump onto .Net Fiddle to give it a try. In this function you take any number and check if it can be divisible by 3 or 5. The trick to this function is to use the % mod operator to check if a number is divisible by another number. The mod operator will return a number if there is a remainder after division between the two supplied numbers. If the number returned after division using the mod operator you will return zero – meaning there isn’t a remainder after division. This is what the function is all about. Here’s my FizzBuzz implementation I wrote this morning after reading the Hacker News post.

Simple FizzBuzz implementation in C#

public class Program
{
	public static void Main()
	{
		int i = 0;
		while(i <=< span>100)
		{
			string fizzWord = GetFizz(i);
			Console.WriteLine(fizzWord);
			i = i + 1;
		}
		
	}
	
	public static string GetFizz(int i)
	{
		if(i % 3 == 0 && i % 5==0)
		{
		  return "FizzBuzz";
		}
		else if(i % 3 == 0)
		{
			return "Fizz";
		}
		else if(i % 5 == 0)
		{
			return "Buzz";
		}
		
		return i.ToString();
	}
}

Good morning. A few notes that I wanted to record for this lovely fall Friday.

1. Near record warm has passed us and we’re back to normal cold fall. Should be great for saunaing.
2. Made a fantastic oat milk cortado this morning. Using regular Oatly blend, normally I use the Barista’s version, but today’s turned out fantastic. I’d say top five of all time home made cortados.
3. Driving T to school this morning he commented that so many people have black jackets. I replied saying they were a popular color. That brought up the question of what does “popular” mean. After I explained that it’s something that a lot of people like, for example Christmas, ice cream, soccer are all things that are popular because many people like them. When I asked him if he could think of something that was also popular, a few seconds passed and he replied “I know something that is popular for adults”. I asked what and he said “relaxing”. He got that right.
4. The Armchair Media Explorer has been slowly gaining traffic among the fans of the popular podcast Armchair Expert. People love it, but I really need someone with a large following to help promote it. So this morning I emailed Dax, Monica and their producer Rob in hopes that they read my emails. Having them Tweet (X?), Instagram it or just promote it would go a long ways for the platform.
5. Started a new project I’m calling the Radio Station Project. It’s going to contain a lot of radio station data and some nice data visualizations. More to come after I can collect some data.

Over the past year I’ve been working with JetTip to provide their smart alert system with real-time FAA flight data. We finally launched the service into production last month so I decided to write this blog post about the real-time FAA flight data powering the JetTip smart alert system. The collaboration between JetTip and me has led us to the creation of a cutting-edge software solution that has a direct connection to the FAA data stream which is now integral to the JetTip smart alert system.

I started working with JetTip a couple summers ago when they hired me to build the JetTip mobile app. The app has been downloaded by thousands of users for both iOS and Android mobile operating systems. The mobile app allowed JetTip’s users to move from a text messages based alert system to a push notification system. This update not only saves money via the loss of text messaging rates but allows more flexibility for the end users who can now pause and update their notifications much more easily via the app interface.

The mobile app project was just the beginning of what’s turned into a pretty rad relationship. Over the past couple years I’ve gotten to know Nick from JetTip quite well and even consider him a friend. When he came to me with the idea of creating a system to process the FAA data in real-time I was on board immediately. So, as flight data providers shifted their focus to enterprise clients and costs surged, we saw an opportunity to use our development backgrounds and data processing experience to create our own flight data processing product.

I’ve become pretty comfortable processing large amounts of data, so plugging into the FAA fire host wasn’t a huge overhaul. The biggest challenge was how to process all that data so fast and store it efficiently. Managing gigs and gigs of data is not a trivial thing, I quickly become pretty good at fine tuning MySQL databases and managing server resources. The core objective was to develop a system capable of ingesting and processing all of that FAA flight data accurately. This system was not just about managing data; it was about transforming it into actionable insights for all the aviation enthusiasts out there. But build in a way that we can utilize the data source in the future for more products.

This direct feed has revolutionized how JetTip subscribers receive information and opened up my mind to additional flight data products that we can develop in the future. Part of the new service that we’ve created is virtually instant diversion alerts, real-time notifications of international departures, and the ability to see flight plans well into the future were all made possible by this integration. Based on this information, I think there is room for more robust products that are just as good, or better, than some of the competitors out there that we can provide at a much lower cost.

Looking Ahead

I’ve been working on this product for the past nine months and have learned a ton about high transactional databases, Java Messaging and managing large databases. We’re excited about the future possibilities this data has in store. The feedback from the community has been pretty great and have spurred more thoughts about how to incorporating these insights into additional products. The goal is to not only maintain this data set, but grow the level of service provided and products to the plane spotting community and anyone else interested in real-time flight updates.

This blog post aims to provide a background to the JetTip announcement regarding their new in-house FAA data source. For more details on this exciting development, please refer to the original JetTip post.

I recently faced an issue where my Cloudflare managed API endpoint was functioning correctly—returning a 200 OK status when I hit the endpoint manually—but Cloudflare’s Load Balancer was reporting a “Critical” health status. After a lot of trial and error with some investigation, I found that the problem was with the Header Settings in the monitor health check. This post will outline the steps I took to get the health monitor check to return healthy.

Initial Troubleshooting

I created a simple endpoint in my API specifically for the health monitor. The endpoint was a simple GET and returned a 200 along with the server name as the body text. This endpoint was returning a 200 response code from Postman and through my browser, so I double checked that the monitor configuration was correct in Cloudflare:

• URL: I made sure it was pointing to the correct endpoint that was returning 200 when I manually hit the url.
• Method: Set to GET as my API was expecting.
• Timeout and Frequency: Set to 60.

These checked out but the health of the monitor was still returning “Critical”. At first I didn’t think that I needed to set any additional headers, ignorantly thinking that Cloudflare would would set default headers of the monitor like Postman does, but that’s not the case. So I went to the next step and manually set the headers.

The Breakthrough: Header Settings

After further digging and reading troubleshooting posts on Cloudflare forums, I decided to manually set the headers under the Advanced settings for the monitor. Within the health monitor set up, I filled out the name, url and type of request. Then I clicked Advanced Settings and created the following header settings for the monitor.

• Host: I set this to the domain that the health check was targeting, for example, api.parkasoftware.com.
• User-Agent: I set this to Cloudflare-Health-Check.
• Authorization: Since my API was public I didn’t set this to anything.
• Accept: I set this to application/json.

And would’nt you know it, my API health monitor started returning Healthy!

The How-To: Setting Up Headers in Cloudflare

Here are the steps I took to get the Headers set up in my Cloudflare load balancer health monitor.

1. Log in to Cloudflare Dashboard: Go to the “Traffic” tab and locate the Load Balancer section. Click edit on the load balancer to edit.
2. Click Monitors: Next to your Load Balancer, you’ll see the health check configurations. Click edit. Click Remove if you already have a monitor configured. Then create a new monitor.
3. Add Default Options: Fill out the default name, Action and Url.
4. Add Headers: Click advanced settings and scroll down to the section where you can add headers. Here, enter the key-value pairs for each header.
   • Key: Host, Value: api.parkasoftware.com
   • Key: User-Agent, Value: Cloudflare-Health-Check
   • Key: Authorization, Value: None or your Bearer access token if required
   • Key: Accept, Value: application/json
5. Save and Test: Once all headers are added, save your changes. It’s a good idea to test the health check to make sure it’s working as expected.

Conclusion

The issue was resolved after correctly configuring the Header Settings in Cloudflare’s health check. If you ever find yourself in a similar situation, double-checking these settings could be the key to solving your problem.

Good luck!

This blog post outlines how to migrate a WordPress website from any hosting provider to WP Engine hosting account without access to source FTP site. The post focuses around utilizing the WP Engine Migration Assistant Plugin. WP Engine offers a specialized plug in to make WordPress migrations a pretty simple from one hosting provider to another. In this example it doesn’t matter what your hosting provider is, this plug in should work with any of them. And best of all, you don’t need access to the source FTP site to do the migration.

Managed Hosting for Business Operations

A large part of my business is providing an array of WordPress hosting services that cover all the backend configurations, including SSL installations, plugin updates, and server-side optimizations for my clients’ websites. This frees them up to focus on their business and what they do best instead of having to struggle working on a system they dont’ understand nor do they care about understanding it. Part of my service offering is migrating WordPress sites from their old hosting provider to my own managed WP Engine hosting service.

Let’s get started.

Prerequisites

• Access to the existing WordPress site’s admin panel
• WP Engine account with appropriate permissions

Migration Using WP Engine Migration Assistant Plugin

This is how you utilize the WP Engine Migration Assistant Plug in to migrate just about any WordPress site to your WP Engine hosting account.

Step 1: WP Engine Plugin Installation

1. Log into the existing/source WordPress site.
2. Navigate to Plugins -> Add New on the WordPress Dashboard.
3. Search for WP Engine Automated Migration. Or you can download the plug in here.
4. Click Install and then Activate.

Step 2: Retrieve Migration Credentials

1. Log in to the WP Engine User Portal.
2. Create the new site environment if you have not already done so.
3. Navigate to new WP Engine site and click Migrations in the left side navigation menu.
4. You’ll see a screen that looks like this one below. Here you see the site properties that you’ll need to input into the source/existing website migration plug in. You can generate the migration SFTP credentials here if you have not already done so.

Step 3: Plugin Configuration

1. On the existing/source WordPress Dashboard, go to WP Engine Migration from the left side navigation.
2. Input the migration credentials from Step 2.
3. Click Start Migration.

Step 4: Monitoring and Verification

1. Monitor migration status in the WP Engine User Portal.
2. You’ll receive a confirmation email upon successful migration.

Step 5: DNS Update

1. Now update the DNS records to point to WP Engine’s IP address or CNAME records.

Conclusion

This blog post provides a step by step approach for migrating a WordPress website from any provider to WP Engine utilizing the WP Engine Migration plug in.

For more specialized migration services or hosting solutions, feel free to contact me. Happy migrating!

I'm in the middle of migrating all my apps and databases to a new Macbook Air machine. Since I do all my .Net Core development on MacOS I use Docker containers to manage any SQL Server databases that I'm working with. In this blog post I'll show how I migrated my SQL Server databases between machines and Docker containers.

Create a database backup on machine 1

I used Azure Data Studio to manage SQL Server databases from my Mac. Azure Data studio is a fine substitute for SQL Server Management Studio, but it lakes the majority of the features. Though I'll take the lack of features for the ability to development on my macOS machine any day.

To back up a database from Azure Data Studio, connect to your server, navigate to the database and right click the database. Then select the Backup option from the drop down menu. Select the options you need and click Backup. Take not of the Backup files location as you're going to need this to copy the file from the Docker container to your local machine. Here my backup copy will be made in /var/opt/mssql/data folder within the current Docker container.

Copy the database backup to a central location

Now using the Docker command docker cp copy the the database backup file from the Docker container to your local machine and then to a central location where you can access the backup file from the destination machine.

1. Open the Docker dashboard on the source machine, locate the SQL Server container, then copy the container id.

2.  Open Terminal and execute the docker cp command with the following parameters: {yourContainerId}:{containerBackupFileLocation} {destinationFolder}

docker cp cbd5323d5caf78c9b7434ff46eccbba0b5c20e2e4807d71fd83a6394372fc1c0:/var/opt/mssql/data/Machine-1-2023818-11-11-11.bak ~/code

3.  This will copy the .bak file from the previous step into a folder called code on your local machine. Make sure the destination folder code exists before you run this command.

4. Transfer the .bak to a central location that the new machine can access. Something like Dropbox or shared filed location is good. And then download the file to the new machine.

5. Run the following command from the new machine to create the backup folder within the new Docker Container. sql is the name of the new SQL Server container running on the new machine.

sudo docker exec -it sql mkdir /var/opt/mssql/backup

6. Run the following command on the new machine to copy the database from your new machine into the new SQL Server container. Replacing `Machine 1-2023818-11-11-11.bak` with the name of your backup file.

sudo docker cp Machine-1-2023818-11-11-11.bak sql:/var/opt/mssql/backup

7. Open Azure Data Studio, right click on your database name and select restore. The current version of Azure Data Studio requires the database to exist before you can do a restore. If the database does not already exist, create a blank database to restore to. Navigate to the location inside the container that was created in the previous step.

That should do it. You are now able to use the old database. I actually ran into an issue during this process where the containers I was using for my new M1 machine were too far ahead of the existing database that I was trying to transfer over. So keep in mind that depending on the container you are using, certain versions of SQL Server might not be compatible between Docker instances.

Or how to get the cover image of a book programmatically. The Armchair Expert Media Explorer is a website I built to track all the book, movies, documentaries, podcasts and shows that are discussed on the Armchair Expert podcast between the hosts, Dax and Monica, and their guests. For each book that is entered into the database, I make a call to an API to get the book cover image. This blog post will show how to get the cover image of a book programmatically using C# and a third party API.

Call the GetBook method

I'm using the OpenLibrary API to retrieve book covers for newly added books. The process to return a book cover image is two steps. Firstk call the search endpoint to search for a book by its title and author. The object returned will contain a variable called CoverI which is identifies the cover image for the book.

The second step in the process is to call the covers.openlibrary.org endpoint by passing the CoverI property returned from the first step in the url. You're able to tell the API what size cover image you want (ie S, M, L, XL) by appending the size to the end of the CoverI property - like {book.CoverI}-M. In my case I'm asking for size medium.

Here you can see the starting point to get the book object. I first make a call to `GetBook` by passing in the title and the author as string variables.  

var book = await GetBook(title, author);
    if (book != null && book?.CoverI != 0)
    {
        var thumbnailUrl = $"https://covers.openlibrary.org/b/id/{book.CoverI}-M.jpg";
    }

GetBook method

The GetBook method takes title and author to make a GET request to the search endpoint of the OpenLibrary API. I'm casting the response as OpenLibraryBookResponse which allows me to look at the returned list of documents. Note that Docs is a List<T> because the search returns books that match the search parameters. It's highly likely you will return multiple results from your searches.

In this case, if the title and author search comes up empty, I make another call to just search by the title. This pattern works for 99.99% of all books I'm searching for.

 public async Task<OpenLibraryBook> GetBook(string title, string author)
    {
        using var httpClient = new HttpClient();
        var url = $"https://openlibrary.org/search.json?author={HttpUtility.UrlEncode(author)}&title={HttpUtility.UrlEncode(title)}";
        var response = await httpClient.GetAsync(url);
        var content = await response.Content.ReadAsStringAsync();
        var bookResponse = JsonConvert.DeserializeObject<OpenLibraryBookResponse>(content);

        if (bookResponse.Docs == null || bookResponse.Docs.Count() == 0)
        {
            Console.WriteLine(url);
            url = $"https://openlibrary.org/search.json?q={HttpUtility.UrlEncode(title)}&mode=everything";
            response = await httpClient.GetAsync(url);
            content = await response.Content.ReadAsStringAsync();
            bookResponse = JsonConvert.DeserializeObject<OpenLibraryBookResponse>(content);
            if (bookResponse.Docs == null || bookResponse.Docs.Count() == 0)
            {
                Console.WriteLine(url);
            }
        }
        return bookResponse.Docs.FirstOrDefault();
    }
   

OpenLibraryBook class

This is the class representation of the OpenLibrary API response and book search results. Using JsonConvert.DesrializeObject will convert the JSON response into an object based on the classes below. Once the results has been deserialized into an object you can freely explore all of the properties.

using Newtonsoft.Json;

public class OpenLibraryBookResponse
{
    public int NumFound { get; set; }
    public int Start { get; set; }
    public bool NumFoundExact { get; set; }
    public OpenLibraryBook[] Docs { get; set; }
}

public class OpenLibraryBook
{
    [JsonProperty("key")]
    public string Key { get; set; }

    [JsonProperty("seed")]
    public string[] Seed { get; set; }

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

    [JsonProperty("title")]
    public string Title { get; set; }

    [JsonProperty("title_suggest")]
    public string TitleSuggest { get; set; }

    [JsonProperty("title_sort")]
    public string TitleSort { get; set; }

    [JsonProperty("edition_count")]
    public int EditionCount { get; set; }

    [JsonProperty("edition_key")]
    public string[] EditionKey { get; set; }

    [JsonProperty("publish_date")]
    public string[] PublishDate { get; set; }

    [JsonProperty("publish_year")]
    public int[] PublishYear { get; set; }

    [JsonProperty("first_publish_year")]
    public int FirstPublishYear { get; set; }

    [JsonProperty("number_of_pages_median")]
    public int NumberOfPagesMedian { get; set; }

    [JsonProperty("lcc")]
    public string[] Lcc { get; set; }

    [JsonProperty("isbn")]
    public string[] Isbn { get; set; }

    [JsonProperty("last_modified_i")]
    public long LastModified { get; set; }

    [JsonProperty("ebook_count_i")]
    public int EbookCount { get; set; }

    [JsonProperty("ebook_access")]
    public string EbookAccess { get; set; }

    [JsonProperty("has_fulltext")]
    public bool HasFulltext { get; set; }

    [JsonProperty("public_scan_b")]
    public bool PublicScan { get; set; }

    [JsonProperty("ratings_count_1")]
    public int RatingsCount1 { get; set; }

    [JsonProperty("ratings_count_2")]
    public int RatingsCount2 { get; set; }

    [JsonProperty("ratings_count_3")]
    public int RatingsCount3 { get; set; }

    [JsonProperty("ratings_count_4")]
    public int RatingsCount4 { get; set; }

    [JsonProperty("ratings_count_5")]
    public int RatingsCount5 { get; set; }

    [JsonProperty("ratings_average")]
    public double RatingsAverage { get; set; }

    [JsonProperty("ratings_sortable")]
    public double RatingsSortable { get; set; }

    [JsonProperty("ratings_count")]
    public int RatingsCount { get; set; }

    [JsonProperty("readinglog_count")]
    public int ReadinglogCount { get; set; }

    [JsonProperty("want_to_read_count")]
    public int WantToReadCount { get; set; }

    [JsonProperty("currently_reading_count")]
    public int CurrentlyReadingCount { get; set; }

    [JsonProperty("already_read_count")]
    public int AlreadyReadCount { get; set; }

    [JsonProperty("cover_edition_key")]
    public string CoverEditionKey { get; set; }

    [JsonProperty("cover_i")]
    public int CoverI { get; set; }

    [JsonProperty("publisher")]
    public string[] Publisher { get; set; }

    [JsonProperty("language")]
    public string[] Language { get; set; }

    [JsonProperty("author_key")]
    public string[] AuthorKey { get; set; }

    [JsonProperty("author_name")]
    public string[] AuthorName { get; set; }

    [JsonProperty("author_alternative_name")]
    public string[] AuthorAlternativeName { get; set; }

    [JsonProperty("subject")]
    public string[] Subject { get; set; }
    [JsonProperty("publisher_facet")]

    public string[] PublisherFacet { get; set; }
    [JsonProperty("subject_facet")]

    public string[] SubjectFacet { get; set; }
    [JsonProperty("_version_")]

    public long Version { get; set; }
    [JsonProperty("LccSort")]

    public string LccSort { get; set; }
    [JsonProperty("author_facet")]

    public string[] AuthorFacet { get; set; }
    [JsonProperty("subject_key")]

    public string[] SubjectKey { get; set; }
}

And that is it. If you use the GetBook method along with the supporting classes you should be able to programmatically get cover images of books from the OpenLibrary API.

This is a post to describe a fix for an error in React Native, specifically an Expo Bare project, that looks like "Loaded "env" configuration for the "production" profile: no environment variables specified".

I ran into this bug trying to upgrade a client's React Native Android app. The app is built using Expo and I'm using eas to build and submit both iOS and Android apps to their app stores. After I made a code change, I started a build using eas build but after the build started I remembered I didn't was logged into Expo with the wrong user account. So I killed the build process, logged out of my Expo account, opened a new terminal and logged into the Expo CLI with the right credentials.

I ran a new eas build but the build failed with the following error:

✔ Select platform › Android
Loaded "env" configuration for the "production" profile: no environment variables specified. Learn more: https://docs.expo.dev/build-reference/variables/
You don't have the required permissions to perform this operation.

Entity not authorized: AccountEntity[ID] (viewer = RegularUserViewerContext[ID], action = READ, ruleIndex = -1)
Request ID: ID
    Error: GraphQL request failed.

I did some Googling and found this helpful Github post which made me realize my mistake. When I started the first build using my own Expo account instead of the client's Expo account, the build process wrote a JSON property called extra.eas.projectId to the app.json file of my project. Because I didn't have a project under my Expo account that matched what I was trying to build, Expo created a new project with a new id in my account using with the value written to extra.eas.projectId. As soon as I deleted the extra property from app.json I was able to build the project successfully again.

At first I didn't think the error made any sense, but the more I thought about it you can see that "Entity not authorized" actually makes sense here - the first part about the env configuration is a little bit of a red herring though. So what happened was Expo was trying to build my project under an Expo project that the current user didn't have access to. Which makes sense now.

So, in conclusion if you run into this error, delete this property from your app.json file and do a new eas build command. The new command will create a new extra.eas.projectId with the appropriate project id and you'll be golden.

"extra": {
      "eas": {
        "projectId": "12345678-1234-1234-be5b-f844590a0aad"
      }
    }