param (
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string] $token,
[int32] $definitionId
)

## Construct a basic auth head using PAT
function BasicAuthHeader()
{

  param([string]$authtoken)
  $ba = (":{0}" -f $authtoken)
  $ba = [System.Text.Encoding]::UTF8.GetBytes($ba)
  $ba = [System.Convert]::ToBase64String($ba)
  $h = @{Authorization=("Basic{0}" -f $ba);ContentType="application/json"}
  return $h
}

# Fill in your account name/project name/definition name
$accountName = "anjani1"
$projectName = "TFVCProj"
$definitionNameToRecover = "New Release Definition"
# Find the Id of release definition that got deleted
$deletedReleasesUri = "https://$accountName.vsrm.visualstudio.com/$projectName/_apis/Release/releases?api-version=4.1-preview.6&isDeleted=true&definitionId=$definitionId"
$h = BasicAuthHeader $token
$deletedReleases = Invoke-RestMethod -Uri $deletedReleasesUri -Headers $h -ContentType “application/json" -Method Get
$deletedReleasesIds = $deletedReleases.value.id # | ConvertTo-Json -Depth 100
write-host "Found the total deleted releases : $deletedReleasesIds.count"
For ($i=0; $i -lt $deletedReleasesIds.count; $i++)
{
$deletedReleaseId = $deletedReleasesIds[$i];
Write-Host "Found the deleted id : $deletedReleaseId";
# Recover the deleted release
$undeleteReason = '{ "Comment" : "Deleted by mistake" }'
$undeleteReleaseUri = "https://$accountName.vsrm.visualstudio.com/$projectName/_apis/Release/releases/$deletedReleaseId`?comment=$undeleteReason&api-version=4.1-preview.6"
$undeletedDefinition = Invoke-RestMethod -Uri $undeleteReleaseUri -Headers $h -ContentType “application/json" -Method Put -Body $undeleteReason
write-host "Release id: $deletedReleaseId recovered successfully"
}

using System;
using Microsoft.VisualStudio.Services.Client;
using Microsoft.VisualStudio.Services.Common;
using Microsoft.VisualStudio.Services.ReleaseManagement.WebApi.Clients;
using Microsoft.VisualStudio.Services.WebApi;
using Microsoft.VisualStudio.Services.ReleaseManagement.WebApi;
using Microsoft.VisualStudio.Services.ReleaseManagement.WebApi.Contracts;
using System.Diagnostics;

namespace ReleaseHttpClientSample
{
 class Program
 {

  static void Main(string[] args)

    {

      Uri serverUrl = new Uri("https://anjani1.visualstudio.com");
      var project = "TFVCProj";
      VssCredentials credentials = new VssClientCredentials();
      credentials.Storage = new VssClientCredentialStorage();
      VssConnection connection = new VssConnection(serverUrl, credentials);
      ReleaseHttpClient rmClient = connection.GetClient<ReleaseHttpClient>();
      var releases = rmClient.GetReleasesAsync(project, definitionId: 1, isDeleted: true).Result;
      foreach(var release in releases)
          {
             rmClient.UndeleteReleaseAsync(project, release.Id, "Deleted by mistake").SyncResult();
          }
    }
 }
}

public static void CancelAllInProgressReleases(ReleaseHttpClient2 rmClient)
        {
            var maxModifiedTime = DateTime.Now.AddDays(-numberOfDaysBefore);
            var minModifiedTime = DateTime.Now.AddDays(-numberOfDaysAfter);

            try
            {
                int ctn = 0;
                IPagedCollection<Release> releases = null;
                do
                {
                    releases = rmClient.GetReleasesAsync2(
                    definitionId: definitionId,
                    statusFilter: ReleaseStatus.Active,
                    minCreatedTime: minModifiedTime,
                    maxCreatedTime: maxModifiedTime,
                    top: 100,
                    continuationToken: ctn,
                    expand: ReleaseExpands.Environments).Result;

                    ReleaseEnvironmentUpdateMetadata envMetaData = new ReleaseEnvironmentUpdateMetadata();
                    envMetaData.Status = EnvironmentStatus.Canceled;
                    envMetaData.Comment = "Good to cancel as it's pretty old";

                    foreach (var release in releases)
                    {
                        foreach (var environment in release.Environments)
                        {
                            if (environment.Status == EnvironmentStatus.Queued || environment.Status == EnvironmentStatus.InProgress)
                            {
                                try
                                {
                                    totalDeploymentToCancel++;
                                    Console.WriteLine("Cancelling the environment with releaseId: {0} ReleaseEnvironmentId: {1} ", release.Id, environment.Id);
                                    var result = rmClient.UpdateReleaseEnvironmentAsync(envMetaData, projectName, release.Id, environment.Id).Result;
                                    // rmClient.DeleteReleaseAsync(projectName, release.Id).SyncResult();
                                }
                                catch (Exception ex)
                                {
                                    Console.WriteLine("=======================");
                                    Console.WriteLine("Not Cancelling the deployment with releaseId: {0} ReleaseEnvironmentId: {1} ", release.Id, environment.Id);
                                    Console.WriteLine(ex.Message);
                                    Console.WriteLine("=======================");
                                }
                            }
                        }
                    }

                    int.TryParse(releases.ContinuationToken, out ctn);
                } while (releases.ContinuationToken != null);

                Console.WriteLine("Total cancelled environments: {0}", totalDeploymentToCancel);
            }
            catch(Exception ex)
            {
                Console.WriteLine("Could not get releases with given information");
            }
        }
    }

