Category Archives: PowerShell

Eric Ligman’s FREE Microsoft eBook Giveaway–Revising the download script

Every year, Eric Ligman, director of Sales Excellence for Microsoft, creates a blogpost in which he gives away tons of FREE Microsoft eBooks. This year has 361 in the list.

You name it, it’s in the list. SQL Server, Azure, PowerShell, .NET, BizTalk, SharePoint, Windows Server, and more. You can find Eric’s post at:

https://blogs.msdn.microsoft.com/mssmallbiz/2017/07/11/largest-free-microsoft-ebook-giveaway-im-giving-away-millions-of-free-microsoft-ebooks-again-including-windows-10-office-365-office-2016-power-bi-azure-windows-8-1-office-2013-sharepo/#comments

While there are individual links to each file, what if you want every one of them? He explains on the post why he doesn’t provide a big zip file. He does, however, provide a PowerShell script (attributed to David Crosby) that will do the job.

However, I found some issues with the script. Not that it didn’t work, it did, but there were several things I felt could be done to improve it.

First, there was no progress message issued during the download. As a user, I had no idea which file I was on, so had no concept of how much longer it would take. Thus, I’ve added a little progress message.

I then thought “Hmm, what if my downloads were interrupted, I don’t want to have to start all over”. So, I added some code that sees if the file we’re downloading already exists. This way it won’t re-download a file it already has.

But then another problem arose. What if it had partially downloaded a file? Just checking the file names wouldn’t catch that. So I added further code to compare the file size at the source with the file size on disk. If different, then it will re-download.

So far so good, now it will skip the file only if the file name is already on the local disk, and the file sizes match.

I now encountered my next concern. Crappy internet. I live out in the country, and while I love my privacy and rural living, my internet sucks. It is prone to go down or drop packets. If it had issues during a  download I didn’t want it to crash, but instead go onto the next file.

Thus I added a try/catch error handler, which displays an error message and continues on.

At this point I thought I was done. Just I was about to call it finished though, a typical afternoon Alabama thunderstorm came up. Kaboom! House rattled and power blinked.

This presented my final concern, what if the power went out? I’d want to know where it got to with the downloads. So I added some further code such that when the downloading starts it creates a new log file and appends each message to it.

