Microsoft Power Automate (Microsoft Flow)

Zip File Support in Power Automate is fairly limited. There are actions to extract files from an archive, but no support for creating your own zip files.

I’ve written before about a method to create Zip files in Power Automate for free using SharePoint.

The SharePoint method described worked, but did not provide any file compression, only stored the requested files. If you need compression, the only option until now, is to use a 3rd party connector but that generally means paying a monthly fee and data leaving your environment.

In this post I will demonstrate a new method for working with Zip Files which uses a custom C# connector, to easily create Zip files in Power Automate or extract files from them.

The key features are:

• You will not have to pay any monthly subscription to an API service.
• The data will not leave your Office 365 environment.
• You can create Zip Files easily.
• You can extract data from Zip files without having to extract the contents to OneDrive or SharePoint first

N.B. Custom connectors require a Power Automate Premium License. So, if you do not have one, this solution is not for you.

Introduction to the Zip Connector

Here is a screenshot of the available actions:

Summary of the actions available:

• Create a Zip File – Will accept an array of files and return a Zip File.
• Extract Zip File Content – Will return an array which contains all the files in the source Zip File (subject to some limitations).
• Extracts a file stored in a Zip Archive – This action extracts a single file from a Zip archive given its path within the Zip.
• List files stored in a Zip Archive – This action returns the list of files contained in the Zip file without the File Content.

Creating a Zip File

Here is the most simple example of the Create a Zip File action in a flow:

The action accepts two Parameters:

• The list of files to be compressed.
• The compression level to apply to the files.

The list of files to be compressed can be manually populated as shown above or provided with a JSON array by clicking on the button to switch to Input Entire Array mode:

This should be an array of objects containing values for Name and Content, like this:

[
  {
    "Name": "Text File.txt",
    "Content": "VGhpcyBpcyBhIHRlc3QgZmlsZQ=="
  },
  {
    "Name": "Text File 2.txt",
    "Content": "VGhpcyBpcyB0aGUgc2Vjb25kIHRlc3QgZmlsZQ=="
  },  
]

The file content is a Base64 representation of the file. I will provide more detail on this in the sample flows below.

Compression level has four options:

• Optimal – Which provides the best balance between compression and the speed of the operation.
• Smallest – Produces the smallest possible Zip file but takes longer to complete.
• Fastest – Provides the fastest operation but the resulting Zip file will be slightly larger.

Optimal would be the best option in most cases.

The output of the action is a base64 representation of the Zip file, which can be used in subsequent actions to save the Zip file or send in an email etc.

Simple Power Automate Flow to Zip a Single File

Below is a screenshot of the simplest example of how this action can be used:

The flow has three actions:

• Get file content, which provides the input for the Zip action.
• The Create a Zip file action which zips the input.
• The create file action which takes the output from the zip action to create the file.

Example Flow to Zip many files

Take a look at the flow below and the explanation that follows:

Step by step explanation

First, use the Initialize Variable to hold the file content of the files that we want to zip.

Next use the Get Files (properties only) action to get a list of files that we want to Zip. I selected the option to Include nested items and added an odata filter of FSObjType eq 0 to return file objects and not folders.

Next add Get file content using path and supply the file path from the dynamic output of the Get Files action. This will automatically create an apply to each loop.

Next add an Append to array variable action. Supply JSON in the format of:

{
  "Name": "",
  "Content": ""
}

For the Name – you can use the dynamic content from the Get Files action. You can also supply the Folder path as per my screenshot if you want the Zip file to retain the paths.

For the content use the output of the Get file content using path action.

Next, outside of the apply to each loop, you can supply the array variable to the Create a Zip file action. Don’t forget to switch the action to entire array mode!

In the final action, I am simply creating a file using the Create File action, using the output from the Zip action. But you could easily change that to a Send an Email action or whatever suits your need.

Example Result

I zipped a SharePoint folder containing 87 files that totalled 55 Megabytes, this resulted in a Zip file of 11 Megabytes.

Password and Encryption Support

The libraries required to create a Zip file with password protection are simply not available in the custom code tool in Power Platform. If you need to create Zip files with Password and Encryption Support I would recommend using Flowr from Encodian.

Working with Existing Zip Archives

Power Automate has two actions for working with Zip Files:

Both of these actions work in a similar way, you specify a source Zip file, a destination folder and it will extract the files for you:

The output from this action is a JSON array of file information which you can then work with to get the file contents, here is some example output:

[
  {
	"Id": "b!Xm9bgFp6o0yRZXE2CnS2bsR4d_A2tk.01CM5RGF5GTCVBUQWV6VGJWZGNKHZ3O3BC",
	"Name": "2k-Rows.csv",
	"NameNoExt": "2k-Rows",
	"DisplayName": "2k-Rows.csv",
	"Path": "/drives/b!Xm9bgFp64d_A2tk/root:/_zip/ZipExtract/Shared Documents/Zip Test/CSV Files/2k-Rows.csv",
	"LastModified": "2024-06-27T07:35:40Z",
	"Size": 140421,
	"MediaType": "text/csv",
	"IsFolder": false,
	"ETag": ""{1AAA98A6-D542-4CF5-9B64-CD51F3B76C22},2"",
	"FileLocator": "b!Xm9bgFp6o0yRZXE2CnS2bsRojWZetglOshpzGJWZGNKHZ3O3BC",
	"LastModifiedBy": "Paul Murana"
  }
]

