Send Windows Notifications with PowerShell

0:04Hi, guys. My name is Trevor Sullivan. Welcome to this CBT Nuggets skill where we're going to be talking about a really exciting topic surrounding the PowerShell automation framework. Now, this particular skill is going to specifically cover using PowerShell on the Microsoft Windows platform. And the task that we're going to be performing using PowerShell in this skill is going to be sending operating system notifications from your PowerShell automation scripts. Now, why might you want to send notifications from your automation scripts?

0:38Well, there's a lot of different use cases for sending notifications. For example, you might want to send a notification when a backup job that runs for several hours has completed. So that way, you just have a visual indication that the job is complete, and you can now go and take action on that particular job that ran. Another thing you might want to do is perform some cleanup of some kind of system. So for example, maybe you've got some file system locations that have a lot of outdated files, and you want to go back and clean up that data.

1:11Well, depending on where that data is stored and how much data you have, it could take several minutes or perhaps even hours to perform a cleanup of that data. The same thing could be true inside of a database. Maybe you want to go through and query for certain data inside of a database and go out and clean stale records out of that database to make sure that the database is optimized and performing very well. There's a whole bunch of different use cases for sending notifications, and we're just going to explore a community module called BurntToast and how to actually use all of the different functionality that is exposed by this feature rich module.

1:50If you're just getting familiar with PowerShell for the first time, this probably isn't the best skill to get started with PowerShell on because we're going to assume that you already know how to install PowerShell, and that you understand some of the basic concepts in PowerShell, like how modules work, and how commands work, and how parameters on different PowerShell functions work. So go ahead and check out some of our other training on CBT Nuggets if this is your first time touching PowerShell. I hope this has been informative for you, and I'd like to thank you for viewing.

0:04Hi, guys, and welcome back. In this video, we're going to start by taking a look at the BurntToast PowerShell module that enables us to create notifications from our PowerShell scripts on the Microsoft Windows platform. But before we do that, let's take a really quick look at a GitHub repository that serves as a companion to this video training skill at CBT Nuggets. So if you head over in your web browser to github.com/cbttrevor, there is going to be a PowerShell notifications repository just like on my screen here.

0:39So github.com/cbttrevor will take you over to this GitHub organization. And within this GitHub organization, I've got a bunch of different companion repositories that match up with some of the training content that I've been producing on the CBT Nuggets platform. So go ahead and drill into the PowerShell notifications repository. I know it says "private" right here, but by the time that this training goes live, that will be publicly accessible to anyone. And then what you'll see here is that I've broken down each of the learning objectives for this particular skill into subfolders so that you can follow along very easily after this recording has been produced.

1:18So go ahead and just use the Git clone command to clone this repository, either using the SSH URI or the HTTPS URI. It really doesn't matter which one you use since you're just going to be cloning it locally and using it in a read only capacity. Now one of the great things about the BurntToast PowerShell module that we're going to be looking at is that it's produced by a community member named Josh King. He's the user who has produced this module, or started off this module, and has been actively maintaining it for quite some time.

1:51So Josh's GitHub user name is Windos, Win-D-O-S. I'm not really sure what that stands for. But under his user name, there is a GitHub repository called BurntToast. And as you can see here, this is where all of the active development of this PowerShell module is occurring. In fact, there's even a nice little graphic here, and there's a bunch of badges here that show you the latest version of the module that's been published to the PowerShell Gallery, which is version 0.8.2.

2:24The number of downloads, which I believe is actually incorrect at this point in time due to some statistical issues with the PowerShell Gallery. And it also shows you the CI/CD pipeline that's running inside of the Azure pipeline service, as to whether the build is succeeding or failing for some reason. We also see the code coverage here, which indicates how much of the code is being covered by tests, automated tests. Now as you'll see, we're going to basically be installing this PowerShell module using the Install Module command, which is included with PowerShell out of the box.

2:58So you don't need to install any modules to get that install module, it just comes as part of the PowerShell package. And we use that command to install other third party modules, such as BurntToast in this case, from the PowerShell Gallery at powershellgallery.com. Now, if you scroll down in the README here a little bit, you'll see some examples, or just screenshots, and example commands that you can call to send operating system notifications in the Windows 10 platform using the BurntToast module.

3:28Now, this is certainly not comprehensive. We're going to explore a lot of the intricate options that are available to you in this module that allow you to do even more customizations than just what is shown here. But as some preliminary examples, you can kind of see that there is custom text being emitted, there is a custom header or title that's being emitted onto the notification, and you can even customize the image that is being used to present the notification as well. And then down here, you can actually see that if we had maybe a meeting reminder to say, hey, you've got a meeting coming up in 10 or 15 minutes or something like that, that you can actually create a snoozeable alarm notification using this module as well.

4:10So this is a lot of functionality in here and there's a lot more that's not even being presented there. But first, I want to show you the PowerShell Gallery. So this is the repository, or sometimes known as a registry, that's built on the Nugget APIs that allow you to publish and download packages. So if you were to go to powershellgallery.com in your web browser and search for the BurntToast module, you should see that show up here. And we're only getting one result because BurntToast is a pretty unique, kind of cool name.

4:42And if you're wondering where the name BurntToast actually came from, the toast part of it actually came from the Windows platform. So when you get a notification down in the lower right corner of the screen-- kind of where I am in this particular video-- you would actually call that a notification toast. And what's cool is that the notifications will actually show up over here in what's called the Windows 10 Action Center. And if you want to open up the Action Center really easily, you can simply hit the Windows A on your keyboard, and that shortcut will actually invoke the Action Center and show you all of the notifications, along with all of these settings down here for your system.

5:24So what we're going to do now is actually jump into Microsoft Visual Studio code, which is my preferred text editor of choice any time that I'm doing any kind of development work or programming tutorials, like this one. And if you don't have Visual Studio code, I would strongly recommend you download it at code.visualstudio.com. But for now, I'm just going to jump over here. And I've already opened up this PowerShell and notifications Git repository that I've cloned locally on my system-- actually, I developed it locally here. But I didn't have to clone it, of course. But basically, we're in the 02 lesson here.

