Consultant Tips on Mart's blog

Golden Tips To Leave Companies Without A Nasty Smell

blog@martdegraaf.nl (Mart de Graaf) — Thu, 10 Aug 2023 15:00:00 +0200

As a consultant when a job ends you need to transition from the previous to the next. How do you efficiently clean up all open ends? The open branches that you leave behind are sort of dead code. Nobody is going to take care of it. Make sure you don’t generate more work for ex-colleagues following these tips.

Using the scripts below we can create a small to-do list, which you should do before leaving a company.

💬 “The first impression is just as important as the last impression. Make sure you leave a good impression.” - Mart de Graaf

1. No open work items

Even if you would work with Trello, it would be nice to hand over open items to coworkers. When working in Azure DevOps, you can use the following Powershell script to get all open work items assigned to you.

In the PowerShell script below we can easily get all open work items. This is not only handy when leaving companies but also when you want to get an overview of all open work items. You can use this script to get knowledge of all open work items or to hand over the work to a colleague. You could also do this in Azure DevOps, but when you already have a PAT-token, you can check this as well with this easy script.

OpenWorkItems.ps1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


# Set variables
$organizationUrl = "https://dev.azure.com/MART" # Replace Mart with organization name
$projectName = "ProjectName" # Replace ProjectName with project name

# Get the access token from current az login session
# see https://learn.microsoft.com/en-us/azure/devops/integrate/get-started/authentication/service-principal-managed-identity?toc=%2Fazure%2Fdevops%2Forganizations%2Fsecurity%2Ftoc.json&view=azure-devops#q-can-i-use-a-service-principal-or-managed-identity-with-azure-cli
$accessToken = az account get-access-token --resource 499b84ac-1321-427f-aa17-267ca6975798 --query "accessToken" --output tsv
if ($null -eq $accessToken) {
    exit 1
}
# Set headers
$headers = @{
    "Authorization" = ("Bearer {0}" -f $accessToken)
    "Accept"        = "application/json"
}

# Get a list of workitems for given username
$workItemsUrl = "$organizationUrl/$projectName/_apis/wit/wiql?api-version=6.0"

$wiql = @"
SELECT [System.Id], [System.Title], [System.State], [System.AssignedTo], [System.Tags], [System.WorkItemType]
FROM workitems
WHERE [System.TeamProject] = @project
AND [System.WorkItemType] = 'Task'
AND [System.State] <> 'Closed'
AND [System.State] <> 'Removed'
AND [System.State] <>  'Done'
AND [System.AssignedTo] = @me
ORDER BY [System.ChangedDate] desc
"@

$body = @{ query = $wiql } | ConvertTo-Json

$workItemsResponse = Invoke-RestMethod -Uri $workItemsUrl -Headers $headers -Method Post -Body $body -ContentType "application/json"

# use workitemsbatch api to get all SELECT values

$workItemsUrl = "$organizationUrl/$projectName/_apis/wit/workitemsbatch?api-version=6.0"

# get the ids from $workItemsResponse.workItems in a list max 200
$ids = $workItemsResponse.workItems.id | Select-Object -First 200

# body is the list of ids in the workitemsresponse workitems.id, and the fields to select in a fields array
$body = @{ ids = $ids; fields = "System.Id", "System.Title", "System.State", "System.AssignedTo", "System.Tags", "System.WorkItemType" } | ConvertTo-Json

$workItemsResponse2 = Invoke-RestMethod -Uri $workItemsUrl -Headers $headers -Method Post -Body $body -ContentType "application/json"

Write-Host "Workitems found '$($workItemsResponse.workItems.count)'"

# write the response to a JSON file
$workItemsResponse2 | ConvertTo-Json -Depth 100 | Out-File -FilePath "workitems.json" -Force

Output

It will be output in a JSON file, for now. I think that will be easy to read if you are leaving. It also limits to 200 work items. If you have more than 200 work items, you probably have a problem.

2. No open branches 🥦 or pull requests

When working with Git, you can use the following Powershell script to get all open branches. You can use this script to get knowledge of all open branches or to create a pull request for each branch. The pull request can be used to hand over the work to a colleague.

OpenBranches.ps1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99


# Set variables
$organizationUrl = "https://dev.azure.com/MART" # Replace Mart with organization name
$projectName = "ProjectName" # Replace ProjectName with project name