I realize some of you have superfast gigabit internet and will be able to download these almost instantly. (I hate you by the way. #jealous). Therefore I made logging optional, so it wouldn’t create an extra file if you didn’t want it. Just set the $log variable to $false, and it will skip logging.

So there you go, a revised download script that will handle stopping and restarting the script gracefully, will look for errors, and adds logging so you can track progress.

You’ll find the revised script on my GitHub site, in the PowerShell folder:

https://github.com/arcanecode/PowerShell

Just look for the file “Eric Ligmans Microsoft eBook Giveaway Revised Download Script.ps1

There’s also a readme style file by the same name, which echoes this blog post.

Advertisements

What happened to Save-AzureRmProfile?

I’ve been working a lot in the Azure PowerShell area of late. One thing I wanted to be able to do is have my scripts login automatically to Azure. In many examples the cmdlet Save-AzureRmProfile was used to save your Azure credentials, then later you could use Import-AzureRmProfile to import them.

But, when I attempted to run Save-AzureRmProfile I got the error ‘Save-AzureRmProfile is not recognized as the name of a cmdlet, function, script file, or operable program’.  Huh? I checked the docs, and it does include a listing for Save-AzureRmProfile.

https://docs.microsoft.com/en-us/powershell/module/azurerm.profile/save-azurermprofile?view=azurermps-3.8.0

This is a case of the PowerShell AzureRM module getting ahead of the docs. After beating my head against the wall, I found the cmdlets had been replaced with the new noun of AzureRmContext.

To use them, first login to Azure manually. Then, use the new Save-AzureRmContext to save your information to a file.


# Setup – First login manually per previous section
Add-AzureRmAccount

# Now save your context locally (Force will overwrite if there)
$path = "C:\Azure\PS\ProfileContext.ctx’
Save-AzureRmContext -Path $path -Force

Once that’s done, from then on you can use the Import-AzureRmContext to automate the login.


# Once the above two steps are done, you can simply import
$path = C:\Azure\PS\ProfileContext.ctx’
Import-AzureRmContext -Path $path

Be warned, this does present a security issue. If someone were to steal your context file, they could then login as you. You need to be sure your context file is stored in a safe location no one can get to.

IT ops and news talk–Episode 3 Secure that Jump Server

I owe everyone an apology, I missed blogging about this at the time it occurred. Last December I was a guest on Don Box’s podcast, “IT ops and news talk”. I appeared on Episode 3, Secure that Jump Server.

In the podcast we discuss the testing of PowerShell code with Pester. After that we got into an interesting discussion on the current state of DevOps. Give it a listen I think you’ll enjoy, it’s about half an hour in length. Don is a great interviewer it was a lot of fun.

As a follow on to the discussion, you might want to learn more about Pester. I have a complete course on the subject in my Pluralsight course Testing PowerShell with Pester. If you don’t know anything about PowerShell, but want to learn, then I’d suggest my Beginning PowerShell Scripting for Developers. Note that even though it says “…for Developers” we don’t mean programmers (although it could), instead it refers to people who wish to develop scripts in PowerShell.

What? What was that? You in the back row waving your hand? You say you don’t have a Pluralsight subscription? Hey, no problem. Just email me, free <at> arcanetc.com and I can send you a code good for 30 days of free access to Pluralsight, with which you can watch not just my courses, but any course from Pluralsight’s library of over 5,000 courses.

PowerShell Book Suggestions from IT/Dev Connections

In my session today at IT/Dev Connections in Las Vegas, several people asked me for book recommendations on PowerShell in general, and DSC (Desired State Configuration) in particular.

The book I’ve used for a while is from APress, Windows PowerShell Desired State Configuration Revealed.

I found a second DSC book today, Learning PowerShell DSC. To be honest I just found it, but from looking over the table of contents it looks pretty nice. I’ll report back later when I’ve had time to go over it in more depth. (Disclaimer, the publisher this book is also the publisher of my upcoming book, otherwise I don’t have any other affiliation).

A good all around yet deep book is PowerShell In Depth. Two of the authors, Don Jones and Jeffery Hicks, are here with us at IT/Dev Connections. Note the link is to the paper version, if you want the Kindle / iBooks / PDF version you’ll have to go directly to the publishers website. 

Finally, if you are seeking something that would be a fast read but still provide great value, I’d suggest “Learn PowerShell in a Month of Lunches”. The next version will be out in December of this year, but if you can’t wait, you can find the current version here. As with the previous recommendation, you can get the electronic version from the publishers website.

ArcaneCode–Headed your way!

I’ve not done much blogging, as I’ve been swamped with other activities. In addition I’ll be doing quite a bit of speaking, so let me catch you up.

Recently I did a webinar for Pluralsight, “Why you should invest in PowerShell”. If you missed it the recording is now up, take a look, it’s free!

http://go.pluralsight.com/C0010781

Next, I just completed the first draft of my fifth book, SQL Server 2016 Reporting Services Cookbook. I’m coauthoring with another MVP and great guy, Dinesh Priyankara. The book is available from PACKT Publishing in Alpha form.

https://www.packtpub.com/big-data-and-business-intelligence/sql-server-2016-reporting-services-cookbook

I’ll make my debut appearance at IT/Dev Connections next week. I’ll be doing two sessions, the first is on October 11th, 2016: Zero to Hero with PowerShell and SQL Server. We’ll begin with a quick overview of PowerShell, then dive into using it with SQL Server. You’ll see examples of using it for both maintenance and development tasks.

The next day is my second session is “So You Think MDX is Hard?”. This is for people who are new to MDX, and want to learn. You’ll see how to start from no knowledge all the way to building calculated members and sets.

If you’ll be at IT/Dev Connections feel free to come by and say hi, would love to meet as many as possible.

As if that’s not enough, on Saturday October 15th 2016 I will be at the DevSpaces Conference in Huntsville AL. At 4pm I’ll be presenting “High Class PowerShell: Objects and Classes in PowerShell”. You’ll see how to create your own classes using PowerShell. We’ll cover techniques valid in PowerShell versions 3 and 4, as well as see how the new class types in PowerShell version 5 work.

As they say on TV, but wait! There’s more!

On November 1st 2016 I will be coming to Atlanta to the Atlanta SQL Server BI user group. My presentation “Shiny and New: SQL Server 2016 Reporting Services” should be a lot of fun, and introduce you to the new features in SQL Server 2016.

Whew! There’s two more Atlanta based events in Nov/Dec it looks like I’ll be at, once those are finalized I’ll let everyone know.

I’ve also established a GitHub repository for my various samples. You’ll find it at https://github.com/arcanecode. As I move forward I’ll keep this repository updated.

Zero to Hero with PowerShell and SQL Server–Precon at DevDataDay

{dev = data} DAY Birmingham 2016Are you looking to learn about PowerShell? Do you use SQL Server? Then boy have I got a bargain for you!

I’m doing a precon for our upcoming devdataday event. The precon will take place on Friday, August 19th, the day before devdataday.

This is designed to be a course for the PowerShell novice. No prior knowledge required! I’ll start the day with an introduction to PowerShell, basic usage and cmdlets. Next we’ll dive into programming scripts in PowerShell, starting with the basics of loops, conditional logic, and functions. We’ll move into advanced topics, including creating your own reusable modules and testing them.
The real meat of the day comes next, learning how to interact with SQL Server from PowerShell. Both the SQL Provider and SMO (SQL Management Objects) DLL library will be covered in full. Most importantly you’ll learn how to read the online SMO library documentation and how to convert the examples into PowerShell syntax. The day will culminate by building a reusable module for working with many SQL Server common tasks, such as T-SQL code generation, or performing health checks on your servers.
The day will wrap up with a look at Pester, the new open source PowerShell testing tool. You’ll see how to test all the code you generated during the day. Don’t be left behind, learn how to leverage the power of PowerShell in your SQL Server environment.

To register, just go to https://devdatadaypowershellprecon.eventbrite.com/

Updating and Sorting the Microsoft Word QuickStyle Gallery with PowerShell

 

Introduction

I’m currently working on my fifth book, this one is for the folks at PACKT Publishing. It’s still in the early stages so I can’t say too much, but if you like SQL Server Reporting Services, you’ll enjoy this book.

All book publishers use their own set of styles in Microsoft Word to allow them to control the layout of the book when it goes to print. There will be special styles for italics, bold, code listings, and more. The techniques here though are applicable to more than just book or magazine publishers.

You’re company may have a limited set of styles it approves for use in internal documents. Perhaps you need to adjust your set of QuickStyles based on what type of document you are authoring. One set for company memos, another for technical documentation, and yet another set of styles for love letters.

Using the PowerShell script in this post can make it easy for you to setup your QuickStyle gallery based on the type of document you are creating.

When working on the book it’s been convenient to clear out the list of built in styles in the QuickStyle gallery, and replace them with the ones I need for my publisher. Doing it manually though is a time consuming process.

Unfortunately I experienced further oddities. Every time I got a chapter back from my editor, my curated list of styles had been replaced. I don’t think it’s anything my editor did deliberately, she’s a really nice lady. I believe it’s some quirk of Word, related to the fact we appear to be on different versions. I knew I couldn’t keep sucking up time adding, removing, and sorting these each time I got a chapter back. I needed a way to automate.

I did some looking online, but couldn’t find a total solution that fit my needs. I found some VBA code for adding and removing styles from the QuickStyle gallery, but nothing on how to sort items in the gallery.

Being the geek I am means I love PowerShell. So I rolled up my sleeves and dove into the Microsoft Word object model. Specifically, I focused in on the Style object.

I’m a firm believer in the adage that you should completely understand any script you cut and paste off the web. So while I’ll place the complete script at the bottom of this post for easy copy / paste, I’ll step through it first to explain the various components.

Before I proceed, one important note: updating the QuickStyle gallery using the code below only updates one specific document. Other existing Word documents, or new documents you create, won’t be affected by this script.

1. Set a variable to hold the file name to update.

$wordFile = 'C:\Book\Chapter02.docx'

I start by setting a variable to hold the file name of the Word document I want to update. At some point I’ll probably turn this into a module and make this a parameter to the main routine, but for today this gets the job done and is easy for people who also want to use the script.

2. Back up the file.

$bakfile = $wordFile + '.bak'
Copy-Item -Path $wordFile -Destination $bakfile -Force

 

The next thing I do is make a backup. First, if something happens I want to be able to go back. Second, you should always backup before doing something like this, so making it built in prevents issues (as well as avoiding nasty comments on this post). Winking smile

3. Load an array with your desired styles.

$myStyles = @( 'Normal [PACKT]',
               'Numbered Bullet [PACKT]',
               'Screen Text [PACKT]',
               'Code In Text [PACKT]',
               'Code Within Bullets [PACKT]',
               'Code listing [PACKT]',
               'Italics [PACKT]',
               'Figure [PACKT]',
               'Chapterref [PACKT]',
               'Bold [PACKT]',
               'Heading 1,Heading 1 [PACKT]',
               'Heading 2,Heading 2 [PACKT]',
               'Heading 3,Heading 3 [PACKT]',
               'Tip [PACKT]',
               'Layout Information [PACKT]',
               'Figure Caption [PACKT]',
               'Part Heading [PACKT]'
             )

Next up, I load a list of the styles I want to place in my QuickStyles. Also, the array should have the styles in the order you wish them in the gallery. This list is specific to the styles I use most frequently on this project. To see the complete list of available styles within your document, open up Word and load your document. On the bottom right of the QuickStyle gallery is a little button that will bring up the style list.

SNAGHTML3fa2582

Once open, you’ll see a list of all the styles available in this document. Here’s the top of the list, scrolling down will reveal a LOT of styles.

image

The names that appear in here are the ones that you’d use in the array. Just type them into the array declaration exactly as they appear in the Styles list.

4. Load up style type enumerations.

# Load up the style type enumerations.
$wdStyleTypeParagraph = 1  # Paragraph style.
$wdStyleTypeCharacter = 2  # Body character style.
$wdStyleTypeTable = 3      # Table style.
$wdStyleTypeList = 4       # List style.

When we set the property to place something in the QuickStyles gallery, we have to be careful as only certain types of styles may appear in the QuickStyles area. We check this using a property of the Style object called Type, which has several enumerations. While I probably could have loaded the enumerations from the class, sometimes simple is good. Since the values for the enumerations were easily found in MSDN, I just replicated them as variables in PowerShell.

In this script we only use two of them, but for completeness I listed them all should I (or you) ever want to reuse this script as a basis for other Word work with PowerShell.

5. Create a new instance of Word.

$word = New-Object -ComObject Word.Application

The next step is pretty simple. All we do is create a new object of type Microsoft Word, and put a reference to it in the $word variable. Creating the new Word object is akin to opening up Word without a document in it.

6. Make Word visible.

$word.Visible = $true

This next step is optional. By default, when you create a new Word object it is not displayed to the user. If you are applying this to a whole batch of Word documents, I’d omit this step as it will slow down the process. For just one document though it’s not much of an impact. And to be honest, it’s pretty cool to watch Word as it removes then adds the styles.

7. Open the Word document to update.

$doc = $word.Documents.Open($wordFile)

This is probably an obvious step, but we need to load the document we want to update into our Word object. The Open method returns a new variable of type Document (MSDN). The $word variable represents Microsoft Word, the $doc variable represents the specific DOCX file (or DOC) that we want to update.

8. Reset all styles to remove them from the QuickStyles; additionally reset their priority.

foreach ($sty in $doc.Styles)
{
  # Only these two types can be QuickStyles
  if ( ($sty.Type -eq $wdStyleTypeCharacter) -or ($sty.Type -eq $wdStyleTypeParagraph) ) 
    { $sty.QuickStyle = $false }
  
  $sty.Priority = 100
}

This next section is important to understand. The document has a collection of Style objects, stored in the Styles collection. We start by looping over each Style in the document.

Each Style object has a property named QuickStyle, which has a value of true or false. This flag sets whether a style should appear in the QuickStyles gallery (true) or not (false). If you recall from the enumerations section above, there are some styles that cannot be in the QuickStyle area. If we were to attempt to set the QuickStyle property on these, we would get an error (even if setting it to false). Hence the need to check the Type property and only attempt to set the QuickStyle property for those Styles who can appear in the QuickStyle list.

The real challenge in terms of investigation came in ordering the styles within the QuickStyle area. To order them manually, start by clicking the lower right button on the styles dialog.

image

When the Manage Styles window appears, click on the Recommend tab.

image

 

To the left of each style name, you see a number or the word “last”. This number represents the order in which it will recommend styles to you. In other words, the order in which they will appear in the QuickStyles gallery.

With the buttons at the bottom you can rearrange the order in which they appear. Note, it is possible to have multiple styles with the same value. If that happens Word will arrange all styles with the same recommended value alphabetically. The word “last” simply tells Word to put these styles at the very end of the QuickStyles gallery.

It took a lot of research, but I finally figured out the “Recommended” value is contained in a property called “Priority” within the Style object. The word last is represented by the value 100, giving a valid range of 1 to 100 for Priorities.

In the above code I am setting all styles, even the styles built into Word, to 100 which is the equivalent of ‘last’. For my situation this is fine, as I’m only going to be using this specific set of styles in this specific document so I don’t really care about the built in ones. Even if I changed my mind later, all I would need to do is add the built in styles (or any new ones I create) to my array and rerun the script.

At this point then we’ve removed all styles from the QuickStyles gallery, as well as set their priorities to ‘last’. Now it’s time to add the styles we want and order them.

9. Add our desired styles to the QuickStyle gallery and order them.

$priority = 1
foreach ($mySty in $myStyles)
{ 
  # Setting to true will make the style appear in the QuickStyle gallery
  $doc.Styles($mySty).QuickStyle = $true
  # The priority is an integer which determines the sort order within the QS gallery
  $doc.Styles($mySty).Priority = $priority++
}

With this next code, we are going to add our list of styles as well as sort them. It starts by setting the starting point for our Priority (the order) to the value 1, our starting point.

We then enter a foreach loop, where we iterate over each style in the array we assembled back in step 3. Within the loop, we set the QuickStyle property to true. Naturally I’ve only placed style names into the array that are allowed to be in the Style gallery. If you have doubts you could add a check against the Type property, as we did in Step 8, before setting the QuickStyle property.

Note that the Styles collection allows us to address a style by passing in the name of the style. When you assemble the array then, it is important to match the name that appears in Word exactly so it can find it in the array.

Next up is setting the Priority. Again, the Priority is the order in which styles are displayed in the gallery. After assigning the value I use the ++ operator to increase the value for the next iteration of the loop.

Note that since I have far less than 100 items, I don’t have any error checking for exceeding the 100 mark. If you have more than 100 styles for your QuickStyles you’ll need to modify this code. Although quite frankly if you have more than 100 styles in your QuickStyles, it’s not really that quick and you should probably rethink your editing habits. Winking smile

10. Save your work.

$doc.Save()

As the next to the last step, we’ll have the script go ahead and save the document.

11. Close Word (optional).

$doc.Close()

If you modified this script to work in a big loop so you could batch updates, or perhaps you will just want to apply the fix and go on, you could have the script go ahead and close Word. On the other hand, if after applying the updates to the style gallery you’ll immediately want to start editing, just comment out this last step. 

Summary

A final note to close this out, I’ve tested the script with Word 2016 and PowerShell 5.0. From the documentation in MSDN the same techniques also apply to Word 2013. I’ve not tried it on previous versions of Word, but in theory it should work all the way back to the version in which the QuickStyle gallery was introduced. If you’ve tried it on an older version let us know the results by posting a comment below.

Additionally, while I’ve written this on PowerShell 5.0 I’m not doing anything new or unusual, it should work as far back as PowerShell 3.0.

Below is the script, complete with comments to act as a reminder of the explanations above. Just copy and paste, modify the $wordFile and the $myStyles array, and you should be good to go.

 


The Script

<#-----------------------------------------------------------------------------
  Updating and Sorting the Microsoft Word QuickStyle Gallery, ArcaneCode style!

  Author: Robert C. Cain | @ArcaneCode | arcane@arcanetc.com
          http://arcanecode.com
 
  This script is Copyright (c) 2016 Robert C. Cain. All rights reserved.
  No warranty or guarantee is implied or expressly granted. Use at your own
  risk. 

  This script may not be reproduced in whole or in part without the express
  written consent of the author. 
-----------------------------------------------------------------------------#>

# Set the path / file name of the file you want to update
$wordFile = 'C:\Book\Chapter02.docx'

# Make a backup before we do changes. Note if the BAK exists it will be overwritten
$bakfile = $wordFile + '.bak'
Copy-Item -Path $wordFile -Destination $bakfile -Force

# Create an array of the styles you wish, in the order you want 
# them to appear in the QuickStyle area 
$myStyles = @( 'Normal [PACKT]',
               'Numbered Bullet [PACKT]',
               'Screen Text [PACKT]',
               'Code In Text [PACKT]',
               'Code Within Bullets [PACKT]',
               'Code listing [PACKT]',
               'Italics [PACKT]',
               'Figure [PACKT]',
               'Chapterref [PACKT]',
               'Bold [PACKT]',
               'Heading 1,Heading 1 [PACKT]',
               'Heading 2,Heading 2 [PACKT]',
               'Heading 3,Heading 3 [PACKT]',
               'Tip [PACKT]',
               'Layout Information [PACKT]',
               'Figure Caption [PACKT]',
               'Part Heading [PACKT]'
             )

# Load up the style type enumerations.
$wdStyleTypeParagraph = 1  # Paragraph style.
$wdStyleTypeCharacter = 2  # Body character style.
$wdStyleTypeTable = 3      # Table style.
$wdStyleTypeList = 4       # List style.

# Create a new instance of Word
$word = New-Object -ComObject Word.Application

# This is optional, if set it will display Word and let you watch the fun
$word.Visible = $true

# Open the document you wish to reset the styles for
$doc = $word.Documents.Open($wordFile)

# First, reset all styles to not be Quick Styles, 
# and set the priorty to 100 (which will be 'last' in Word)
foreach ($sty in $doc.Styles)
{
  # Only these two types can be QuickStyles
  if ( ($sty.Type -eq $wdStyleTypeCharacter) -or ($sty.Type -eq $wdStyleTypeParagraph) ) 
    { $sty.QuickStyle = $false }
  
  $sty.Priority = 100
}

# Now set the styles like we want 'em!
$priority = 1
foreach ($mySty in $myStyles)
{ 
  # Setting to true will make the style appear in the QuickStyle gallery
  $doc.Styles($mySty).QuickStyle = $true
  # The priority is an integer which determines the sort order within the QS gallery
  $doc.Styles($mySty).Priority = $priority++
}

# Save the document. 
$doc.Save()

# Close up word (Optional, if you want to start editing 
# right away you can comment this out)
$doc.Close()

I have to give a shout out to the folks at Sapien for their PowerShell Studio tool. It has a great feature, Copy HTML, which takes pieces of PowerShell code, copies it to the clipboard and in the process adds the appropriate HTML tags to do the nice coloring.