5:57And our objective here is to basically get the module installed and learn about some of the core capabilities that it offers. So jump over into these script.ps1 file, which is just a simple PowerShell script. The actual name of the script could be whatever you want. So you could hit F2 over here in the Explorer and call it Install BurntToast. The name of the actual script doesn't really matter. I just happen to-- script.ps1 is kind of a generic name, just so that you have something to point to in each of the different lessons here.

6:29So go ahead and pop that open. And then in BS code, I'll just take Control-B to close that sidebar there just give us a little bit more space to work with on the screen. And on the very first line here, the first two lines rather, you'll see that we are going to use a PowerShell command called Find Module that allows you to search the PowerShell gallery that we just looked at-- powershellgallery.com. And you can search for a module based on its name. You can also search based on things like tags. So I could do Find-Module -tag notifications, for example.

7:03And basically, this will allow you to search through the PowerShell Gallery. But as long as you know what the module name is-- so I've actually got a bunch of different notifications related modules here. But if you already know what the module name is, it's usually just easiest to search for it by its actual name. And that will show you the latest version of that PowerShell module that is in the gallery. Now, if you have a specific scenario where you want to install an older version of a particular module, you can actually do Find-Module -AllVersions.

7:36And as long as you specify the module name along with all versions, it'll actually show you the historic versions that were previously published, so that you can install a specific version of that module based on your specific requirements, which is pretty cool. So now what we're going to do, now that we know the name of the module that we want to install, we're going to call the Install Module command. And again, this is built into PowerShell. So if we're to do Get Command install dash module, you should see that we get back the Install Module command here, and it's part of the PowerShell Get Module that's included with PowerShell.

8:16That's just part of the core PowerShell product and what we're going to do is basically specify the name parameter, which obviously is the name of the module that we want to install from the PowerShell Gallery. And then there's this scope parameter. So if you don't specify the scope parameter and you just do Install Module dash name, then that is going to install the module to your admin directory or your all users directory, so that any user who logs into the system can use that module. Now, if I tack on the scope current user, that will install to my current user profile directory instead of installing to all users, and it doesn't require administrative permissions.

8:55So like me, if you have Visual Studio code running as a nonadministrative user under user account control, UAC in Windows, then it's preferred, generally, to install to your current user directory so that you don't have to run VS Code as an administrator, and potentially open yourself up to security vulnerabilities. So now that we have installed the module here, the next thing that you probably want to do is import the module. Now importing modules is not strictly necessary in PowerShell, thanks to a feature called PowerShell module auto loading.

9:31And there's actually a variable called PS Module Auto Loading Preference that you can set if you explicitly want to disable module auto loading, but it is actually enabled by default. So it's a good practice to call Import Module, just so that you can specify where inside of your script you want to import a module. Maybe you want to do it at the beginning, maybe you want to do it somewhere partway through your script once you actually need the functionality that's exposed by that particular module. But just be aware that in some cases, you might need to explicitly import it.

10:04Now, once the module has been imported into our environment, we can run GMO, which is short for Get dash Module. Sorry. Let me type that correctly there. So Get dash Module. And if you scroll through the list of modules, you should see BurntToast imported into your current PowerShell session. So now the next thing that we typically do with a PowerShell module when we're new and we're just learning about the module, and we're kind of trying to figure out how to actually use it-- I mean, you could read the documentation for it. Documentation isn't always up to date, so sometimes it's just nice to have introspection mans that allow us to inspect the module and see what is available.

10:42So if we run Get Command Module BurntToast, it'll actually spit out a list of all the different PowerShell commands that are exported by the BurntToast module. So this is really convenient. So you can see there's a whole bunch of different commands here that allow us to create these things, like headers, images, inputs, progress bars, text, visual elements, and things like that. It might seem a little bit overwhelming at first, but by the end of this skill, you'll understand how to use many of these commands in more detail.

11:14However, I'm going to draw your attention specifically to this one command called New BurntToast Notification. As well as a second one called, Submit BT Notification. These are really going to be the meat of where presenting a notification to the end user is going to come into play. So now that you understand how to learn about the module, get it installed, and inspect with the commands that are exported by that module, let's go ahead and actually build your first notification using this module.

11:44I hope this has been informative for you and I'd like to thank you for viewing.

0:04Hi, learners. Welcome back. In this video, we're going to take a look at how to create your first notifications using the BurntToast PowerShell module that is being developed by a community member. Now, in the previous video, we took a look at how to get the module installed and to take a look at how to introspect the module or examine the module to see what commands are exported by it. So now, let's jump back into a Visual Studio Code and take a look at how to actually invoke the new BurntToast notification command.

0:37I'm just going to switch back over to my desktop here. And I've got Visual Studio code open in front of me just as I did in the previous video. And the first thing I'd like to call your attention to is that if you're following along with the companion GitHub repository, go ahead and just jump over into the 03 directory. And our objective here is really just to focus on learning about the basics of creating notifications. So open up the script dot ps 1 file and hit Control-B just to close the sidebar. That'll give us a little extra room to work with on the screen here.

1:08Now, the first thing that you typically do once you've got a module installed and you know what command do you want to invoke is you can call the Get-Help command. And that's going to print out some useful information about the command. But if we do Get-Help dash name New-BurntToast notification, it'll give us a brief synopsis of what this particular command does. And then under syntax here, it's going to show us how to actually invoke the command. And basically show us all of the supported parameters and what kinds of values to pass into each of those parameters.

1:46Now, a lot of PowerShell commands out there are pretty simplistic in nature and don't offer a whole ton of parameters. But New-BurntToast notification is not one of those. It actually is very customizable. And it has lots of different parameters on it that can be called in different configurations. So you might see a lot of redundancy. So as you're looking at the syntax, you're like, man now I've got New-BurntToast notification dash text. And then I've got New-BurntToast notification dash text again, and again, and again, et cetera.