$dayTolerance = 14

# Get the access token from current az login session
# see https://learn.microsoft.com/en-us/azure/devops/integrate/get-started/authentication/service-principal-managed-identity?toc=%2Fazure%2Fdevops%2Forganizations%2Fsecurity%2Ftoc.json&view=azure-devops#q-can-i-use-a-service-principal-or-managed-identity-with-azure-cli
$accessToken = az account get-access-token --resource 499b84ac-1321-427f-aa17-267ca6975798 --query "accessToken" --output tsv
if ($null -eq $accessToken) {
    exit 1
}
# Set headers
$headers = @{
    "Authorization" = ("Bearer {0}" -f $accessToken)
    "Accept"        = "application/json"
}

# Get a list of repositories in the project
$reposUrl = "$organizationUrl/$projectName/_apis/git/repositories?api-version=6.0"
$reposResponse = Invoke-RestMethod -Uri $reposUrl -Headers $headers -Method Get

Write-Host "Repos found '$reposResponse.count'"

#create dictionary openBranchesPerUser
$openBranchesPerUser = @{}

foreach ($repo in $reposResponse.value) {
    $repoName = $repo.name
    
    if ($repo.isDisabled) {
        Write-Host "Skipping disabled repo: '$repoName'" -foregroundcolor Gray
        continue;
    }
    
    Write-Host "Checking '$repoName':" -foregroundcolor yellow
	
    $branchesUrl = "$organizationUrl/$projectName/_apis/git/repositories/$repoName/refs?filter=heads&api-version=6.0"
    $branchesResponse = Invoke-RestMethod -Uri $branchesUrl -Headers $headers -Method Get
    foreach ($branch in $branchesResponse.value) {
        $branchName = $branch.name
        $BranchNameTrimmed = $branchName.replace('refs/heads/', '')
        if ($BranchNameTrimmed -eq 'master') {
            continue;
        }
        if ($BranchNameTrimmed -eq 'main') {
            continue;
        }
        $encodedBranchName = [System.Uri]::EscapeDataString($branchName)
        $pushesUrl = "$organizationUrl/$projectName/_apis/git/repositories/$repoName/pushes?searchCriteria.includeRefUpdates&searchCriteria.refName=$encodedBranchName&api-version=6.0"
        ## Write-Host "$branchName - $pushesUrl"
        $pushesResponse = Invoke-RestMethod -Uri $pushesUrl -Headers $headers -Method Get
        # get first push in the list
        $push = $pushesResponse.value[0];
        $firstPush = $pushesResponse.value[-1];

        #Convert $lastPush.date to DateTime object
        $lastPushDate = [DateTime]::Parse($firstPush.date);
        # if the last push date is older than today minus the dayTolerance, skip the branch
        if ($lastPushDate -gt (Get-Date).AddDays(-$dayTolerance)) {
            Write-Host "Skipping '$repoName' - '$branchName' - last push date '$($lastPush.date)'  compare date '$((Get-Date).AddDays(-$dayTolerance))' '$($push.pushedBy.uniqueName)'"  -foregroundcolor Red
            continue;
        }
        else {
            Write-Host "Checking '$repoName' - '$branchName' - last push date '$($lastPush.date)' compare date '$((Get-Date).AddDays(-$dayTolerance))' '$($push.pushedBy.uniqueName)' "
        }

        $pushedBy = $firstPush.pushedBy.uniqueName
        # Add to openBranchesPerUser dictionary with the user name as key and a object as value including branch name, repositoy and respository url
        if ($openBranchesPerUser.ContainsKey($pushedBy)) {
            $openBranchesPerUser[$pushedBy] += [PSCustomObject]@{
                Repository    = $repoName
                RepositoryUrl = $repo.webUrl + "/branches?_a=all"
                Branch        = $branchName
                firstPushDate = $firstPush.date
                lastPushDate  = $push.date
                lastPusher    = $push.pushedBy.uniqueName
            }
        }
        else {
            $openBranchesPerUser.Add($pushedBy, @([PSCustomObject]@{
                        Repository    = $repoName
                        RepositoryUrl = $repo.webUrl + "/branches?_a=all"
                        Branch        = $branchName
                        firstPushDate = $firstPush.date
                        lastPushDate  = $push.date
                    }))
        }
    }
}

