Add NVMe Boot Support to a HP EliteDesk 800 G1

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:

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": "https://www.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": "https://www.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!

This post explains how to sort an array of objects in Power Automate. This method only works for objects that contain a numeric value on which to sort.

I have done a previous post on How to Sort an Array in Power Automate using Office Scripts, which works very well, but Office Scripts are not available in all environments.

This example demonstrates how to sort an array of objects using only native Power Automate actions. The question was originally raised on the Power Automate community forums. The original poster actually wants to find only the top three values, which I will also cover.

Sorting in Power Automate

Since there is no method to sort an array, we have to build our own for this purpose, which is surprisingly difficult to do. Here is the sample JSON array which we are going to sort:

[
  {
    "label": "Car",
    "score": 0.26
  },
  {
    "label": "Bus",
    "score": 0.26
  },
  {
    "label": "Train",
    "score": 0.34
  },
  {
    "label": "Boat",
    "score": 0.45
  },
  {
    "label": "Truck",
    "score": 0.62
  },
  {
    "label": "Bike",
    "score": 0.11
  }
]

Notice that both Car, and Bus have the same score. The aim is to sort the array in either descending or ascending order to look like this:

[
  {
    "label": "Truck",
    "score": 0.62
  },
  {
    "label": "Boat",
    "score": 0.45
  },
  {
    "label": "Train",
    "score": 0.34
  },
  {
    "label": "Bus",
    "score": 0.26
  },
  {
    "label": "Car",
    "score": 0.26
  },
  {
    "label": "Bike",
    "score": 0.11
  }
]

Power Automate does have the max and min expressions which can help you find the largest and smallest entries of an array, but there is no way to determine the position of the element within the array.

The xpath expression however, can be used to find the position of an array element, so we can use that to created a sorted array.

Here is an example flow, which I will explain further below:

To implement this flow for yourself, you need to Initialize two variables. One called ArrayOfObjects which contains the array you want to sort and a second one called Sorted – which should be empty.

The flow works by first finding the position of the highest or lowest values from ArrayOfObjects and then:

• Inserting each value into the new array.
• Removing the found value from the original array.

You can copy the scope and paste the entire thing into your own flow by copying the code below:

{
  "id": "4c808717-bb30-4633-94fa-2af031ee4cdc",
  "brandColor": "#8C3900",
  "connectionReferences": {},
  "connectorDisplayName": "Control",
  "icon": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzIiIGhlaWdodD0iMzIiIHZlcnNpb249IjEuMSIgdmlld0JveD0iMCAwIDMyIDMyIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPg0KIDxwYXRoIGQ9Im0wIDBoMzJ2MzJoLTMyeiIgZmlsbD0iIzhDMzkwMCIvPg0KIDxwYXRoIGQ9Im04IDEwaDE2djEyaC0xNnptMTUgMTF2LTEwaC0xNHYxMHptLTItOHY2aC0xMHYtNnptLTEgNXYtNGgtOHY0eiIgZmlsbD0iI2ZmZiIvPg0KPC9zdmc+DQo=",
  "isTrigger": false,
  "operationName": "SortArray",
  "operationDefinition": {
    "type": "Scope",
    "actions": {
      "Settings": {
        "type": "Compose",
        "inputs": {
          "SortOrder": "Dsc",
          "Attribute": "score"
        },
        "runAfter": {},
        "description": "Modify the settings below to change the sort order or the object attribute to sort on",
        "metadata": {
          "operationMetadataId": "5e788764-ea85-4254-b18d-6fe0e9e4561a"
        }
      },
      "Apply_to_each": {
        "type": "Foreach",
        "foreach": "@range(0,length(variables('ArrayOfObjects')))",
        "actions": {
          "RemoveFoundElement": {
            "type": "Compose",
            "inputs": "@union\r\n(\r\n  take(variables('ArrayOfObjects'),outputs('ElementPosition')),\r\n  skip(variables('ArrayOfObjects'),add(outputs('ElementPosition'),1))\r\n)",
            "runAfter": {
              "Append_to_Sorted_Array": [
                "Succeeded"
              ]
            },
            "metadata": {
              "operationMetadataId": "6f13a269-e383-48bb-9899-7b3fb1243e80"
            }
          },
          "Update_Array_Of_Objects_With_Removed_Element": {
            "type": "SetVariable",
            "inputs": {
              "name": "ArrayOfObjects",
              "value": "@outputs('RemoveFoundElement')"
            },
            "runAfter": {
              "RemoveFoundElement": [
                "Succeeded"
              ]
            },
            "metadata": {
              "operationMetadataId": "e50136bb-7b12-42db-acc4-70338d823317"
            }
          },
          "ArrayOfValues": {
            "type": "Select",
            "inputs": {
              "from": "@variables('ArrayOfObjects')",
              "select": "@item()[outputs('Settings')['Attribute']]"
            },
            "runAfter": {},
            "description": "item()[outputs('Settings')['Attribute']]",
            "metadata": {
              "operationMetadataId": "ad3f6b94-8dc5-489b-9210-38e3671c8255"
            }
          },
          "Prepare": {
            "type": "Compose",
            "inputs": {
              "Root": {
                "Values": "@variables('ArrayOfObjects')"
              }
            },
            "runAfter": {
              "ArrayOfValues": [
                "Succeeded"
              ]
            },
            "metadata": {
              "operationMetadataId": "ebf6f3bb-6669-4792-be20-de49ce49f573"
            }
          },
          "XML": {
            "type": "Compose",
            "inputs": "@xml(outputs('Prepare'))",
            "runAfter": {
              "Prepare": [
                "Succeeded"
              ]
            },
            "description": "xml(outputs('Prepare'))",
            "metadata": {
              "operationMetadataId": "c8af3e8c-24b8-4b8e-b76c-893389262fcc"
            }
          },
          "Append_to_Sorted_Array": {
            "type": "AppendToArrayVariable",
            "inputs": {
              "name": "Sorted",
              "value": "@variables('ArrayOfObjects')[outputs('ElementPosition')]"
            },
            "runAfter": {
              "ElementPosition": [
                "Succeeded"
              ]
            },
            "metadata": {
              "operationMetadataId": "48c26b4c-094e-4928-9fde-4c6c6b700cb3"
            }
          },
          "ElementPosition": {
            "type": "Compose",
            "inputs": "@if\r\n(\r\n  equals(outputs('Settings')['SortOrder'], 'Asc'),\r\n  int(xpath(outputs('XML'), concat('count(//Root/Values[', outputs('Settings')['Attribute'] ,'= ', min(body('ArrayOfValues')),']/preceding-sibling::*)'))),  \r\n  int(xpath(outputs('XML'), concat('count(//Root/Values[', outputs('Settings')['Attribute'] ,'= ', max(body('ArrayOfValues')),']/preceding-sibling::*)')))  \r\n)",
            "runAfter": {
              "xpath_expression": [
                "Succeeded"
              ]
            },
            "metadata": {
              "operationMetadataId": "4c6aa711-ae8f-44f5-b460-1baa6921dae1"
            }
          },
          "xpath_expression": {
            "type": "Compose",
            "inputs": "@if(\r\n  equals(outputs('Settings')['SortOrder'], 'Asc'),\r\n  concat('count(//Root/Values[', outputs('Settings')['Attribute'] ,'= ', min(body('ArrayOfValues')),']/preceding-sibling::*)'),  \r\n  concat('count(//Root/Values[', outputs('Settings')['Attribute'] ,'= ', max(body('ArrayOfValues')),']/preceding-sibling::*)')  \r\n)",
            "runAfter": {
              "XML": [
                "Succeeded"
              ]
            }
          }
        },
        "runAfter": {
          "Settings": [
            "Succeeded"
          ]
        },
        "description": "range(0,length(variables('ArrayOfObjects')))",
        "metadata": {
          "operationMetadataId": "f5e1ebe2-13e2-4c60-a619-7e74808a028c"
        }
      }
    },
    "runAfter": {
      "Initialize_Sorted": [
        "Succeeded"
      ]
    }
  }
}