2:17So why are we seeing this duplication here? Well, PowerShell has a concept called parameter sets. And basically, when you're building out a PowerShell function like newsprint BurntToast notification, that's a PowerShell function. When you specify the input parameters through that function, you can actually assign them to different what are called parameter sets. And so what that allows you to do is actually call the same command or the same function, in this case, we're going to call New-BurntToast notification. But there are different groups of parameters that work together somewhat differently to get a desired result. So if you start looking through the list here, you actually start to see some variation in the parameters that are being offered here.

3:01So for example, there is a parameter here called snooze and dismiss which we'll look at later. But if we specify that parameter, it is exclusive of certain other parameters that perhaps allow us to do things like Add Custom buttons or something like that. So just be aware that each of these syntax elements here is basically a unique parameter set that allows you to call the command in a unique way. Now, you don't need to worry too much about that because a lot of these commands that we're going to be calling are pretty simplistic in nature.

3:34And we're just going to be using maybe one or two parameters like dash text to customize the actual text that's being displayed on the notification. And then down here, under the description field you get a little bit more deep information than the synopsis. A synopsis is this like a one sentence overview of what the command does. And then if you really want to get a deeper understanding of the command, you can drill down under description and take a look there. Now, something else that you can do is you Get-Help dash name and then tack on the dash full.

4:05So by default, there are certain elements from the help that are being committed by the help system. But if you do dash full, then it'll actually print out a lot more information. So it actually show you the built in examples. So we can take a look at example number one which is just a very basic call to New-BurntToast notification. Then example two, gets a little bit more advanced where we tack on a custom parameter. And then it just progressively gets more and more complex. There's also some more information that is shown in here as well that gives you information about the parameters.

4:41So if you do Get-Help desk full, you'll actually get this parameter section that opens up. And it actually tells you a nice little description or what each of the parameters does. So for example, the text parameter it says, specifies the text to show on the notification. Up to three strings can be displayed. And the first will be boldened as a title. So that's very helpful information to know. So let's take Control-Tilly to close the integrated terminal in the VS code. And let's take a look at a very simple example.

5:13In fact, I'm going to duplicate this line up using Alt-Shift up arrow just to copy the line up. And then I'm going to remove the text [INAUDIBLE].. I want to show you just how easy it is to get started with this module. So on line number five here, if I just put my cursor on line number five and hit F8, F8 will tell VS code to run the current line where the cursor is located. And so that's going to just call New-BurntToast notification. If I do that again, you'll see on the bottom right of the screen here I'm getting just a default notification with a nice little default icon there.

5:45And it says Windows PowerShell. Now, obviously, notifications are really only meaningful if they have custom text associated with them. So as we just looked at we can specify the text parameter and that will specify the text to display. So let's hit F8 here on line number six now. And you'll see that we have now customized the text to say my first notification. And it still has the default image. And it's telling us it's from Windows PowerShell.

6:15Now, what if you wanted to specify some dynamic content for the text? Like maybe you want to display how many unread emails you currently have. Or how many computer accounts are in Active Directory that are older than 90 days. Or something useful, some systems management information. Well, what I can do here in this example is actually wrap the text in parentheses and use this concept called .NET string formatting or substitution where I can basically [INAUDIBLE] Get-Process dot count.

6:46And if I hit F8 there, you'll see it just prints out a number which is useful. That's telling me how many processes are running on the current system. And then I can specify my string on the left hand side of this dash F operator which is short for string formatting in PowerShell. And right here, you'll see this curly brace with a zero in the middle. And that's basically the first element in an index-- an array of elements on the right hand side of the dash F operator that we want to substitute in there. So it's a zero based index because it's an array.

7:18And so basically, this first element here Get-Process dot count is going to get substituted where this zero is in the string. So this is just a nice way of constructing a string without having to use a string concatenation where you say here's the first part of my string, plus this dynamic value, plus some other static value. Just a different way of expressing strings as templates. And then once we wrap all of that in parentheses, we can pass that resulting string into the text parameter and display that as a notification.

7:49So you can see I get a nice notification saying there are currently 323 processes running on the system. So now, we've added some dynamism into our message that we're posting to the notification. Now, another nice feature that the BurntToast module offers is the ability to suppress the pop up notification. And this is nice because as we explored earlier when I hit Windows-A, over here on the right hand side of the screen in the Action Center is where I have a running history of all my notifications.

8:25And maybe if you're a heavy user of the Action Center, maybe instead of popping up that notification on the screen, you actually just want to send it directly into the Action Center without displaying it. So you can do that by using what's called a switch parameter. And a switch parameter in PowerShell just really quickly basically means that if the parameter is present, then it's true. If it's not present, then it's false. So you don't actually have to pass in a true or false Boolean value into the parameter. Because the fact that this parameter is specified just like this with a dash of pop up, that means that it's going to be true.

9:03Now, if you did want to force it to be true or false, you could actually put a colon and then put either true or false. But that's a little bit less common. So I'm just going to specify some static text here and say, I'm in the action centre. And we're going to add on that suppress pop up parameter. If I hit F8 on that, nothing really happens. And that's because we're not popping up that notification in the lower right hand corner of the screen. Apologies that my face is kind of covering these notifications actually. I just realized that. But if I hit Windows-A, and I'll just hit Windows-Plus to open up the magnifier here, you can see that I got this message here saying, I'm in the Action Center.

9:42Even though it never popped up in the lower right hand corner of [INAUDIBLE]. Let me hit Windows-Escape and that will remove my magnification there. And then one last feature that I wanted to cover in this video is the ability to specify a custom timestamp. This is really cool because if you wanted a notification to have a future timestamp or a timestamp sometime in the past, then you can actually do that by customizing the timestamp that's associated with the notification when you send it using the new BurntToast [INAUDIBLE]..