# Write openBranchesPer user as a table, exclude RepositoryUrl
$openBranchesPerUser.GetEnumerator() | ForEach-Object {
    Write-Host "User: $($_.Key)" -ForegroundColor Green
    $_.Value | Format-Table -Property Repository, Branch, firstPushDate, lastPushDate, lastPusher -AutoSize
}

# Write openBranchesPerUser to a JSON file
$openBranchesPerUser | ConvertTo-Json | Out-File -FilePath "openBranchesPerUser.json" -Encoding ascii

Output

The output will be visible in the console and a JSON file.

3. Get feedback

Ask for feedback from your colleagues and manager. This feedback can be used to improve yourself in the future. It can also be used to improve the company you worked for. If you don’t ask for feedback, you will never know what you could have done better.

When asking for feedback keep in mind it’s to improve yourself, not to get a compliment. You can ask for feedback in the following way:

💬 “What could I have done better while working together?”

4. Say goodbye

Take the time to say goodbye to your colleagues and express your gratitude for the time you spent working together. You never know when you might cross paths with them again in the future.

Make sure you connect on social media with people you want to connect on the long term.

Checklist

:check_box_with_check: Hand over open work items, or unassign them
:check_box_with_check: Delete open branches
:check_box_with_check: Say Goodbye to your team and colleagues
:check_box_with_check: Check for your ip whitelists in Azure DevOps

Conclusion

When leaving a company, you want to leave no technical debt behind and clean up after yourself. You can use the scripts in this article to help you with that.

Efficiently use Outlook Rules to Delete Azure DevOps Email Clutter

blog@martdegraaf.nl (Mart de Graaf) — Thu, 01 Jun 2023 18:14:56 +0100

We want to spend time on the most important things right? Are you also annoyed by the number of emails generated by Azure DevOps? See how I fixed the email overdose using an Outlook rule.

E-mail headers

To remove all emails would be nice, but we won’t see any mentions. To know how to recognize a mention email I opened a mention email. I found the headers by clicking the three dots in the Outlook web version. And then Open the ‘View’ dropdown and select ‘View message details’.

View message details" />

Outlook web - View > View message details

We see that some headers indicate that the message trigger contained ‘Mention’. This is essential information for our next steps. Here below the headers I found in the email message.

1
2
3
4
5
6


X-VSS-Scope: organisation/project/Repository
X-VSS-Event-Type: ms.vss-mentions.identity-mention-event
X-VSS-Subscription-ID: ms.vss-mentions.identity-mention-subscription
X-VSS-Event-Initiator: Mart de Graaf
X-VSS-Event-Initiator-Ascii: Mart de Graaf
X-VSS-Event-Trigger: Mention

Outlook Rules

I am not praising the Outlook client, I want to talk about the Rules feature of Outlook. The rules are found in the classic Outlook by pressing ‘File’ and then clicking the big ‘Manage Rules & Alerts’ button. Let’s create a rule to delete and mark all those emails as read.

The first step is to define conditions. We know Azure DevOps emails from azuredevops@microsoft.com. For my case, I wanted to scope emails to a certain organization, which can be done by filtering specific words in the message header.

Rule conditions

The emails should be deleted, but also be marked as read. Nothing is more annoying than a number after your delete folder, right?

Rule actions

We still would like to receive the Mention emails. So we need to make an exception for them. As said earlier this can be done by filtering the message header for specific words.

Rule exceptions

Full Outlook Rule

The only thing you have to edit in my example is the organisationName.

1
2
3
4
5


from azuredevops@microsoft.com
 and with VSS-Scope: organisationName
delete it
 and mark it as read
except if the message header contains 'X-VSS-Event-Trigger: Mention' or 'X-VSS-Subscription-ID: ms.vss-mentions.identity-mention-subscription'

:megaphone: Have any suggestions, I would love to hear them!

Conclusion and discussion

Help yourself keep control of your inbox. I think you should work from the board and business wishes, and not from your inbox.

Efficiently Git Clone All Repositories from Azure DevOps using PowerShell: A Step-by-Step Guide

blog@martdegraaf.nl (Mart de Graaf) — Mon, 15 May 2023 18:14:56 +0100