In many cases the above actions are perfectly adequate, but do require you to write the files out to a folder, and then read them back in again if you want to use the file content in the flow.

The actions included in this connector work in a different way. Instead of extracting the Zip Archive contents to a folder the content of each file in the Zip Archive is returned to the flow for direct use. This makes for a much cleaner flow.

There are three actions for working with Zip archives:

Extract Zip File Content

This action will extract the entire contents of the provided Zip File and return a JSON array of file information and the file content:

Here is a sample of the output:

• All Files Extracted – This informs you that all files were extracted from the archive. This will return false of either the entire size of the output generated would be over 100MB or a single file within the archive is over 100MB.
• File Count – The number of files extracted.
• Files – An array which contains the File information and file data:
  • Filepath – The path of the file within the Zip File.
  • FilenameWithExtension – Just the Filename without the path.
  • FolderPath – The path of the file within the Zip without the File name.
  • FileContent – The base64 representation of the File.

The files array can be used in any action that can handle arrays, such as an apply to each loop, a select action or a filter array action.

List files stored in a Zip Archive

This action is the same as the Extract Zip File Content action except it does not return the file content. This is designed so that you can examine the content of the Zip file and then extract specific files with the Extract File action. Example response:

[
  {
    "Filepath": "test file.txt",
    "FilenameWithExtension": "test file.txt",
    "FolderPath": "",
    "FileSize": 14,
    "OverSizeLimit": false
  }
]

The output includes an additional property called OverSizeLimit, if the file within the archive is over 100MB this will be true and you will be unable to extract it as it will be over the maximum size of an action that Power Automate allows.

The array of output can be filtered so that you can extract only the files you want to access. You can then use the Extract File action on each file you want to extract.

Extract a file stored in a Zip Archive

Once you have used the List Files action to list the contents of a Zip File, you can then use this action to extract each file from the archive:

The output array of the List Files action can be used as the input for an Apply to each loop and then each file can be extracted from the Zip. Note how the Zip File Content content is the same for both actions.

Limitations

Power Platform Custom Connectors are limited to an execution time of five seconds. This means that if you supply the connector with too much data it will fail.

The connector also returns an additional header of x-processingtime which tells you how long the operation took to process, you can see this in the raw outputs or with an expression:

outputs('Create_a_Zip_file')?['headers']?['x-processingtime']

This will tell you how many milliseconds the operation took, the maximum allowed being 5,000.

Purchase this connector

If you would like to use this connector in your own environment, you can purchase it from Gumroad. You will receive an Zip file containing a solution which you can import into your environment which will make the custom connector available.

---

How to Import the connector

After you have purchased the connector from Gumroad, importing it is easy:

• Go to https://make.powerautomate.com/
• Select Solutions from the left hand menu:
  
• Click on Import solution from the top menu:
  
• Click on the browse button and upload the Zip solution file.
• Click Next.
• Click on Import.
• The solution will now import. This normally takes a few minutes. Then the action will be available in your flows under the custom tab:
  

Conclusion

This connector provides a really neat way to add Zip functionality to your flows. Crucially your data does not leave your environment and uses only tools already built into your environment.

You will not have to pay a monthly fee to produce Zip files, just a simple one time purchase:

Please let me know in the comments how you get on and if you have any feedback.

When using the SharePoint Update Item action in Microsoft Power Automate it forces you to enter values for mandatory columns. For lists with many columns this can be a long process if you only want to update a few fields. Example:

This list item contains a number of fields:

Field Name	Type	Mandatory
Name	Single Line of Text	Yes
Department	Single Line of Text	Yes
Gender	Choice	No
Marital Status	Choice	No
Status	Multiple Selection Choice	No
Homepage	Hyperlink or Picture	No

If you want to be able to update one or more of those fields without supplying the information for every field, there is an easy way to do it.

The Update Item Trick

The update item action helpfully retrieves the column information from SharePoint for us to give us the fields to fill in. Most of the time, this is what we want. But here is how to force it so that it cannot do that.

Simply Create a Compose action and type the name of your list into it. Then create an Update Item action, choose your SharePoint site as normal, but for the list name choose Enter Custom Value and from the dynamic content panel choose the output of your compose action:

Now your Update Item action will not suggest any columns at all and you must supply this information manually:

Updating the SharePoint List Item

Our example list has a bunch of different column types and they are all updated in a slightly different way. So I will give examples of how to update each type, and then update multiple fields in a single request.

Single Line of Text