10:16So what you basically want to do is specify a date time value to this. If I hit Control-Space to invoke the intelligence here in VS code, you can see that the custom timestamp takes a date time object which is a pretty standard .NET object system dot date time. And the way that we can get a date time object in PowerShell is simply to call the Get-Date command. If I was just to select this little Get-Date command and hit F8, you'll see that it prints out this date and time. And this is actually a date time object.

10:47It's actually not just a string. It's actually an object that's being emitted as a string or a formatted as a in the terminal here. But it is actually giving us a system dot date time object. And what's cool about the system dot date time object is that if you put a period after it in parentheses here, there are actually a bunch of methods, functions that you can call on that instance of the date time object. And some of those functions that you can call, methods call are actually called add days, add hours, add milliseconds, add minutes, et cetera.

11:23If I say I want to create a notification that happened 10 minutes ago or 10 minutes in the future, I can add 10 minutes. Or if you want to subtract minutes, then you can just say add negative 10 minutes. And that will actually-- they take the current date and time back to 10 minutes and do that as the custom timestamp. So let's go ahead and hit F8 on line number 15 here. You'll see I get this message pop up down here. It says, hello, I am from the past. Now, the notification itself-- actually, let me just move out of the way really quickly here.

11:59There we go. So if I rerun that, you'll see that this notification doesn't actually have the date and time on it. However, if I was to open up the Action Center using Windows-A, then you'll see that we can open up the notification list. And down here below all of the more recent notifications, we have these notifications saying, hello, I am from the past. So the nice thing is that the Action Center here in the Windows platform is actually chronologically ordering those notifications even though they were sent after others.

12:33Because the timestamp is in the past so it's putting them down here in the bottom. So as you can see, there's a lot of really great functionality. Even just the basic functionality in the BurntToast module for PowerShell is really neat. Now, that you've learned some of the basics about how to create notifications, let's take a look at some other customization options like titles and sounds. I hope this has been informative for you. And I'd like to thank you for viewing.

0:04Hi, guys, and welcome back. Now that you've learned how to get the BurntToast module installed on your system and you've explored the module and understood some of the different commands that are available in it and you've created your first notifications using this module, let's take a look at a couple of additional features that are available. Specifically, you can customize the image file that is being presented in your notification. Additionally, second of all, you can customize the heading on the notification.

0:35And then third of all, you can actually configure a custom alarm sound instead of using the default notification sound in the Windows platform. Let's jump back into Visual Studio code and take a look at how to consume these additional features. Here we are back in Visual Studio code. And if you're following along with the companion git repository, go ahead and drill into the 04 directory called Customize Notifications with a Title and Image and [AUDIO OUT]. And our learning objective here is, of course, to customize the title and the image of our notifications as well as using a semi-custom sound.

1:15You can actually import your own custom sounds from the file system, but the module actually exposes several different alarm sounds that you use. So let's drill into the scripts.ps1, and I'll hit Control-B to close that sidebar. Open up our screen a little bit more here. And as we explored in the previous video, there is a parameter on the new BurntToast notification command that allows us to specify a heading. If you recall, if I hit Control-Space on the text parameter here, the text parameter actually accepts a string-- or sorry-- an array of string.

1:51And so what we can do is specify the first string as a heading, and then the second and third strings will basically be printed out as just the main body of the notification. So let's go ahead and test this out. Let's hit F8 here on line number 2. And of course, I'm in the way again. And what you'll see here is that on this notification, we have a heading as well as subtext and third-level text. So it's actually putting a line space or a line break in the notification for us underneath of that heading.

2:27And the heading is a little bit bold there, so it stands out a little bit more. So one of the other things that I wanted to call your attention to is that there is limited support for how much text you can put into a notification. So if I create a notification here that has a heading of really long text, and then after that, I print out some text that's gibberish here. But I'm just trying to make a very, very, very long paragraph here-- let's hit F8 on that line number 4. And what you'll notice is that-- zoomed in here-- the text actually does get cut off here at the end.

3:03So as you're constructing your notifications, make sure that you are aware of those limitations, of how many characters you can print, and make sure that you are using concise messages for your window and Toast node. I'll hit Windows, Escape there and close my zoom-in effect there with the magnifier. And now what I wanted to show you is an additional heading feature that is available. So you can get a heading by just specifying at least two elements in the text parameters.

3:37So the first element will be used as the heading, and the second and/or third will be used as the main body text. However, there is a parameter on the new BurntToast notification command called the --header parameter. And what this allows us to do is actually specify a custom header value you pass into the notification. Now, this is going to make the notification a little bit taller, but it's actually going to show that heading that we specify above the main body of the notification.

4:07So the way that we create a header to pass into this header parameter is to actually use another command that's exposed by the BurntToast PowerShell module. And that command is called New-BTHeader. So if you were to call a NewBTHeader, hit a dash, you can see that you can specify a title, arguments and activation type, which we're not going to talk about right now. And you can also specify an E, which is just equally identify that header in that particular notification post.

4:38I'm honestly not sure why that's a necessary parameter. Typically, you're only going to have one header anyway. But maybe somebody can explain that to me. All right. So what we're going to do is assign the result of this command. Let's actually just select this command and hit F8. And you'll see it prints out this object to the terminal here. So what we want to do is actually capture that header object into a variable. And you can name the variable whatever you want to. I just happen to name header here because it's self-explanatory as to what that particular variable does.

5:10So once you've defined that, then you can call the New-BurntToast notification command, pass in the header parameter, and then pass in the header variable as input to the header parameter, and that will customize your [AUDIO OUT] better, of course. So let's hit F8 there, and I'll just do [AUDIO OUT] here, Windows Magnifier. And what you'll see is that we now have this notification here that has-- below, this has a custom title. And up here, above the image, we have this additional heading that's showing up up here.