As a consultant, starting a new project with a client can be a daunting task. One way to make the transition smoother is by cloning all the repositories on your first day. This allows you to have quick access to all the necessary files and resources, enabling you to perform your job efficiently and effectively. In this blog post, we will explore the benefits of cloning repositories, a script for doing so, and some common pitfalls to avoid.

Skip to the code sample

Organizing your Git repos

When working for multiple clients or even just having private projects next to your client projects it can come in handy to organize your git repositories. For some Frontend repositories, the path with node_modules was too long and that forced me to place my folders on the Disk level. A path for a project for me would look like C:\Git\{ClientName}\{RepositoryName}.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


C:\Git
 ┣ Client1
 ┃ ┣ Client1.Repository1
 ┃ ┣ Client1.Repository2
 ┃ ┗ Client1.Repository3
 ┣ Client2
 ┃ ┣ Client2.Repository1
 ┃ ┗ Client2.Repository2
 ┗ private
 ┃ ┣ Blog
 ┃ ┗ Demo

Using workspaces in Git Fork

Fork is a tool that will help you focus on the right workload. Using the structure as discussed with Fork, you can focus on the right repositories. Cloned new repositories but not seen by Fork? Reload the whole folder using right-click and ‘Rescan repositories’. Get Git Fork from git-fork.com.

Fork Repository Manager

Use Fork Workspaces to focus on the current environment. It will also help you work on private projects outside of work hours on the same workstation. You can also create workspaces for different domains or teams if you are for example the lead or architect in a project.

Fork workspaces

Configure your git username

Depending on the network infra, you will need to configure your commit username to the email of your client. Some instances block all git pushes from committers with a different domain.

1

git config [--global] user.email "username@corperate.com"

In the script to clone all repositories, you can also enable the script to set the committer email for every repository.

Clone all repositories

To clone all repositories in Azure DevOps we can use the REST API to find all existing repositories. The code example consists of a Powershell script and a configuration file with settings and Authorization.

Configuration

Make sure to create a file named: CloneAllRepos.config with the contents written below. Make sure every parameter is configured as your workspace.

CloneAllRepos.config

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


[General]
Url=https://dev.azure.com/MART/project

[LocalGitConfig]
GitPath=C:\Git\
OrgName=MART

[GitOptions]
PruneLocalBranches=false # Optional defaults to false
GitEmail=username@corperate.com

💡 ~~Don’t know where to find a Personal Access Token in Azure DevOps? Read: Microsoft’s docs on personal access tokens.~~

On 2024 april 17, I updated the script to get an access token using the current session of the az cli. see Azure DevOps API Authentication.

CloneAllRepos.ps1

When I first encountered the idea to clone all repos idea it was on a corporate wiki. After some backtracing, I found the source: Script to clone all Git repositories from your Azure DevOps collection.

The PowerShell script below does a git pull for existing repositories and performs a git clone on untracked repositories.

I edited the script to fit my needs with some extra parameters.

It puts the repos in the given directory in settings.
It prunes local branches when PruneLocalBranches is set to true.
It sets the git username email to the configured GitUsername under GitOptions, it’s ignored when empty.

CloneAllRepos.ps1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76


# Read configuration file
Get-Content "CloneAllRepos.config" | foreach-object -begin {$h=@{}} -process { 
    $k = [regex]::split($_,'='); 
    if(($k[0].CompareTo("") -ne 0) -and ($k[0].StartsWith("[") -ne $True)) { 
        $h.Add($k[0], $k[1]) 
    } 
}
#AzDO config
$url = $h.Get_Item("Url")
# LocalGitConfig
$gitPath = $h.Get_Item("GitPath")
$orgName = $h.Get_Item("OrgName")
$pruneLocalBranches = $h.Get_Item("PruneLocalBranches") -eq "true"
$gitEmail = $h.Get_Item("GitEmail")

# Get the access token from current az login session
# see https://learn.microsoft.com/en-us/azure/devops/integrate/get-started/authentication/service-principal-managed-identity?toc=%2Fazure%2Fdevops%2Forganizations%2Fsecurity%2Ftoc.json&view=azure-devops#q-can-i-use-a-service-principal-or-managed-identity-with-azure-cli
$accessToken = az account get-access-token --resource 499b84ac-1321-427f-aa17-267ca6975798 --query "accessToken" --output tsv
if ($null -eq $accessToken) {
    exit 1
}