The single line of text field is the easiest to update. Simply supply the field name and the new value, like this:

{
  "Title": "Paulie"
}

Hyperlink

With the hyperlink we need to first supply the field name, and then the URL and description.

{
  "homepage": {
    "Url": "http://tachytelic.net",
    "Description": "somesite"
  }
}

Single Choice Column

The single choice column can only take a single value. So, only the field name and value are required.

{
  "Marital_x0020_Status": {
    "Value": "Common-Law"
  }
}

Multi Choice Column

The multi choice column must be supplied with an array of values, so an example would look like this:

{
  "Status": [
    {
      "Value": "Subscribed"
    },
    {
      "Value": "Liked"
    }
  ]
}

Updating Multiple Columns

If you want to update multiple values, you can easily combine the examples above, like this:

{
	"Title": "Paulie",
	"homepage": {
		"Url": "http://tachytelic.net",
		"Description": "somesite"
	},
	"Marital_x0020_Status": {
		"Value": "Common-Law"
	},
	"Status": [{
			"Value": "Subscribed"
		},
		{
			"Value": "Liked"
		}
	]
}

Conclusion

So, as you can see from the above, by supplying the JSON directly to the Update Item action, you can easily update columns without having to supply the information for every other column again.

Hope this helps.

This post describes how to merge two separate arrays that contain a common value. My friend Tom Riha recently wrote a good post on how to do this. His method will work well for a small dataset, but for a large array it would be quite time consuming as it uses an Apply to each loop.

I also did a video on this subject in response to the a question on the Power Automate Forums:

The Example Data

We are going to combine two arrays, here is the first one:

[
    {
        "Name": "Tom",
        "Country": "CZ"
    },
    {
        "Name": "Paul",
        "Country": "UK"
    }
]

The second array:

[
    {
        "Name": "Tom",
        "Age": "younger than Paul"
    },
    {
        "Name": "Paul",
        "Age": "older than Tom"
    }
]

The combined array we want to create:

[
  {
    "Name": "Tom",
    "Country": "CZ",
    "Age": "younger than Paul"
  },
  {
    "Name": "Paul",
    "Country": "UK",
    "Age": "older than Tom"
  }
]

In order to combine these into a single array, we need a common value in each array. In this example the Name key is common to both arrays. We are going to use the powerful xpath expression to perform this in a single step.

Array Preparation

Before we can use xpath, the second array needs to be converted to XML, and before we can do that, we need to do some preparation. Check out this screenshot:

All of the above actions are Compose actions. The step named PrpareArray2 simply wraps the output of Array2 around some additional JSON and produces the following output:

{
  "Root": {
    "Array": [
      {
        "Name": "Tom",
        "Age": "younger than Paul"
      },
      {
        "Name": "Paul",
        "Age": "older than Tom"
      }
    ]
  }
}

Now that it is in the proper format the step named XML converts the array to XML and produces the following output:

<Root>
	<Array>
		<Name>Tom</Name>
		<Age>younger than Paul</Age>
	</Array>
	<Array>
		<Name>Paul</Name>
		<Age>older than Tom</Age>
	</Array>
</Root>

Combine the Arrays

With all of that prep work done, we can begin to actually merge the arrays. See this Select action:

As you can see, all of the work is done in a single select action, but it requires a bit of explanation. The first part is straightforward:

• The input for the select is Array1
• The Keys Name and Country are drawn from Array1 using the item() syntax.
• The Age key is pulled from the XML using the xpath expression.

The xpath expression is easier to read like this:

xpath
(
  outputs('XML'), 
  concat('//Array[Name/text()="', item()['Name'], '"]/Age/text()')
)?[0]

The concat function is used to dynamically create an xpath query by using the name from the current item. So in the first iteration of the loop the xpath expression would be:

//Array[Name/text()="Tom"]/Age/text()

What are we asking xpath to do here:

• Find all of the elements within Array
• Only find nodes within Array where Name is equal to Tom
• Grab the text value of the Age where the Name matched.

You can test this out for yourself by copying the XML above and pasting it into xpather.com – then copy the expression above and you should see results like this:.

xpath will return an array of results, even if there is only a single match, so the final part of the expression is: [0] to grab the first result of the array.

So in a single select action we can combine the arrays easily. In our example we could simply it further by using the addProperty function in the select instead of key/value pairs.

In this example the Select action was changed to text mode instead key/value mode. Then I used the expression:

addProperty
(
  item(), 
  'Age', 
  xpath(outputs('XML'), concat('//Array[Name/text()="', item()['Name'], '"]/Age/text()'))?[0]
)

This simply takes the current item and adds a new property called Age and assigns the value returned from the xpath expression.

Conclusion

Which method should you use and is this method worth the hassle?

It depends on how performance dependant your flow is. If you are only working with a small amount of data, the method Tom shows is easier and will execute quickly.

If you are working with hundreds or thousands of rows of data, then this method will be much faster. It’s always fun to compare different methods of doing the same thing!