public static ReleaseDefinition AddSecretVariableInReleaseDefinition(ReleaseHttpClient rmClient, string projectName, ReleaseDefinition definition)
        {
            var secretVariableKey = "secretVariableKey";
           var secretVariableValue = new ConfigurationVariableValue { Value = "secretVariableValue", IsSecret = true };
            definition.Variables.Add(secretVariableKey, secretVariableValue);
            var updatedDefinition = rmClient.UpdateReleaseDefinitionAsync(definition, projectName).Result;
            return updatedDefinition;
        }

var cloneDefinitionContextMenu = (function () {
    "use strict";

    return {
        execute: function (sourceItemContext) {
            // Load VSTS controls and REST client
            VSS.require(["VSS/Controls", "VSS/Service", "ReleaseManagement/Core/RestClient"],
            function (Controls, VSS_Service, RM_WebApi) {
                var newDefinitionName = prompt("New definition name:", sourceItemContext.definition.name + " - Copy");
                if (newDefinitionName != null)
                {
                    sourceItemContext.view.logMessage("Creating " + newDefinitionName + "...");
                    var vsoContext = VSS.getWebContext();
                    // Get a RM client to make REST calls
                    var rmClient = VSS_Service.getCollectionClient(RM_WebApi.ReleaseHttpClient);
                    rmClient.getReleaseDefinition(vsoContext.project.id,sourceItemContext.definition.id).then(function(definition){
                        definition.name = newDefinitionName;
						rmClient.createReleaseDefinition(definition, vsoContext.project.id).then(() => {
                            sourceItemContext.view.refresh();
                            sourceItemContext.view.logMessage("Cloned \'"+ sourceItemContext.definition.name +"\' and created \'" + newDefinitionName + "\'");
                        }, function(error){
                            sourceItemContext.view.logError(error);
                        });
                    }, function(error){
                        sourceItemContext.view.logError(error);
                    });
                }
            });
        }
    }
}());

using System;
using Microsoft.VisualStudio.Services.Client;
using Microsoft.VisualStudio.Services.Common;
using Microsoft.VisualStudio.Services.ReleaseManagement.WebApi.Clients;

namespace ReleaseHttpClientSample
{
    class Program
    {
        static void Main(string[] args)
        {
            Uri serverUrl = new Uri("https://{your tenant name}.visualstudio.com");
            VssCredentials credentials = new VssClientCredentials();
            credentials.Storage = new VssClientCredentialStorage();

            VssConnection connection = new VssConnection(serverUrl, credentials);

            ReleaseHttpClient rmClient = connection.GetClient<ReleaseHttpClient>();

             var releaseDefinitions = rmClient.GetReleaseDefinitionsAsync("{your project name}").Result;

            Console.Out.WriteLine("Release definitions " + releaseDefinitions.Count);
        }
    }
}

using System;
using Microsoft.VisualStudio.Services.Client;
using Microsoft.VisualStudio.Services.Common;
using Microsoft.VisualStudio.Services.ReleaseManagement.WebApi.Clients;

namespace ReleaseHttpClientSample
{
    class Program
    {
        static void Main(string[] args)
        {
            string collectionUri = args[0];
            string projectName = args[1];
            string patToken = args[2];
            int releaseId = int.Parse(args[3]);

            VssConnection connection = new VssConnection(new Uri(collectionUri), new VssBasicCredential("username", patToken));
            ReleaseHttpClient client = connection.GetClient<ReleaseHttpClient>();
            var release = client.GetReleaseAsync(projectName, releaseId).Result;

            var variableValue = new ConfigurationVariableValue();
            variableValue.Value = "bar";
            release.Variables.Add("foo", variableValue);

            var updatedRelease = client.UpdateReleaseAsync(release, projectName, releaseId).Result;

     } 
   } 
}

public static async Task<string> GetReleaseDefinitionsUsingPATToken()
        {
            var username = "nobody";
            var token = "<Give your PAT Token here>";

            var url = "https://{accountname}.visualstudio.com/{projectname}/_apis/release/definitions?api-version=3.0-preview.1";

            using (HttpClient client = new HttpClient())
            {
                var mediaTypeHeader = new MediaTypeWithQualityHeaderValue("application/json");
                client.DefaultRequestHeaders.Accept.Add(mediaTypeHeader);

                var credentialBytes = Encoding.ASCII.GetBytes($"{username}:{token}");
                var encodedCredentialBytes = Convert.ToBase64String(credentialBytes);
                client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", encodedCredentialBytes);

                var response = await client.GetAsync(url);
                var body = await response.Content.ReadAsStringAsync();
                return body;
            }
        }