$headers = @{
    "Authorization" = ("Bearer {0}" -f $accessToken)
    "Accept" = "application/json"
}

# Retrieve list of all repositories
$resp = Invoke-WebRequest -Headers $headers -Uri ("{0}/_apis/git/repositories?api-version=1.0" -f $url)
$json = convertFrom-JSON $resp.Content

# Clone or pull all repositories
$initpath =  ("{0}{1}" -f  $gitPath,$orgName)

foreach ($entry in $json.value) { 
    set-location $initpath
    $name = $entry.name 
    Write-Host $name -ForegroundColor Green

    if($entry.isDisabled){
        Write-Host "Skipping disabled repo: '$name'" -ForegroundColor Yellow
        continue;
    }

    $url = $entry.remoteUrl #-replace "://", ("://{0}@" -f $gitcred)
    if(!(Test-Path -Path $name)) {
        git clone $url
    } else {
        Write-Host "Directory '$name' exists lets pull"
        set-location $name
        git pull
        $defaultBranch = git symbolic-ref --short HEAD

        if($pruneLocalBranches){
            Write-Host "Pruning local branches $name" -ForegroundColor Yellow
            $branches = git branch -vv | Where-Object { $_ -notmatch "::" } | ForEach-Object { ($_ -split '\s+')[1] }

            foreach ($branch in $branches) {
                if ($branch -eq $defaultBranch) {
                    Write-Host "Skipping default branch '$branch'."
                    continue
                }
                if ((git branch -vv | Where-Object { $_ -match "$branch\s+\[origin\/" })) {
                    Write-Host "Skipping branch '$branch' as it has a remote reference."
                }
                else {
                    git branch -D $branch
                    Write-Host "Deleted local branch '$branch'." -ForegroundColor Green
                }
            }
        }
        if($gitEmail){
            git config user.email "$gitEmail"
        }
    }
}

🤖 If you have some additional ideas, let ChatGPT help you. Supply ChatGPt with the context: Rewrite this PowerShell script to also . Here is the current version of the PowerShell script: .. Let me know if you thought of a clever solution.

Run it

Run the script it using a PowerShell prompt for example using for example Windows Terminal.

1

./CloneAllRepos.ps1

Using scripting for common tasks

In the world of microservices, we choose to duplicate some of the plumbing. When you want to change multiple repos knowledge on scripting can be helpful. In this series, I explored how to automate git tasks with PowerShell.

Some examples are:

Updating multiple NuGet packages.
Enforcing certain Nuget. config configurations.
Renaming business terminology on multiple branches.

Automating

With this structure, you could automate actions over multiple repositories. In the code below I wrote an example of automating script for changing the Nuget.config file in every repository. If your packages have the same layout changes can be done easier and faster. Also, please check out my article using binary replace.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


git checkout main
git pull
git checkout -b fix/nugetconfig

# DO THE NECESSARY CHANGE in nuget.config.

git mv -f NuGet.config nuget.config
git add *

git commit -m "Only use private Nuget upstream"
git push --set-upstream origin fix/nugetconfig
git checkout main

Conclusion and discussion

Make your workflow faster with scripting and your knowledge of the Git CLI. When you have to do repetitive tasks such as updating a single package on multiple (microservice-like) repositories, try to automate it. It may for the first occurrence not be profitable, but after three times, you will be faster than doing it manually. It can also help you clean up your workspace and be more tidy.

Consultant Tips on Mart's blog

Golden Tips To Leave Companies Without A Nasty Smell

1. No open work items

Output

2. No open branches 🥦 or pull requests

Output

3. Get feedback

4. Say goodbye

Checklist

Conclusion

Further reading

Efficiently use Outlook Rules to Delete Azure DevOps Email Clutter

E-mail headers

Outlook Rules

Full Outlook Rule

Conclusion and discussion

Efficiently Git Clone All Repositories from Azure DevOps using PowerShell: A Step-by-Step Guide

Organizing your Git repos

Using workspaces in Git Fork

Configure your git username

Clone all repositories

Configuration

CloneAllRepos.ps1

Run it

Using scripting for common tasks

Automating

Conclusion and discussion