Once you have copied the code above you can simply paste it into your own flow by adding a new action, going to My clipboard and then press CTRL-V and you will see the scope appear:

Detail of how the flow works

For each iteration of the loop, the variable ArrayOfObjects is converted to XML. The example data produces this XML on the first iteration of the loop:

<Root>
  <Values>
	<label>Car</label>
	<score>0.26</score>
  </Values>
  <Values>
	<label>Bus</label>
	<score>0.26</score>
  </Values>
  <Values>
	<label>Train</label>
	<score>0.34</score>
  </Values>
  <Values>
	<label>Boat</label>
	<score>0.45</score>
  </Values>
  <Values>
	<label>Truck</label>
	<score>0.62</score>
  </Values>
  <Values>
	<label>Bike</label>
	<score>0.11</score>
	</Values>
</Root>

During this first run it finds the highest value in the score attribute of the array. It does this using a dynamic xpath expression. Inside the scope there is compose action called xpath expression, the value of which is never used again, but I left it in place so that you can see what the flow is doing. In the first iteration the xpath produced is:

count(//Root/Values[score= 0.62]/preceding-sibling::*)

If you copy the XML above into xpather.com and then copy the expression to the expression box you will see that it returns a value of 4. The number 4 in this case represents the count of array elements before the target value was found.

The array position is then used for two purposes:

• To reconstruct the original array so that contains all of the elements except the one which was found.
• To add the found element to a new array.

In the next iteration of the loop, the found value is no longer present in the original array. This process keeps going until there is only one element left in the array.

Finding the top three values

Although I have explained how to sort an array. The original posters question was just to find the top three values. There are two ways this flow can be modified to achieve this:

Modify the apply to each loop

The source for the apply to each loop uses the following expression:

range(0,length(variables('ArrayOfObjects')))

With our sample data, this will produce the following JSON array:

[ 0, 1, 2, 3, 4, 5 ]

To get only the top 3 from the original array, the expression for the apply to each loop could be changed to:

range(1,3)

This will produce the fastest result as the apply to each loop will run only as many times as required to produce the Top 3 entries.

Using the take expression

The other alternative is to leave the scope to sort the entire array and when it is finished use the take expression within a compose action to extract the first 3 entries:

take(variables('Sorted'), 3)

This is the best method to use if you want an entire sorted array as opposed to a Top X.

Conclusion

This is a fairly advanced flow but it is easy to implement by copying the scope code. It would nice if there was a native sort action, if you feel the same, please add your vote to the idea on the forum.