5:47So this notification is going to be a little bit taller than the other ones that we were looking at before, but it has this nice heading that's separate. It's a little bit more prominent than just the heading that's shown as a default part of the notification. Now, one of the other features I wanted to cover in this video was how to customize the image that is displayed in a Notification Toast. So what we can do is pass in our header here, our text. And we can also specify another new parameter. We're going to introduce the App Logo parameter.

6:18So the App Logo parameter-- if I hit Control-Space in my editor here, you'll see that it accepts a string value-- just a singleton string, not an array of strings. Of course, because we only have one position on the screen, on the notification to display an image, we can't specify more than one, of course. Now, I've downloaded a PNG version, just a raster image version of the Python logo locally. And so we're going to basically pass that file system path in to the app logo parameter, and that will cause the Notification Toast to use that image instead of the default BurntToast image that's included with the module.

6:57So let's go ahead and hit F8 here on line number 11. And you can see that I'm now getting this nice little message here that says Message from Python. And of course, I've got my custom heading up here as well. And of course, primarily what we're interested in here is that the Python logo is now showing up as the notification image. So you could use this for other purposes, like maybe sending out notifications about how many emails are currently unread in your inbox, or if you could have a little computer icon if you're managing computer accounts in Active Directory with PowerShell, and send notifications that way as well.

7:37So the last feature that I wanted to cover in this particular video is the customized sound. So I'm not sure if you can hear on my desktop, but I'm actually getting some custom audio here from this alarm 3 sound. So the New-BurntToastNotification command, with its many different parameters, offers a dash sound parameter. And this allows you to specify some built-in sounds. Again, you can't specify a custom sound. But if I hit Control-Space, you can see that there are a series of built-in bounds that I can select from.

8:09So maybe I'll choose alarm 7. And if I were to put F8 on that and unmute, you can see that that sounds a little bit different than what the default Windows 10 notification sounds like. That's just an introduction to some of the core features in the new BurntToast notification commands, such as how would you customize the sound, customize the logo, as well as provide custom headers on your notifications. I hope this has been informative for you, and I'd like to thank you for viewing.

0:04Hi, guys, and welcome back. We've taken a look at some of the more advanced features in the BurntToast PowerShell module, and I'd like to continue that trend by taking a look at a couple of other options that allow you to create additional buttons on top of your BurntToast notifications. Let's jump over into Microsoft Visual Studio code here and get started. Now if you're following along with the GitHub companion repository, all the PowerShell notifications here, go ahead and open up the folder 05 Enable Snoozing and Add Custom Buttons on Notifications.

0:40And that's exactly what we're going to do here, So the readme just really quickly covers our learning objective here. But if we close that and open up the script.ps1 file-- I'll hit Control-B once again to open up our screen there. And the first thing that I wanted to do is point out the snooze and dismiss switch parameter. So we looked at another switch parameter earlier called suppress pop up that allows you to suppress the pop up in the lower right hand corner of the Windows operating system and instead send the message directly or the notification directly into the Windows Action Center when I hit Windows-A as the keyboard shortcut.

1:21Now we're going to look at a different switch parameter-- again, a switch parameter being a parameter that we don't have to pass a value into. It's either present or not present. And that parameter is called snooze and dismiss. So so far, what we've taken a look at is how to create kind of static and dynamic notifications that have text on them. However, what if you wanted to take some kind of action in response to one of those notifications popping up? Well, one of those things might be something like a meeting reminder. Maybe you want to use a PowerShell script to remind you that you've got meetings at particular times of the day.

1:56Maybe you want to build a custom email client or a custom chat client that integrates with Slack or some other kind of chat system. And using PowerShell, you can integrate those applications with the Windows notification subsystem so that you can get notifications just like you would from any native app. So if we specify the snooze and dismiss parameter here, this is just a really simple way to get us some functionality that tells us, hey, your meeting is starting in 10 minutes. So now I have two buttons on top of the notification that we did not have before.

2:30So I can either just dismiss the notification immediately, which will remove it from my list of historic notifications, or I can select a snooze time anywhere from five minutes all the way up to a day, and I can click the snooze button. And that will snooze it for that amount of time. Now that's a pretty useful feature, just being able to snooze the notification and say, you know what? I know that's important, but I'll go ahead and get back to it at some point in future. Now another even more useful integration capability that's offered by BurntToast is the ability to create custom actions or custom buttons on the notification post.

3:10So to do that, what we're going to do is take a look at this new parameter-- yes, I know, another parameter on BurntToast notification. It's a very complex command with a lot of different capabilities, but bear with me. But if we take a look at this dash button parameter here, then you'll notice that it takes an iToast button array of objects as input values to that parameter. So how do you get one of those iToast button objects? Well, what we need to do is take a look at the New-BTButton command, which, of course, is part of the BurntToast PowerShell module.

3:48So if I expand up my terminal here and just do Get-Command -module BurntToast again, you'll see that one of those commands that we looked at earlier when we were kind of exploring and inspecting the module is New-BTButton. So how do we actually use that command? Well, if we just let the intellisense do the work for us here, we do New-BTButton and then put a dash to specify a parameter. And you can see that we have these options here to do either snooze or dismiss separately like we looked at earlier.

4:19Or we can specify a custom argument along with what's called an activation type, which is exactly what I have done here. So imagine the following scenario. Let's say that you're using a cloud platform like Microsoft Azure or maybe Amazon Web Services, and you are running a bunch of virtual machine infrastructure up in the cloud. And let's say that one of your colleagues is going through the list of virtual machines and is trying to do some kind of cost optimization work. And they say, hey, I'm going to stop this virtual machine that's called production because, you know, everybody wants to stop a virtual machine named production because that's not going to cause any problems, right?

4:56Well, let's say that you want to get some kind of notification when an alarm in the, let's say, the CloudWatch service in Amazon Web Services is triggered, indicating that that machine has gone offline. Well, we can use new BurntToast notification to create a message basically saying, hey, this virtual machine named XYZ 123 has been shut down. But then we want to be able to take some kind of immediate action in response to that. We need to get that virtual machine back up and running so that it is running my production application, right?

5:30Well, what you can do is specify the activation type of protocol on the button that you're creating for the notification. Also, you can specify the content parameter, and that is going to determine the text that is shown on this custom button. Additionally, under the arguments parameter here, we can specify a URL that we want to invoke as a result of clicking this button. So then what we need to do is assign that result of that New-BTButton over to a variable so that we have a reference to refer to that button.

6:03So I'm just going to call it a button, but again, it's just a variable name. You can call it whatever you want to, maybe AWS button. And then over here on the New-BurntToastNotification command, we need to pass in a reference to that button. By simply dereferencing the variable using the dollar variable name [INAUDIBLE]. So let's go ahead and select both lines seven and eight here. So I'll just do Shift-Down Arrow a couple of times. Select both those lines. Hit F8 in VScode. And as you can now see, we've got this nice notification down here saying virtual machine outage.

6:39VM named XYZ123 has been shut down. And what's cool is that I've got this button here. But instead of being snooze or dismiss, it's this custom button that says open console. Or maybe I should have changed it to open AWS console. And one other thing I probably should have done too, now that I think about it, is I probably should have customized this BurntToast icon to be like AWS. That was a little bit more customized. But I'll leave that to you guys for your own exploration. So if I were to click the Open Console button, that is now going to pop open my web browser and navigate me directly over to the AWS Management Console, which is right now on my other screen.

7:16So I apologize for doing that. So that's just a quick introduction to some of the customization that you can do using custom actions, custom buttons, as well as snoozing, reminders from the Windows Action Center. I hope this has been informative for you and I'd like to thank you for viewing.

0:04Howdy, guys. Welcome back. Now in the previous video, we took a look at some really cool customization features that allow you to create interactive notification Toasts on the Windows 10 platform using the BurntToast PowerShell module. Now we're going to continue this customization trend in a slightly different way. So instead of creating buttons, we can actually create what are called context menu items on a notification Toast. So let's jump in over to Microsoft Visual Studio Code, our editor, and take a look at how to [AUDIO OUT]..

0:39So for starters here, let's head over to the Control-Shift-E. We'll open up the Explorer on my keyboard here. And I'm under this 06 folder Add Context Menus to Notifications. And of course, that is exactly what we're going to be doing in this video-- adding additional capabilities to our notifications. So in the previous video, we took a look at how to use the button parameter on the new BurntToast notification command. Now the feature that we're about to look at right now is actually not available on the new BurntToast notification command.

1:16Instead, if you scroll down here in our script.ps1 file down to line number 13, you will notice that we are using a different command called Submit-BTNotification. Now I'm not entirely sure why this capability of context menus is not available on the new BurntToast notification command. and However, it's very possible that the module will change as it continues to develop in the future, and maybe we'll see that option be available.

1:46However, for now, we are on the, I think, 0.8.2 version, yep, of the BurntToast PowerShell module. And as of right now, if we want to use this context menu feature we must do it using the Submit-BTNotification command. All right, so how do we actually get to this point? Well, let's close our integrated terminal there. And I want to call your attention to yet another command inside of the BurntToast PowerShell module. And that command is called New-BTContextMenuItem.

2:19Thanks to the verb dash noun nomenclature for command naming in PowerShell, it should be pretty obvious just from plain English what this command does. It creates a new context menu item for the BurntToast PowerShell module. Now there are a few different parameters here that we want to take a look at. Now very similar to the buttons that we created in the previous video, we have this activation type of protocol. So basically, that's going to leave it up to the operating system to look at the protocol that is specified in the argument's URI and take action there.

2:50So of course, we're using HTTPS here, and that's going to pop open inside of our default web browser. So the arguments parameter is, of course, the URL to whatever web page we want to pull up. And then over here, we've got content, which is just a name for the context menu item. So it's just the text that's going to show up for the context menu item. Now what's cool is that you're not limited to just one context menu item. You can actually create several different ones. So let's say that we wanted to be able to quickly respond to events that happened inside of our cloud accounts using these context menu items.

3:28So maybe you're doing some work in AWS, some work in Google Cloud, and maybe some work in the Microsoft Azure portal. And so you want to have shortcuts to these directly in your notification toasts so that when one of these events occurs, you can really quickly pull up one of those consoles and take some kind of action in it. Now if it was me, I'd probably use the PowerShell module for each of those cloud platforms to perform whatever automated actions I needed to, but you choose the right tool for your preference. Now something that's a little bit different here with the Submit-BTNotification.

4:01is that we have to construct what's called a BurntToast content object. And BurntToast content object takes a couple of parameters. So one of those is going to be an Actions object. So we have to use the New-BTAction command to construct one of these action objects. And one of the parameters on BTAction New-BTAction, is called context menu items. And yes, there is an S at the end indicating that it accepts an array.

4:33So if I hit Control-Space here, you'll see that we have an array as indicated by the square brackets here of Toast context menu items. And those are the objects that are being emitted by the new context menu item command up here on lines 1, 2, and 3. So what we're going to do is basically just assign each of those contexts menu items to a variable. Of course, you could just assign all of them to an array, a single array, and then pass the array in as well. But again there's multiple ways to do things.

5:03I just happen to use three separate variables for this purpose. But once we construct the action object, we assign that to a variable. And then we also need this thing called a visual object. I'm not really quite sure why you need this because you're not really configuring anything that's perceivable by the end user in this case. But you do have to create this thing called a binding and then pass it in. And that gives you a visual object. And then that gets passed into New-BTContent as well. So once you've constructed this New-BTContent that contains the visual and the action-- and the action, of course, contains child references to the context menu items-- then you can finally submit the BTNotification.

5:43And pass in that content object, and you should see something along the lines of this down here. Now this looks pretty unexciting, right? It just says Windows PowerShell new notification. Of course, we could further customize that with some text. What I want to call your attention to here is actually our context menu. All the context menu items that we created are under this little gear icon or this little Settings icon. So if we click on the Settings icon, you can see that I've got these context menu items that allow me to open up the AWS Management Console, the Google Cloud console, as well as the Microsoft Azure portal.

6:20So whenever you create those context menu items, they're going to show up right here under that little gear icon. So be aware of that. I'll hit Windows-Escape and close my Windows magnifier there. And of course, because we have that notification persisted over here in our Action Center when I hit Windows-A to pop open my Action Center, I can still always refer back to that little gear icon up here in the Action Center as well. So if for some reason you've closed that notification or you missed it before it disappeared, then you can always hit Windows-A, pop open the Action Center, and go back and refer to the context menu.

6:59There's a lot of really rich capabilities that you can perform here. You could even change one of these URLs in the arguments of the context menu item to call a custom API, for example, that's maybe hosted internally or even just locally on your development system and perform of some automation tasks as part of your own custom API as well. This is some really cool functionality. I really like the fact that you have multiple choices. You've got buttons, got context menu items. You can customize the text and the logo and the headings. As you can see, there's a lot of really cool functionality inside of these Windows 10 notification posts.

7:32I hope this has been informative for you, and I'd like to thank you for viewing.

0:04Hey hey, guys, and welcome back. We're moving right along. We've covered a lot of really cool stuff-- how to create notifications, how to add headings and custom sounds, how to add buttons and snoozing capabilities, and even add context menu items to your Windows 10 notification toasts as well. Now in this video, our last major video of functionality on the BurntToast PowerShell module is going to cover the progress bar's capability. Yes, there's even more functionality we still haven't explored yet.

0:34So let's jump over into Visual Studio code here. And if you're following along in the companion GitHub repository over at github.com/cbttrevor/powershell notifications, then go ahead and open up the 07 directory. And our objective here is to learn how to create progress bars. Now why would you want to create a progress bar? Well, progress bars can be used to indicate kind of a status of any kind of long running task. So you have status bars in your web browser when you're downloading large files.

1:06If you're using a BitTorrent client to download something like an Ubuntu ISO, which I do on a periodic basis, you know, I get a progress of how much of the file has been completed, how much more is remaining, things like that. And so you might want to have those kind of indicators if you're doing backup jobs. Like, if you're backing up maybe 10 terabytes of data, maybe you want to know status intervals as to how that backup job is going. Or maybe you're doing some cleanup tasks in Microsoft Active Directory, or maybe you're cleaning up a resource groups in Microsoft Azure to reduce the number of resources that you're being billed for inside of your cloud platform.

1:45Well, you can use notifications to get progress updates on your scripts in PowerShell. So go ahead and pop open the script.ps1 file here. And that's going to be in the 07 Build Progress Bars directory. And let's take a look at an example. Hit Control-Tilde, and that'll just close the terminal here. Sorry there. Close the VS Code terminal. And basically, what we're going to be doing here is mocking up a scenario where we want to clean up computer accounts in Microsoft Active Directory.

2:17And maybe you've got hundreds or thousands of computer accounts. And so, you know, this script is going to run for maybe 10 or 15 minutes. I'm not exactly sure how long it'll take. I don't actually have an Active Directory instance up and running locally, which is why we're kind of mocking this up here. So what I've done is I've created a variable with an array of computer names that we want to clean up in our Active Directory instance. Now as we iterate over these in a-- over each array here, we want to get some indication of how many have been cleaned up and how many are remaining as a percentage from 0% to 100%, right?

2:54So when that job is 100% done, then we can-- you know, we're done. We move on with our lives. So we've got 1, 2, 3, 4, 5, 6-- six computer objects here in our computer name array. So if we just hit F8 to populate that array, populate that variable in our PowerShell session, you've now got this computer names array. We can just spit it out to the terminal there. Or we can grab the built-in count property in PowerShell, which tells us how many items are in the array. So there's six items in the array.

3:26So if we are on item number two out of six, that's 33% done. If we're on item four out of six, that's 66% done, et cetera, et cetera. So how do we use the BurntToast PowerShell module to indicate the progress of this long running task? Well, basically, what we need to do is, first of all, we need to calculate the percentage of the completion. So basically, what we would do is for each item in the computer names array, we would grab the first computer name and operate on that one, then go to the next one and so on and so forth.

3:59So for-each is just a nice looping construct in PowerShell. And in order to calculate the percentage of completion, we need to take the index of-- we have this method on arrays in .NET or in PowerShell in this case-- index of the current item, which is the dollar item variable here in my for-each loop. And we need to add one because if we do index of the first computer here-- let's actually just grab that, say computernames.indexofdesktopx.

4:33Then you'll see that we get a 0. And that's because arrays in most programming languages are zero-based. However, we have six items. And so we need to start at 1-- 1, 2, 3, 4, 5, 6-- to get our percentage complete. So what we need to do is basically just add 1 to the index of the current item. So on the first item, instead of giving us a 0, it'll give us a 1 instead. So that way, when we divide by the total number of computers in this list, computernames.count, we'll get an accurate portrayal of the percentage.

5:08So now as it pertains to the BurntToast module specifically, we're going to be going back to the new BurntToast notification command instead of using submit BT notification as we looked at in the previous video or working with context menu items. Now the new BurntToast notification command has yet another parameter here called Progress Bar. And the Progress Bar parameter expects an array of progress bar objects, adaptive progress bar objects. I don't know why that's the type name, but it has something to do with the core Windows APIs that are being wrapped by this module.

5:42So in order to generate one of those adaptive progress bar objects, we need to use another command in the module called new BT progress bar. So if we do Get Command, module BurntToast as usual, we'll see that there is a command called new BT progress bar. So as we start typing out that command, new BT progress bar, and put a dash, you can see that there are a few different parameters that are available on it. So value is going to be our current percentage of completion.

6:15And then value display is going to be the total number of objects that we are operating on. So in this case here, our value display is going to be computernames.count, and that's going to give us in this case because we have six array elements in the computer names variable. And then because we've already calculated the percentage and assigned that to a variable called $percent, I can simply pass that in to the value parameter. Now the progress bars do you have a custom title on them as well. So you can just use the title property there.

6:47And then you can also provide a custom status for the current state of the process. So we looked at earlier .NET string formatting in PowerShell and how we can create dynamic strings in, I think, the third video in this skill, where we created our first notifications using the BurntToast module. And what we're doing is we're basically constructing this dynamic string where we're passing in the current item that we're iterating on in the for-each loop in PowerShell. So we're basically just going to substitute in the computer name that we're currently operating on into the string template here.

7:21So that's going to give us a progress bar object, and then we just pass that progress bar object into the new BurntToast notification. Now there is a specific parameter I want to call out here, and this is called unique identifier. So BurntToast has a unique identifier parameter so that you can update the status of an existing notification. So if we were to leave that parameter off-- and I'm also going to tack on the silent parameter to repress the audio from occurring even though I have it muted. Just a good practice because when we do this for-each loop, we're going to be triggering lots of different notifications.

7:55So if I just hit F5 on that, you'll see in the lower right hand corner of my screen here that we are getting separate-- it won't be obvious right here, but when we open up the Action Center, you'll see this. We're actually getting separate notifications for each of the computer objects that is being, quote, "cleaned up" in this instance. So if I hit Windows A, pop open the Action Center, and just scroll up here, you'll see that each computer account that we're iterating over is actually generating a whole notification of its own.

8:27So what we want to do is actually reduce that duplication in this case. And instead, what we want to do is consolidate all of those into a single notification that gets updated as the process continues. So I'm just going to hit clear all notifications so that we can start fresh here with no notifications in the Action Center. So now let's go ahead and do Control--Z to bring back that unique identifier parameter. And you can really call it whatever you want to. It's basically just a unique name for this particular task.

8:58If you're running lots of tasks simultaneously, you probably want to use some kind of dynamic naming convention where you have a randomized identifier for each one of those. But I'm just calling this one clean up for now. And then let me change the interval here to 1,000. So I'm basically just using a start sleep command to kind of emulate a slower running ask. Let me actually do 1,500, 1.5 second. So if I hit F5 and rerun this, now that we've brought this unique identifier back, you'll see what changes here is that now, we have, in the Action Center here, instead of having a brand new separate notification, we're actually just updating the one notification that we have here.

9:39So we've kept this a lot cleaner. And even though we're still displaying new notifications each time, it is ultimately behind the scenes updating just that one. I'll Windows Escape here, close my magnifier. And I just wanted to kind of show you just an introduction to the progress bar. This is a really nice bit of functionality in the BurntToast PowerShell module that, as I understand it, I think this is a fairly new capability. So anytime that you're building out some kind of long running script that's going to run for maybe several minutes or maybe even several hours in some cases-- maybe you're building out a report, and you're pulling queries from different databases and merging data together.

10:15And you want to kind of get an idea of where your script of that and the process. Consider using BurntToast progress bars to help you accomplish that. I hope this has been informative for you, and I'd like to thank you for viewing.

0:04Hi, guys, and welcome back. So in this final video, I just wanted to review what we've learned in this particular CBT Nuggets skill. So we took a look at the very beginning at the BurntToast module. We looked at the GitHub repository where that module is being developed as an open source project. And one of the great things about open source projects is that you can get involved in those projects. So if you have ideas for feature requests in the BurntToast PowerShell module or maybe you come across a bug and something doesn't quite work the way that you expect it to or maybe when you pass in the right parameters or what you think are the right parameters, you get an error message, and you get a bunch of ugly red text on your screen, and you're like, hey, why is this happening, you can ask questions there.

0:48The PowerShell community is actually very welcoming and very helpful, so definitely rely on those people in the community to help you out. You can also post issues on services like Stack Overflow. So if you have a question about how to use BurntToast, instead of starting a discussion over on the GitHub repository, you might want to go ahead and document that over on Stack Overflow, since that is a really popular Q&A site for software developers and engineers. So we took a look at the module, the module project page.

1:19We also looked at the PowerShell Gallery, where powershellgallery.com hosts a whole bunch of third party modules as well as vendor supported modules from services like Microsoft and Amazon Web Services and Google Cloud and lots of other very popular software tools out there in the ecosystem. And then we took a look at how to actually install the PowerShell module in our local PowerShell session using Visual Studio code and PowerShell Core addition on the Windows 10 platform. Then we dived into how to create some really basic notifications.

1:51We started out with just some static text. And then we got a little bit more advanced by creating dynamic text and adding headings to our notifications as well as things like how to suppress the notification prompt from showing up. But it can just go directly to the Action Center. Then we dived in some more advanced notification concepts-- things like how to create idles to add to our notifications as well as applying custom sounds to our notifications as well to override just the default sounds in the Windows 10 platform, which can get a little boring after a while.

2:27Nice to have some choices in what kind of indicators you're presenting as part of your notations. We also took a look at how to add some custom buttons, how to do snoozing of alarms to remind you about upcoming events or things like that. Then we took a look at how to create context menus that you can add custom functionality into your notifications. And then finally, we took a look at how to create progress bars so that you can apply progress bars and get a status update very easily right there in your Action Center as to where your long running tasks are at [INAUDIBLE]..

3:01So I hope this has been an informative skill for you. If you guys have any feedback, feel free to leave a comment. And make sure that you use those voting buttons on each of the videos to thumbs up or thumbs down depending on what your opinion was of this training content. Feel free to hit me up on Twitter at pcgeek86 or head over to my personal website as well, where I talk a lot about PowerShell and a lot of different techniques that you can apply to the PowerShell framework. I hope this has been informative for you, and I'd like to thank you for viewing.